@tailor-platform/sdk 1.58.0 → 1.60.0

package/dist/vitest/index.d.mts

@@ -1,5 +1,6 @@
 import { n as TailorEnv } from "../env-B-g-qgE4.mjs";
 import { Kysely, OperationNode, OperationNodeKind, Transaction } from "kysely";
+import { Mock } from "vitest";
 import { Plugin } from "vitest/config";
 
 //#region src/vitest/mock.d.ts
@@ -58,60 +59,55 @@ interface IconvCall {
   method: string;
   args: unknown[];
 }
-interface WorkflowCall {
-  method: "triggerWorkflow" | "wait" | "resolve";
-  args: unknown[];
+declare class MockQueryResult {
+  command: string;
+  rowCount: number;
+  rows: unknown[];
+  constructor(rows: unknown[]);
 }
 /**
- * Mock control object for TailorDB operations.
- *
- * Automatically injected into `globalThis.tailordb` by the tailor-runtime environment.
- * Use this object to configure query responses and assert on executed queries.
+ * Acquire a disposable mock for TailorDB operations. Installs a mock
+ * `tailordb.Client` whose `queryObject` is a shared `vi.fn()` (so query
+ * responses can be staged before the client is constructed). Restored on
+ * dispose.
+ * @returns Disposable TailorDB mock control object
  * @example
  * ```typescript
- * import { tailordbMock } from "@tailor-platform/sdk/vitest";
- *
- * beforeEach(() => tailordbMock.reset());
- *
- * test("content-based", () => {
- *   tailordbMock.setQueryResolver((query) => {
- *     if (query.includes("SELECT")) return [{ id: "1" }];
- *     return [];
- *   });
- * });
+ * import { mockTailordb } from "@tailor-platform/sdk/vitest";
  *
- * test("order-based", () => {
- *   tailordbMock.enqueueResults(
- *     [],            // BEGIN (empty result)
- *     [{ age: 30 }], // SELECT (one row)
- *     [],            // COMMIT (empty result)
- *   );
+ * test("order-based", async () => {
+ *   using db = mockTailordb();
+ *   db.enqueueResults([], [{ age: 30 }], []); // BEGIN / SELECT / COMMIT
+ *   // …
+ *   expect(db.queryObject).toHaveBeenCalledTimes(3);
+ *   expect(db.Client).toHaveBeenCalledWith({ namespace: "tailordb" });
  * });
  * ```
  */
-declare const tailordbMock: {
+declare function mockTailordb(): {
+  /** The mock `tailordb.Client` constructor (`vi.fn`). */Client: Mock<(this: any, config?: {
+    namespace?: string;
+  }) => void>; /** The shared `queryObject` `vi.fn` used by every client and transaction. */
+  queryObject: Mock<(_query: string, _params?: unknown[]) => Promise<MockQueryResult>>;
   /**
-   * Set a fallback query resolver. Called when the result queue is empty.
+   * Set a fallback query resolver. Called when the enqueue queue is empty.
    * @param resolver - Function that returns rows for a given query and params
    */
   setQueryResolver(resolver: QueryResolver$1): void;
   /**
-   * Enqueue rows for the next `queryObject` call. Arguments are the row objects returned
-   * by that single query. Call with no arguments for an empty result. Consumed in FIFO
-   * order; when the queue is exhausted, subsequent calls fall back to `setQueryResolver`
-   * (default: empty rows). Use `enqueueResults` to stage rows for multiple queries in one
-   * call.
+   * Enqueue rows for the next `queryObject` call (FIFO; takes priority over
+   * `setQueryResolver`). Call with no arguments for an empty result.
    * @param rows - Row objects to return from the next `queryObject` call
    */
   enqueueResult(...rows: unknown[]): void;
   /**
-   * Enqueue rows for multiple subsequent `queryObject` calls. Each argument is a rows
-   * array for one query, consumed in FIFO order.
+   * Enqueue rows for multiple subsequent `queryObject` calls (FIFO).
    * @param rowsList - Rows arrays, one per upcoming query
    */
   enqueueResults(...rowsList: unknown[][]): void;
   /**
-   * All queries executed via `queryObject`, in order.
+   * All queries executed via `queryObject`, in order, derived from the vi.fn
+   * call records.
    * @returns Executed queries array
    */
   readonly executedQueries: ExecutedQuery$1[];
@@ -119,58 +115,43 @@ declare const tailordbMock: {
    * All TailorDB clients created, with their namespace and end state.
    * @returns Created clients array
    */
-  readonly createdClients: CreatedClient[]; /** Reset all TailorDB mock state. Call in `beforeEach`. */
+  readonly createdClients: CreatedClient[]; /** Reset query responses and recorded calls (keeps the mock installed). */
   reset(): void;
-};
+} & Disposable;
 /**
- * Mock control object for workflow operations.
- *
- * Automatically injected into `globalThis.tailor.workflow` by the tailor-runtime environment.
+ * Acquire a disposable mock for workflow operations (`tailor.workflow`).
+ * Restored on dispose.
+ * @returns Disposable workflow mock control object
  * @example
  * ```typescript
- * import { workflowMock } from "@tailor-platform/sdk/vitest";
+ * import { mockWorkflow } from "@tailor-platform/sdk/vitest";
  *
- * beforeEach(() => workflowMock.reset());
- *
- * test("job handler", () => {
- *   workflowMock.setJobHandler((jobName, args) => {
- *     if (jobName === "validate") return { valid: true };
- *     return null;
- *   });
- * });
- *
- * test("wait point", () => {
- *   workflowMock.setWaitHandler(() => ({ approved: true }));
- *   // …
- *   expect(workflowMock.waitCalls).toEqual([{ key: "approval", payload: undefined }]);
- * });
- *
- * test("resolve point", () => {
- *   workflowMock.setResolveHandler((_executionId, _key, callback) =>
- *     callback({ approved: true }),
- *   );
- *   // …
- *   expect(workflowMock.resolveCalls).toEqual([
- *     { executionId: "mock-execution-id", key: "approval" },
- *   ]);
+ * test("job handler", async () => {
+ *   using wf = mockWorkflow();
+ *   wf.setJobHandler((name) => (name === "validate" ? { valid: true } : null));
+ *   await runWorkflowUnderTest(); // calls tailor.workflow.triggerJobFunction("validate", {})
+ *   expect(wf.triggerJobFunction).toHaveBeenCalledWith("validate", {});
  * });
  * ```
  */
-declare const workflowMock: {
+declare function mockWorkflow(): {
+  /** The `triggerJobFunction` `vi.fn`. */triggerJobFunction: Mock<(jobName: string, args?: unknown) => unknown>; /** The `triggerWorkflow` `vi.fn`. */
+  triggerWorkflow: Mock<(workflowName: string, args?: unknown, _options?: TriggerWorkflowOptions) => Promise<string>>; /** The `wait` `vi.fn`. */
+  wait: Mock<(_key: string, _payload?: unknown) => unknown>; /** The `resolve` `vi.fn`. */
+  resolve: Mock<(_executionId: string, _key: string, _callback: (payload: unknown) => unknown) => Promise<void>>;
   /**
-   * Set a fallback job handler. Called when the result queue is empty.
-   * @param handler - Function that returns a result for a given job name and args
+   * Set a fallback job handler. Called when the enqueue queue is empty.
+   * @param handler - Function returning a result for a job name and args
    */
   setJobHandler(handler: JobHandler): void;
   /**
-   * Enqueue a single result for the next `triggerJobFunction` call. Consumed in FIFO
-   * order; when the queue is exhausted, subsequent calls fall back to `setJobHandler`
-   * (default: null). Use `enqueueResults` to stage multiple results in one call.
-   * @param result - Result to return from the next `triggerJobFunction` call
+   * Enqueue a single result for the next `triggerJobFunction` call (FIFO;
+   * takes priority over `setJobHandler`).
+   * @param result - Result to return from the next call
    */
   enqueueResult(result: unknown): void;
   /**
-   * Enqueue results for multiple subsequent `triggerJobFunction` calls.
+   * Enqueue results for multiple subsequent `triggerJobFunction` calls (FIFO).
    * @param results - Results to enqueue, one per upcoming call
    */
   enqueueResults(...results: unknown[]): void;
@@ -180,38 +161,31 @@ declare const workflowMock: {
    */
   readonly triggeredJobs: TriggeredJob[];
   /**
-   * Configure what `tailor.workflow.triggerWorkflow` returns. Pass a string to return
-   * the same execution ID for every call, or a function `(name, args, options) => string`
-   * to compute one per call. Default: `"mock-execution-id"`.
-   * @param handler - Static execution ID or a function that returns one
+   * Configure what `triggerWorkflow` returns. Pass a string (same id every
+   * call) or `(name, args, options) => string`. Default: a placeholder UUID.
+   * @param handler - Static execution ID or a function returning one
    */
   setTriggerHandler(handler: string | TriggerHandlerFn): void;
   /**
-   * Configure what `tailor.workflow.wait` returns. Pass a function `(key, payload) => unknown`
-   * to compute one per call, or any other value to return it for every call. Default: `null`.
-   * @param handler - Static value or a function that returns one
+   * Configure what `wait` returns. Pass `(key, payload) => unknown` or any
+   * other value to return it for every call. Default: `null`.
+   * @param handler - Static value or a function returning one
    */
   setWaitHandler: SetWaitHandler;
   /**
    * Set the `env` passed to job bodies invoked via `createWorkflowJob().trigger()`.
-   * Cleared by `workflowMock.reset()`.
+   * Cleared on dispose / reset.
    * @param env - Env passed to job bodies.
    */
   setEnv(env: TailorEnv): void;
   /**
-   * Configure how `tailor.workflow.resolve` runs the user-supplied callback. The handler
-   * receives `(executionId, key, callback)` — invoke `callback(payload)` to drive
-   * resolve→wait wiring in tests. Default: callback is not invoked (records the call only).
+   * Configure how `resolve` runs the user-supplied callback. Default: callback
+   * is not invoked (records the call only).
    * @param handler - Function invoked per `resolve` call
    */
   setResolveHandler(handler: ResolveHandler): void;
   /**
-   * Calls to triggerWorkflow, wait, resolve (not triggerJobFunction — use triggeredJobs).
-   * @returns Workflow calls array
-   */
-  readonly calls: WorkflowCall[];
-  /**
-   * `tailor.workflow.wait` calls reshaped as `{ key, payload }` for assertions.
+   * `wait` calls reshaped as `{ key, payload }` for assertions.
    * @returns Wait call records
    */
   readonly waitCalls: {
@@ -219,33 +193,81 @@ declare const workflowMock: {
     payload: unknown;
   }[];
   /**
-   * `tailor.workflow.resolve` calls reshaped as `{ executionId, key }` for assertions.
+   * `resolve` calls reshaped as `{ executionId, key }` for assertions.
    * @returns Resolve call records
    */
   readonly resolveCalls: {
     executionId: string;
     key: string;
-  }[]; /** Reset all workflow mock state. Call in `beforeEach`. */
+  }[]; /** Reset all workflow responses and recorded calls (keeps the mock installed). */
   reset(): void;
-};
-/** Mock control for `tailor.secretmanager` — secret store and call recording. */
-declare const secretmanagerMock: {
+} & Disposable;
+/**
+ * Acquire a disposable mock for `tailor.secretmanager`. The secret store is
+ * inherited (cloned) from the currently-installed mock on acquisition and
+ * restored on dispose, so secrets seeded outside the test survive across
+ * `using` scopes while per-test `setSecrets()` overrides stay isolated.
+ * @returns Disposable SecretManager mock control object
+ * @example
+ * ```typescript
+ * import { mockSecretmanager } from "@tailor-platform/sdk/vitest";
+ *
+ * test("reads secrets from vault", async () => {
+ *   using sm = mockSecretmanager();
+ *   sm.setSecrets({ "my-vault": { API_KEY: "sk-123" } });
+ *   // …
+ * });
+ * ```
+ */
+declare function mockSecretmanager(): {
+  /** The `getSecret` `vi.fn`. */getSecret: Mock<(vault: string, name: string) => Promise<string | undefined>>; /** The `getSecrets` `vi.fn`. */
+  getSecrets: Mock<(<const T extends readonly string[]>(vault: string, names: T) => Promise<Partial<Record<T[number], string>>>)>;
   setSecrets(secrets: Record<string, Record<string, string>>): void;
   readonly calls: SecretCall[];
   reset(): void;
-};
-/** Mock control for `tailor.authconnection` — token store and call recording. */
-declare const authconnectionMock: {
-  setTokens(tokens: Record<string, unknown>): void;
+} & Disposable;
+/**
+ * Acquire a disposable mock for `tailor.authconnection`. Restored on dispose.
+ * @returns Disposable AuthConnection mock control object
+ * @example
+ * ```typescript
+ * import { mockAuthconnection } from "@tailor-platform/sdk/vitest";
+ *
+ * test("returns configured token", async () => {
+ *   using ac = mockAuthconnection();
+ *   ac.setTokens({ google: { access_token: "ya29.xxx" } });
+ *   // …
+ * });
+ * ```
+ */
+declare function mockAuthconnection(): {
+  /** The `getConnectionToken` `vi.fn`. */getConnectionToken: Mock<(connectionName: string) => Promise<any>>;
+  setTokens(value: Record<string, unknown>): void;
   readonly calls: AuthConnectionCall[];
   reset(): void;
-};
-/** Mock control for `tailor.idp` — IDP client responses and call recording. */
-declare const idpMock: {
-  setResolver(resolver: IdpResolver): void;
+} & Disposable;
+/**
+ * Acquire a disposable mock for `tailor.idp`. Restored on dispose.
+ * @returns Disposable IDP mock control object
+ * @example
+ * ```typescript
+ * import { mockIdp } from "@tailor-platform/sdk/vitest";
+ *
+ * test("resolver-based", async () => {
+ *   using idp = mockIdp();
+ *   idp.setResolver((method) =>
+ *     method === "user" ? { id: "u-1", name: "alice", disabled: false } : null,
+ *   );
+ *   // …
+ * });
+ * ```
+ */
+declare function mockIdp(): {
+  /** The mock IDP `Client` constructor (`vi.fn`). */Client: Mock;
+  setResolver(value: IdpResolver): void;
   /**
-   * Enqueue a single result for the next IDP call. Consumed in FIFO order; falls back
-   * to `setResolver` when exhausted. Use `enqueueResults` to stage multiple in one call.
+   * Enqueue a single result for the next IDP call (FIFO; falls back to
+   * `setResolver` when exhausted).
    * @param result - Result to return from the next IDP call
    */
   enqueueResult(result: unknown): void;
@@ -256,14 +278,45 @@ declare const idpMock: {
   enqueueResults(...results: unknown[]): void;
   readonly calls: IdpCall[];
   reset(): void;
-};
-/** Mock control for `tailordb.file` — file operation responses and call recording. */
-declare const fileMock: {
-  setResolver(resolver: FileResolver): void;
+} & Disposable;
+/**
+ * Acquire a disposable mock for `tailor.iconv`. Restored on dispose.
+ * @returns Disposable Iconv mock control object
+ * @example
+ * ```typescript
+ * import { mockIconv } from "@tailor-platform/sdk/vitest";
+ *
+ * test("mock encoding conversion", () => {
+ *   using iconv = mockIconv();
+ *   iconv.setResolver((method) => (method === "decode" ? "decoded-text" : null));
+ *   // …
+ * });
+ * ```
+ */
+declare function mockIconv(): {
+  setResolver(value: IconvResolver): void;
+  readonly calls: IconvCall[];
+  reset(): void;
+} & Disposable;
+/**
+ * Acquire a disposable mock for `tailordb.file`. Restored on dispose.
+ * @returns Disposable File mock control object
+ * @example
+ * ```typescript
+ * import { mockFile } from "@tailor-platform/sdk/vitest";
+ *
+ * test("mock file download", async () => {
+ *   using file = mockFile();
+ *   file.enqueueResult({ data: new Uint8Array([1, 2, 3]), metadata: { ... } });
+ *   // …
+ * });
+ * ```
+ */
+declare function mockFile(): {
+  setResolver(value: FileResolver): void;
   /**
-   * Enqueue a single result for the next `tailordb.file` call. Consumed in FIFO order;
-   * falls back to `setResolver` when exhausted. Use `enqueueResults` to stage multiple
-   * in one call.
+   * Enqueue a single result for the next `tailordb.file` call (FIFO; falls
+   * back to `setResolver` when exhausted).
    * @param result - Result to return from the next file call
    */
   enqueueResult(result: unknown): void;
@@ -274,13 +327,7 @@ declare const fileMock: {
   enqueueResults(...results: unknown[]): void;
   readonly calls: FileCall[];
   reset(): void;
-};
-/** Mock control for `tailor.iconv` — encoding call recording. */
-declare const iconvMock: {
-  setResolver(resolver: IconvResolver): void;
-  readonly calls: IconvCall[];
-  reset(): void;
-};
+} & Disposable;
 //#endregion
 //#region src/vitest/mock-kysely.d.ts
 /** A single statement executed against the mock, captured in order. */
@@ -362,8 +409,8 @@ declare function createKyselyMock<DB = Record<string, never>>(): KyselyMock<DB>;
  *    via beforeEach/afterEach since Vitest needs it during initialization.
  *
  * 3. **Platform API mocks** (environment) — All platform APIs are auto-injected with
- *    control objects: `tailordbMock`, `workflowMock`, `secretmanagerMock`,
- *    `authconnectionMock`, `idpMock`, `fileMock`, `iconvMock`. Each
+ *    control objects: `mockTailordb`, `mockWorkflow`, `mockSecretmanager`,
+ *    `mockAuthconnection`, `mockIdp`, `mockFile`, `mockIconv`. Each
  *    provides response configuration, call recording, and reset.
  *
  * 4. **Environment resolution** — Rewrites `environment: "tailor-runtime"` to the
@@ -378,7 +425,7 @@ declare function createKyselyMock<DB = Record<string, never>>(): KyselyMock<DB>;
  * ## Options
  *
  * - **`config`** — Path to `tailor.config.ts`. Loads `defineSecretManager()` values
- *   into `secretmanagerMock` so `getSecret()` returns the configured values.
+ *   into `mockSecretmanager` so `getSecret()` returns the configured values.
  * @example
  * ```typescript
  * // vitest.config.ts
@@ -400,5 +447,5 @@ declare function tailorRuntime(options?: {
   config?: string;
 }): Plugin[];
 //#endregion
-export { type ExecutedQuery, type KyselyMock, authconnectionMock, createKyselyMock, fileMock, iconvMock, idpMock, secretmanagerMock, tailorRuntime, tailordbMock, workflowMock };
+export { type ExecutedQuery, type KyselyMock, createKyselyMock, mockAuthconnection, mockFile, mockIconv, mockIdp, mockSecretmanager, mockTailordb, mockWorkflow, tailorRuntime };
 //# sourceMappingURL=index.d.mts.map

package/dist/vitest/index.mjs

@@ -1,5 +1,5 @@
 
-import { a as fileMock, d as workflowMock, l as secretmanagerMock, o as iconvMock, r as authconnectionMock, s as idpMock, u as tailordbMock } from "../mock-B6PI49C_.mjs";
+import { a as mockSecretmanager, i as mockIdp, n as mockFile, o as mockTailordb, r as mockIconv, s as mockWorkflow, t as mockAuthconnection } from "../mock-Dpu__UeJ.mjs";
 import { builtinModules } from "node:module";
 import { fileURLToPath } from "node:url";
 import { dirname, isAbsolute, matchesGlob, relative, resolve } from "node:path";
@@ -234,7 +234,7 @@ function createBlockPlugin() {
 			}
 			if (replacements.length === 0) return void 0;
 			let transformed = code;
-			for (const r of replacements.sort((a, b) => b.start - a.start)) transformed = transformed.slice(0, r.start) + r.replacement + transformed.slice(r.end);
+			for (const r of replacements.toSorted((a, b) => b.start - a.start)) transformed = transformed.slice(0, r.start) + r.replacement + transformed.slice(r.end);
 			return {
 				code: transformed,
 				map: null
@@ -475,8 +475,8 @@ function createKyselyMock() {
 *    via beforeEach/afterEach since Vitest needs it during initialization.
 *
 * 3. **Platform API mocks** (environment) — All platform APIs are auto-injected with
-*    control objects: `tailordbMock`, `workflowMock`, `secretmanagerMock`,
-*    `authconnectionMock`, `idpMock`, `fileMock`, `iconvMock`. Each
+*    control objects: `mockTailordb`, `mockWorkflow`, `mockSecretmanager`,
+*    `mockAuthconnection`, `mockIdp`, `mockFile`, `mockIconv`. Each
 *    provides response configuration, call recording, and reset.
 *
 * 4. **Environment resolution** — Rewrites `environment: "tailor-runtime"` to the
@@ -491,7 +491,7 @@ function createKyselyMock() {
 * ## Options
 *
 * - **`config`** — Path to `tailor.config.ts`. Loads `defineSecretManager()` values
-*   into `secretmanagerMock` so `getSecret()` returns the configured values.
+*   into `mockSecretmanager` so `getSecret()` returns the configured values.
 * @example
 * ```typescript
 * // vitest.config.ts
@@ -514,5 +514,5 @@ function tailorRuntime(options) {
 }
 
 //#endregion
-export { authconnectionMock, createKyselyMock, fileMock, iconvMock, idpMock, secretmanagerMock, tailorRuntime, tailordbMock, workflowMock };
+export { createKyselyMock, mockAuthconnection, mockFile, mockIconv, mockIdp, mockSecretmanager, mockTailordb, mockWorkflow, tailorRuntime };
 //# sourceMappingURL=index.mjs.map