Skip to content

The open alternative to Salesforce, designed for AI.

15.0 KB
Raw Blame
import {
  FIELD_ENUM_BINDINGS,
  INDEX_ENUM_BINDINGS,
  NAVIGATION_MENU_ITEM_ENUM_BINDINGS,
  PAGE_LAYOUT_WIDGET_ENUM_BINDINGS,
  OBJECT_ENUM_BINDINGS,
  PAGE_LAYOUT_ENUM_BINDINGS,
  PAGE_LAYOUT_TAB_ENUM_BINDINGS,
  VIEW_ENUM_BINDINGS,
  VIEW_FIELD_ENUM_BINDINGS,
  WORKFLOW_ENUM_BINDINGS,
  buildRoleEnumBindings,
  type EnumBinding,
} from '@/app/pull/write-define-file';
import {
  buildIndexFileBaseName,
  buildViewFieldFileBaseName,
  type FieldLocation,
  toFileBaseName,
} from '@/app/pull/pull-file-base-name';
import { stripGraphqlTypename } from '@/app/pull/strip-graphql-typename';
import { kebabCase } from '@/app/pull/kebab-case';
import { type Manifest } from 'twenty-shared/application';
import { SystemPermissionFlag } from 'twenty-shared/constants';
import { fromApplicationManifestToApplicationConfig } from '@/app/pull/from-application-manifest-to-application-config';
import { fromRoleManifestToRoleConfig } from '@/app/pull/from-role-manifest-to-role-config';
import { buildPullFieldFileName } from '@/app/pull/build-pull-field-file-name';
import { buildPullNavigationMenuItemFileName } from '@/app/pull/build-pull-navigation-menu-item-file-name';
import { getObjectNameForPullFile } from '@/app/pull/get-object-name-for-pull-file';
import { getPageLayoutNameForPullFile } from '@/app/pull/get-page-layout-name-for-pull-file';
import { getNavigationFolderNameForPullFile } from '@/app/pull/get-navigation-folder-name-for-pull-file';
import { isDefined } from 'twenty-shared/utils';
import { type ScannedSourceFile } from '@/app/source/scan-project-source-files';

export const PULL_ENTITY_KINDS = [
  'application',
  'object',
  'field',
  'index',
  'permissionFlag',
  'role',
  'view',
  'viewField',
  'pageLayout',
  'pageLayoutTab',
  'navigationMenuItem',
  'pageLayoutWidget',
  'workflow',
  'skill',
  'agent',
  'validationRule',
  'relatedRecordPath',
] as const;

export type PullEntityKind = (typeof PULL_ENTITY_KINDS)[number];

export type PullEntity = {
  kind: PullEntityKind;
  universalIdentifier: string;
  definer: string;
  config: unknown;
  enumBindings: EnumBinding[];
  defaultFolder: string;
  fileSuffix: string;
  fileBaseName: string;
  parentName: string | null;
};

export type SkippedPullEntity = {
  kind: PullEntityKind;
  universalIdentifier: string;
  reason: string;
};

export const buildPullEntities = ({
  manifest,
  sourceFileByUniversalIdentifier = new Map(),
  systemPermissionFlag = SystemPermissionFlag,
}: {
  manifest: Manifest;
  sourceFileByUniversalIdentifier?: ReadonlyMap<string, ScannedSourceFile>;
  systemPermissionFlag?: Record<string, string>;
}): { entities: PullEntity[]; skipped: SkippedPullEntity[] } => {
  const applicationUniversalIdentifier =
    manifest.application.universalIdentifier;
  const entities: PullEntity[] = [];
  const skipped: SkippedPullEntity[] = [];

  entities.push({
    kind: 'application',
    universalIdentifier: applicationUniversalIdentifier,
    definer: 'defineApplication',
    config: fromApplicationManifestToApplicationConfig(manifest),
    enumBindings: [],
    defaultFolder: 'src',
    fileSuffix: '.config.ts',
    fileBaseName: 'application',
    parentName: null,
  });

  const writtenObjectUniversalIdentifiers = new Set<string>();
  const fieldLocationByUniversalIdentifier = new Map<string, FieldLocation>();
  const standaloneFields = [...(manifest.fields ?? [])];

  for (const objectManifest of manifest.objects ?? []) {
    const inlineFields = [];

    for (const field of objectManifest.fields ?? []) {
      fieldLocationByUniversalIdentifier.set(field.universalIdentifier, {
        objectName: objectManifest.nameSingular,
        fieldName: field.name,
      });
      if (
        sourceFileByUniversalIdentifier.get(
          field.universalIdentifier.toLowerCase(),
        )?.entityKey === 'fields'
      ) {
        standaloneFields.push({
          ...field,
          objectUniversalIdentifier: objectManifest.universalIdentifier,
        });
      } else {
        inlineFields.push(field);
      }
    }

    writtenObjectUniversalIdentifiers.add(objectManifest.universalIdentifier);

    entities.push({
      kind: 'object',
      universalIdentifier: objectManifest.universalIdentifier,
      definer: 'defineObject',
      config: { ...objectManifest, fields: inlineFields },
      enumBindings: OBJECT_ENUM_BINDINGS,
      defaultFolder: 'src/objects',
      fileSuffix: '.object.ts',
      fileBaseName: kebabCase(objectManifest.nameSingular),
      parentName: null,
    });
  }

  for (const fieldManifest of standaloneFields) {
    const objectName = getObjectNameForPullFile({
      objectUniversalIdentifier: fieldManifest.objectUniversalIdentifier,
      manifest,
    });

    fieldLocationByUniversalIdentifier.set(fieldManifest.universalIdentifier, {
      objectName,
      fieldName: fieldManifest.name,
    });

    entities.push({
      kind: 'field',
      universalIdentifier: fieldManifest.universalIdentifier,
      definer: 'defineField',
      config: fieldManifest,
      enumBindings: FIELD_ENUM_BINDINGS,
      defaultFolder: 'src/fields',
      fileSuffix: '.field.ts',
      fileBaseName: buildPullFieldFileName({
        objectName,
        fieldName: fieldManifest.name,
        fieldUniversalIdentifier: fieldManifest.universalIdentifier,
      }),
      parentName: objectName,
    });
  }

  for (const indexManifest of manifest.indexes ?? []) {
    if (
      !writtenObjectUniversalIdentifiers.has(
        indexManifest.objectUniversalIdentifier,
      )
    ) {
      skipped.push({
        kind: 'index',
        universalIdentifier: indexManifest.universalIdentifier,
        reason: 'its object is not part of the written source',
      });
      continue;
    }

    const objectName = getObjectNameForPullFile({
      objectUniversalIdentifier: indexManifest.objectUniversalIdentifier,
      manifest,
    });

    entities.push({
      kind: 'index',
      universalIdentifier: indexManifest.universalIdentifier,
      definer: 'defineIndex',
      config: indexManifest,
      enumBindings: INDEX_ENUM_BINDINGS,
      defaultFolder: 'src/indexes',
      fileSuffix: '.index.ts',
      fileBaseName: buildIndexFileBaseName({
        indexManifest,
        objectName,
        fieldLocationByUniversalIdentifier,
      }),
      parentName: objectName,
    });
  }

  for (const validationRuleManifest of manifest.validationRules ?? []) {
    entities.push({
      kind: 'validationRule',
      universalIdentifier: validationRuleManifest.universalIdentifier,
      definer: 'defineValidationRule',
      config: validationRuleManifest,
      enumBindings: [],
      defaultFolder: 'src/validation-rules',
      fileSuffix: '.validation-rule.ts',
      fileBaseName: toFileBaseName({
        segments: [validationRuleManifest.name],
        universalIdentifier: validationRuleManifest.universalIdentifier,
      }),
      parentName: getObjectNameForPullFile({
        objectUniversalIdentifier:
          validationRuleManifest.objectUniversalIdentifier,
        manifest,
      }),
    });
  }

  for (const permissionFlagManifest of manifest.permissionFlags ?? []) {
    entities.push({
      kind: 'permissionFlag',
      universalIdentifier: permissionFlagManifest.universalIdentifier,
      definer: 'definePermissionFlag',
      config: permissionFlagManifest,
      enumBindings: [],
      defaultFolder: 'src/permission-flags',
      fileSuffix: '.permission-flag.ts',
      fileBaseName: toFileBaseName({
        segments: [permissionFlagManifest.key],
        universalIdentifier: permissionFlagManifest.universalIdentifier,
      }),
      parentName: null,
    });
  }

  for (const roleManifest of manifest.roles ?? []) {
    entities.push({
      kind: 'role',
      universalIdentifier: roleManifest.universalIdentifier,
      definer:
        roleManifest.universalIdentifier ===
        manifest.application.defaultRoleUniversalIdentifier
          ? 'defineApplicationRole'
          : 'defineRole',
      config: fromRoleManifestToRoleConfig({
        roleManifest,
        applicationUniversalIdentifier,
      }),
      enumBindings: buildRoleEnumBindings(systemPermissionFlag),
      defaultFolder: 'src/roles',
      fileSuffix: '.role.ts',
      fileBaseName: toFileBaseName({
        segments: [roleManifest.label],
        universalIdentifier: roleManifest.universalIdentifier,
      }),
      parentName: null,
    });
  }

  for (const viewManifest of manifest.views ?? []) {
    entities.push({
      kind: 'view',
      universalIdentifier: viewManifest.universalIdentifier,
      definer: 'defineView',
      config: viewManifest,
      enumBindings: VIEW_ENUM_BINDINGS,
      defaultFolder: 'src/views',
      fileSuffix: '.view.ts',
      fileBaseName: toFileBaseName({
        segments: [viewManifest.name],
        universalIdentifier: viewManifest.universalIdentifier,
      }),
      parentName: getObjectNameForPullFile({
        objectUniversalIdentifier: viewManifest.objectUniversalIdentifier,
        manifest,
      }),
    });
  }

  for (const viewFieldManifest of manifest.viewFields ?? []) {
    entities.push({
      kind: 'viewField',
      universalIdentifier: viewFieldManifest.universalIdentifier,
      definer: 'defineViewField',
      config: viewFieldManifest,
      enumBindings: VIEW_FIELD_ENUM_BINDINGS,
      defaultFolder: 'src/view-fields',
      fileSuffix: '.view-field.ts',
      fileBaseName: buildViewFieldFileBaseName({
        viewFieldManifest,
        fieldLocationByUniversalIdentifier,
      }),
      parentName: null,
    });
  }

  for (const pageLayoutManifest of manifest.pageLayouts ?? []) {
    entities.push({
      kind: 'pageLayout',
      universalIdentifier: pageLayoutManifest.universalIdentifier,
      definer: 'definePageLayout',
      config: stripGraphqlTypename(pageLayoutManifest),
      enumBindings: PAGE_LAYOUT_ENUM_BINDINGS,
      defaultFolder: 'src/page-layouts',
      fileSuffix: '.page-layout.ts',
      fileBaseName: toFileBaseName({
        segments: [pageLayoutManifest.name],
        universalIdentifier: pageLayoutManifest.universalIdentifier,
      }),
      parentName: isDefined(pageLayoutManifest.objectUniversalIdentifier)
        ? getObjectNameForPullFile({
            objectUniversalIdentifier:
              pageLayoutManifest.objectUniversalIdentifier,
            manifest,
          })
        : null,
    });
  }

  for (const pageLayoutTabManifest of manifest.pageLayoutTabs ?? []) {
    const { pageLayoutUniversalIdentifier } = pageLayoutTabManifest;

    if (!isDefined(pageLayoutUniversalIdentifier)) {
      skipped.push({
        kind: 'pageLayoutTab',
        universalIdentifier: pageLayoutTabManifest.universalIdentifier,
        reason: 'it does not name the page layout it belongs to',
      });
      continue;
    }

    entities.push({
      kind: 'pageLayoutTab',
      universalIdentifier: pageLayoutTabManifest.universalIdentifier,
      definer: 'definePageLayoutTab',
      config: stripGraphqlTypename(pageLayoutTabManifest),
      enumBindings: PAGE_LAYOUT_TAB_ENUM_BINDINGS,
      defaultFolder: 'src/page-layout-tabs',
      fileSuffix: '.page-layout-tab.ts',
      fileBaseName: toFileBaseName({
        segments: [pageLayoutTabManifest.title],
        universalIdentifier: pageLayoutTabManifest.universalIdentifier,
      }),
      parentName: getPageLayoutNameForPullFile({
        pageLayoutUniversalIdentifier,
        manifest,
      }),
    });
  }

  for (const navigationMenuItemManifest of manifest.navigationMenuItems ?? []) {
    const { folderUniversalIdentifier } = navigationMenuItemManifest;

    entities.push({
      kind: 'navigationMenuItem',
      universalIdentifier: navigationMenuItemManifest.universalIdentifier,
      definer: 'defineNavigationMenuItem',
      config: navigationMenuItemManifest,
      enumBindings: NAVIGATION_MENU_ITEM_ENUM_BINDINGS,
      defaultFolder: 'src/navigation-menu-items',
      fileSuffix: '.navigation-menu-item.ts',
      fileBaseName: buildPullNavigationMenuItemFileName({
        navigationMenuItemManifest,
        manifest,
      }),
      parentName: isDefined(folderUniversalIdentifier)
        ? getNavigationFolderNameForPullFile({
            folderUniversalIdentifier,
            manifest,
          })
        : null,
    });
  }

  for (const pageLayoutWidgetManifest of manifest.pageLayoutWidgets ?? []) {
    const { objectUniversalIdentifier } = pageLayoutWidgetManifest;

    entities.push({
      kind: 'pageLayoutWidget',
      universalIdentifier: pageLayoutWidgetManifest.universalIdentifier,
      definer: 'definePageLayoutWidget',
      config: stripGraphqlTypename(pageLayoutWidgetManifest),
      enumBindings: PAGE_LAYOUT_WIDGET_ENUM_BINDINGS,
      defaultFolder: 'src/page-layout-widgets',
      fileSuffix: '.page-layout-widget.ts',
      fileBaseName: toFileBaseName({
        segments: [pageLayoutWidgetManifest.title],
        universalIdentifier: pageLayoutWidgetManifest.universalIdentifier,
      }),
      parentName: isDefined(objectUniversalIdentifier)
        ? getObjectNameForPullFile({ objectUniversalIdentifier, manifest })
        : null,
    });
  }

  for (const workflowManifest of manifest.workflows ?? []) {
    entities.push({
      kind: 'workflow',
      universalIdentifier: workflowManifest.universalIdentifier,
      definer: 'defineWorkflow',
      config: workflowManifest,
      enumBindings: WORKFLOW_ENUM_BINDINGS,
      defaultFolder: 'src/workflows',
      fileSuffix: '.workflow.ts',
      fileBaseName: toFileBaseName({
        segments: [workflowManifest.name],
        universalIdentifier: workflowManifest.universalIdentifier,
      }),
      parentName: null,
    });
  }

  for (const skillManifest of manifest.skills ?? []) {
    entities.push({
      kind: 'skill',
      universalIdentifier: skillManifest.universalIdentifier,
      definer: 'defineSkill',
      config: skillManifest,
      enumBindings: [],
      defaultFolder: 'src/skills',
      fileSuffix: '.skill.ts',
      fileBaseName: toFileBaseName({
        segments: [skillManifest.name],
        universalIdentifier: skillManifest.universalIdentifier,
      }),
      parentName: null,
    });
  }

  for (const relatedRecordPathManifest of manifest.relatedRecordPaths ?? []) {
    entities.push({
      kind: 'relatedRecordPath',
      universalIdentifier: relatedRecordPathManifest.universalIdentifier,
      definer: 'defineRelatedRecordPath',
      config: relatedRecordPathManifest,
      enumBindings: [],
      defaultFolder: 'src/related-record-paths',
      fileSuffix: '.related-record-path.ts',
      fileBaseName: toFileBaseName({
        segments: [],
        universalIdentifier: relatedRecordPathManifest.universalIdentifier,
      }),
      parentName: null,
    });
  }

  for (const agentManifest of manifest.agents ?? []) {
    entities.push({
      kind: 'agent',
      universalIdentifier: agentManifest.universalIdentifier,
      definer: 'defineAgent',
      config: agentManifest,
      enumBindings: [],
      defaultFolder: 'src/agents',
      fileSuffix: '.agent.ts',
      fileBaseName: toFileBaseName({
        segments: [agentManifest.name],
        universalIdentifier: agentManifest.universalIdentifier,
      }),
      parentName: null,
    });
  }

  return { entities, skipped };
};