api reference

static createDatabase(data: DatabaseCreateInput): Promise<Database>;

await api.createDatabase({
  name: 'audit_log',
  category: 'Ops',
  desc: 'Audit',
  restricted: false,
  groups: [],
  users: [],
  definition: [{
    name: 'auditId', type: 'UUID',
    isPrimaryKey: true, isArray: false, isUnique: true,
    isNullable: false, isIndex: true, foreignReferences: [],
  }],
});

static cloneDatabase<TAsync extends boolean = false>(
      name: string,
      options?: DatabaseCloneInput & { async?: TAsync },
    ): Promise<
      TAsync extends true
        ? CloneDatabaseAcceptedResponse
        : TAsync extends false
          ? CloneDatabaseCompletedResponse
          : CloneDatabaseResponse
    >;

const result = await api.cloneDatabase('customers', {
  includeItems: false,
  includePartitions: true,
});

return result.databases;

static exportDatabase<TAsync extends boolean = false>(
      name: string,
      options?: ExportDatabaseOptions & { async?: TAsync },
    ): Promise<
      TAsync extends true
        ? ExportDatabaseAcceptedResponse
        : TAsync extends false
          ? ExportDatabaseCompletedResponse
          : ExportDatabaseResponse
    >;

const result = await api.exportDatabase('contracts', {
  format: 'xlsx',
  storageDestination: 'ROOT',
  fileName: 'contracts-full.xlsx',
  restricted: false,
  fields: ['contractId', 'customerId'],
  sort: { contractId: 'ASC' },
});

return result.storageEntryId;

static startDatabaseOperation(name: string, options: Omit<DatabaseOperationInput, 'databaseName'>): Promise<{ accepted: true; jobId: string; status: string }>;

const operation = await api.startDatabaseOperation('orders', {
  action: 'UPDATE', request: { filter: { field: 'status', op: 'eq', value: 'READY' } },
  data: { status: 'PROCESSED' }, skipNotification: false,
});

static importDatabase(name: string, options: ImportDatabaseOptions): Promise<{ importId: string; jobId: string; status: string }>;

static updateDatabaseImportMapping(
      importId: string, mapping: NonNullable<ImportDatabaseOptions['mapping']>,
    ): Promise<{ importId: string; status: string }>;

static commitDatabaseImport(importId: string): Promise<{ importId: string; status: string }>;

static updateDatabase(name: string, data: DatabaseUpdateInput): Promise<Database>;

await api.updateDatabase('orders', {
  version: current.version,
  audit: true,
});

static deleteDatabase(name: string): Promise<void>;

await api.deleteDatabase('orders');

static restoreDatabase(name: string): Promise<void>;

await api.restoreDatabase('orders');

static truncateDatabase(
      name: string,
      options?: TruncateDatabaseOptions,
    ): Promise<void>;

await api.truncateDatabase('orders', { restartIdentity: false });

static transactionDatabase<T>(
      callback: (tx: DatabaseTransactionApi) => Promise<T> | T,
      options?: DatabaseTransactionStartOptions,
    ): Promise<T>;

await api.transactionDatabase(async (tx) => {
  const existing = await tx.getDatabaseData(
    'contracts',
    { filter: { field: 'contractId', op: 'eq', value: api.input('contractId') }, take: 1 },
    { lock: 'update' },
  );
  if (existing.results === 0) {
    await tx.insertDatabaseData('contracts', [
      { contractId: api.input('contractId') },
    ]);
  }
});

static getDatabaseData<T = any>(
      name: string,
      request?: DatabaseBoundedReadQuery,
    ): Promise<GetDatabaseDataResponse<T>>;

const rows = await api.getDatabaseData('customers', {
  fields: ['customerId', 'name'],
  filter: { field: 'status', op: 'eq', value: 'ACTIVE' },
  sort: { name: 'ASC' },
  take: 100,
});

static getDatabaseDataRow<T = any>(name: string, query: DatabaseRowQuery): Promise<T | null>;

static countDatabase(name: string, query?: DatabaseCountQuery): Promise<number>;

static walkDatabaseData<T = any>(
      name: string,
      query: SelectInput,
      callback: (batch: T[], context: { batch: number; processed: number }) => void | Promise<void>,
      options?: DatabaseWalkOptions,
    ): Promise<DatabaseWalkResult>;

await api.walkDatabaseData('customers', { take: 100000, sort: ['customerId'] },
  async (batch) => {
    await api.upsertDatabaseData('customer_export', batch, { return: false });
  }, { batchSize: 10000 });

static getDatabaseAudit(
      name: string,
      query?: DatabaseAuditQuery,
    ): Promise<DatabaseAuditResponse>;

static insertDatabaseData(
      name: string,
      data: LooseObject<any>[],
      options?: DatabaseDataWriteOptions,
    ): Promise<DatabaseDataActionResponse>;

await api.insertDatabaseData('customers', [
  { customerId: 'c-1', name: 'Acme' },
]);

static upsertDatabaseData(
      name: string,
      data: LooseObject<any>[],
      options?: DatabaseUpsertOptions,
    ): Promise<DatabaseDataActionResponse>;

await api.upsertDatabaseData('customers', [
  { customerId: 'c-1', status: 'ACTIVE' },
]);

static updateDatabaseData(
      name: string,
      oldObject: LooseObject<any>,
      newObject: LooseObject<any>,
    ): Promise<ResourceItem>;

await api.updateDatabaseData(
  'customers',
  { customerId: 'c-1' },
  { status: 'ACTIVE' },
);

static deleteDatabaseData(name: string, data: LooseObject<any>[]): Promise<any>;

await api.deleteDatabaseData('customers', [
  { customerId: 'c-1' },
]);

static updateDatabaseDataRequest(
      name: string,
      request: DatabaseMutationRequest,
      payload: DatabaseUpdateData,
      options?: { return?: boolean; onlyKeys?: boolean },
    ): Promise<{ success: number; elapsed: number; data?: any }>;

await api.updateDatabaseDataRequest(
  'customers',
  { filter: { field: 'status', op: 'eq', value: 'NEW' } },
  { status: 'PROCESSED' },
);

static deleteDatabaseDataRequest(
      name: string,
      request: DatabaseMutationRequest,
      options?: { return?: boolean; onlyKeys?: boolean },
    ): Promise<{ success: number; elapsed: number; data?: any }>;

await api.deleteDatabaseDataRequest('customers', {
  filter: { field: 'archivedAt', op: 'isNotNull' },
});

static queryDatabase(query: string, params?: any[]): Promise<any>;

const rows = await api.queryDatabase('SELECT NOW() AS now');

static currentUser(): LoggedUser;

const user = api.currentUser();

static isDebug(): boolean;

const restricted = api.isDebug();

static getCache(key: string): any;

const token = api.getCache('token');

static setCache(key: string, value: any, options?: { reference?: boolean }): void;

api.setCache('token', 'abc');
api.setCache('rows', rows, { reference: true });

static getContext(): Context;

const ctx = api.getContext();

static getErrors(): ProcessLog[];

const errors = api.getErrors();

static getExecutionId(): string;

const executionId = api.getExecutionId();

static getOperationId(): string;

const op = api.getOperationId();

static executeComponent<T = LooseObject<any>>(
      request: ComponentExecuteRequest,
    ): Promise<ComponentExecuteResult<T>>;

const [pricing, taxes] = await Promise.all([
  api.executeComponent({ componentId: pricingComponentId, inputs: { customerId }, timeoutMs: 9000 }),
  api.executeComponent({ componentId: taxComponentId, inputs: { customerId }, timeoutMs: 9000 }),
]);

static input(name?: string): Input;

const customerId = api.input()?.body?.customerId;

static log(
      log: string | LogInterface,
      type?: 'ERROR' | 'WARN' | 'INFO' | 'DEBUG',
      duration?: number,
      time?: string,
    ): void;

api.log(
  { message: 'Call finished', args: { status: 200 } },
  'INFO',
  120,
);

static exit(): void;

if (!enabled) {
  api.exit();
}

static throw(code: number, body?: any): void;

api.throw(400, { message: 'customerId is required' });

static getCurrentInstance(): string;

const instanceId = api.getCurrentInstance();

static getInstanceData(
      dataSource:
        | 'Users'
        | 'Groups'
        | 'RoleGroups'
        | 'Keys'
        | 'Secrets'
        | 'SecretsData'
        | 'Templates'
        | 'Events'
        | 'Schedule'
        | 'Jobs'
        | 'Webhooks'
        | 'Components'
        | 'Logs'
        | 'Files'
        | 'EventsHistory'
        | 'Endpoints'
        | 'Databases'
        | 'DatabaseData',
      request?: InstanceData,
    ): Promise<any>;

const files = await api.getInstanceData('Files', {
  take: 20,
  sort: ['-createdAt'],
});

static getInstanceDetails(): InstanceDetails;

const details = api.getInstanceDetails();

static publishMessage(channel: string, message: any): Promise<void>;

await api.publishMessage('ALL', { state: 'started' });

static getInstanceCache(key: string): Promise<any>;

const state = await api.getInstanceCache('sync:state');

static setInstanceCache(
      key: string,
      value: any,
      seconds?: number,
    ): Promise<void>;

await api.setInstanceCache('sync:state', { step: 'loading' }, 300);

static setInstanceCacheIfNotExists(
      key: string,
      value: any,
      seconds?: number,
    ): Promise<boolean>;

const created = await api.setInstanceCacheIfNotExists('sync:state', { step: 'queued' }, 300);

static getOrSetInstanceCache(
      key: string,
      value: any,
      seconds?: number,
    ): Promise<any>;

const state = await api.getOrSetInstanceCache('sync:state', { step: 'queued' }, 300);

static removeInstanceCache(key: string, wildcard?: boolean): Promise<void>;

await api.removeInstanceCache('sync:*', true);

static existsInstanceCache(key: string): Promise<boolean>;

const exists = await api.existsInstanceCache('sync:state');

static persistInstanceCache(key: string): Promise<void>;

await api.persistInstanceCache('sync:state');

static expireInstanceCache(key: string, ttl: number): Promise<void>;

await api.expireInstanceCache('sync:state', 600);

static getExpireInstanceCache(key: string): Promise<number | null>;

const ttl = await api.getExpireInstanceCache('sync:state');

static listInstanceCache(key: string): Promise<string[]>;

const keys = await api.listInstanceCache('sync:*');

static incrementInstanceCache(
      key: string,
      by?: number,
      seconds?: number,
    ): Promise<number>;

const count = await api.incrementInstanceCache('sync:counter', 1, 300);

static decrementInstanceCache(
      key: string,
      by?: number,
      seconds?: number,
    ): Promise<number>;

const count = await api.decrementInstanceCache('sync:counter');

static compareAndSetInstanceCache(
      key: string,
      expected: any,
      value: any,
      seconds?: number,
    ): Promise<boolean>;

const swapped = await api.compareAndSetInstanceCache('sync:state', { step: 'queued' }, { step: 'running' }, 300);

static acquireIdempotencyKey(
      key: string,
      ttl: number,
      value?: any,
    ): Promise<boolean>;

const first = await api.acquireIdempotencyKey('orders:123', 600, { state: 'running' });

static getIdempotencyKey(key: string): Promise<any>;

const current = await api.getIdempotencyKey('orders:123');

static releaseIdempotencyKey(key: string): Promise<void>;

// This attempt acquired the key, no business operation started, and the key has not expired.
await api.releaseIdempotencyKey('orders:123');

static concurrencyLimit(
      key: string,
      limit: number,
      ttl: number,
      leaseOwnerId?: string,
    ): Promise<boolean>;

const locked = await api.concurrencyLimit('sync:customers', 1, 300);

static rateLimit(key: string, limit: number, ttl: number): Promise<boolean>;

const allowed = await api.rateLimit('outbound:crm', 10, 60);

static releaseRateLimit(key: string): Promise<void>;

await api.releaseRateLimit('outbound:crm');

static releaseConcurrencyLimit(key: string, leaseOwnerId?: string): Promise<void>;

// In the same runtime invocation, once for each successful admission.
await api.releaseConcurrencyLimit('sync:customers');

static triggerEvent(
      name: string,
      message: any,
      options?: TriggerEventOptions,
    ): Promise<string>;

const eventId = await api.triggerEvent(
  'customer_sync',
  { customerId: 'c-1' },
  {
    scheduleFor: new Date(Date.now() + 5 * 60 * 1000).toISOString(),
    metadata: { correlationId: 'sync-123' },
  },
);

static triggerTarget(
      targetType: ExecutionTargetType,
      targetId: string,
      input?: Record<string, JsonValue>,
      options?: AutomationScheduleOptions,
    ): Promise<string>;

const jobId = await api.triggerTarget(
  'JOB_TEMPLATE',
  templateId,
  { customerId: 'c-1' },
  { scheduleFor: Date.now() + 5 * 60 * 1000 },
);

static triggerJob(
      templateIdOrName: string,
      templateInputs?: Record<string, JsonValue>,
      options?: AutomationScheduleOptions,
    ): Promise<string>;

const jobId = await api.triggerJob(
  templateId,
  { customerId: 'c-1' },
  { scheduleFor: new Date(Date.now() + 15 * 60 * 1000) },
);

static triggerWebhook(
      webhook: WebhookInput,
      options?: AutomationScheduleOptions,
    ): Promise<Webhook>;

const webhook = await api.triggerWebhook({
  request: {
    url: 'https://example.com/hook',
    method: 'POST',
    body: { ok: true },
  },
}, {
  scheduleFor: new Date(Date.now() + 5 * 60 * 1000).toISOString(),
});

static cancelJobs(input: JobsBulkInput): Promise<AutomationOperation>;

const operation = await api.cancelJobs({ filter: { field: 'status', op: 'eq', value: 'SCHEDULED' } });

static retryJobs(input: JobsBulkInput): Promise<AutomationOperation>;

const operation = await api.retryJobs({ filter: { field: 'status', op: 'eq', value: 'ERROR' } });

static deleteJobs(input: JobsBulkInput): Promise<AutomationOperation>;

const operation = await api.deleteJobs({ filter: { field: 'status', op: 'eq', value: 'FINISHED' } });

static cancelWebhooks(input: WebhooksBulkInput): Promise<AutomationOperation>;

const operation = await api.cancelWebhooks({ filter: { field: 'status', op: 'eq', value: 'SCHEDULED' } });

static retryWebhooks(input: WebhooksBulkInput): Promise<AutomationOperation>;

const operation = await api.retryWebhooks({ filter: { field: 'status', op: 'eq', value: 'ERROR' } });

static deleteWebhooks(input: WebhooksBulkInput): Promise<AutomationOperation>;

const operation = await api.deleteWebhooks({ filter: { field: 'status', op: 'eq', value: 'FINISHED' } });

static previewAutomationOperation(resource: 'jobs' | 'webhooks', action: 'cancel' | 'retry' | 'delete', input: JobsBulkInput | WebhooksBulkInput): Promise<{ matched: number; eligible: number }>;

static getAutomationOperation(operationId: string): Promise<AutomationOperation>;

const operation = await api.getAutomationOperation(input.operationId);

static getAutomationOperationItems(operationId: string, after?: string): Promise<{ data: Array<{ resourceId: string; status: string; resultId: string | null; errorCode: string | null }>; nextCursor: string | null }>;

const page = await api.getAutomationOperationItems(input.operationId);

static httpCall(config: HttpRequestInterface, options: Omit<HttpRequestOptionsInterface, 'responseType' | 'target'> & {
      responseType: 'stream'; streamFormat: 'sse'; timeout?: number; proxy?: false;
    }): Promise<HttpStreamResponse<HttpSseEvent>>;

static httpCall(config: HttpRequestInterface, options: Omit<HttpRequestOptionsInterface, 'responseType' | 'target'> & {
      responseType: 'stream'; streamFormat?: 'bytes'; timeout?: number; proxy?: false;
    }): Promise<HttpStreamResponse<Uint8Array>>;

static httpCall(config: HttpRequestInterface, options: HttpRequestOptionsInterface & { responseType: 'storage'; target: HttpStorageTargetRef; timeout?: number; proxy?: boolean }): Promise<{
      status: number; statusText: string; time: number; headers: LooseObject<string | string[]>;
      revo?: HttpRevoResponseScope;
      request: { config: HttpRequestInterface; options: HttpRequestOptionsInterface };
    } & ({ data: undefined; storage: { session: StorageUploadSession; entry: StorageEntryView } } | { data: string; storage?: undefined })>;

static httpCall(
      config: HttpRequestInterface,
      options?: HttpRequestOptionsInterface & {
        timeout?: number;
        proxy?: boolean;
      },
    ): Promise<{
      status: number;
      statusText: string;
      time: number;
      headers: LooseObject<string | string[]>;
      revo?: HttpRevoResponseScope;
      data: any;
      storage?: { session: StorageUploadSession; entry: StorageEntryView };
      request: {
        config: HttpRequestInterface & { timeout?: number };
        options: HttpRequestOptionsInterface & {
          timeout?: number;
          proxy?: boolean;
        };
      };
    }>;

const response = await api.httpCall(
  {
    url: 'https://example.com/customers',
    method: 'POST',
    data: { customerId: 'customer-1' },
  },
  {
    requestType: 'json',
    responseType: 'json',
    timeout: 15000,
  },
);

Multipart request with one Storage file:
const response = await api.httpCall(
  {
    url: 'https://example.com/upload',
    method: 'POST',
    formData: [
      { key: 'description', value: 'Contract' },
      { key: 'file' },
    ],
  },
  {
    requestType: 'form-data',
    source: { storageEntryId },
  },
);

Multipart request with multiple Storage files:
const response = await api.httpCall(
  {
    url: 'https://example.com/merge',
    method: 'POST',
    formData: [
      { key: 'contract', storageEntryId: contractEntryId },
      { key: 'attachments', storageEntryId: attachmentsEntryId },
    ],
  },
  { requestType: 'form-data' },
);

Storage response stream:
const response = await api.httpCall(
  { url: 'https://example.com/report.csv', method: 'GET' },
  {
    responseType: 'storage',
    target: {
      name: 'report.csv',
      contentTypeHint: 'text/csv',
      computeStats: 'sync',
    },
  },
);

Storage request stream:
await api.httpCall(
  { url: 'https://example.com/import', method: 'POST' },
  { requestType: 'storage', source: { storageEntryId } },
);

Storage conversion:
await api.httpCall(
  { url: 'https://example.com/convert', method: 'POST' },
  {
    requestType: 'storage',
    source: { storageEntryId: sourceEntryId },
    responseType: 'storage',
    target: { name: 'converted.pdf', contentTypeHint: 'application/pdf' },
  },
);