@zavudev/sdk 0.31.0 → 0.43.0

package/src/resources/functions/functions.ts

@@ -0,0 +1,562 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import { APIResource } from '../../core/resource';
+import * as SecretsAPI from './secrets';
+import {
+  SecretListResponse,
+  SecretSetParams,
+  SecretSetResponse,
+  SecretUnsetParams,
+  Secrets,
+} from './secrets';
+import { APIPromise } from '../../core/api-promise';
+import { RequestOptions } from '../../internal/request-options';
+import { path } from '../../internal/utils/path';
+
+export class Functions extends APIResource {
+  secrets: SecretsAPI.Secrets = new SecretsAPI.Secrets(this._client);
+
+  /**
+   * Create a new Zavu Function. The function starts in `draft` status. A dedicated
+   * API key is auto-provisioned and injected as the `ZAVU_API_KEY` secret so the
+   * function can call back into the Zavu API without manual setup.
+   *
+   * Provide `sourceCode` to seed the draft. Call
+   * `POST /v1/functions/{functionId}/deploy` afterwards to publish.
+   *
+   * @example
+   * ```ts
+   * const _function = await client.functions.create({
+   *   name: 'Order Bot',
+   *   slug: 'order-bot',
+   *   dependencies: { openai: '^4.20.0' },
+   *   description:
+   *     'Replies to order status questions on WhatsApp.',
+   *   sourceCode:
+   *     "import { defineFunction } from '@zavu/functions';\n\nexport default defineFunction(async (event, ctx) => {\n  ctx.log('received', event.type);\n});\n",
+   * });
+   * ```
+   */
+  create(body: FunctionCreateParams, options?: RequestOptions): APIPromise<FunctionCreateResponse> {
+    return this._client.post('/v1/functions', { body, ...options });
+  }
+
+  /**
+   * Get function
+   *
+   * @example
+   * ```ts
+   * const _function = await client.functions.retrieve(
+   *   'functionId',
+   * );
+   * ```
+   */
+  retrieve(functionID: string, options?: RequestOptions): APIPromise<FunctionRetrieveResponse> {
+    return this._client.get(path`/v1/functions/${functionID}`, options);
+  }
+
+  /**
+   * Update the draft source code and/or dependency map without triggering a build.
+   * Visible in the dashboard immediately, but the live (deployed) function does not
+   * change until `POST /v1/functions/{functionId}/deploy` runs.
+   *
+   * @example
+   * ```ts
+   * const _function = await client.functions.update(
+   *   'functionId',
+   * );
+   * ```
+   */
+  update(
+    functionID: string,
+    body: FunctionUpdateParams,
+    options?: RequestOptions,
+  ): APIPromise<FunctionUpdateResponse> {
+    return this._client.patch(path`/v1/functions/${functionID}`, { body, ...options });
+  }
+
+  /**
+   * Permanently delete a function and cascade: triggers, secrets, deployment
+   * history, managed agents+tools, and revoke the auto-provisioned API key. The AWS
+   * Lambda + log group are torn down asynchronously.
+   *
+   * @example
+   * ```ts
+   * const _function = await client.functions.delete(
+   *   'functionId',
+   * );
+   * ```
+   */
+  delete(functionID: string, options?: RequestOptions): APIPromise<FunctionDeleteResponse> {
+    return this._client.delete(path`/v1/functions/${functionID}`, options);
+  }
+
+  /**
+   * Publish the function. If `sourceCode` or `dependencies` are provided in the
+   * body, they replace the current draft before deployment. Returns immediately with
+   * a deployment ID — poll `GET /v1/functions/deployments/{deploymentId}` until
+   * status is `active` or `failed`.
+   *
+   * @example
+   * ```ts
+   * const response = await client.functions.deploy(
+   *   'functionId',
+   * );
+   * ```
+   */
+  deploy(
+    functionID: string,
+    body: FunctionDeployParams | null | undefined = {},
+    options?: RequestOptions,
+  ): APIPromise<FunctionDeployResponse> {
+    return this._client.post(path`/v1/functions/${functionID}/deploy`, { body, ...options });
+  }
+
+  /**
+   * Fetch a deployment to poll its status during a deploy.
+   *
+   * @example
+   * ```ts
+   * const response = await client.functions.getDeployment(
+   *   'deploymentId',
+   * );
+   * ```
+   */
+  getDeployment(deploymentID: string, options?: RequestOptions): APIPromise<FunctionGetDeploymentResponse> {
+    return this._client.get(path`/v1/functions/deployments/${deploymentID}`, options);
+  }
+
+  /**
+   * Fetch invocation logs for a function. Logs are paginated via `nextToken`. Pass
+   * `startTime` / `endTime` (Unix epoch milliseconds) to bound the window, or
+   * `filterPattern` to filter messages.
+   *
+   * @example
+   * ```ts
+   * const response = await client.functions.tailLogs(
+   *   'functionId',
+   * );
+   * ```
+   */
+  tailLogs(
+    functionID: string,
+    query: FunctionTailLogsParams | null | undefined = {},
+    options?: RequestOptions,
+  ): APIPromise<FunctionTailLogsResponse> {
+    return this._client.get(path`/v1/functions/${functionID}/logs`, { query, ...options });
+  }
+}
+
+export interface FunctionCreateResponse {
+  /**
+   * A Zavu Function — user-supplied TypeScript that runs in Zavu Cloud and reacts to
+   * messaging events or HTTP requests.
+   */
+  function: FunctionCreateResponse.Function;
+}
+
+export namespace FunctionCreateResponse {
+  /**
+   * A Zavu Function — user-supplied TypeScript that runs in Zavu Cloud and reacts to
+   * messaging events or HTTP requests.
+   */
+  export interface Function {
+    id: string;
+
+    createdAt: string;
+
+    /**
+     * npm dependencies installed in the function bundle. Keys are package names,
+     * values are semver ranges.
+     */
+    dependencies: { [key: string]: string };
+
+    /**
+     * Whether the function can be invoked over HTTPS via its public URL.
+     */
+    httpEnabled: boolean;
+
+    /**
+     * Memory allocation in MB.
+     */
+    memoryMb: number;
+
+    name: string;
+
+    /**
+     * Runtime the function is deployed on.
+     */
+    runtime: 'nodejs24';
+
+    /**
+     * URL-safe identifier, unique per project.
+     */
+    slug: string;
+
+    /**
+     * Lifecycle status of a Zavu Function.
+     */
+    status: 'draft' | 'bundling' | 'deploying' | 'active' | 'failed' | 'disabled';
+
+    /**
+     * Per-invocation timeout in seconds.
+     */
+    timeoutSec: number;
+
+    updatedAt: string;
+
+    /**
+     * ID of the deployment currently serving traffic.
+     */
+    activeDeploymentId?: string | null;
+
+    description?: string | null;
+
+    /**
+     * HTTPS endpoint when httpEnabled is true.
+     */
+    publicUrl?: string | null;
+  }
+}
+
+export interface FunctionRetrieveResponse {
+  /**
+   * A Zavu Function — user-supplied TypeScript that runs in Zavu Cloud and reacts to
+   * messaging events or HTTP requests.
+   */
+  function: FunctionRetrieveResponse.Function;
+}
+
+export namespace FunctionRetrieveResponse {
+  /**
+   * A Zavu Function — user-supplied TypeScript that runs in Zavu Cloud and reacts to
+   * messaging events or HTTP requests.
+   */
+  export interface Function {
+    id: string;
+
+    createdAt: string;
+
+    /**
+     * npm dependencies installed in the function bundle. Keys are package names,
+     * values are semver ranges.
+     */
+    dependencies: { [key: string]: string };
+
+    /**
+     * Whether the function can be invoked over HTTPS via its public URL.
+     */
+    httpEnabled: boolean;
+
+    /**
+     * Memory allocation in MB.
+     */
+    memoryMb: number;
+
+    name: string;
+
+    /**
+     * Runtime the function is deployed on.
+     */
+    runtime: 'nodejs24';
+
+    /**
+     * URL-safe identifier, unique per project.
+     */
+    slug: string;
+
+    /**
+     * Lifecycle status of a Zavu Function.
+     */
+    status: 'draft' | 'bundling' | 'deploying' | 'active' | 'failed' | 'disabled';
+
+    /**
+     * Per-invocation timeout in seconds.
+     */
+    timeoutSec: number;
+
+    updatedAt: string;
+
+    /**
+     * ID of the deployment currently serving traffic.
+     */
+    activeDeploymentId?: string | null;
+
+    description?: string | null;
+
+    /**
+     * HTTPS endpoint when httpEnabled is true.
+     */
+    publicUrl?: string | null;
+  }
+}
+
+export interface FunctionUpdateResponse {
+  /**
+   * A Zavu Function — user-supplied TypeScript that runs in Zavu Cloud and reacts to
+   * messaging events or HTTP requests.
+   */
+  function: FunctionUpdateResponse.Function;
+}
+
+export namespace FunctionUpdateResponse {
+  /**
+   * A Zavu Function — user-supplied TypeScript that runs in Zavu Cloud and reacts to
+   * messaging events or HTTP requests.
+   */
+  export interface Function {
+    id: string;
+
+    createdAt: string;
+
+    /**
+     * npm dependencies installed in the function bundle. Keys are package names,
+     * values are semver ranges.
+     */
+    dependencies: { [key: string]: string };
+
+    /**
+     * Whether the function can be invoked over HTTPS via its public URL.
+     */
+    httpEnabled: boolean;
+
+    /**
+     * Memory allocation in MB.
+     */
+    memoryMb: number;
+
+    name: string;
+
+    /**
+     * Runtime the function is deployed on.
+     */
+    runtime: 'nodejs24';
+
+    /**
+     * URL-safe identifier, unique per project.
+     */
+    slug: string;
+
+    /**
+     * Lifecycle status of a Zavu Function.
+     */
+    status: 'draft' | 'bundling' | 'deploying' | 'active' | 'failed' | 'disabled';
+
+    /**
+     * Per-invocation timeout in seconds.
+     */
+    timeoutSec: number;
+
+    updatedAt: string;
+
+    /**
+     * ID of the deployment currently serving traffic.
+     */
+    activeDeploymentId?: string | null;
+
+    description?: string | null;
+
+    /**
+     * HTTPS endpoint when httpEnabled is true.
+     */
+    publicUrl?: string | null;
+  }
+}
+
+export interface FunctionDeleteResponse {
+  deleted: boolean;
+
+  name?: string;
+
+  slug?: string;
+}
+
+export interface FunctionDeployResponse {
+  deployment: FunctionDeployResponse.Deployment;
+}
+
+export namespace FunctionDeployResponse {
+  export interface Deployment {
+    id: string;
+
+    createdAt: string;
+
+    functionId: string;
+
+    /**
+     * Stage of a function deployment.
+     */
+    status: 'pending' | 'bundling' | 'uploading' | 'publishing' | 'active' | 'failed' | 'superseded';
+
+    /**
+     * Monotonically increasing deployment version, starting at 1.
+     */
+    version: number;
+
+    bundleBytes?: number | null;
+
+    deployedAt?: string | null;
+
+    /**
+     * Failure reason when status is 'failed'.
+     */
+    errorMessage?: string | null;
+
+    sourceCodeBytes?: number | null;
+  }
+}
+
+export interface FunctionGetDeploymentResponse {
+  deployment: FunctionGetDeploymentResponse.Deployment;
+}
+
+export namespace FunctionGetDeploymentResponse {
+  export interface Deployment {
+    id: string;
+
+    createdAt: string;
+
+    functionId: string;
+
+    /**
+     * Stage of a function deployment.
+     */
+    status: 'pending' | 'bundling' | 'uploading' | 'publishing' | 'active' | 'failed' | 'superseded';
+
+    /**
+     * Monotonically increasing deployment version, starting at 1.
+     */
+    version: number;
+
+    bundleBytes?: number | null;
+
+    deployedAt?: string | null;
+
+    /**
+     * Failure reason when status is 'failed'.
+     */
+    errorMessage?: string | null;
+
+    sourceCodeBytes?: number | null;
+  }
+}
+
+export interface FunctionTailLogsResponse {
+  events: Array<FunctionTailLogsResponse.Event>;
+
+  /**
+   * Pass to the next request to fetch the following page of logs.
+   */
+  nextToken?: string | null;
+}
+
+export namespace FunctionTailLogsResponse {
+  export interface Event {
+    message: string;
+
+    timestamp: string;
+  }
+}
+
+export interface FunctionCreateParams {
+  name: string;
+
+  /**
+   * URL-safe identifier (lowercase, digits, hyphens). Must be unique per project.
+   */
+  slug: string;
+
+  /**
+   * npm dependencies. Keys are package names, values are semver ranges.
+   */
+  dependencies?: { [key: string]: string };
+
+  description?: string;
+
+  /**
+   * Whether to expose a public HTTPS URL for this function.
+   */
+  httpEnabled?: boolean;
+
+  memoryMb?: 128 | 256 | 512 | 1024;
+
+  /**
+   * Runtime the function is deployed on.
+   */
+  runtime?: 'nodejs24';
+
+  /**
+   * TypeScript source code for the function entry point (max ~900KB).
+   */
+  sourceCode?: string;
+
+  timeoutSec?: number;
+}
+
+export interface FunctionUpdateParams {
+  /**
+   * New dependency map (replaces existing dependencies).
+   */
+  dependencies?: { [key: string]: string };
+
+  /**
+   * New source code to publish (replaces the draft).
+   */
+  sourceCode?: string;
+}
+
+export interface FunctionDeployParams {
+  /**
+   * New dependency map (replaces existing dependencies).
+   */
+  dependencies?: { [key: string]: string };
+
+  /**
+   * New source code to publish (replaces the draft).
+   */
+  sourceCode?: string;
+}
+
+export interface FunctionTailLogsParams {
+  /**
+   * End of the log window in Unix epoch milliseconds.
+   */
+  endTime?: number;
+
+  filterPattern?: string;
+
+  limit?: number;
+
+  nextToken?: string;
+
+  /**
+   * Start of the log window in Unix epoch milliseconds.
+   */
+  startTime?: number;
+}
+
+Functions.Secrets = Secrets;
+
+export declare namespace Functions {
+  export {
+    type FunctionCreateResponse as FunctionCreateResponse,
+    type FunctionRetrieveResponse as FunctionRetrieveResponse,
+    type FunctionUpdateResponse as FunctionUpdateResponse,
+    type FunctionDeleteResponse as FunctionDeleteResponse,
+    type FunctionDeployResponse as FunctionDeployResponse,
+    type FunctionGetDeploymentResponse as FunctionGetDeploymentResponse,
+    type FunctionTailLogsResponse as FunctionTailLogsResponse,
+    type FunctionCreateParams as FunctionCreateParams,
+    type FunctionUpdateParams as FunctionUpdateParams,
+    type FunctionDeployParams as FunctionDeployParams,
+    type FunctionTailLogsParams as FunctionTailLogsParams,
+  };
+
+  export {
+    Secrets as Secrets,
+    type SecretListResponse as SecretListResponse,
+    type SecretSetResponse as SecretSetResponse,
+    type SecretSetParams as SecretSetParams,
+    type SecretUnsetParams as SecretUnsetParams,
+  };
+}

package/src/resources/functions/index.ts

@@ -0,0 +1,23 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+export {
+  Functions,
+  type FunctionCreateResponse,
+  type FunctionRetrieveResponse,
+  type FunctionUpdateResponse,
+  type FunctionDeleteResponse,
+  type FunctionDeployResponse,
+  type FunctionGetDeploymentResponse,
+  type FunctionTailLogsResponse,
+  type FunctionCreateParams,
+  type FunctionUpdateParams,
+  type FunctionDeployParams,
+  type FunctionTailLogsParams,
+} from './functions';
+export {
+  Secrets,
+  type SecretListResponse,
+  type SecretSetResponse,
+  type SecretSetParams,
+  type SecretUnsetParams,
+} from './secrets';

package/src/resources/functions/secrets.ts

@@ -0,0 +1,112 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import { APIResource } from '../../core/resource';
+import { APIPromise } from '../../core/api-promise';
+import { buildHeaders } from '../../internal/headers';
+import { RequestOptions } from '../../internal/request-options';
+import { path } from '../../internal/utils/path';
+
+export class Secrets extends APIResource {
+  /**
+   * Lists every secret key set on the function. Plaintext is NEVER returned — only
+   * the last 4 characters of each value, for visual confirmation.
+   *
+   * @example
+   * ```ts
+   * const secrets = await client.functions.secrets.list(
+   *   'functionId',
+   * );
+   * ```
+   */
+  list(functionID: string, options?: RequestOptions): APIPromise<SecretListResponse> {
+    return this._client.get(path`/v1/functions/${functionID}/secrets`, options);
+  }
+
+  /**
+   * Create or update a secret on a function. Marks the function out-of-sync; the
+   * next `POST /deploy` re-publishes the Lambda with the new env. Keys must match
+   * `[A-Z_][A-Z0-9_]*` (uppercase env-var style) and cannot start with reserved
+   * prefixes (AWS*, LAMBDA*, etc).
+   *
+   * @example
+   * ```ts
+   * const response = await client.functions.secrets.set('key', {
+   *   functionId: 'functionId',
+   *   value: 'value',
+   * });
+   * ```
+   */
+  set(key: string, params: SecretSetParams, options?: RequestOptions): APIPromise<unknown> {
+    const { functionId, ...body } = params;
+    return this._client.put(path`/v1/functions/${functionId}/secrets/${key}`, { body, ...options });
+  }
+
+  /**
+   * Remove a secret from a function. Doesn't take effect on the running Lambda until
+   * the next deploy.
+   *
+   * @example
+   * ```ts
+   * await client.functions.secrets.unset('key', {
+   *   functionId: 'functionId',
+   * });
+   * ```
+   */
+  unset(key: string, params: SecretUnsetParams, options?: RequestOptions): APIPromise<void> {
+    const { functionId } = params;
+    return this._client.delete(path`/v1/functions/${functionId}/secrets/${key}`, {
+      ...options,
+      headers: buildHeaders([{ Accept: '*/*' }, options?.headers]),
+    });
+  }
+}
+
+export interface SecretListResponse {
+  secrets: Array<SecretListResponse.Secret>;
+}
+
+export namespace SecretListResponse {
+  export interface Secret {
+    id: string;
+
+    key: string;
+
+    valueLast4: string;
+
+    createdAt?: number;
+
+    syncedToAws?: boolean;
+
+    updatedAt?: number;
+  }
+}
+
+export type SecretSetResponse = unknown;
+
+export interface SecretSetParams {
+  /**
+   * Path param: Zavu Function ID.
+   */
+  functionId: string;
+
+  /**
+   * Body param
+   */
+  value: string;
+}
+
+export interface SecretUnsetParams {
+  /**
+   * Zavu Function ID.
+   */
+  functionId: string;
+}
+
+export declare namespace Secrets {
+  export {
+    type SecretListResponse as SecretListResponse,
+    type SecretSetResponse as SecretSetResponse,
+    type SecretSetParams as SecretSetParams,
+    type SecretUnsetParams as SecretUnsetParams,
+  };
+}

package/src/resources/functions.ts

@@ -0,0 +1,3 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+export * from './functions/index';