Improve application ast (#17016)

# Summary

- Introduces a new, flexible folder structure for Twenty SDK
applications using file suffix-based entity detection
- Adds defineApp, defineFunction, defineObject, and defineRole helper
functions with built-in validation
- Refactors manifest loading to use jiti runtime evaluation for
TypeScript config files
- Separates validation logic into dedicated module with comprehensive
error reporting

  # New Application Folder Structure

Applications now use a convention-over-configuration approach where
entities are detected by their file suffix, allowing flexible
organization within the src/app/ folder.

  # Required Structure

    my-app/
    ├── package.json
    ├── yarn.lock
    └── src/
        ├── app/
│ └── application.config.ts # Required - main application configuration
└── utils/ # Optional - handler implementations & utilities

  # Entity Detection by File Suffix

    - *.object.ts - Custom object definitions
    - *.function.ts - Serverless function definitions
    - *.role.ts - Role definitions

  # Supported Folder Organizations

  ## Traditional (by type):
    src/app/
    ├── application.config.ts
    ├── objects/
    │   └── postCard.object.ts
    ├── functions/
    │   └── createPostCard.function.ts
    └── roles/
        └── admin.role.ts

  ## Feature-based:
    src/app/
    ├── application.config.ts
    └── post-card/
        ├── postCard.object.ts
        ├── createPostCard.function.ts
        └── postCardAdmin.role.ts

  ## Flat:
    src/app/
    ├── application.config.ts
    ├── postCard.object.ts
    ├── createPostCard.function.ts
    └── admin.role.ts

  # New Helper Functions

  ## defineApp(config)

    import { defineApp } from 'twenty-sdk';

    export default defineApp({
      universalIdentifier: '4ec0391d-...',
      displayName: 'My App',
      description: 'App description',
      icon: 'IconWorld',
    });

  ## defineObject(config)

    import { defineObject, FieldType } from 'twenty-sdk';

    export default defineObject({
      universalIdentifier: '54b589ca-...',
      nameSingular: 'postCard',
      namePlural: 'postCards',
      labelSingular: 'Post Card',
      labelPlural: 'Post Cards',
      icon: 'IconMail',
      fields: [
        {
          universalIdentifier: '58a0a314-...',
          type: FieldType.TEXT,
          name: 'content',
          label: 'Content',
        },
      ],
    });

  ## defineFunction(config)

    import { defineFunction } from 'twenty-sdk';
    import { myHandler } from '../utils/my-handler';

    export default defineFunction({
      universalIdentifier: 'e56d363b-...',
      name: 'My Function',
      handler: myHandler,
      triggers: [
        {
          universalIdentifier: 'c9f84c8d-...',
          type: 'route',
          path: '/my-route',
          httpMethod: 'POST',
        },
      ],
    });

  ## defineRole(config)

    import { defineRole, PermissionFlag } from 'twenty-sdk';

    export default defineRole({
      universalIdentifier: 'b648f87b-...',
      label: 'App User',
      objectPermissions: [
        {
          objectNameSingular: 'postCard',
          canReadObjectRecords: true,
        },
      ],
      permissionFlags: [PermissionFlag.UPLOAD_FILE],
    });

  # Test plan

    - Verify npx twenty app sync works with new folder structure
    - Verify npx twenty app dev works with new folder structure
    - Verify validation errors display correctly for invalid configs
- Verify all three folder organization styles work (traditional,
feature-based, flat)
    - Run existing E2E tests to ensure backward compatibility

packages/twenty-sdk/src/cli/commands/app-sync.command.ts

@@ -3,7 +3,11 @@ import { CURRENT_EXECUTION_DIRECTORY } from '@/cli/constants/current-execution-d
 import { ApiService } from '@/cli/services/api.service';
 import { GenerateService } from '@/cli/services/generate.service';
 import { type ApiResponse } from '@/cli/types/api-response.types';
+import { ManifestValidationError } from '@/cli/utils/validate-manifest';
+import { displayEntitySummary } from '@/cli/utils/display-entity-summary';
 import { loadManifest } from '@/cli/utils/load-manifest';
+import { displayWarnings } from '@/cli/utils/display-warnings';
+import { displayErrors } from '@/cli/utils/display-errors';
 
 export class AppSyncCommand {
   private apiService = new ApiService();
@@ -28,36 +32,47 @@ export class AppSyncCommand {
   }
 
   private async synchronize({ appPath }: { appPath: string }) {
-    const { manifest, packageJson, yarnLock, shouldGenerate } =
-      await loadManifest(appPath);
+    try {
+      const { manifest, packageJson, yarnLock, shouldGenerate, warnings } =
+        await loadManifest(appPath);
 
-    let serverlessSyncResult = await this.apiService.syncApplication({
-      manifest,
-      packageJson,
-      yarnLock,
-    });
+      displayEntitySummary(manifest);
 
-    if (shouldGenerate) {
-      await this.generateService.generateClient(appPath);
+      displayWarnings(warnings);
 
-      const { manifest: manifestWithClient } = await loadManifest(appPath);
-
-      serverlessSyncResult = await this.apiService.syncApplication({
-        manifest: manifestWithClient,
+      let serverlessSyncResult = await this.apiService.syncApplication({
+        manifest,
         packageJson,
         yarnLock,
       });
-    }
 
-    if (serverlessSyncResult.success === false) {
-      console.error(
-        chalk.red('❌ Serverless functions Sync failed:'),
-        serverlessSyncResult.error,
-      );
-    } else {
-      console.log(chalk.green('✅ Serverless functions synced successfully'));
-    }
+      if (shouldGenerate) {
+        await this.generateService.generateClient(appPath);
 
-    return serverlessSyncResult;
+        const { manifest: manifestWithClient } = await loadManifest(appPath);
+
+        serverlessSyncResult = await this.apiService.syncApplication({
+          manifest: manifestWithClient,
+          packageJson,
+          yarnLock,
+        });
+      }
+
+      if (serverlessSyncResult.success === false) {
+        console.error(
+          chalk.red('❌ Serverless functions Sync failed:'),
+          serverlessSyncResult.error,
+        );
+      } else {
+        console.log(chalk.green('✅ Serverless functions synced successfully'));
+      }
+
+      return serverlessSyncResult;
+    } catch (error) {
+      if (error instanceof ManifestValidationError) {
+        displayErrors(error);
+      }
+      throw error;
+    }
   }
 }