Funzioni logiche

import type { RoutePayload } from 'twenty-sdk/logic-function';

const handler = async (event: RoutePayload) => {
  const { headers, queryStringParameters, pathParameters, body } = event;
  const { method, path } = event.requestContext.http;

  return { message: 'Success' };
};

export default defineLogicFunction({
  universalIdentifier: 'e56d363b-0bdc-4d8a-a393-6f0d1c75bdcf',
  name: 'webhook-handler',
  handler,
  httpRouteTriggerSettings: {
    path: '/webhook',
    httpMethod: 'POST',
    isAuthRequired: false,
    forwardedRequestHeaders: ['x-webhook-signature', 'content-type'],
  },
});

const handler = async (event: RoutePayload) => {
  const signature = event.headers['x-webhook-signature'];
  const contentType = event.headers['content-type'];

  // Validate webhook signature...
  return { received: true };
};

import { Response } from 'twenty-sdk/logic-function';

const handler = async (event: RoutePayload) => {
  return new Response('<h1>Hello</h1>', {
    status: 201,
    headers: { 'content-type': 'text/html' },
  });
};

POST https://your-twenty-server.com/webhooks/server/:applicationRegistrationId/:resolverLogicFunctionUniversalIdentifier

import { getServerRouteUrl } from 'twenty-sdk/utils';

const destinationUrl = getServerRouteUrl(
  INVOICE_PAID_RESOLVER_UNIVERSAL_IDENTIFIER,
);

serverRouteTriggerSettings: {
  forwardedRequestHeaders: ['x-hub-signature-256'],
  httpMethods: ['GET', 'POST'],
}

const handler = async (event: RoutePayload) => {
  if (event.requestContext.http.method === 'GET') {
    return new Response(event.queryStringParameters['hub.challenge']);
  }
  // …handle the delivered event
};

import type {
  DatabaseEventBatchPayload,
  DatabaseEventPayload,
  ObjectRecordCreateEvent,
  ObjectRecordDestroyEvent,
  ObjectRecordUpdateEvent,
} from 'twenty-sdk/logic-function';

type Person = {
  id: string;
  emails?: { primaryEmail?: string };
};

type PersonCreatedEvent = DatabaseEventPayload<ObjectRecordCreateEvent<Person>>;

const handler = async (event: PersonCreatedEvent) => {
  const person = event.properties.after;

  return {
    personId: event.recordId,
    email: person.emails?.primaryEmail,
  };
};

type PersonUpdatedEvent = DatabaseEventPayload<ObjectRecordUpdateEvent<Person>>;

const handler = async (event: PersonUpdatedEvent) => {
  const { before, after, diff, updatedFields } = event.properties;

  return {
    personId: event.recordId,
    updatedFields,
    previousEmail: before.emails?.primaryEmail,
    currentEmail: after.emails?.primaryEmail,
    emailDiff: diff.emails,
  };
};

export default defineLogicFunction({
  ...,
  databaseEventTriggerSettings: {
    eventName: 'person.updated',
    updatedFields: ['emails'],
  },
});

type PersonDestroyedEvent = DatabaseEventPayload<
  ObjectRecordDestroyEvent<Person>
>;

const handler = async (event: PersonDestroyedEvent) => {
  const personBeforeDestroy = event.properties.before;

  return {
    personId: event.recordId,
    email: personBeforeDestroy.emails?.primaryEmail,
  };
};

export default defineLogicFunction({
  ...,
  databaseEventTriggerSettings: {
    eventName: 'person.updated',
    batchMode: true,
  },
});

type PeopleUpdatedBatch = DatabaseEventBatchPayload<
  ObjectRecordUpdateEvent<Person>
>;

const handler = async (batch: PeopleUpdatedBatch) => {
  const updatedEmails = batch.events.map(
    (event) => event.properties.after.emails?.primaryEmail,
  );

  return { workspaceId: batch.workspaceId, updatedEmails };
};

import type { LogicFunctionExecutionContext } from 'twenty-sdk/logic-function';

const handler = async (
  event: DatabaseEventPayload,
  { workspaceId, workspaceMemberId }: LogicFunctionExecutionContext,
) => {
  if (workspaceMemberId === null) {
    throw new Error('This function must be triggered by a person');
  }

  return { reviewedBy: workspaceMemberId, workspaceId };
};

import { CoreApiClient } from 'twenty-client-sdk/core';

const asPerson = new CoreApiClient();
const asApplication = new CoreApiClient({ runAs: 'application' });

const handler = async (event: DatabaseEventPayload) => {
  // config records only your app may read
  const { slackUserLinks } = await asApplication.query({ ... });

  // created as the person, so it is attributed and permission-checked
  await asPerson.mutation({ createNote: { ... } });
};

import { RestApiClient } from 'twenty-client-sdk/rest';

const asApplication = new RestApiClient({ runAs: 'application' });

export default defineLogicFunction({
  ...,
  toolTriggerSettings: {
    inputSchema: {
      type: 'object',
      properties: {
        companyName: {
          type: 'string',
          description: 'The name of the company to enrich',
        },
        domain: {
          type: 'string',
          description: 'The company website domain (optional)',
        },
      },
      required: ['companyName'],
    },
  },
});

import { defineLogicFunction } from 'twenty-sdk/define';
import { jsonSchemaToInputSchema, type InputJsonSchema } from 'twenty-sdk/logic-function';

const inputSchema: InputJsonSchema = {
  type: 'object',
  properties: {
    companyName: { type: 'string', label: 'Company name' },
    domain: { type: 'string', label: 'Domain' },
  },
  required: ['companyName'],
};

export default defineLogicFunction({
  ...,
  toolTriggerSettings: { inputSchema },
  workflowActionTriggerSettings: {
    label: 'Enrich Company',
    icon: 'IconBuilding',
    inputSchema: jsonSchemaToInputSchema(inputSchema),
  },
});

export default defineLogicFunction({
  ...,
  toolTriggerSettings: {
    frontComponentUniversalIdentifier: '74c526eb-cb68-4cf7-b05c-0dd8c288d948',
  },
});

import { CoreApiClient } from 'twenty-client-sdk/core';

const client = new CoreApiClient();

// Query records
const { companies } = await client.query({
  companies: {
    edges: {
      node: {
        id: true,
        name: true,
        domainName: {
          primaryLinkLabel: true,
          primaryLinkUrl: true,
        },
      },
    },
  },
});

// Create a record
const { createCompany } = await client.mutation({
  createCompany: {
    __args: {
      data: {
        name: 'Acme Corp',
      },
    },
    id: true,
    name: true,
  },
});

// Only on an object whose records are private: choose who can read the created record
const { createContract } = await client.mutation({
  createContract: {
    __args: {
      data: {
        name: 'Acme Corp renewal',
      },
      shareWith: [
        {
          roleId: '7f0c1b6e-2d4a-4c8e-9b3f-5a6d7e8f9a0b',
          accessLevel: 'READ_WRITE',
        },
      ],
    },
    id: true,
  },
});

import { CoreApiClient, CoreSchema } from 'twenty-client-sdk/core';
import { useState } from 'react';

const [company, setCompany] = useState<
  Pick<CoreSchema.Company, 'id' | 'name'> | undefined
>(undefined);

const client = new CoreApiClient();
const result = await client.query({
  company: {
    __args: { filter: { position: { eq: 1 } } },
    id: true,
    name: true,
  },
});
setCompany(result.company);

import { MetadataApiClient } from 'twenty-client-sdk/metadata';

const metadataClient = new MetadataApiClient();

// List first 10 objects in the workspace
const { objects } = await metadataClient.query({
  objects: {
    edges: {
      node: {
        id: true,
        nameSingular: true,
        namePlural: true,
        labelSingular: true,
        applicationId: true,
      },
    },
    __args: {
      filter: {},
      paging: { first: 10 },
    },
  },
});

import { MetadataApiClient } from 'twenty-client-sdk/metadata';
import * as fs from 'fs';

const metadataClient = new MetadataApiClient();

const uploadedFile = await metadataClient.uploadFile({
  fileBuffer: fs.readFileSync('./invoice.pdf'),
  filename: 'invoice.pdf',
  fieldMetadataUniversalIdentifier: '58a0a314-d7ea-4865-9850-7fb84e72f30b',
});

console.log(uploadedFile);
// { id: '...', path: '...', size: 12345, createdAt: '...', url: 'https://...' }