1751 extensibility twenty sdk v2 use twenty sdk to define a serverless function trigger (#15347)

This PR adds 2 columns handlerPath and handlerName in serverlessFunction
to locate the entrypoint of a serverless in a codebase

It adds the following decorators in twenty-sdk:
- ServerlessFunction
- DatabaseEventTrigger
- RouteTrigger
- CronTrigger
- ApplicationVariable

It still supports deprecated entity.manifest.jsonc 

Overall code needs to be cleaned a little bit, but it should work
properly so you can try to test if the DEVX fits your needs

See updates in hello-world application

```typescript
import axios from 'axios';
import {
  DatabaseEventTrigger,
  ServerlessFunction,
  RouteTrigger,
  CronTrigger,
  ApplicationVariable,
} from 'twenty-sdk';

@ApplicationVariable({
  universalIdentifier: 'dedc53eb-9c12-4fe2-ba86-4a2add19d305',
  key: 'TWENTY_API_KEY',
  description: 'Twenty API Key',
  isSecret: true,
})
@DatabaseEventTrigger({
  universalIdentifier: '203f1df3-4a82-4d06-a001-b8cf22a31156',
  eventName: 'person.created',
})
@RouteTrigger({
  universalIdentifier: 'c9f84c8d-b26d-40d1-95dd-4f834ae5a2c6',
  path: '/post-card/create',
  httpMethod: 'GET',
  isAuthRequired: false,
})
@CronTrigger({
  universalIdentifier: 'dd802808-0695-49e1-98c9-d5c9e2704ce2',
  pattern: '0 0 1 1 *', // Every year 1st of January
})
@ServerlessFunction({
  universalIdentifier: 'e56d363b-0bdc-4d8a-a393-6f0d1c75bdcf',
})
class CreateNewPostCard {
  main = async (params: { recipient: string }): Promise<string> => {
    const { recipient } = params;

    const options = {
      method: 'POST',
      url: 'http://localhost:3000/rest/postCards',
      headers: {
        'Content-Type': 'application/json',
        Authorization: `Bearer ${process.env.TWENTY_API_KEY}`,
      },
      data: { name: recipient ?? 'Unknown' },
    };

    try {
      const { data } = await axios.request(options);

      console.log(`New post card to "${recipient}" created`);

      return data;
    } catch (error) {
      console.error(error);
      throw error;
    }
  };
}

export const createNewPostCardHandler = new CreateNewPostCard().main;

```


### [edit] V2 

After the v1 proposal, I see that using a class method to define the
serverless function handler is pretty confusing. Lets leave
serverlessFunction configuration decorators on the class, but move the
handler like before. Here is the v2 hello-world serverless function:

```typescript
import axios from 'axios';
import {
  DatabaseEventTrigger,
  ServerlessFunction,
  RouteTrigger,
  CronTrigger,
  ApplicationVariable,
} from 'twenty-sdk';

@ApplicationVariable({
  universalIdentifier: 'dedc53eb-9c12-4fe2-ba86-4a2add19d305',
  key: 'TWENTY_API_KEY',
  description: 'Twenty API Key',
  isSecret: true,
})
@DatabaseEventTrigger({
  universalIdentifier: '203f1df3-4a82-4d06-a001-b8cf22a31156',
  eventName: 'person.created',
})
@RouteTrigger({
  universalIdentifier: 'c9f84c8d-b26d-40d1-95dd-4f834ae5a2c6',
  path: '/post-card/create',
  httpMethod: 'GET',
  isAuthRequired: false,
})
@CronTrigger({
  universalIdentifier: 'dd802808-0695-49e1-98c9-d5c9e2704ce2',
  pattern: '0 0 1 1 *', // Every year 1st of January
})
@ServerlessFunction({
  universalIdentifier: 'e56d363b-0bdc-4d8a-a393-6f0d1c75bdcf',
})
export class ServerlessFunctionDefinition {}

export const main = async (params: { recipient: string }): Promise<string> => {
  const { recipient } = params;

  const options = {
    method: 'POST',
    url: 'http://localhost:3000/rest/postCards',
    headers: {
      'Content-Type': 'application/json',
      Authorization: `Bearer ${process.env.TWENTY_API_KEY}`,
    },
    data: { name: recipient ?? 'Unknown' },
  };

  try {
    const { data } = await axios.request(options);

    console.log(`New post card to "${recipient}" created`);

    return data;
  } catch (error) {
    console.error(error);
    throw error;
  }
};

```


### [edit] V3

After the v2 proposal, we don't really like decorators on empty classes.
We decided to go with a Vercel approach with a config constant

```typescript
import axios from 'axios';
import { ServerlessFunctionConfig } from 'twenty-sdk';

export const main = async (params: { recipient: string }): Promise<string> => {
  const { recipient } = params;

  const options = {
    method: 'POST',
    url: 'http://localhost:3000/rest/postCards',
    headers: {
      'Content-Type': 'application/json',
      Authorization: `Bearer ${process.env.TWENTY_API_KEY}`,
    },
    data: { name: recipient ?? 'Unknown' },
  };

  try {
    const { data } = await axios.request(options);

    console.log(`New post card to "${recipient}" created`);

    return data;
  } catch (error) {
    console.error(error);
    throw error;
  }
};

export const config: ServerlessFunctionConfig = {
  universalIdentifier: 'e56d363b-0bdc-4d8a-a393-6f0d1c75bdcf',
  routeTriggers: [
  {
    universalIdentifier: 'c9f84c8d-b26d-40d1-95dd-4f834ae5a2c6',
    path: '/post-card/create',
    httpMethod: 'GET',
    isAuthRequired: false,
  }
  ],
  cronTriggers: [
    {
      universalIdentifier: 'dd802808-0695-49e1-98c9-d5c9e2704ce2',
      pattern: '0 0 1 1 *', // Every year 1st of January
    }
  ],
  databaseEventTriggers: [
  {
    universalIdentifier: '203f1df3-4a82-4d06-a001-b8cf22a31156',
    eventName: 'person.created',
   }
  ]
}

```

packages/twenty-cli/src/utils/__tests__/get-decorated-class.spec.ts

@@ -1,13 +1,13 @@
-import { getDecoratedClass } from '../../utils/get-decorated-class';
+import { getObjectMetadataDecoratedClass } from '../../utils/get-object-metadata-decorated-class';
 
 describe('getDecoratedClass', () => {
   it('should return properly formatted class', () => {
-    const result = getDecoratedClass({
+    const result = getObjectMetadataDecoratedClass({
       data: { nameSingular: 'Name', namePlural: 'Names' },
       name: 'MyNewObject',
     });
 
-    const expectedResult = `import { ObjectMetadata } from 'twenty-sdk';
+    const expectedResult = `import { ObjectMetadata } from 'twenty-sdk/application';
 
 @ObjectMetadata({
   nameSingular: 'Name',

packages/twenty-cli/src/utils/__tests__/load-manifest.spec.ts

@@ -0,0 +1,276 @@
+import { tmpdir } from 'node:os';
+import { join, resolve } from 'node:path';
+import { ensureDirSync, writeFileSync, removeSync } from 'fs-extra';
+import { copyBaseApplicationProject } from '../app-template';
+import { loadManifest } from '../load-manifest';
+
+const write = (root: string, file: string, content: string) => {
+  const abs = join(root, file);
+  ensureDirSync(resolve(abs, '..'));
+  writeFileSync(abs, content, 'utf8');
+};
+
+const tsLibMock = `declare module 'tslib' {
+   export const __decorate: any;
+   export const __metadata: any;
+   export const __param: any;
+   export const __awaiter: any;
+   export const __read: any;
+   export const __spread: any;
+   export const __spreadArray: any;
+   export const __assign: any;
+ }`;
+const twentySdkTypesMock = `
+declare module 'twenty-sdk/application' {
+  export type SyncableEntityOptions = { universalIdentifier: string };
+  
+  type ApplicationVariable = SyncableEntityOptions & {
+    value?: string;
+    description?: string;
+    isSecret?: boolean;
+  };
+  
+  export type ApplicationConfig = SyncableEntityOptions & {
+    displayName?: string;
+    description?: string;
+    icon?: string;
+    applicationVariables?: Record<string, ApplicationVariable>;
+  };
+
+  type RouteTrigger = {
+    type: 'route';
+    path: string;
+    httpMethod: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+    isAuthRequired: boolean;
+  };
+  
+  type CronTrigger = {
+    type: 'cron';
+    pattern: string;
+  };
+  
+  type DatabaseEventTrigger = {
+    type: 'databaseEvent';
+    eventName: string;
+  };
+  
+  type ServerlessFunctionTrigger = SyncableEntityOptions &
+    (RouteTrigger | CronTrigger | DatabaseEventTrigger);
+  
+  export type ServerlessFunctionConfig = SyncableEntityOptions & {
+    name?: string;
+    description?: string;
+    timeoutSeconds?: number;
+    triggers?: ServerlessFunctionTrigger[];
+  };
+  
+  type ObjectMetadataOptions = SyncableEntityOptions & {
+    nameSingular: string;
+    namePlural: string;
+    labelSingular: string;
+    labelPlural: string;
+    description?: string;
+    icon?: string;
+  };
+  
+  export const ObjectMetadata = (_: ObjectMetadataOptions): ClassDecorator => {
+    return () => {};
+  };
+}
+`;
+
+const serverlessFunctionMock = `
+import { type ServerlessFunctionConfig } from 'twenty-sdk/application';
+
+export const main = async (params: any): Promise<any> => {
+  return {};
+}
+
+export const config: ServerlessFunctionConfig = {
+  universalIdentifier: 'e56d363b-0bdc-4d8a-a393-6f0d1c75bdcf',
+  name: 'hello',
+  timeoutSeconds: 2,
+  triggers: [
+    {
+      universalIdentifier: 'c9f84c8d-b26d-40d1-95dd-4f834ae5a2c6',
+      type: 'route',
+      path: '/post-card/create',
+      httpMethod: 'GET',
+      isAuthRequired: false
+    },
+    {
+      universalIdentifier: 'dd802808-0695-49e1-98c9-d5c9e2704ce2',
+      type: 'cron',
+      pattern: '0 0 1 1 *', // Every year 1st of January
+    },
+    {
+      universalIdentifier: '203f1df3-4a82-4d06-a001-b8cf22a31156',
+      type: 'databaseEvent',
+      eventName: 'person.created'
+    }
+  ]
+};`;
+
+const objectMock = `import { ObjectMetadata } from 'twenty-sdk/application';
+
+@ObjectMetadata({
+  universalIdentifier: '54b589ca-eeed-4950-a176-358418b85c05',
+  nameSingular: 'postCard',
+  namePlural: 'postCards',
+  labelSingular: 'Post card',
+  labelPlural: 'Post cards',
+  description: ' A post card object',
+  icon: 'IconMail',
+})
+export class PostCard {}
+`;
+
+describe('loadManifest (integration)', () => {
+  const appName = 'my-app';
+  const appDisplayName = 'My App';
+  const appDescription = 'My app description';
+  const appDirectory = join(tmpdir(), 'twenty-manifest-');
+
+  beforeEach(async () => {
+    await copyBaseApplicationProject({
+      appName,
+      appDisplayName,
+      appDescription,
+      appDirectory,
+    });
+
+    write(appDirectory, 'src/Account.ts', objectMock);
+
+    write(appDirectory, 'src/hello.ts', serverlessFunctionMock);
+
+    write(
+      appDirectory,
+      'src/types/twenty-sdk-application.d.ts',
+      twentySdkTypesMock,
+    );
+
+    write(
+      appDirectory,
+      'src/types/tslib.d.ts',
+      // minimal + future-proof
+      tsLibMock,
+    );
+  });
+
+  afterEach(() => {
+    removeSync(appDirectory);
+  });
+
+  it('builds a full manifest for a valid workspace', async () => {
+    const { packageJson, yarnLock, manifest } =
+      await loadManifest(appDirectory);
+
+    expect(packageJson.name).toBe('my-app');
+    expect(packageJson.version).toBe('0.0.1');
+    expect(packageJson.license).toBe('MIT');
+    expect(yarnLock).toContain('# This file is generated by running ');
+
+    // application
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    const { universalIdentifier: _, ...otherInfo } = manifest.application;
+    expect(otherInfo).toEqual({
+      displayName: 'My App',
+      description: 'My app description',
+    });
+
+    // objects collected from @ObjectMetadata
+    for (const object of manifest.objects) {
+      // eslint-disable-next-line @typescript-eslint/no-unused-vars
+      const { universalIdentifier: _, ...otherInfo } = object;
+      expect(otherInfo).toEqual({
+        description: ' A post card object',
+        icon: 'IconMail',
+        labelPlural: 'Post cards',
+        labelSingular: 'Post card',
+        namePlural: 'postCards',
+        nameSingular: 'postCard',
+      });
+    }
+
+    // serverless functions
+    for (const serverlessFunction of manifest.serverlessFunctions) {
+      const {
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        universalIdentifier: _,
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        handlerPath: __,
+        triggers,
+        ...otherInfo
+      } = serverlessFunction;
+
+      expect(otherInfo).toEqual({
+        handlerName: 'main',
+        name: 'hello',
+        timeoutSeconds: 2,
+      });
+
+      for (const trigger of triggers) {
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        const { universalIdentifier: _, ...otherInfo } = trigger;
+        switch (trigger.type) {
+          case 'route':
+            expect(otherInfo).toEqual({
+              isAuthRequired: false,
+              httpMethod: 'GET',
+              path: '/post-card/create',
+              type: 'route',
+            });
+            break;
+          case 'cron':
+            expect(otherInfo).toEqual({
+              pattern: '0 0 1 1 *',
+              type: 'cron',
+            });
+            break;
+          case 'databaseEvent':
+            expect(otherInfo).toEqual({
+              eventName: 'person.created',
+              type: 'databaseEvent',
+            });
+            break;
+        }
+      }
+    }
+  });
+
+  it('should not define serverless for util file', async () => {
+    write(
+      appDirectory,
+      'src/utils/format.ts',
+      `
+export const format = async (params: any): Promise<any> => {
+  return {};
+}
+`,
+    );
+
+    const { manifest } = await loadManifest(appDirectory);
+    expect(manifest.serverlessFunctions.length).toBe(1);
+  });
+
+  it('manifest should contains typescript sources', async () => {
+    const { manifest } = await loadManifest(appDirectory);
+    // the method is already exercised in loadManifest; just assert again:
+    expect(Object.keys(manifest.sources)).toEqual([
+      'application.config.ts',
+      'src',
+    ]);
+    expect(Object.keys(manifest.sources['src'])).toEqual([
+      'Account.ts',
+      'hello.ts',
+    ]);
+  });
+
+  it('fails fast if TS validation fails', async () => {
+    write(appDirectory, 'src/utils/broken.ts', `const x: number = 'oops';`);
+
+    await expect(loadManifest(appDirectory)).rejects.toThrow(
+      /TypeScript validation failed/,
+    );
+  });
+});