The open alternative to Salesforce, designed for AI.
TypeScript crmcrm-systemcustomergood-first-issuegraphqlhacktoberfestjavascriptmarketingmonoreponestjsopen-sourcepostgresqlreactreactjssalestypescriptweb
import { type TargetFunction } from '@/app/source/extract-define-entity';
import { planPullWrites } from '@/app/pull/plan-pull-writes';
import { preparePullEntities } from '@/app/pull/prepare-pull-entities';
import { type ScannedSourceFile } from '@/app/source/scan-project-source-files';
import {
type Manifest,
type NavigationMenuItemManifest,
type PageLayoutManifest,
type PageLayoutTabManifest,
type StandaloneViewFieldManifest,
type ViewFilterManifest,
type ViewManifest,
} from 'twenty-shared/application';
import { STANDARD_PAGE_LAYOUT_UNIVERSAL_IDENTIFIERS } from 'twenty-shared/metadata';
import {
NavigationMenuItemType,
PageLayoutTabLayoutMode,
PageLayoutType,
WidgetType,
ViewFilterOperand,
} from 'twenty-shared/types';
import { describe, expect, it } from 'vitest';
const planManifestPullWrites = (
options: Parameters<typeof preparePullEntities>[0] & {
workspaceUniversalIdentifiers: ReadonlySet<string>;
},
) => {
const { entities, baseEntities, skipped } = preparePullEntities(options);
return {
...planPullWrites({ ...options, entities, baseEntities }),
skipped,
};
};
const APP_UID = '11111111-1111-4111-8111-111111111111';
const PET_UID = '22222222-2222-4222-8222-222222222222';
const NAME_FIELD_UID = '33333333-3333-4333-8333-333333333333';
const ROCKET_UID = '44444444-4444-4444-8444-444444444444';
const ROCKET_NAME_FIELD_UID = '55555555-5555-4555-8555-555555555555';
const JUNCTION_UID = '66666666-6666-4666-8666-666666666666';
const JUNCTION_ID_FIELD_UID = '77777777-7777-4777-8777-777777777777';
const ALL_PETS_VIEW_UID = '88888888-8888-4888-8888-888888888888';
const HEALTHY_PETS_VIEW_UID = '99999999-9999-4999-8999-999999999999';
const OVERVIEW_VIEW_UID = 'aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa';
const SECOND_OVERVIEW_VIEW_UID = 'bbbbbbbb-bbbb-4bbb-8bbb-bbbbbbbbbbbb';
const THIRD_OVERVIEW_VIEW_UID = 'ffffffff-ffff-4fff-8fff-ffffffffffff';
const HEALTHY_PETS_FILTER_UID = 'cccccccc-cccc-4ccc-8ccc-cccccccccccc';
const PET_NAME_VIEW_FIELD_UID = 'dddddddd-dddd-4ddd-8ddd-dddddddddddd';
const ROCKET_NAME_VIEW_FIELD_UID = 'eeeeeeee-eeee-4eee-8eee-eeeeeeeeeeee';
const PET_PAGE_LAYOUT_UID = '12121212-1212-4121-8121-121212121212';
const ROCKET_PAGE_LAYOUT_UID = '13131313-1313-4131-8131-131313131313';
const SECOND_PET_PAGE_LAYOUT_UID = '14141414-1414-4141-8141-141414141414';
const COMPANY_EXTRA_TAB_UID = '15151515-1515-4151-8151-151515151515';
const PERSON_EXTRA_TAB_UID = '16161616-1616-4161-8161-161616161616';
const DOCS_WIDGET_UID = '17171717-1717-4171-8171-171717171717';
const PET_CARE_FOLDER_NAVIGATION_ITEM_UID =
'18181818-1818-4181-8181-181818181818';
const DAILY_OPS_FOLDER_NAVIGATION_ITEM_UID =
'19191919-1919-4191-8191-191919191919';
const DOCS_NAVIGATION_ITEM_UID = '1a1a1a1a-1a1a-41a1-81a1-1a1a1a1a1a1a';
const SECOND_DOCS_NAVIGATION_ITEM_UID = '1b1b1b1b-1b1b-41b1-81b1-1b1b1b1b1b1b';
const PET_NAVIGATION_ITEM_UID = '1c1c1c1c-1c1c-41c1-81c1-1c1c1c1c1c1c';
const SUPPORT_ROLE_UID = '1d1d1d1d-1d1d-41d1-81d1-1d1d1d1d1d1d';
const buildObject = ({
universalIdentifier,
nameSingular,
labelIdentifierFieldMetadataUniversalIdentifier,
label = 'Name',
}: {
universalIdentifier: string;
nameSingular: string;
labelIdentifierFieldMetadataUniversalIdentifier: string;
label?: string;
}) => ({
universalIdentifier,
nameSingular,
namePlural: `${nameSingular}s`,
labelSingular: nameSingular,
labelPlural: `${nameSingular}s`,
labelIdentifierFieldMetadataUniversalIdentifier,
fields: [
{
universalIdentifier: labelIdentifierFieldMetadataUniversalIdentifier,
name: 'name',
label,
type: 'TEXT',
},
],
});
const buildManifest = (objects: unknown[]): Manifest =>
({
application: {
universalIdentifier: APP_UID,
displayName: 'Pets',
description: '',
defaultRoleUniversalIdentifier: 'role-uid',
},
objects,
fields: [],
indexes: [],
}) as unknown as Manifest;
const MANIFEST = buildManifest([
buildObject({
universalIdentifier: PET_UID,
nameSingular: 'pet',
labelIdentifierFieldMetadataUniversalIdentifier: NAME_FIELD_UID,
}),
]);
const buildView = (
overrides: Partial<ViewManifest> & { universalIdentifier: string },
): ViewManifest => ({
name: 'Overview',
objectUniversalIdentifier: PET_UID,
...overrides,
});
const buildViewField = (
overrides: Partial<StandaloneViewFieldManifest> & {
universalIdentifier: string;
},
): StandaloneViewFieldManifest => ({
viewUniversalIdentifier: OVERVIEW_VIEW_UID,
fieldMetadataUniversalIdentifier: NAME_FIELD_UID,
position: 0,
...overrides,
});
const buildPageLayout = (
overrides: Partial<PageLayoutManifest> & { universalIdentifier: string },
): PageLayoutManifest => ({
name: 'Overview',
type: PageLayoutType.RECORD_PAGE,
objectUniversalIdentifier: PET_UID,
...overrides,
});
const buildPageLayoutTab = (
overrides: Partial<PageLayoutTabManifest> & { universalIdentifier: string },
): PageLayoutTabManifest => ({
pageLayoutUniversalIdentifier:
STANDARD_PAGE_LAYOUT_UNIVERSAL_IDENTIFIERS.companyRecordPage
.universalIdentifier,
title: 'Extra',
position: 60,
layoutMode: PageLayoutTabLayoutMode.VERTICAL_LIST,
...overrides,
});
const buildNavigationMenuItem = (
overrides: Partial<NavigationMenuItemManifest> & {
universalIdentifier: string;
},
): NavigationMenuItemManifest => ({
type: NavigationMenuItemType.LINK,
position: 0,
...overrides,
});
const buildManifestWithDocsPageLayout = (url: string): Manifest => ({
...buildManifest([
buildObject({
universalIdentifier: PET_UID,
nameSingular: 'pet',
labelIdentifierFieldMetadataUniversalIdentifier: NAME_FIELD_UID,
}),
buildObject({
universalIdentifier: ROCKET_UID,
nameSingular: 'rocket',
labelIdentifierFieldMetadataUniversalIdentifier: ROCKET_NAME_FIELD_UID,
}),
]),
pageLayouts: [
buildPageLayout({
universalIdentifier: ROCKET_PAGE_LAYOUT_UID,
name: 'Board',
objectUniversalIdentifier: ROCKET_UID,
}),
buildPageLayout({
universalIdentifier: PET_PAGE_LAYOUT_UID,
tabs: [
{
universalIdentifier: COMPANY_EXTRA_TAB_UID,
title: 'Docs',
position: 0,
layoutMode: PageLayoutTabLayoutMode.VERTICAL_LIST,
widgets: [
{
universalIdentifier: DOCS_WIDGET_UID,
title: 'Docs',
type: WidgetType.IFRAME,
position: {
layoutMode: PageLayoutTabLayoutMode.VERTICAL_LIST,
index: 0,
},
configuration: { configurationType: 'IFRAME', url },
},
],
},
],
}),
],
});
const buildNameFilter = (value: string): ViewFilterManifest => ({
universalIdentifier: HEALTHY_PETS_FILTER_UID,
fieldMetadataUniversalIdentifier: NAME_FIELD_UID,
operand: ViewFilterOperand.IS,
value,
});
const buildManifestWithFilteredView = (filterValue: string): Manifest => ({
...MANIFEST,
views: [
buildView({ universalIdentifier: ALL_PETS_VIEW_UID, name: 'All pets' }),
buildView({
universalIdentifier: HEALTHY_PETS_VIEW_UID,
name: 'Healthy pets',
filters: [buildNameFilter(filterValue)],
}),
],
});
const buildManifestWithNavigationMenu = (link: string): Manifest => ({
...MANIFEST,
navigationMenuItems: [
buildNavigationMenuItem({
universalIdentifier: PET_CARE_FOLDER_NAVIGATION_ITEM_UID,
type: NavigationMenuItemType.FOLDER,
name: 'Pet care',
}),
buildNavigationMenuItem({
universalIdentifier: DOCS_NAVIGATION_ITEM_UID,
name: 'Docs',
link,
position: 1,
folderUniversalIdentifier: PET_CARE_FOLDER_NAVIGATION_ITEM_UID,
}),
],
});
describe('planPullWrites', () => {
it('should write every entity when the project has no source and no base', () => {
const plan = planManifestPullWrites({
manifest: MANIFEST,
baseManifest: null,
workspaceUniversalIdentifiers: new Set(),
scannedFiles: [],
});
expect(plan.writes.map((write) => write.relativePath)).toEqual([
'src/application.config.ts',
'src/objects/pet.object.ts',
]);
expect(plan.writes.every((write) => !write.isRegeneration)).toBe(true);
expect(plan.deletions).toEqual([]);
});
it('should regenerate the application config in the file that already declares one', () => {
const scannedFiles: ScannedSourceFile[] = [
{
relativePath: 'src/application-config.ts',
entityKey: 'application',
targetFunctionName: 'defineApplication',
universalIdentifier: 'a-placeholder-identifier',
isReadable: true,
},
];
const plan = planManifestPullWrites({
workspaceUniversalIdentifiers: new Set(),
manifest: MANIFEST,
baseManifest: null,
scannedFiles,
});
const applicationWrite = plan.writes.find(
(write) => write.kind === 'application',
);
expect(applicationWrite?.relativePath).toBe('src/application-config.ts');
expect(applicationWrite?.isRegeneration).toBe(true);
});
it('should leave a file untouched when its entity has not changed since the base', () => {
const scannedFiles: ScannedSourceFile[] = [
{
relativePath: 'src/application.config.ts',
entityKey: 'application',
targetFunctionName: 'defineApplication',
universalIdentifier: APP_UID,
isReadable: true,
},
{
relativePath: 'src/objects/pet.object.ts',
entityKey: 'objects',
targetFunctionName: 'defineObject',
universalIdentifier: PET_UID,
isReadable: true,
},
];
const plan = planManifestPullWrites({
workspaceUniversalIdentifiers: new Set(),
manifest: MANIFEST,
baseManifest: MANIFEST,
scannedFiles,
});
expect(plan.writes).toEqual([]);
expect(plan.unchanged).toHaveLength(2);
});
it('should rewrite only the entity that changed on the server', () => {
const scannedFiles: ScannedSourceFile[] = [
{
relativePath: 'src/application.config.ts',
entityKey: 'application',
targetFunctionName: 'defineApplication',
universalIdentifier: APP_UID,
isReadable: true,
},
{
relativePath: 'src/objects/pet.object.ts',
entityKey: 'objects',
targetFunctionName: 'defineObject',
universalIdentifier: PET_UID,
isReadable: true,
},
];
const plan = planManifestPullWrites({
workspaceUniversalIdentifiers: new Set(),
manifest: buildManifest([
buildObject({
universalIdentifier: PET_UID,
nameSingular: 'pet',
labelIdentifierFieldMetadataUniversalIdentifier: NAME_FIELD_UID,
label: 'Renamed on the server',
}),
]),
baseManifest: MANIFEST,
scannedFiles,
});
expect(plan.writes.map((write) => write.relativePath)).toEqual([
'src/objects/pet.object.ts',
]);
expect(plan.writes[0].isRegeneration).toBe(true);
expect(plan.writes[0].content).toContain('Renamed on the server');
});
it('should delete the file of an entity the base knew and the workspace no longer has', () => {
const scannedFiles: ScannedSourceFile[] = [
{
relativePath: 'src/objects/rocket.object.ts',
entityKey: 'objects',
targetFunctionName: 'defineObject',
universalIdentifier: ROCKET_UID,
isReadable: true,
},
];
const plan = planManifestPullWrites({
workspaceUniversalIdentifiers: new Set(),
manifest: MANIFEST,
baseManifest: buildManifest([
buildObject({
universalIdentifier: PET_UID,
nameSingular: 'pet',
labelIdentifierFieldMetadataUniversalIdentifier: NAME_FIELD_UID,
}),
buildObject({
universalIdentifier: ROCKET_UID,
nameSingular: 'rocket',
labelIdentifierFieldMetadataUniversalIdentifier:
ROCKET_NAME_FIELD_UID,
}),
]),
scannedFiles,
});
expect(plan.deletions).toEqual([
{
universalIdentifier: ROCKET_UID,
relativePath: 'src/objects/rocket.object.ts',
},
]);
});
it('should report a local entity that neither the workspace nor the base knows', () => {
const scannedFiles: ScannedSourceFile[] = [
{
relativePath: 'src/objects/unpushed.object.ts',
entityKey: 'objects',
targetFunctionName: 'defineObject',
universalIdentifier: 'an-unpushed-identifier',
isReadable: true,
},
];
const plan = planManifestPullWrites({
workspaceUniversalIdentifiers: new Set(),
manifest: MANIFEST,
baseManifest: null,
scannedFiles,
});
expect(plan.localOnlyRelativePaths).toEqual([
'src/objects/unpushed.object.ts',
]);
expect(plan.deletions).toEqual([]);
});
it('should not report a local file as local-only when the export reported its entity', () => {
const scannedFiles: ScannedSourceFile[] = [
{
relativePath: 'src/logic-functions/notify-owner.logic-function.ts',
entityKey: 'logicFunctions',
targetFunctionName: 'defineLogicFunction',
universalIdentifier: 'a-logic-function-the-writer-cannot-write',
isReadable: true,
},
];
const plan = planManifestPullWrites({
workspaceUniversalIdentifiers: new Set([
'a-logic-function-the-writer-cannot-write',
]),
manifest: MANIFEST,
baseManifest: null,
scannedFiles,
});
expect(plan.localOnlyRelativePaths).toEqual([]);
});
it('should place a new entity beside existing files of its kind', () => {
const scannedFiles: ScannedSourceFile[] = [
{
relativePath: 'app/data-model/rocket.object.ts',
entityKey: 'objects',
targetFunctionName: 'defineObject',
universalIdentifier: ROCKET_UID,
isReadable: true,
},
];
const plan = planManifestPullWrites({
workspaceUniversalIdentifiers: new Set(),
manifest: MANIFEST,
baseManifest: null,
scannedFiles,
});
expect(
plan.writes.find((write) => write.kind === 'object')?.relativePath,
).toBe('app/data-model/pet.object.ts');
});
it('should qualify colliding file names with the name of each parent object', () => {
const plan = planManifestPullWrites({
manifest: {
...MANIFEST,
objects: [
buildObject({
universalIdentifier: PET_UID,
nameSingular: 'pet',
labelIdentifierFieldMetadataUniversalIdentifier: NAME_FIELD_UID,
}),
buildObject({
universalIdentifier: ROCKET_UID,
nameSingular: 'rocket',
labelIdentifierFieldMetadataUniversalIdentifier:
ROCKET_NAME_FIELD_UID,
}),
],
fields: [
{
universalIdentifier: 'field-one',
name: 'notes',
label: 'Notes',
type: 'TEXT',
objectUniversalIdentifier: PET_UID,
},
{
universalIdentifier: 'field-two',
name: 'notes',
label: 'Notes',
type: 'TEXT',
objectUniversalIdentifier: ROCKET_UID,
},
],
} as unknown as Manifest,
baseManifest: null,
workspaceUniversalIdentifiers: new Set(),
scannedFiles: [],
});
expect(
plan.writes
.filter((write) => write.kind === 'field')
.map((write) => write.relativePath)
.sort(),
).toEqual([
'src/fields/pet-notes.field.ts',
'src/fields/rocket-notes.field.ts',
]);
});
it('should never write over a file that belongs to another entity', () => {
const plan = planManifestPullWrites({
manifest: MANIFEST,
baseManifest: null,
workspaceUniversalIdentifiers: new Set(),
scannedFiles: [
{
relativePath: 'src/objects/pet.object.ts',
entityKey: 'objects',
targetFunctionName: 'defineObject',
universalIdentifier: 'a-different-identifier',
isReadable: true,
},
],
});
const objectWrite = plan.writes.find((write) => write.kind === 'object');
expect(objectWrite?.relativePath).not.toBe('src/objects/pet.object.ts');
expect(objectWrite?.relativePath).toBe(
`src/objects/${PET_UID.slice(0, 8)}-pet.object.ts`,
);
});
it('should not claim a path that differs only by case', () => {
const plan = planManifestPullWrites({
manifest: MANIFEST,
baseManifest: null,
workspaceUniversalIdentifiers: new Set(),
scannedFiles: [
{
relativePath: 'src/objects/Pet.object.ts',
entityKey: 'objects',
targetFunctionName: 'defineObject',
universalIdentifier: 'a-different-identifier',
isReadable: true,
},
],
});
expect(
plan.writes
.find((write) => write.kind === 'object')
?.relativePath.toLowerCase(),
).not.toBe('src/objects/pet.object.ts');
});
it('should keep a file whose define file could not be read', () => {
const plan = planManifestPullWrites({
manifest: MANIFEST,
baseManifest: null,
workspaceUniversalIdentifiers: new Set(),
scannedFiles: [
{
relativePath: 'src/objects/pet.object.ts',
entityKey: null,
targetFunctionName: null,
universalIdentifier: null,
isReadable: false,
},
],
});
expect(plan.writes.map((write) => write.relativePath)).not.toContain(
'src/objects/pet.object.ts',
);
});
it('should place a new view beside existing view files', () => {
const plan = planManifestPullWrites({
manifest: {
...MANIFEST,
views: [
buildView({ universalIdentifier: OVERVIEW_VIEW_UID }),
buildView({
universalIdentifier: ALL_PETS_VIEW_UID,
name: 'All pets',
}),
],
},
baseManifest: null,
workspaceUniversalIdentifiers: new Set(),
scannedFiles: [
{
relativePath: 'app/screens/overview.view.ts',
entityKey: 'views',
targetFunctionName: 'defineView',
universalIdentifier: OVERVIEW_VIEW_UID,
isReadable: true,
},
],
});
expect(
plan.writes.find(
(write) => write.universalIdentifier === ALL_PETS_VIEW_UID,
)?.relativePath,
).toBe('app/screens/all-pets.view.ts');
});
it('should place a new standalone view field beside existing view field files', () => {
const plan = planManifestPullWrites({
manifest: {
...buildManifest([
buildObject({
universalIdentifier: PET_UID,
nameSingular: 'pet',
labelIdentifierFieldMetadataUniversalIdentifier: NAME_FIELD_UID,
}),
buildObject({
universalIdentifier: ROCKET_UID,
nameSingular: 'rocket',
labelIdentifierFieldMetadataUniversalIdentifier:
ROCKET_NAME_FIELD_UID,
}),
]),
views: [buildView({ universalIdentifier: OVERVIEW_VIEW_UID })],
viewFields: [
buildViewField({
universalIdentifier: ROCKET_NAME_VIEW_FIELD_UID,
fieldMetadataUniversalIdentifier: ROCKET_NAME_FIELD_UID,
}),
buildViewField({ universalIdentifier: PET_NAME_VIEW_FIELD_UID }),
],
},
baseManifest: null,
workspaceUniversalIdentifiers: new Set(),
scannedFiles: [
{
relativePath: 'app/screens/overview.view.ts',
entityKey: 'views',
targetFunctionName: 'defineView',
universalIdentifier: OVERVIEW_VIEW_UID,
isReadable: true,
},
{
relativePath: 'app/screens/columns/rocket-name.view-field.ts',
entityKey: 'viewFields',
targetFunctionName: 'defineViewField',
universalIdentifier: ROCKET_NAME_VIEW_FIELD_UID,
isReadable: true,
},
],
});
expect(
plan.writes.find(
(write) => write.universalIdentifier === PET_NAME_VIEW_FIELD_UID,
)?.relativePath,
).toBe('app/screens/columns/pet-name.view-field.ts');
});
it('should qualify colliding view file names with the kebab-cased name of each object', () => {
const plan = planManifestPullWrites({
manifest: {
...buildManifest([
buildObject({
universalIdentifier: JUNCTION_UID,
nameSingular: 'petCareAgreement',
labelIdentifierFieldMetadataUniversalIdentifier:
JUNCTION_ID_FIELD_UID,
}),
buildObject({
universalIdentifier: ROCKET_UID,
nameSingular: 'rocket',
labelIdentifierFieldMetadataUniversalIdentifier:
ROCKET_NAME_FIELD_UID,
}),
]),
views: [
buildView({
universalIdentifier: OVERVIEW_VIEW_UID,
objectUniversalIdentifier: JUNCTION_UID,
}),
buildView({
universalIdentifier: SECOND_OVERVIEW_VIEW_UID,
objectUniversalIdentifier: ROCKET_UID,
}),
],
},
baseManifest: null,
workspaceUniversalIdentifiers: new Set(),
scannedFiles: [],
});
expect(
plan.writes
.filter((write) => write.kind === 'view')
.map((write) => write.relativePath)
.sort(),
).toEqual([
'src/views/pet-care-agreement-overview.view.ts',
'src/views/rocket-overview.view.ts',
]);
});
it('should fall back to identifier-prefixed names when two views of one object share a name', () => {
const plan = planManifestPullWrites({
manifest: {
...MANIFEST,
views: [
buildView({ universalIdentifier: OVERVIEW_VIEW_UID }),
buildView({ universalIdentifier: SECOND_OVERVIEW_VIEW_UID }),
],
},
baseManifest: null,
workspaceUniversalIdentifiers: new Set(),
scannedFiles: [],
});
expect(
plan.writes
.filter((write) => write.kind === 'view')
.map((write) => write.relativePath)
.sort(),
).toEqual([
`src/views/${OVERVIEW_VIEW_UID.slice(0, 8)}-pet-overview.view.ts`,
`src/views/${SECOND_OVERVIEW_VIEW_UID.slice(0, 8)}-pet-overview.view.ts`,
]);
});
it('should prefix only the views whose qualified names still collide', () => {
const plan = planManifestPullWrites({
manifest: {
...buildManifest([
buildObject({
universalIdentifier: PET_UID,
nameSingular: 'pet',
labelIdentifierFieldMetadataUniversalIdentifier: NAME_FIELD_UID,
}),
buildObject({
universalIdentifier: ROCKET_UID,
nameSingular: 'rocket',
labelIdentifierFieldMetadataUniversalIdentifier:
ROCKET_NAME_FIELD_UID,
}),
]),
views: [
buildView({ universalIdentifier: OVERVIEW_VIEW_UID }),
buildView({ universalIdentifier: SECOND_OVERVIEW_VIEW_UID }),
buildView({
universalIdentifier: THIRD_OVERVIEW_VIEW_UID,
objectUniversalIdentifier: ROCKET_UID,
}),
],
},
baseManifest: null,
workspaceUniversalIdentifiers: new Set(),
scannedFiles: [],
});
expect(
plan.writes
.filter((write) => write.kind === 'view')
.map((write) => write.relativePath)
.sort(),
).toEqual([
`src/views/${OVERVIEW_VIEW_UID.slice(0, 8)}-pet-overview.view.ts`,
`src/views/${SECOND_OVERVIEW_VIEW_UID.slice(0, 8)}-pet-overview.view.ts`,
'src/views/rocket-overview.view.ts',
]);
});
it('should keep a qualified file name within the length cap', () => {
const longName = 'x'.repeat(100);
const plan = planManifestPullWrites({
manifest: {
...buildManifest([
buildObject({
universalIdentifier: PET_UID,
nameSingular: 'pet',
labelIdentifierFieldMetadataUniversalIdentifier: NAME_FIELD_UID,
}),
buildObject({
universalIdentifier: ROCKET_UID,
nameSingular: 'rocket',
labelIdentifierFieldMetadataUniversalIdentifier:
ROCKET_NAME_FIELD_UID,
}),
]),
views: [
buildView({ universalIdentifier: OVERVIEW_VIEW_UID, name: longName }),
buildView({
universalIdentifier: SECOND_OVERVIEW_VIEW_UID,
name: longName,
objectUniversalIdentifier: ROCKET_UID,
}),
],
},
baseManifest: null,
workspaceUniversalIdentifiers: new Set(),
scannedFiles: [],
});
expect(
plan.writes
.filter((write) => write.kind === 'view')
.map((write) => write.relativePath)
.sort(),
).toEqual([
`src/views/pet-${'x'.repeat(76)}.view.ts`,
`src/views/rocket-${'x'.repeat(73)}.view.ts`,
]);
});
it('should leave an unchanged view untouched and regenerate the view whose filter changed on the server', () => {
const scannedFiles: ScannedSourceFile[] = [
{
relativePath: 'src/application.config.ts',
entityKey: 'application',
targetFunctionName: 'defineApplication',
universalIdentifier: APP_UID,
isReadable: true,
},
{
relativePath: 'src/objects/pet.object.ts',
entityKey: 'objects',
targetFunctionName: 'defineObject',
universalIdentifier: PET_UID,
isReadable: true,
},
{
relativePath: 'src/views/all-pets.view.ts',
entityKey: 'views',
targetFunctionName: 'defineView',
universalIdentifier: ALL_PETS_VIEW_UID,
isReadable: true,
},
{
relativePath: 'src/views/healthy-pets.view.ts',
entityKey: 'views',
targetFunctionName: 'defineView',
universalIdentifier: HEALTHY_PETS_VIEW_UID,
isReadable: true,
},
];
const plan = planManifestPullWrites({
workspaceUniversalIdentifiers: new Set(),
manifest: buildManifestWithFilteredView('Max'),
baseManifest: buildManifestWithFilteredView('Rex'),
scannedFiles,
});
expect(
plan.unchanged.map((entity) => entity.universalIdentifier),
).toContain(ALL_PETS_VIEW_UID);
expect(plan.writes.map((write) => write.relativePath)).toEqual([
'src/views/healthy-pets.view.ts',
]);
expect(plan.writes[0].isRegeneration).toBe(true);
expect(plan.writes[0].content).toContain("value: 'Max',");
expect(plan.writes[0].content).toContain('operand: ViewFilterOperand.IS,');
});
it('should place a new page layout beside existing page layout files', () => {
const plan = planManifestPullWrites({
manifest: {
...MANIFEST,
pageLayouts: [
buildPageLayout({ universalIdentifier: ROCKET_PAGE_LAYOUT_UID }),
buildPageLayout({
universalIdentifier: PET_PAGE_LAYOUT_UID,
name: 'Pet page',
}),
],
},
baseManifest: null,
workspaceUniversalIdentifiers: new Set(),
scannedFiles: [
{
relativePath: 'app/screens/overview.page-layout.ts',
entityKey: 'pageLayouts',
targetFunctionName: 'definePageLayout',
universalIdentifier: ROCKET_PAGE_LAYOUT_UID,
isReadable: true,
},
],
});
expect(
plan.writes.find(
(write) => write.universalIdentifier === PET_PAGE_LAYOUT_UID,
)?.relativePath,
).toBe('app/screens/pet-page.page-layout.ts');
});
it('should place a new standalone page layout tab beside existing page layout tab files', () => {
const plan = planManifestPullWrites({
manifest: {
...MANIFEST,
pageLayoutTabs: [
buildPageLayoutTab({ universalIdentifier: COMPANY_EXTRA_TAB_UID }),
buildPageLayoutTab({
universalIdentifier: PERSON_EXTRA_TAB_UID,
pageLayoutUniversalIdentifier:
STANDARD_PAGE_LAYOUT_UNIVERSAL_IDENTIFIERS.personRecordPage
.universalIdentifier,
title: 'Insights',
}),
],
},
baseManifest: null,
workspaceUniversalIdentifiers: new Set(),
scannedFiles: [
{
relativePath: 'app/screens/tabs/extra.page-layout-tab.ts',
entityKey: 'pageLayoutTabs',
targetFunctionName: 'definePageLayoutTab',
universalIdentifier: COMPANY_EXTRA_TAB_UID,
isReadable: true,
},
],
});
expect(
plan.writes.find(
(write) => write.universalIdentifier === PERSON_EXTRA_TAB_UID,
)?.relativePath,
).toBe('app/screens/tabs/insights.page-layout-tab.ts');
});
it('should qualify colliding page layout file names with the kebab-cased name of each object', () => {
const plan = planManifestPullWrites({
manifest: {
...buildManifest([
buildObject({
universalIdentifier: JUNCTION_UID,
nameSingular: 'petCareAgreement',
labelIdentifierFieldMetadataUniversalIdentifier:
JUNCTION_ID_FIELD_UID,
}),
buildObject({
universalIdentifier: ROCKET_UID,
nameSingular: 'rocket',
labelIdentifierFieldMetadataUniversalIdentifier:
ROCKET_NAME_FIELD_UID,
}),
]),
pageLayouts: [
buildPageLayout({
universalIdentifier: PET_PAGE_LAYOUT_UID,
objectUniversalIdentifier: JUNCTION_UID,
}),
buildPageLayout({
universalIdentifier: ROCKET_PAGE_LAYOUT_UID,
objectUniversalIdentifier: ROCKET_UID,
}),
],
},
baseManifest: null,
workspaceUniversalIdentifiers: new Set(),
scannedFiles: [],
});
expect(
plan.writes
.filter((write) => write.kind === 'pageLayout')
.map((write) => write.relativePath)
.sort(),
).toEqual([
'src/page-layouts/pet-care-agreement-overview.page-layout.ts',
'src/page-layouts/rocket-overview.page-layout.ts',
]);
});
it('should qualify colliding standalone tab file names with the kebab-cased name of each page layout', () => {
const plan = planManifestPullWrites({
manifest: {
...MANIFEST,
pageLayoutTabs: [
buildPageLayoutTab({ universalIdentifier: COMPANY_EXTRA_TAB_UID }),
buildPageLayoutTab({
universalIdentifier: PERSON_EXTRA_TAB_UID,
pageLayoutUniversalIdentifier:
STANDARD_PAGE_LAYOUT_UNIVERSAL_IDENTIFIERS.personRecordPage
.universalIdentifier,
}),
],
},
baseManifest: null,
workspaceUniversalIdentifiers: new Set(),
scannedFiles: [],
});
expect(
plan.writes
.filter((write) => write.kind === 'pageLayoutTab')
.map((write) => write.relativePath)
.sort(),
).toEqual([
'src/page-layout-tabs/company-record-page-extra.page-layout-tab.ts',
'src/page-layout-tabs/person-record-page-extra.page-layout-tab.ts',
]);
});
it('should fall back to identifier-prefixed names when two page layouts of one object share a name', () => {
const plan = planManifestPullWrites({
manifest: {
...MANIFEST,
pageLayouts: [
buildPageLayout({ universalIdentifier: PET_PAGE_LAYOUT_UID }),
buildPageLayout({ universalIdentifier: SECOND_PET_PAGE_LAYOUT_UID }),
],
},
baseManifest: null,
workspaceUniversalIdentifiers: new Set(),
scannedFiles: [],
});
expect(
plan.writes
.filter((write) => write.kind === 'pageLayout')
.map((write) => write.relativePath)
.sort(),
).toEqual([
`src/page-layouts/${PET_PAGE_LAYOUT_UID.slice(0, 8)}-pet-overview.page-layout.ts`,
`src/page-layouts/${SECOND_PET_PAGE_LAYOUT_UID.slice(0, 8)}-pet-overview.page-layout.ts`,
]);
});
it('should leave an unchanged page layout untouched and regenerate the page layout whose widget changed on the server', () => {
const scannedFiles: ScannedSourceFile[] = [
{
relativePath: 'src/application.config.ts',
entityKey: 'application',
targetFunctionName: 'defineApplication',
universalIdentifier: APP_UID,
isReadable: true,
},
{
relativePath: 'src/objects/pet.object.ts',
entityKey: 'objects',
targetFunctionName: 'defineObject',
universalIdentifier: PET_UID,
isReadable: true,
},
{
relativePath: 'src/objects/rocket.object.ts',
entityKey: 'objects',
targetFunctionName: 'defineObject',
universalIdentifier: ROCKET_UID,
isReadable: true,
},
{
relativePath: 'src/page-layouts/board.page-layout.ts',
entityKey: 'pageLayouts',
targetFunctionName: 'definePageLayout',
universalIdentifier: ROCKET_PAGE_LAYOUT_UID,
isReadable: true,
},
{
relativePath: 'src/page-layouts/overview.page-layout.ts',
entityKey: 'pageLayouts',
targetFunctionName: 'definePageLayout',
universalIdentifier: PET_PAGE_LAYOUT_UID,
isReadable: true,
},
];
const plan = planManifestPullWrites({
workspaceUniversalIdentifiers: new Set(),
manifest: buildManifestWithDocsPageLayout('https://example.com/new'),
baseManifest: buildManifestWithDocsPageLayout('https://example.com/old'),
scannedFiles,
});
expect(
plan.unchanged.map((entity) => entity.universalIdentifier),
).toContain(ROCKET_PAGE_LAYOUT_UID);
expect(plan.writes.map((write) => write.relativePath)).toEqual([
'src/page-layouts/overview.page-layout.ts',
]);
expect(plan.writes[0].isRegeneration).toBe(true);
expect(plan.writes[0].content).toContain("url: 'https://example.com/new',");
expect(plan.writes[0].content).toContain(
'layoutMode: PageLayoutTabLayoutMode.VERTICAL_LIST,',
);
expect(plan.writes[0].content).toContain('type: WidgetType.IFRAME,');
});
it('should place a new navigation menu item beside existing navigation menu item files', () => {
const plan = planManifestPullWrites({
manifest: {
...MANIFEST,
navigationMenuItems: [
buildNavigationMenuItem({
universalIdentifier: PET_CARE_FOLDER_NAVIGATION_ITEM_UID,
type: NavigationMenuItemType.FOLDER,
name: 'Pet care',
}),
buildNavigationMenuItem({
universalIdentifier: PET_NAVIGATION_ITEM_UID,
type: NavigationMenuItemType.OBJECT,
position: 8,
targetObjectUniversalIdentifier: PET_UID,
folderUniversalIdentifier: PET_CARE_FOLDER_NAVIGATION_ITEM_UID,
}),
],
},
baseManifest: null,
workspaceUniversalIdentifiers: new Set(),
scannedFiles: [
{
relativePath: 'app/navigation/pet-care.navigation-menu-item.ts',
entityKey: 'navigationMenuItems',
targetFunctionName: 'defineNavigationMenuItem',
universalIdentifier: PET_CARE_FOLDER_NAVIGATION_ITEM_UID,
isReadable: true,
},
],
});
expect(
plan.writes.find(
(write) => write.universalIdentifier === PET_NAVIGATION_ITEM_UID,
)?.relativePath,
).toBe('app/navigation/pet.navigation-menu-item.ts');
});
it('should qualify colliding navigation menu item file names with the kebab-cased name of each folder', () => {
const plan = planManifestPullWrites({
manifest: {
...MANIFEST,
navigationMenuItems: [
buildNavigationMenuItem({
universalIdentifier: PET_CARE_FOLDER_NAVIGATION_ITEM_UID,
type: NavigationMenuItemType.FOLDER,
name: 'Pet care',
}),
buildNavigationMenuItem({
universalIdentifier: DAILY_OPS_FOLDER_NAVIGATION_ITEM_UID,
type: NavigationMenuItemType.FOLDER,
name: 'Daily ops',
position: 1,
}),
buildNavigationMenuItem({
universalIdentifier: DOCS_NAVIGATION_ITEM_UID,
name: 'Docs',
link: 'https://example.com/pet-care',
folderUniversalIdentifier: PET_CARE_FOLDER_NAVIGATION_ITEM_UID,
}),
buildNavigationMenuItem({
universalIdentifier: SECOND_DOCS_NAVIGATION_ITEM_UID,
name: 'Docs',
link: 'https://example.com/daily-ops',
folderUniversalIdentifier: DAILY_OPS_FOLDER_NAVIGATION_ITEM_UID,
}),
],
},
baseManifest: null,
workspaceUniversalIdentifiers: new Set(),
scannedFiles: [],
});
expect(
plan.writes.find(
(write) => write.universalIdentifier === DOCS_NAVIGATION_ITEM_UID,
)?.relativePath,
).toBe('src/navigation-menu-items/pet-care-docs.navigation-menu-item.ts');
expect(
plan.writes.find(
(write) =>
write.universalIdentifier === SECOND_DOCS_NAVIGATION_ITEM_UID,
)?.relativePath,
).toBe('src/navigation-menu-items/daily-ops-docs.navigation-menu-item.ts');
expect(
plan.writes.find(
(write) =>
write.universalIdentifier === PET_CARE_FOLDER_NAVIGATION_ITEM_UID,
)?.relativePath,
).toBe('src/navigation-menu-items/pet-care.navigation-menu-item.ts');
expect(
plan.writes.find(
(write) =>
write.universalIdentifier === DAILY_OPS_FOLDER_NAVIGATION_ITEM_UID,
)?.relativePath,
).toBe('src/navigation-menu-items/daily-ops.navigation-menu-item.ts');
});
it('should fall back to identifier-prefixed names when two navigation menu items outside any folder share a name', () => {
const plan = planManifestPullWrites({
manifest: {
...MANIFEST,
navigationMenuItems: [
buildNavigationMenuItem({
universalIdentifier: DOCS_NAVIGATION_ITEM_UID,
name: 'Docs',
link: 'https://example.com/pet-care',
}),
buildNavigationMenuItem({
universalIdentifier: SECOND_DOCS_NAVIGATION_ITEM_UID,
name: 'Docs',
link: 'https://example.com/daily-ops',
position: 1,
}),
],
},
baseManifest: null,
workspaceUniversalIdentifiers: new Set(),
scannedFiles: [],
});
expect(
plan.writes
.filter((write) => write.kind === 'navigationMenuItem')
.map((write) => write.relativePath)
.sort(),
).toEqual([
`src/navigation-menu-items/${DOCS_NAVIGATION_ITEM_UID.slice(0, 8)}-docs.navigation-menu-item.ts`,
`src/navigation-menu-items/${SECOND_DOCS_NAVIGATION_ITEM_UID.slice(0, 8)}-docs.navigation-menu-item.ts`,
]);
});
it('should leave an unchanged navigation menu item untouched and regenerate the item whose link changed on the server', () => {
const scannedFiles: ScannedSourceFile[] = [
{
relativePath: 'src/application.config.ts',
entityKey: 'application',
targetFunctionName: 'defineApplication',
universalIdentifier: APP_UID,
isReadable: true,
},
{
relativePath: 'src/objects/pet.object.ts',
entityKey: 'objects',
targetFunctionName: 'defineObject',
universalIdentifier: PET_UID,
isReadable: true,
},
{
relativePath:
'src/navigation-menu-items/pet-care.navigation-menu-item.ts',
entityKey: 'navigationMenuItems',
targetFunctionName: 'defineNavigationMenuItem',
universalIdentifier: PET_CARE_FOLDER_NAVIGATION_ITEM_UID,
isReadable: true,
},
{
relativePath: 'src/navigation-menu-items/docs.navigation-menu-item.ts',
entityKey: 'navigationMenuItems',
targetFunctionName: 'defineNavigationMenuItem',
universalIdentifier: DOCS_NAVIGATION_ITEM_UID,
isReadable: true,
},
];
const plan = planManifestPullWrites({
workspaceUniversalIdentifiers: new Set(),
manifest: buildManifestWithNavigationMenu('https://example.com/new'),
baseManifest: buildManifestWithNavigationMenu('https://example.com/old'),
scannedFiles,
});
expect(
plan.unchanged.map((entity) => entity.universalIdentifier),
).toContain(PET_CARE_FOLDER_NAVIGATION_ITEM_UID);
expect(plan.writes.map((write) => write.relativePath)).toEqual([
'src/navigation-menu-items/docs.navigation-menu-item.ts',
]);
expect(plan.writes[0].isRegeneration).toBe(true);
expect(plan.writes[0].content).toContain(
"link: 'https://example.com/new',",
);
expect(plan.writes[0].content).toContain(
'type: NavigationMenuItemType.LINK,',
);
});
const planWithDefaultRoleFile = (
roleFileTargetFunctionName: TargetFunction,
) => {
const manifestWithDefaultRole = {
...MANIFEST,
application: {
...MANIFEST.application,
defaultRoleUniversalIdentifier: SUPPORT_ROLE_UID,
},
roles: [{ universalIdentifier: SUPPORT_ROLE_UID, label: 'Support' }],
} as unknown as Manifest;
const scannedFiles: ScannedSourceFile[] = [
{
relativePath: 'src/application.config.ts',
entityKey: 'application',
targetFunctionName: 'defineApplication',
universalIdentifier: APP_UID,
isReadable: true,
},
{
relativePath: 'src/objects/pet.object.ts',
entityKey: 'objects',
targetFunctionName: 'defineObject',
universalIdentifier: PET_UID,
isReadable: true,
},
{
relativePath: 'src/default-role.ts',
entityKey: 'roles',
targetFunctionName: roleFileTargetFunctionName,
universalIdentifier: SUPPORT_ROLE_UID,
isReadable: true,
},
];
return planManifestPullWrites({
workspaceUniversalIdentifiers: new Set(),
manifest: manifestWithDefaultRole,
baseManifest: manifestWithDefaultRole,
scannedFiles,
});
};
it('should regenerate a file whose define function differs from the one pull writes, even when its entity did not change', () => {
const plan = planWithDefaultRoleFile('defineRole');
expect(plan.writes.map((write) => write.relativePath)).toEqual([
'src/default-role.ts',
]);
expect(plan.writes[0].isRegeneration).toBe(true);
expect(plan.writes[0].content).toContain(
'export default defineApplicationRole({',
);
expect(plan.unchanged).toHaveLength(2);
});
it('should leave a default role file written with defineApplicationRole untouched when its role did not change', () => {
const plan = planWithDefaultRoleFile('defineApplicationRole');
expect(plan.writes).toEqual([]);
expect(plan.unchanged).toHaveLength(3);
});
it('repairs a duplicated inline view field without rewriting its standalone definition', () => {
const viewField = buildViewField({
universalIdentifier: PET_NAME_VIEW_FIELD_UID,
});
const view = buildView({
universalIdentifier: OVERVIEW_VIEW_UID,
fields: [],
});
const manifest = { ...MANIFEST, views: [view], viewFields: [viewField] };
const scannedFiles: ScannedSourceFile[] = [
{
relativePath: 'src/application.config.ts',
entityKey: 'application',
targetFunctionName: 'defineApplication',
universalIdentifier: APP_UID,
isReadable: true,
},
{
relativePath: 'src/objects/pet.object.ts',
entityKey: 'objects',
targetFunctionName: 'defineObject',
universalIdentifier: PET_UID,
isReadable: true,
},
{
relativePath: 'src/views/overview.ts',
entityKey: 'views',
targetFunctionName: 'defineView',
universalIdentifier: OVERVIEW_VIEW_UID,
isReadable: true,
config: { ...view, fields: [viewField] },
},
{
relativePath: 'src/view-fields/name.ts',
entityKey: 'viewFields',
targetFunctionName: 'defineViewField',
universalIdentifier: PET_NAME_VIEW_FIELD_UID,
isReadable: true,
config: viewField,
},
];
const plan = planManifestPullWrites({
manifest,
baseManifest: manifest,
scannedFiles,
workspaceUniversalIdentifiers: new Set(),
});
expect(plan.writes.map(({ relativePath }) => relativePath)).toEqual([
'src/views/overview.ts',
]);
expect(plan.writes[0].content).not.toContain(PET_NAME_VIEW_FIELD_UID);
expect(plan.unchanged).toContainEqual(
expect.objectContaining({ universalIdentifier: PET_NAME_VIEW_FIELD_UID }),
);
expect(plan.deletions).toEqual([]);
});
});