Skip to content

The open alternative to Salesforce, designed for AI.

7.6 KB
Raw Blame
import {
  type EnumSymbolResolver,
  printTypescriptValue,
} from '@/app/pull/print-typescript-value';
import {
  AggregateOperations,
  DateDisplayFormat,
  FieldMetadataType,
  IndexType,
  NavigationMenuItemType,
  NumberDataType,
  ObjectOpenRecordIn,
  ObjectRecordGroupByDateGranularity,
  PageLayoutTabLayoutMode,
  PageLayoutType,
  RelationOnDeleteAction,
  RelationType,
  RowLevelPermissionPredicateGroupLogicalOperator,
  RowLevelPermissionPredicateOperand,
  ViewCalendarLayout,
  ViewFilterGroupLogicalOperator,
  ViewFilterOperand,
  ViewOpenRecordIn,
  ViewSortDirection,
  ViewType,
  ViewVisibility,
  WidgetType,
} from 'twenty-shared/types';
import { SystemPermissionFlag } from 'twenty-shared/constants';
import { isDefined } from 'twenty-shared/utils';

const MAX_IMPORT_LINE_LENGTH = 80;

export type EnumBinding = {
  path: string[];
  symbol: string;
  members: Record<string, string>;
};

const buildFieldEnumBindings = (prefix: string[]): EnumBinding[] => [
  {
    path: [...prefix, 'type'],
    symbol: 'FieldType',
    members: FieldMetadataType,
  },
  {
    path: [...prefix, 'universalSettings', 'relationType'],
    symbol: 'RelationType',
    members: RelationType,
  },
  {
    path: [...prefix, 'universalSettings', 'onDelete'],
    symbol: 'OnDeleteAction',
    members: RelationOnDeleteAction,
  },
  {
    path: [...prefix, 'universalSettings', 'dataType'],
    symbol: 'NumberDataType',
    members: NumberDataType,
  },
  {
    path: [...prefix, 'universalSettings', 'displayFormat'],
    symbol: 'DateDisplayFormat',
    members: DateDisplayFormat,
  },
];

export const FIELD_ENUM_BINDINGS: EnumBinding[] = buildFieldEnumBindings([]);

export const OBJECT_ENUM_BINDINGS: EnumBinding[] = [
  {
    path: ['openRecordIn'],
    symbol: 'ObjectOpenRecordIn',
    members: ObjectOpenRecordIn,
  },
  ...buildFieldEnumBindings(['fields', '[]']),
];

export const INDEX_ENUM_BINDINGS: EnumBinding[] = [
  { path: ['indexType'], symbol: 'IndexType', members: IndexType },
];

export const buildRoleEnumBindings = (
  systemPermissionFlag: Record<string, string>,
): EnumBinding[] => [
  {
    path: ['rowLevelPermissionPredicateGroups', '[]', 'logicalOperator'],
    symbol: 'RowLevelPermissionPredicateGroupLogicalOperator',
    members: RowLevelPermissionPredicateGroupLogicalOperator,
  },
  {
    path: ['rowLevelPermissionPredicates', '[]', 'operand'],
    symbol: 'RowLevelPermissionPredicateOperand',
    members: RowLevelPermissionPredicateOperand,
  },
  {
    path: ['permissionFlagUniversalIdentifiers', '[]'],
    symbol: 'SystemPermissionFlag',
    members: systemPermissionFlag,
  },
];

export const ROLE_ENUM_BINDINGS = buildRoleEnumBindings(SystemPermissionFlag);

const buildAggregateOperationBinding = (path: string[]): EnumBinding => ({
  path,
  symbol: 'AggregateOperations',
  members: AggregateOperations,
});

export const VIEW_FIELD_ENUM_BINDINGS: EnumBinding[] = [
  buildAggregateOperationBinding(['aggregateOperation']),
];

export const VIEW_ENUM_BINDINGS: EnumBinding[] = [
  { path: ['type'], symbol: 'ViewType', members: ViewType },
  { path: ['visibility'], symbol: 'ViewVisibility', members: ViewVisibility },
  {
    path: ['openRecordIn'],
    symbol: 'ViewOpenRecordIn',
    members: ViewOpenRecordIn,
  },
  buildAggregateOperationBinding(['kanbanAggregateOperation']),
  {
    path: ['calendarLayout'],
    symbol: 'ViewCalendarLayout',
    members: ViewCalendarLayout,
  },
  buildAggregateOperationBinding(['fields', '[]', 'aggregateOperation']),
  {
    path: ['filters', '[]', 'operand'],
    symbol: 'ViewFilterOperand',
    members: ViewFilterOperand,
  },
  {
    path: ['filterGroups', '[]', 'logicalOperator'],
    symbol: 'ViewFilterGroupLogicalOperator',
    members: ViewFilterGroupLogicalOperator,
  },
  {
    path: ['sorts', '[]', 'direction'],
    symbol: 'ViewSortDirection',
    members: ViewSortDirection,
  },
];

const buildPageLayoutWidgetEnumBindings = (prefix: string[]): EnumBinding[] => [
  { path: [...prefix, 'type'], symbol: 'WidgetType', members: WidgetType },
  {
    path: [...prefix, 'position', 'layoutMode'],
    symbol: 'PageLayoutTabLayoutMode',
    members: PageLayoutTabLayoutMode,
  },
  buildAggregateOperationBinding([
    ...prefix,
    'configuration',
    'aggregateOperation',
  ]),
  ...[
    'dateGranularity',
    'primaryAxisDateGranularity',
    'secondaryAxisGroupByDateGranularity',
  ].map((key) => ({
    path: [...prefix, 'configuration', key],
    symbol: 'ObjectRecordGroupByDateGranularity',
    members: ObjectRecordGroupByDateGranularity,
  })),
];

const buildPageLayoutTabEnumBindings = (prefix: string[]): EnumBinding[] => [
  {
    path: [...prefix, 'layoutMode'],
    symbol: 'PageLayoutTabLayoutMode',
    members: PageLayoutTabLayoutMode,
  },
  ...buildPageLayoutWidgetEnumBindings([...prefix, 'widgets', '[]']),
];

export const PAGE_LAYOUT_WIDGET_ENUM_BINDINGS: EnumBinding[] =
  buildPageLayoutWidgetEnumBindings([]);

export const PAGE_LAYOUT_TAB_ENUM_BINDINGS: EnumBinding[] =
  buildPageLayoutTabEnumBindings([]);

export const NAVIGATION_MENU_ITEM_ENUM_BINDINGS: EnumBinding[] = [
  {
    path: ['type'],
    symbol: 'NavigationMenuItemType',
    members: NavigationMenuItemType,
  },
];

export const PAGE_LAYOUT_ENUM_BINDINGS: EnumBinding[] = [
  { path: ['type'], symbol: 'PageLayoutType', members: PageLayoutType },
  ...buildPageLayoutTabEnumBindings(['tabs', '[]']),
];

const STEP_PATH = ['version', 'steps', '[]'];

const buildViewFilterOperandBinding = (path: string[]): EnumBinding => ({
  path,
  symbol: 'ViewFilterOperand',
  members: ViewFilterOperand,
});

// twenty-sdk/define exports no filter group operator enums, so those stay string literals.
export const WORKFLOW_ENUM_BINDINGS: EnumBinding[] = [
  buildViewFilterOperandBinding([
    'version',
    'trigger',
    'settings',
    'filter',
    'stepFilters',
    '[]',
    'operand',
  ]),
  buildViewFilterOperandBinding([
    ...STEP_PATH,
    'input',
    'stepFilters',
    '[]',
    'operand',
  ]),
  buildViewFilterOperandBinding([
    ...STEP_PATH,
    'input',
    'filter',
    'recordFilters',
    '[]',
    'operand',
  ]),
  {
    path: [...STEP_PATH, 'input', '[]', 'type'],
    symbol: 'FieldType',
    members: FieldMetadataType,
  },
];

const isSamePath = (left: string[], right: string[]): boolean =>
  left.length === right.length &&
  left.every((segment, index) => segment === right[index]);

export const writeDefineFile = ({
  definer,
  config,
  enumBindings = [],
}: {
  definer: string;
  config: unknown;
  enumBindings?: EnumBinding[];
}): { content: string; requiredSdkExports: string[] } => {
  const usedSymbols = new Set<string>();

  const resolveEnumSymbol: EnumSymbolResolver = ({ path, value }) => {
    const binding = enumBindings.find((candidate) =>
      isSamePath(candidate.path, path),
    );

    if (!isDefined(binding)) {
      return undefined;
    }

    const memberName = Object.keys(binding.members).find(
      (key) => binding.members[key] === value,
    );

    if (!isDefined(memberName)) {
      return undefined;
    }

    usedSymbols.add(binding.symbol);

    return `${binding.symbol}.${memberName}`;
  };

  const body = printTypescriptValue({ value: config, resolveEnumSymbol });
  const imported = [definer, ...[...usedSymbols].sort()];
  const singleLineImport = `import { ${imported.join(', ')} } from 'twenty-sdk/define';`;
  const importStatement =
    singleLineImport.length <= MAX_IMPORT_LINE_LENGTH
      ? singleLineImport
      : `import {\n${imported.map((name) => `  ${name},`).join('\n')}\n} from 'twenty-sdk/define';`;

  return {
    content: `${importStatement}

export default ${definer}(${body});
`,
    requiredSdkExports: imported,
  };
};