RevoEngine Documentation

Generated from the same public contract that feeds the Monaco editor. Declaration-marked deprecated compatibility methods are intentionally excluded. Do not edit this page manually.

This page contains 70 methods. Search the docs for an exact method name, or use this index:

api.createDatabase()
api.cloneDatabase()
api.exportDatabase()
api.exportDatabaseView()
api.updateDatabase()
api.deleteDatabase()
api.restoreDatabase()
api.truncateDatabase()
api.transactionDatabase()
api.getDatabaseData()
api.getDatabaseViewData()
api.getDatabaseAudit()
api.insertDatabaseData()
api.upsertDatabaseData()
api.updateDatabaseData()
api.deleteDatabaseData()
api.updateDatabaseDataRequest()
api.deleteDatabaseDataRequest()
api.queryDatabase()
api.currentUser()
api.isDebug()
api.disableDebug()
api.enableDebug()
api.getCache()
api.setCache()
api.getContext()
api.getErrors()
api.getWarnings()
api.getExecutionId()
api.getLogs()
api.getOperationId()
api.executeComponent()
api.input()
api.log()
api.exit()
api.throw()
api.getCurrentInstance()
api.getInstanceData()
api.getInstanceDetails()
api.getSecret()
api.getSecrets()
api.publishMessage()
api.getInstanceCache()
api.setInstanceCache()
api.setInstanceCacheIfNotExists()
api.getOrSetInstanceCache()
api.removeInstanceCache()
api.existsInstanceCache()
api.persistInstanceCache()
api.expireInstanceCache()
api.getExpireInstanceCache()
api.listInstanceCache()
api.incrementInstanceCache()
api.decrementInstanceCache()
api.compareAndSetInstanceCache()
api.acquireIdempotencyKey()
api.getIdempotencyKey()
api.releaseIdempotencyKey()
api.concurrencyLimit()
api.rateLimit()
api.releaseRateLimit()
api.releaseConcurrencyLimit()
api.triggerEvent()
api.triggerTarget()
api.triggerJob()
api.triggerWebhook()
api.httpCall()
api.sftpExec()
api.sftpPut()
api.sftpGet()

`api.createDatabase()`

Creates a logical database. The server assigns databaseId, version, and timestamps; never generate or send those values. A normal database needs at least one definition. Notes:

No-op in debug mode.

Signature

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

Example

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: [],
  }],
});

`api.cloneDatabase()`

Clones a logical database by name or database id. Notes:

No-op in debug mode.
By default waits for the clone and returns cloned database metadata.
Set { async: true } to start a backend clone task and return immediately with an accepted response.
Omit name to use the backend default source-name plus _Clone.

Signature

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

Example

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

return result.databases;

`api.exportDatabase()`

Exports logical database rows directly into Storage as CSV. Notes:

No-op in debug mode.
By default waits for the export, final compose, and storage entry persistence.
Set { async: true } to return immediately with an accepted response.
Omit storageDestination for private user storage, use ROOT for Explorer root, or provide an accessible Explorer folder storageEntryId.

Signature

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

Example

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

return result.storageEntryId;

`api.exportDatabaseView()`

Exports a saved database view or materialized view directly into Storage as CSV. The saved view owns its joins and CTEs; callers may add projection, filters, grouping, sorting, and paging over the resulting view definition. Defaults to waiting for the completed Storage entry. Set async: true for kickoff semantics.

Signature

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

No dedicated example is encoded in the current editor declaration. The signature is authoritative.

`api.updateDatabase()`

Updates selected logical-database fields. The public contract requires the current version for optimistic locking; send only the fields that should change. Do not copy server-owned databaseId, timestamps, or size into this payload. Notes:

No-op in debug mode.

Signature

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

Example

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

`api.deleteDatabase()`

Soft-deletes a logical database. Notes:

No-op in debug mode.

Signature

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

Example

await api.deleteDatabase(databaseId);

`api.restoreDatabase()`

Restores a deleted logical database. Notes:

No-op in debug mode.

Signature

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

Example

await api.restoreDatabase(databaseId);

`api.truncateDatabase()`

Removes all rows from a logical database. Notes:

No-op in debug mode.
TRUNCATE does not create row audit events, even when database audit is enabled.
Use an ordinary filtered delete, such as primary key IS NOT NULL, to preserve row audit events.
Identity counters are preserved by default.
Set restartIdentity only when generated key reuse is explicitly intended.

Signature

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

Example

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

`api.transactionDatabase()`

Runs database-data operations inside a short-lived transaction. Notes:

Commits automatically when the callback resolves.
Rolls back automatically when the callback throws.
The default timeout is 15,000 ms.
Use { flexTimeout: true } when the transaction intentionally needs the enclosing execution’s remaining timeout budget.
Long transactions reserve a database connection and may retain locks; keep waits and remote side effects outside the callback when possible.
SERIALIZABLE is the default isolation level.
Parallel tx.* operations are rejected; await each tx.* call sequentially.

Signature

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

Example

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') },
    ]);
  }
});

`api.getDatabaseData()`

Reads database rows using the structured query shape. Notes:

This is the canonical read API.

Signature

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

Example

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

`api.getDatabaseViewData()`

Reads a saved database view by its logical name. The saved view owns its joins and CTEs; callers may add projection, filters, casts, grouping, sorting, count, and pagination over the resulting definition.

Signature

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

No dedicated example is encoded in the current editor declaration. The signature is authoritative.

`api.getDatabaseAudit()`

Reads newest-first audit events. Prefer narrow fields and changed/filter over a full snapshot.* or changes.* payload. Missing requested paths return null.

Signature

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

No dedicated example is encoded in the current editor declaration. The signature is authoritative.

`api.insertDatabaseData()`

Inserts rows. Notes:

No-op in debug mode.

Signature

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

Example

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

`api.upsertDatabaseData()`

Upserts rows. Notes:

No-op in debug mode.

Signature

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

Example

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

`api.updateDatabaseData()`

Updates rows matched by oldObject. Notes:

No-op in debug mode.

Signature

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

Example

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

`api.deleteDatabaseData()`

Deletes rows. Notes:

No-op in debug mode.

Signature

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

Example

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

`api.updateDatabaseDataRequest()`

Bulk-updates rows matched by an advanced structured filter. Notes:

No-op in debug mode.

Signature

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

Example

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

`api.deleteDatabaseDataRequest()`

Bulk-deletes rows matched by an advanced structured filter. Notes:

No-op in debug mode.

Signature

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

Example

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

`api.queryDatabase()`

Executes raw SELECT/WITH SQL when the structured helpers are not enough. Do not use this for writes; use insert/upsert/update/delete helpers or transactionDatabase for write flows.

Signature

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

Example

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

`api.currentUser()`

Returns the current logged user or service account.

Signature

static currentUser(): LoggedUser;

Example

const user = api.currentUser();

`api.isDebug()`

Returns true when debug mode is enabled.

Signature

static isDebug(): boolean;

Example

if (api.isDebug()) {
  api.log('Debug mode', 'WARN');
}

`api.disableDebug()`

Disables debug mode for the current execution.

Signature

static disableDebug(): void;

Example

api.disableDebug();

`api.enableDebug()`

Enables debug mode for the current execution.

Signature

static enableDebug(): void;

Example

api.enableDebug();

`api.getCache()`

Reads request-scoped in-memory cache.

Signature

static getCache(key: string): any;

Example

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

`api.setCache()`

Writes request-scoped in-memory cache.

Signature

static setCache(key: string, value: any): void;

Example

api.setCache('token', 'abc');

`api.getContext()`

Returns the current execution context.

Signature

static getContext(): Context;

Example

const ctx = api.getContext();

`api.getErrors()`

Returns collected error logs.

Signature

static getErrors(): ProcessLog[];

Example

const errors = api.getErrors();

`api.getWarnings()`

Returns collected warning logs.

Signature

static getWarnings(): ProcessLog[];

Example

const warnings = api.getWarnings();

`api.getExecutionId()`

Returns the UUID that identifies the current low-code execution. For durable jobs this is the job id. Endpoint and Sandbox executions receive an independent execution UUID while retaining their operation id for distributed request tracing.

Signature

static getExecutionId(): string;

Example

const executionId = api.getExecutionId();

`api.getLogs()`

Returns collected info logs.

Signature

static getLogs(): LooseObject<any>[];

Example

const logs = api.getLogs();

`api.getOperationId()`

Returns the current operation id.

Signature

static getOperationId(): string;

Example

const op = api.getOperationId();

`api.executeComponent()`

Executes another active component in the managed RevoEngine runtime and returns its execution result. Notes:

Supports CODE_JS, CODE_TS, and CUSTOM_NODEJS components.
CODE_JS and CODE_TS run in a fresh, isolated RevoEngine V8 environment.
CUSTOM_NODEJS runs in its governed RevoEngine component environment.
If timeoutMs is omitted, the child receives the parent execution’s remaining timeout budget.
A larger timeoutMs is clamped to that remaining budget.
At least 1 second of parent budget is required for nested component execution.
Promise.all() starts independent child component executions.

Signature

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

Example

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

`api.input()`

Returns the current execution payload. Notes:

In endpoint context this usually includes body, query, headers, params, path, and method.
In event or job context it commonly includes type and message.
Passing a name returns a single top-level property.

Signature

static input(name?: string): Input;

Example

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

`api.log()`

Adds a log entry.

Signature

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

Example

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

`api.exit()`

Stops execution early without marking it as a sandbox failure.

Signature

static exit(): void;

Example

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

`api.throw()`

Stores an HTTP-style response and aborts execution. Notes:

Reserved 502 and 503 codes are not allowed from Endpoint user code.

Signature

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

Example

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

`api.getCurrentInstance()`

Returns the current instance id.

Signature

static getCurrentInstance(): string;

Example

const instanceId = api.getCurrentInstance();

`api.getInstanceData()`

Reads data from platform-managed sources.

Signature

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>;

Example

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

`api.getInstanceDetails()`

Returns public instance metadata.

Signature

static getInstanceDetails(): InstanceDetails;

Example

const details = api.getInstanceDetails();

`api.getSecret()`

Resolves a single secret value by name.

Signature

static getSecret(name: string): Promise<string>;

Example

const apiKey = await api.getSecret('CRM_API_KEY');

`api.getSecrets()`

Resolves multiple secret values by name.

Signature

static getSecrets(name: string[]): Promise<{ [key: string]: string }>;

Example

const secrets = await api.getSecrets([
  'CRM_API_KEY',
  'CRM_API_URL',
]);

`api.publishMessage()`

Publishes a realtime message. Notes:

No-op in debug mode.
Currently only the ‘ALL’ channel is supported.

Signature

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

Example

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

`api.getInstanceCache()`

Reads instance-scoped cache.

Signature

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

Example

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

`api.setInstanceCache()`

Writes instance-scoped cache. Notes:

No-op in debug mode.

Signature

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

Example

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

`api.setInstanceCacheIfNotExists()`

Writes instance-scoped cache only when the key does not exist. Notes:

No-op in debug mode.

Signature

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

Example

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

`api.getOrSetInstanceCache()`

Reads a cache key or stores the fallback value atomically if it is missing.

Signature

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

Example

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

`api.removeInstanceCache()`

Removes cache keys. Notes:

No-op in debug mode.

Signature

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

Example

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

`api.existsInstanceCache()`

Checks whether an instance cache key exists.

Signature

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

Example

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

`api.persistInstanceCache()`

Makes a cache key persistent. Notes:

No-op in debug mode.

Signature

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

Example

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

`api.expireInstanceCache()`

Sets cache TTL in seconds. Notes:

No-op in debug mode.

Signature

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

Example

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

`api.getExpireInstanceCache()`

Returns cache TTL in seconds, 0 for no expiry, or null when the key does not exist.

Signature

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

Example

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

`api.listInstanceCache()`

Lists instance cache keys by prefix or pattern.

Signature

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

Example

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

`api.incrementInstanceCache()`

Atomically increments an integer cache key. Notes:

No-op in debug mode.
‘by’ must be an integer.

Signature

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

Example

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

`api.decrementInstanceCache()`

Atomically decrements an integer cache key. Notes:

No-op in debug mode.
‘by’ must be an integer.

Signature

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

Example

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

`api.compareAndSetInstanceCache()`

Atomically updates a cache key only when the current value matches ‘expected’. Notes:

No-op in debug mode.

Signature

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

Example

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

`api.acquireIdempotencyKey()`

Acquires an idempotency key in the instance-scoped managed cache. Notes:

No-op in debug mode.

Signature

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

Example

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

`api.getIdempotencyKey()`

Reads stored idempotency metadata.

Signature

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

Example

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

`api.releaseIdempotencyKey()`

Releases an idempotency key. Notes:

No-op in debug mode.

Signature

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

Example

await api.releaseIdempotencyKey('orders:123');

`api.concurrencyLimit()`

Acquires an instance-scoped concurrency token. Notes:

No-op in debug mode.

Signature

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

Example

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

`api.rateLimit()`

Acquires an instance-scoped rate-limit token. Notes:

No-op in debug mode.

Signature

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

Example

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

`api.releaseRateLimit()`

Releases a rate-limit key. Notes:

No-op in debug mode.

Signature

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

Example

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

`api.releaseConcurrencyLimit()`

Releases a concurrency-limit key. Notes:

No-op in debug mode.

Signature

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

Example

await api.releaseConcurrencyLimit('sync:customers');

`api.triggerEvent()`

Schedules a custom event. Notes:

The existing Date argument and scheduleDate option remain supported.
New code should use scheduleFor with a Date, ISO 8601 date-time, or Unix timestamp in milliseconds.
The absolute time cannot be in the past or more than 30 days ahead.
No-op in debug mode.

Signature

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

Example

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

`api.triggerTarget()`

Schedules generic execution against a normalized target. Notes:

Use JOB_TEMPLATE for legacy template execution or AGENT for agent-native dispatch.
The existing absolute Date argument remains supported.
New code should pass { scheduleFor }; the maximum horizon is 30 days.
No-op in debug mode.

Signature

static triggerTarget(
      targetType: ExecutionTargetType,
      targetId: string,
      input?: any,
      scheduleDate?: Date | AutomationScheduleOptions,
    ): Promise<string>;

Example

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

`api.triggerJob()`

Schedules a job template. Notes:

No-op in debug mode.
Convenience wrapper for api.triggerTarget('JOB_TEMPLATE', templateId, ...).
The existing absolute Date argument remains supported.
New code should pass { scheduleFor }; the maximum horizon is 30 days.

Signature

static triggerJob(
      templateId: string,
      input?: any,
      scheduleDate?: Date | AutomationScheduleOptions,
    ): Promise<string>;

Example

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

`api.triggerWebhook()`

Schedules a webhook delivery. Notes:

The existing absolute Date argument remains supported.
New code should pass { scheduleFor }; the maximum horizon is 30 days.
No-op in debug mode.

Signature

static triggerWebhook(
      webhook: WebhookInput,
      scheduleDate?: Date | AutomationScheduleOptions,
    ): Promise<Webhook>;

Example

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(),
});

`api.httpCall()`

Performs an outbound HTTP request. Notes:

Supports proxy mode, form-data, Storage streaming, and optional current credentials.
Use source: { storageEntryId } when streaming an Explorer Storage file into an HTTP request.
Use target: { name, ... } or target: { storageEntryId, replace: true } when streaming an HTTP response into Explorer Storage.
source and target may be used together to stream a Storage entry through an external conversion API and save its response into Storage.
For multipart requests, put formData on the first config argument. Use one empty part with source, or put storageEntryId directly on each binary formData part.
HTTP Storage targets use one provider-streamed direct upload and are finalized automatically. Use storage.createUploadSession plus storage.uploadPart for resumable/chunked session workflows.
requestType: 'storage' and responseType: 'storage' are not valid; Storage is selected by source/target while requestType/responseType describe HTTP encoding.
response.data is undefined when the response is stored; use response.storage.entry after successful finalization.
For text files, prefer computeStats: 'sync' on the storage target so line stats are immediately available after finalize.
JSON is the default request and response format. Explicit requestType: 'json' is valid for every supported HTTP method and may be combined with any response type because it does not declare a request body.

Signature

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

Example

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: 'stream',
    target: {
      name: 'report.csv',
      contentTypeHint: 'text/csv',
      computeStats: 'sync',
    },
  },
);

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

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

`api.sftpExec()`

Executes multiple SFTP commands in order. Notes:

No-op in debug mode.

Signature

static sftpExec(commands: any[], config: SFTPClient): Promise<any>;

Example

await api.sftpExec([['mkdir', '/archive']], connection);

`api.sftpPut()`

Streams an Explorer Storage entry directly to SFTP without loading file bytes into low-code memory. Notes:

No-op in debug mode.
Prefer { storageEntryId } for Explorer Storage files. String inputs are legacy fileIds.
SFTP references use Explorer Storage; namespace is not part of this API.

Signature

static sftpPut(
      source: SFTPFileSourceRef,
      path: string,
      config: SFTPClient,
    ): Promise<void>;

Example

await api.sftpPut({ storageEntryId }, '/outbound/report.csv', connection);

`api.sftpGet()`

Streams an SFTP file directly into Explorer Storage and returns the finalized Storage entry. Notes:

No-op in debug mode.
Use { storage: … } to create an entry or { storageEntryId, replace: true } to replace one.
Repeated finalization signals are idempotent.
For text files, computeStats: ‘sync’ makes line statistics available immediately.

Signature

static sftpGet(
      target: SFTPFileTargetRef,
      path: string,
      config: SFTPClient,
    ): Promise<void | { session: StorageUploadSession; entry: StorageEntryView }>;

Example

const result = await api.sftpGet({
  storage: {
    name: 'daily.csv',
    parentStorageEntryId: folderId,
    contentTypeHint: 'text/csv',
    computeStats: 'sync',
    retention: { ttlSeconds: 604800 },
  },
}, '/incoming/report.csv', connection);

Last modified on September 5, 2026

​api.createDatabase()

​Signature

​Example

​api.cloneDatabase()

​Signature

​Example

​api.exportDatabase()

​Signature

​Example

​api.exportDatabaseView()

​Signature

​api.updateDatabase()

​Signature

​Example

​api.deleteDatabase()

​Signature

​Example

​api.restoreDatabase()

​Signature

​Example

​api.truncateDatabase()

​Signature

​Example

​api.transactionDatabase()

​Signature

​Example

​api.getDatabaseData()

​Signature

​Example

​api.getDatabaseViewData()

​Signature

​api.getDatabaseAudit()

​Signature

​api.insertDatabaseData()

​Signature

​Example

​api.upsertDatabaseData()

​Signature

​Example

​api.updateDatabaseData()

​Signature

​Example

​api.deleteDatabaseData()

​Signature

​Example

​api.updateDatabaseDataRequest()

​Signature

​Example

​api.deleteDatabaseDataRequest()

​Signature

​Example

​api.queryDatabase()

​Signature

​Example

​api.currentUser()

​Signature

​Example

​api.isDebug()

​Signature

​Example

​api.disableDebug()

​Signature

​Example

​api.enableDebug()

​Signature

​Example

​api.getCache()

​Signature

​Example

​api.setCache()

​Signature

​Example

​api.getContext()

​Signature

​Example

​api.getErrors()

​Signature

​Example

​api.getWarnings()

​Signature

`api.createDatabase()`

Signature

Example

`api.cloneDatabase()`

Signature

Example

`api.exportDatabase()`

Signature

Example

`api.exportDatabaseView()`

Signature

`api.updateDatabase()`

Signature

Example

`api.deleteDatabase()`

Signature

Example

`api.restoreDatabase()`

Signature

Example

`api.truncateDatabase()`

Signature

Example

`api.transactionDatabase()`

Signature

Example

`api.getDatabaseData()`

Signature

Example

`api.getDatabaseViewData()`

Signature

`api.getDatabaseAudit()`

Signature

`api.insertDatabaseData()`

Signature

Example

`api.upsertDatabaseData()`

Signature

Example

`api.updateDatabaseData()`

Signature

Example

`api.deleteDatabaseData()`

Signature

Example

`api.updateDatabaseDataRequest()`

Signature

Example

`api.deleteDatabaseDataRequest()`

Signature

Example

`api.queryDatabase()`

Signature

Example

`api.currentUser()`

Signature

Example

`api.isDebug()`

Signature

Example

`api.disableDebug()`

Signature

Example

`api.enableDebug()`

Signature

Example

`api.getCache()`

Signature

Example

`api.setCache()`

Signature

Example

`api.getContext()`

Signature

Example

`api.getErrors()`

Signature

Example

`api.getWarnings()`

Signature