twenty-sdk 0.6.0 → 0.6.2

package/generated/core/index.ts

@@ -0,0 +1,406 @@
+// @ts-nocheck
+import type {
+  QueryGenqlSelection,
+  Query,
+  MutationGenqlSelection,
+  Mutation,
+} from './schema'
+import {
+  linkTypeMap,
+  createClient as createClientOriginal,
+  generateGraphqlOperation,
+  type FieldsSelection,
+  type GraphqlOperation,
+  type ClientOptions,
+  GenqlError,
+} from './runtime'
+export type { FieldsSelection } from './runtime'
+export { GenqlError }
+
+import types from './types'
+export * from './schema'
+const typeMap = linkTypeMap(types as any)
+
+export interface Client {
+  query<R extends QueryGenqlSelection>(
+    request: R & { __name?: string },
+  ): Promise<FieldsSelection<Query, R>>
+
+  mutation<R extends MutationGenqlSelection>(
+    request: R & { __name?: string },
+  ): Promise<FieldsSelection<Mutation, R>>
+}
+
+export const createClient = function (options?: ClientOptions): Client {
+  return createClientOriginal({
+    url: undefined,
+
+    ...options,
+    queryRoot: typeMap.Query!,
+    mutationRoot: typeMap.Mutation!,
+    subscriptionRoot: typeMap.Subscription!,
+  }) as any
+}
+
+export const everything = {
+  __scalar: true,
+}
+
+export type QueryResult<fields extends QueryGenqlSelection> = FieldsSelection<
+  Query,
+  fields
+>
+export const generateQueryOp: (
+  fields: QueryGenqlSelection & { __name?: string },
+) => GraphqlOperation = function (fields) {
+  return generateGraphqlOperation('query', typeMap.Query!, fields as any)
+}
+
+export type MutationResult<fields extends MutationGenqlSelection> =
+  FieldsSelection<Mutation, fields>
+export const generateMutationOp: (
+  fields: MutationGenqlSelection & { __name?: string },
+) => GraphqlOperation = function (fields) {
+  return generateGraphqlOperation('mutation', typeMap.Mutation!, fields as any)
+}
+
+
+// ----------------------------------------------------
+// CoreApiClient (auto-injected)
+// ----------------------------------------------------
+
+const APP_ACCESS_TOKEN_ENV_KEY = 'TWENTY_APP_ACCESS_TOKEN';
+const API_KEY_ENV_KEY = 'TWENTY_API_KEY';
+
+type CoreApiClientOptions = ClientOptions
+
+type ProcessEnvironment = Record<string, string | undefined>
+
+type GraphqlError = {
+  message?: string;
+  extensions?: { code?: string };
+}
+
+type GraphqlResponsePayload = {
+  data?: Record<string, unknown>
+  errors?: GraphqlError[];
+}
+
+type GraphqlResponse = {
+  status: number;
+  statusText: string;
+  payload: GraphqlResponsePayload | null;
+  rawBody: string;
+}
+
+const getProcessEnvironment = (): ProcessEnvironment => {
+  const processObject = (globalThis as { process?: { env?: ProcessEnvironment } })
+    .process;
+
+  return processObject?.env ?? {};
+}
+
+const getTokenFromAuthorizationHeader = (
+  authorizationHeader: string | undefined,
+): string | null => {
+  if (typeof authorizationHeader !== 'string') {
+    return null;
+  }
+
+  const trimmedAuthorizationHeader = authorizationHeader.trim();
+
+  if (trimmedAuthorizationHeader.length === 0) {
+    return null;
+  }
+
+  if (trimmedAuthorizationHeader === 'Bearer') {
+    return null;
+  }
+
+  if (trimmedAuthorizationHeader.startsWith('Bearer ')) {
+    return trimmedAuthorizationHeader.slice('Bearer '.length).trim();
+  }
+
+  return trimmedAuthorizationHeader;
+}
+
+const getTokenFromHeaders = (headers: HeadersInit | undefined): string | null => {
+  if (!headers) {
+    return null;
+  }
+
+  if (headers instanceof Headers) {
+    return getTokenFromAuthorizationHeader(headers.get('Authorization') ?? undefined);
+  }
+
+  if (Array.isArray(headers)) {
+    const matchedAuthorizationHeader = headers.find(
+      ([headerName]) => headerName.toLowerCase() === 'authorization',
+    );
+
+    return getTokenFromAuthorizationHeader(matchedAuthorizationHeader?.[1]);
+  }
+
+  const headersRecord = headers as Record<string, string | undefined>;
+
+  return getTokenFromAuthorizationHeader(
+    headersRecord.Authorization ?? headersRecord.authorization,
+  );
+}
+
+const hasAuthenticationErrorInGraphqlPayload = (
+  payload: GraphqlResponsePayload | null,
+): boolean => {
+  if (!payload?.errors) {
+    return false;
+  }
+
+  return payload.errors.some((error) => {
+    return (
+      error.extensions?.code === 'UNAUTHENTICATED' ||
+      error.message?.toLowerCase() === 'unauthorized'
+    );
+  });
+}
+
+const defaultOptions: CoreApiClientOptions = {
+  url: `${process.env.TWENTY_API_URL}/graphql`,
+  headers: {
+    'Content-Type': 'application/json',
+  },
+}
+
+export class CoreApiClient {
+  private client: Client;
+  private url: string;
+  private requestOptions: RequestInit;
+  private headers: HeadersInit | (() => HeadersInit | Promise<HeadersInit>);
+  private fetchImplementation: typeof globalThis.fetch | null;
+  private authorizationToken: string | null;
+  private refreshAccessTokenPromise: Promise<string | null> | null = null;
+
+  constructor(options?: CoreApiClientOptions) {
+    const merged: CoreApiClientOptions = {
+      ...defaultOptions,
+      ...options,
+    }
+
+    const {
+      url,
+      headers,
+      fetch: customFetchImplementation,
+      fetcher: _fetcher,
+      batch: _batch,
+      ...requestOptions
+    } = merged;
+
+    this.url = url ?? '';
+    this.requestOptions = requestOptions;
+    this.headers = headers ?? {};
+    this.fetchImplementation = customFetchImplementation ?? globalThis.fetch ?? null;
+
+    const processEnvironment = getProcessEnvironment();
+    const tokenFromHeaders = getTokenFromHeaders(
+      typeof headers === 'function' ? undefined : headers,
+    );
+
+    // Priority: explicit header > TWENTY_APP_ACCESS_TOKEN > TWENTY_API_KEY (legacy fallback).
+    this.authorizationToken =
+      tokenFromHeaders ??
+      processEnvironment[APP_ACCESS_TOKEN_ENV_KEY] ??
+      processEnvironment[API_KEY_ENV_KEY] ??
+      null;
+
+    this.client = createClient({
+      ...merged,
+      headers: undefined,
+      fetcher: async (operation) =>
+        this.executeGraphqlRequestWithOptionalRefresh({
+          operation,
+        }),
+    });
+  }
+
+  query<R extends QueryGenqlSelection>(request: R & { __name?: string }) {
+    return this.client.query(request);
+  }
+
+  mutation<R extends MutationGenqlSelection>(request: R & { __name?: string }) {
+    return this.client.mutation(request);
+  }
+
+  private async executeGraphqlRequestWithOptionalRefresh({
+    operation,
+    headers,
+    requestInit,
+  }: {
+    operation: GraphqlOperation | GraphqlOperation[] | FormData;
+    headers?: HeadersInit;
+    requestInit?: RequestInit;
+  }) {
+    const firstResponse = await this.executeGraphqlRequest({
+      operation,
+      headers,
+      requestInit,
+      token: this.authorizationToken,
+    });
+
+    if (this.shouldRefreshToken(firstResponse)) {
+      const refreshedAccessToken = await this.requestRefreshedAccessToken();
+
+      if (refreshedAccessToken) {
+        const retryResponse = await this.executeGraphqlRequest({
+          operation,
+          headers,
+          requestInit,
+          token: refreshedAccessToken,
+        });
+
+        return this.assertResponseIsSuccessful(retryResponse);
+      }
+    }
+
+    return this.assertResponseIsSuccessful(firstResponse);
+  }
+
+  private async executeGraphqlRequest({
+    operation,
+    headers,
+    requestInit,
+    token,
+  }: {
+    operation: GraphqlOperation | GraphqlOperation[] | FormData;
+    headers?: HeadersInit;
+    requestInit?: RequestInit;
+    token: string | null;
+  }): Promise<GraphqlResponse> {
+    if (!this.fetchImplementation) {
+      throw new Error(
+        'Global `fetch` function is not available, pass a fetch implementation to the Twenty client',
+      );
+    }
+
+    const resolvedHeaders = await this.resolveHeaders();
+    const requestHeaders = new Headers(resolvedHeaders);
+
+    if (headers) {
+      new Headers(headers).forEach((value, key) => requestHeaders.set(key, value));
+    }
+
+    if (operation instanceof FormData) {
+      requestHeaders.delete('Content-Type');
+    } else {
+      requestHeaders.set('Content-Type', 'application/json');
+    }
+
+    if (token) {
+      requestHeaders.set('Authorization', `Bearer ${token}`);
+    } else {
+      requestHeaders.delete('Authorization');
+    }
+
+    const response = await this.fetchImplementation.call(globalThis, this.url, {
+      ...this.requestOptions,
+      ...requestInit,
+      method: requestInit?.method ?? 'POST',
+      headers: requestHeaders,
+      body: operation instanceof FormData ? operation : JSON.stringify(operation),
+    });
+
+    const rawBody = await response.text();
+    let payload: GraphqlResponsePayload | null = null;
+
+    if (rawBody.trim().length > 0) {
+      try {
+        payload = JSON.parse(rawBody) as GraphqlResponsePayload;
+      } catch {
+        payload = null;
+      }
+    }
+
+    return {
+      status: response.status,
+      statusText: response.statusText,
+      payload,
+      rawBody,
+    }
+  }
+
+  private async resolveHeaders(): Promise<HeadersInit> {
+    if (typeof this.headers === 'function') {
+      return (await this.headers()) ?? {};
+    }
+
+    return this.headers ?? {};
+  }
+
+  private shouldRefreshToken(response: GraphqlResponse): boolean {
+    if (response.status === 401) {
+      return true;
+    }
+
+    return hasAuthenticationErrorInGraphqlPayload(response.payload);
+  }
+
+  private assertResponseIsSuccessful(response: GraphqlResponse) {
+    if (response.status < 200 || response.status >= 300) {
+      throw new Error(`${response.statusText}: ${response.rawBody}`);
+    }
+
+    if (response.payload === null) {
+      throw new Error('Invalid JSON response');
+    }
+
+    return response.payload;
+  }
+
+  private async requestRefreshedAccessToken(): Promise<string | null> {
+    const refreshAccessTokenFunction = (
+      globalThis as {
+        frontComponentHostCommunicationApi?: {
+          requestAccessTokenRefresh?: () => Promise<string>
+        }
+      }
+    ).frontComponentHostCommunicationApi?.requestAccessTokenRefresh;
+
+    if (typeof refreshAccessTokenFunction !== 'function') {
+      return null;
+    }
+
+    if (!this.refreshAccessTokenPromise) {
+      this.refreshAccessTokenPromise = refreshAccessTokenFunction()
+        .then((refreshedAccessToken) => {
+          if (
+            typeof refreshedAccessToken !== 'string' ||
+            refreshedAccessToken.length === 0
+          ) {
+            return null;
+          }
+
+          this.setAuthorizationToken(refreshedAccessToken);
+
+          return refreshedAccessToken;
+        })
+        .catch((error) => {
+          console.error('Twenty client: token refresh failed', error);
+
+          return null;
+        })
+        .finally(() => {
+          this.refreshAccessTokenPromise = null;
+        });
+    }
+
+    return this.refreshAccessTokenPromise;
+  }
+
+  private setAuthorizationToken(token: string) {
+    this.authorizationToken = token;
+
+    const processEnvironment = getProcessEnvironment();
+
+    processEnvironment[APP_ACCESS_TOKEN_ENV_KEY] = token;
+    processEnvironment[API_KEY_ENV_KEY] = token;
+  }
+}
+

package/generated/core/runtime/batcher.ts

@@ -0,0 +1,265 @@
+// @ts-nocheck
+import type { GraphqlOperation } from './generateGraphqlOperation'
+import { GenqlError } from './error'
+
+type Variables = Record<string, any>
+
+type QueryError = Error & {
+    message: string
+
+    locations?: Array<{
+        line: number
+        column: number
+    }>
+    path?: any
+    rid: string
+    details?: Record<string, any>
+}
+type Result = {
+    data: Record<string, any>
+    errors: Array<QueryError>
+}
+type Fetcher = (
+    batchedQuery: GraphqlOperation | Array<GraphqlOperation>,
+) => Promise<Array<Result>>
+type Options = {
+    batchInterval?: number
+    shouldBatch?: boolean
+    maxBatchSize?: number
+}
+type Queue = Array<{
+    request: GraphqlOperation
+    resolve: (...args: Array<any>) => any
+    reject: (...args: Array<any>) => any
+}>
+
+/**
+ * takes a list of requests (queue) and batches them into a single server request.
+ * It will then resolve each individual requests promise with the appropriate data.
+ * @private
+ * @param {QueryBatcher}   client - the client to use
+ * @param {Queue} queue  - the list of requests to batch
+ */
+function dispatchQueueBatch(client: QueryBatcher, queue: Queue): void {
+    let batchedQuery: any = queue.map((item) => item.request)
+
+    if (batchedQuery.length === 1) {
+        batchedQuery = batchedQuery[0]
+    }
+
+    client.fetcher(batchedQuery).then((responses: any) => {
+        if (queue.length === 1 && !Array.isArray(responses)) {
+            if (responses.errors && responses.errors.length) {
+                queue[0].reject(
+                    new GenqlError(responses.errors, responses.data),
+                )
+                return
+            }
+
+            queue[0].resolve(responses)
+            return
+        } else if (responses.length !== queue.length) {
+            throw new Error('response length did not match query length')
+        }
+
+        for (let i = 0; i < queue.length; i++) {
+            if (responses[i].errors && responses[i].errors.length) {
+                queue[i].reject(
+                    new GenqlError(responses[i].errors, responses[i].data),
+                )
+            } else {
+                queue[i].resolve(responses[i])
+            }
+        }
+    })
+}
+
+/**
+ * creates a list of requests to batch according to max batch size.
+ * @private
+ * @param {QueryBatcher} client - the client to create list of requests from from
+ * @param {Options} options - the options for the batch
+ */
+function dispatchQueue(client: QueryBatcher, options: Options): void {
+    const queue = client._queue
+    const maxBatchSize = options.maxBatchSize || 0
+    client._queue = []
+
+    if (maxBatchSize > 0 && maxBatchSize < queue.length) {
+        for (let i = 0; i < queue.length / maxBatchSize; i++) {
+            dispatchQueueBatch(
+                client,
+                queue.slice(i * maxBatchSize, (i + 1) * maxBatchSize),
+            )
+        }
+    } else {
+        dispatchQueueBatch(client, queue)
+    }
+}
+/**
+ * Create a batcher client.
+ * @param {Fetcher} fetcher                 - A function that can handle the network requests to graphql endpoint
+ * @param {Options} options                 - the options to be used by client
+ * @param {boolean} options.shouldBatch     - should the client batch requests. (default true)
+ * @param {integer} options.batchInterval   - duration (in MS) of each batch window. (default 6)
+ * @param {integer} options.maxBatchSize    - max number of requests in a batch. (default 0)
+ * @param {boolean} options.defaultHeaders  - default headers to include with every request
+ *
+ * @example
+ * const fetcher = batchedQuery => fetch('path/to/graphql', {
+ *    method: 'post',
+ *    headers: {
+ *      Accept: 'application/json',
+ *      'Content-Type': 'application/json',
+ *    },
+ *    body: JSON.stringify(batchedQuery),
+ *    credentials: 'include',
+ * })
+ * .then(response => response.json())
+ *
+ * const client = new QueryBatcher(fetcher, { maxBatchSize: 10 })
+ */
+
+export class QueryBatcher {
+    fetcher: Fetcher
+    _options: Options
+    _queue: Queue
+
+    constructor(
+        fetcher: Fetcher,
+        {
+            batchInterval = 6,
+            shouldBatch = true,
+            maxBatchSize = 0,
+        }: Options = {},
+    ) {
+        this.fetcher = fetcher
+        this._options = {
+            batchInterval,
+            shouldBatch,
+            maxBatchSize,
+        }
+        this._queue = []
+    }
+
+    /**
+     * Fetch will send a graphql request and return the parsed json.
+     * @param {string}      query          - the graphql query.
+     * @param {Variables}   variables      - any variables you wish to inject as key/value pairs.
+     * @param {[string]}    operationName  - the graphql operationName.
+     * @param {Options}     overrides      - the client options overrides.
+     *
+     * @return {promise} resolves to parsed json of server response
+     *
+     * @example
+     * client.fetch(`
+     *    query getHuman($id: ID!) {
+     *      human(id: $id) {
+     *        name
+     *        height
+     *      }
+     *    }
+     * `, { id: "1001" }, 'getHuman')
+     *    .then(human => {
+     *      // do something with human
+     *      console.log(human);
+     *    });
+     */
+    fetch(
+        query: string,
+        variables?: Variables,
+        operationName?: string,
+        overrides: Options = {},
+    ): Promise<Result> {
+        const request: GraphqlOperation = {
+            query,
+        }
+        const options = Object.assign({}, this._options, overrides)
+
+        if (variables) {
+            request.variables = variables
+        }
+
+        if (operationName) {
+            request.operationName = operationName
+        }
+
+        const promise = new Promise<Result>((resolve, reject) => {
+            this._queue.push({
+                request,
+                resolve,
+                reject,
+            })
+
+            if (this._queue.length === 1) {
+                if (options.shouldBatch) {
+                    setTimeout(
+                        () => dispatchQueue(this, options),
+                        options.batchInterval,
+                    )
+                } else {
+                    dispatchQueue(this, options)
+                }
+            }
+        })
+        return promise
+    }
+
+    /**
+     * Fetch will send a graphql request and return the parsed json.
+     * @param {string}      query          - the graphql query.
+     * @param {Variables}   variables      - any variables you wish to inject as key/value pairs.
+     * @param {[string]}    operationName  - the graphql operationName.
+     * @param {Options}     overrides      - the client options overrides.
+     *
+     * @return {Promise<Array<Result>>} resolves to parsed json of server response
+     *
+     * @example
+     * client.forceFetch(`
+     *    query getHuman($id: ID!) {
+     *      human(id: $id) {
+     *        name
+     *        height
+     *      }
+     *    }
+     * `, { id: "1001" }, 'getHuman')
+     *    .then(human => {
+     *      // do something with human
+     *      console.log(human);
+     *    });
+     */
+    forceFetch(
+        query: string,
+        variables?: Variables,
+        operationName?: string,
+        overrides: Options = {},
+    ): Promise<Result> {
+        const request: GraphqlOperation = {
+            query,
+        }
+        const options = Object.assign({}, this._options, overrides, {
+            shouldBatch: false,
+        })
+
+        if (variables) {
+            request.variables = variables
+        }
+
+        if (operationName) {
+            request.operationName = operationName
+        }
+
+        const promise = new Promise<Result>((resolve, reject) => {
+            const client = new QueryBatcher(this.fetcher, this._options)
+            client._queue = [
+                {
+                    request,
+                    resolve,
+                    reject,
+                },
+            ]
+            dispatchQueue(client, options)
+        })
+        return promise
+    }
+}