@tailor-platform/sdk 2.8.0 → 2.11.0

package/dist/vitest/mocks/file.d.mts

@@ -46,10 +46,10 @@ declare function mockFile(options?: MockFileOptions): {
   calls: FileCall[];
   clear(): void;
   reset(): void;
+  delete: Mock<(namespace: string, tableName: string, fieldName: string, recordId: string) => Promise<void>>;
   upload: Mock<(namespace: string, tableName: string, fieldName: string, recordId: string, data: string | ArrayBuffer | Uint8Array | number[], options?: FileUploadOptions) => Promise<FileUploadResponse>>;
   download: Mock<(namespace: string, tableName: string, fieldName: string, recordId: string) => Promise<FileDownloadResponse>>;
   downloadAsBase64: Mock<(namespace: string, tableName: string, fieldName: string, recordId: string) => Promise<FileDownloadAsBase64Response>>;
-  delete: Mock<(namespace: string, tableName: string, fieldName: string, recordId: string) => Promise<void>>;
   getMetadata: Mock<(namespace: string, tableName: string, fieldName: string, recordId: string) => Promise<FileMetadata>>;
   downloadStream: Mock<(namespace: string, tableName: string, fieldName: string, recordId: string) => Promise<FileDownloadStreamResponse>>;
   uploadStream: Mock<(namespace: string, tableName: string, fieldName: string, recordId: string, readableStream: ReadableStream<Uint8Array | ArrayBuffer>, options?: FileUploadStreamOptions) => Promise<FileUploadResponse>>;

package/dist/vitest/mocks/tailordb-pglite.d.mts

@@ -0,0 +1,88 @@
+import { PGliteClient } from "../pglite-kysely.mjs";
+//#region src/vitest/mocks/tailordb-pglite.d.ts
+/** A query executed through the PGlite-backed TailorDB client. */
+interface ExecutedPGliteQuery {
+  /** Namespace of the `getDB` call that issued the query. */
+  namespace: string;
+  /** SQL text with positional (`$1`, `$2`, ...) placeholders. */
+  query: string;
+  /** Parameter values bound to the placeholders. */
+  params: unknown[];
+}
+/** Options for {@link mockTailordbWithPGlite}. */
+interface MockTailordbPGliteOptions {
+  /**
+   * PGlite instance per `getDB` namespace. A `getDB` call for a namespace
+   * missing here throws instead of falling back to another instance. Pass the
+   * same instance under several namespaces to share one database between them.
+   */
+  namespaces: Record<string, PGliteClient>;
+}
+interface CreatedClient {
+  namespace: string;
+  ended: boolean;
+}
+/**
+ * Acquire a disposable mock that backs the generated `getDB(namespace)` with
+ * PGlite, so resolver/executor/workflow code runs unchanged and its queries
+ * execute as real SQL on an in-memory Postgres. Restored on dispose; the
+ * PGlite instances are borrowed, never closed — close them yourself (e.g. in
+ * `afterAll`).
+ *
+ * Create the tables a test needs up front with `CREATE TABLE` statements
+ * matching the generated Kysely types. PGlite runs full PostgreSQL while
+ * TailorDB supports a subset of it, so a statement passing here can still be
+ * rejected by the platform.
+ *
+ * Transactions on a shared instance are serialized: while one is open,
+ * queries from other `getDB` instances on the same PGlite instance wait for
+ * it to finish. Do not run such tests with `test.concurrent`, and do not
+ * query the same instance through a second `getDB` from inside a transaction
+ * — that waits on itself.
+ * @param options - PGlite instance registration per namespace
+ * @returns Disposable TailorDB mock control object
+ * @example
+ * ```typescript
+ * import { PGlite } from "@electric-sql/pglite";
+ * import { mockTailordbWithPGlite } from "@tailor-platform/sdk/vitest";
+ * import { getDB } from "../generated/tailordb";
+ *
+ * const pglite = new PGlite();
+ * afterAll(() => pglite.close());
+ *
+ * test("real SQL", async () => {
+ *   using _db = mockTailordbWithPGlite({ namespaces: { tailordb: pglite } });
+ *   await pglite.query(`CREATE TABLE "User" ("id" uuid PRIMARY KEY, "name" text NOT NULL)`);
+ *   await getDB("tailordb").insertInto("User").values({ id: crypto.randomUUID(), name: "a" }).execute();
+ * });
+ * ```
+ */
+declare function mockTailordbWithPGlite(options: MockTailordbPGliteOptions): {
+  /** The mock `tailordb.Client` constructor (`vi.fn`). */
+  Client: import("vitest").Mock<(this: any, config?: {
+    namespace?: string;
+  }) => void>;
+  /**
+   * All queries executed on the PGlite instances, in order, with the
+   * namespace that issued each.
+   * @returns Executed queries array
+   */
+  readonly executedQueries: ExecutedPGliteQuery[];
+  /**
+   * All TailorDB clients created, with their namespace and end state.
+   * @returns Created clients array
+   */
+  readonly createdClients: CreatedClient[];
+  /**
+   * Clear recorded queries and clients while keeping the mock installed.
+   * Throws if a transaction is open.
+   */
+  clear(): void;
+  /**
+   * Reset recorded state and restore the default client behavior.
+   * Throws if a transaction is open.
+   */
+  reset(): void;
+} & Disposable;
+//#endregion
+export { ExecutedPGliteQuery, MockTailordbPGliteOptions, mockTailordbWithPGlite };

package/dist/vitest/pglite-kysely.d.mts

@@ -1,5 +1,16 @@
-import { Kysely } from "kysely";
+import { ColumnType, Kysely } from "kysely";
 //#region src/vitest/pglite-kysely.d.ts
+/** Result of a {@link PGliteClient.query} call. */
+interface PGliteQueryResult {
+  /** Rows returned by the statement. */
+  rows: unknown[];
+  /** Number of rows an INSERT/UPDATE/DELETE touched. */
+  affectedRows?: number;
+  /** Postgres command tag of the statement (`"SELECT"`, `"INSERT"`, ...). */
+  command?: string;
+  /** Row count reported alongside the command tag. */
+  rowCount?: number;
+}
 /**
  * The subset of a `@electric-sql/pglite` `PGlite` instance used by
  * {@link createKyselyPGlite}. Any client with a compatible `query`/`close`
@@ -7,18 +18,37 @@ import { Kysely } from "kysely";
  */
 interface PGliteClient {
   /** Run a single SQL statement with positional (`$1`, `$2`, ...) parameters. */
-  query(query: string, params?: unknown[]): Promise<{
-    rows: unknown[];
-    affectedRows?: number;
-  }>;
+  query(query: string, params?: unknown[]): Promise<PGliteQueryResult>;
   /** Release the underlying database. Called by `db.destroy()`. */
   close(): Promise<void>;
 }
+type WritableAs<S, W> = [S] extends [W] ? W : [W] extends [S] ? S : W | Exclude<S, W>;
+type UnmigratedColumn<C> = C extends ColumnType<infer S, infer I, infer U> ? ColumnType<S, WritableAs<S, I>, WritableAs<S, U>> : C;
+/**
+ * `DB` as its rows stand before the migration script has run: every column
+ * accepts on insert and update whatever it can still hold on read.
+ *
+ * The generated `db.ts` types a column the migration makes required as
+ * `ColumnType<T | null, T, T>`, and an enum whose values it narrows as
+ * `ColumnType<Before, After, After>`, so `migrate.ts` cannot write a null
+ * or a removed value into them — and neither can a test that has to stage
+ * the rows the script converts. Type the PGlite instance with
+ * `Unmigrated<Database>` to stage them; `main` still receives a
+ * `Transaction<Database>`.
+ * @example
+ * ```typescript
+ * const db = createKyselyPGlite<Unmigrated<Database>>(new PGlite());
+ * await db.insertInto("User").values({ name: "a", email: null }).execute();
+ * await db.transaction().execute((trx) => main(trx));
+ * ```
+ */
+type Unmigrated<DB> = { [T in keyof DB]: { [C in keyof DB[T]]: UnmigratedColumn<DB[T][C]>; }; };
 /**
  * Create a Kysely instance backed by a PGlite in-memory Postgres, for
  * executing a migration script's queries against real data in tests.
- * Pass the migration's schema as the type argument, e.g.
- * `createKyselyPGlite<Database>(new PGlite())`.
+ * Pass the migration's schema as the type argument — wrapped in
+ * {@link Unmigrated} so the test can stage the rows the script has not yet
+ * backfilled: `createKyselyPGlite<Unmigrated<Database>>(new PGlite())`.
  *
  * PGlite runs full PostgreSQL while TailorDB supports a subset of it, so a
  * statement passing here can still be rejected by the platform; keep a
@@ -27,17 +57,17 @@ interface PGliteClient {
  * @returns A Kysely instance that executes queries on the client and closes it on `destroy()`
  * @example
  * ```typescript
- * // migrations/0005/migrate.test.ts
+ * // migrations/0005/migrate.pglite.test.ts
  * import { PGlite } from "@electric-sql/pglite";
- * import { createKyselyPGlite } from "@tailor-platform/sdk/vitest";
+ * import { createKyselyPGlite, type Unmigrated } from "@tailor-platform/sdk/vitest";
  * import type { Database } from "./db";
  * import { main } from "./migrate";
  *
- * const db = createKyselyPGlite<Database>(new PGlite());
+ * const db = createKyselyPGlite<Unmigrated<Database>>(new PGlite());
  * // create tables matching db.ts, insert rows, then:
  * await db.transaction().execute((trx) => main(trx));
  * ```
  */
 declare function createKyselyPGlite<DB = Record<string, never>>(client: PGliteClient): Kysely<DB>;
 //#endregion
-export { PGliteClient, createKyselyPGlite };
+export { PGliteClient, PGliteQueryResult, Unmigrated, createKyselyPGlite };

package/docs/plugin/custom.md

@@ -83,6 +83,13 @@ interface Plugin<TableConfig = unknown, PluginConfig = unknown> {
 | `executors` | `PluginGeneratedExecutor[]`                     | Additional executors to generate                       |
 | `extends`   | `{ fields?: Record<string, TailorAnyDBField> }` | Fields to add to the source table                      |
 
+Tables in `tables` are validated as complete TailorDB table definitions before registration.
+Fields in `extends.fields` are validated as part of the resulting source table. You can return a
+table builder directly or a structural copy such as `{ ...db.table(...) }`; a copy is accepted as
+long as it retains valid table schema properties. Malformed output stops the build with an error
+that identifies the plugin and relevant table output, without partially registering tables from
+that source table's plugin processing.
+
 **Use cases**:
 
 - Generate derived tables (e.g., archive tables, history tables) from user-defined tables
@@ -115,6 +122,10 @@ onTableLoaded(context) {
 
 Same as `TablePluginOutput` but without `extends` (namespace plugins cannot extend a source table).
 
+Tables in `tables` undergo the same validation and support structural copies. If any returned
+table is malformed, the build stops before namespace-generated tables are registered and the
+error identifies the plugin and relevant table output.
+
 **Use cases**:
 
 - Generate tables that don't derive from a specific user table (e.g., audit log, settings table)
@@ -575,6 +586,90 @@ declare module "@tailor-platform/sdk" {
 }
 ```
 
+### Injecting fields into the attached table's type (declaration merging)
+
+A plugin that adds fields to a table via `onTableLoaded`'s `extends.fields` (see
+[onTableLoaded](#ontableloaded) above) can also make those fields show up on the table's own
+static type right away, computed from the literal per-table config passed to `.plugin()`. Provide
+a declaration merge for the `PluginFieldExtensions` interface, keyed by the same `id` used in
+`PluginConfigs`:
+
+```typescript
+// your-plugin/types.d.ts (shipped with your plugin package)
+import type { TailorDBField } from "@tailor-platform/sdk";
+
+declare module "@tailor-platform/sdk" {
+  interface PluginConfigs<Fields extends string> {
+    "@example/lifecycle": {
+      transitions: Record<string, { from: readonly string[]; to: string }>;
+    };
+  }
+
+  interface PluginFieldExtensions<Fields extends string, Config> {
+    "@example/lifecycle": Config extends {
+      transitions: infer T extends Record<string, { from: readonly string[]; to: string }>;
+    }
+      ? {
+          status: TailorDBField<
+            { type: "enum"; array: false },
+            T[keyof T]["from"][number] | T[keyof T]["to"]
+          >;
+        }
+      : never;
+  }
+}
+```
+
+With this in place, the table returned by `.plugin()` already has the derived field. The status enum
+includes every state that appears anywhere in `transitions` — both a `from` state that a transition
+never produces (like the initial `"PENDING"` below) and every `to` state:
+
+```typescript
+import { db } from "@tailor-platform/sdk";
+
+const approvalRequest = db.table("ApprovalRequest", { title: db.string() }).plugin({
+  "@example/lifecycle": {
+    transitions: {
+      approve: { from: ["PENDING"], to: "APPROVED" },
+      reject: { from: ["PENDING"], to: "REJECTED" },
+    },
+  },
+});
+// approvalRequest's type now includes status: "PENDING" | "APPROVED" | "REJECTED"
+```
+
+The type registered in `PluginFieldExtensions` must describe only the fields being added — it is
+merged into the table's existing fields, not a replacement for them. A field name that collides
+with an existing field, with a file key declared via `.files()`, or with a field injected by
+another plugin attached in the same `.plugin()` call, is a type error at the call site — regardless
+of whether `.files()` or `.plugin()` was called first. `tailor generate` also rejects the same
+collision at runtime, as a backstop for any case a table's static type doesn't otherwise catch.
+
+This only affects the table's static type. The corresponding field exists on the table's
+generated schema, and on the table object's own `fields`, only after `tailor generate` actually
+applies `extends.fields`. Before that, reading an injected field directly off the table
+(`table.fields.status`) returns `undefined`, and `pickFields(["status"])` throws — call these only
+with the table's originally declared fields, not ones a plugin injects.
+
+To keep the declared type and the runtime implementation in sync, give `Plugin`'s optional third
+type parameter the same shape and use it inside `onTableLoaded`:
+
+```typescript
+import { db, type Plugin, type TailorDBField } from "@tailor-platform/sdk";
+
+const lifecyclePlugin: Plugin<
+  LifecycleTableConfig,
+  LifecyclePluginConfig,
+  { status: TailorDBField<{ type: "enum"; array: false }, "PENDING" | "APPROVED" | "REJECTED"> }
+> = {
+  id: "@example/lifecycle",
+  description: "Derives a status field from a transitions map",
+  onTableLoaded(context) {
+    return { extends: { fields: { status: db.enum(["PENDING", "APPROVED", "REJECTED"]) } } };
+  },
+};
+```
+
 ### Resolving plugin-level config from a `Plugin[]` array (declaration merging)
 
 `PluginConfig` is already available inside your own plugin's hooks via `context.pluginConfig`.

package/docs/plugin/index.md

@@ -102,6 +102,11 @@ Plugins can generate:
 - **Field Extensions**: Additional fields added to the source table
 - **Output Files**: TypeScript code and other files via generation-time hooks
 
+Tables produced by definition-time hooks are validated before registration. This includes
+generated tables and source tables after field extensions are applied. Malformed output stops
+the build with an error that identifies the plugin and relevant table output, without partially
+registering tables from that processing step.
+
 Generated files are placed under `.tailor/<plugin-id>/` (the plugin ID is sanitized,
 e.g. `@example/soft-delete` → `example-soft-delete`), such as:
 

package/docs/services/tailordb-migration.md

@@ -815,25 +815,27 @@ A statement-level test verifies what the script issues, not what it does to data
 npm install -D @electric-sql/pglite
 ```
 
-Create the tables the script touches (matching the shape in the generated `db.ts`), stage rows, then run the script in a transaction:
+Create the tables the script touches (matching the shape in the generated `db.ts`), stage rows, then run the script in a transaction. Type the instance with `Unmigrated<Database>` rather than `Database`: `db.ts` types a column the migration makes required as `T | null` on read but `T` on write (and an enum it narrows as the old values on read but the new ones on write), so that `migrate.ts` cannot write what the migration is removing — which would also stop the test from staging the rows the script has to convert. `Unmigrated` lets every column be written with whatever it can still be read as; `main` still receives a `Transaction<Database>`.
 
 ```typescript
 // migrations/0005/migrate.pglite.test.ts
 import { PGlite } from "@electric-sql/pglite";
 import { sql } from "@tailor-platform/sdk/kysely";
-import { createKyselyPGlite } from "@tailor-platform/sdk/vitest";
+import { createKyselyPGlite, type Unmigrated } from "@tailor-platform/sdk/vitest";
 import { afterAll, beforeAll, describe, expect, test } from "vitest";
 import type { Database } from "./db";
 import { main } from "./migrate";
 
-const db = createKyselyPGlite<Database>(new PGlite());
+const db = createKyselyPGlite<Unmigrated<Database>>(new PGlite());
 
 beforeAll(async () => {
   await sql`
     CREATE TABLE "User" (
       "id" uuid PRIMARY KEY DEFAULT gen_random_uuid(),
       "name" text NOT NULL,
-      "email" text
+      "email" text,
+      "createdAt" timestamptz NOT NULL,
+      "updatedAt" timestamptz NOT NULL
     )
   `.execute(db);
 });
@@ -844,10 +846,14 @@ afterAll(async () => {
 
 describe("0005 add required email", () => {
   test("backfills null emails and keeps existing ones", async () => {
-    await sql`
-      INSERT INTO "User" ("name", "email")
-      VALUES ('a', NULL), ('b', 'b@example.com')
-    `.execute(db);
+    const now = new Date();
+    await db
+      .insertInto("User")
+      .values([
+        { name: "a", email: null, createdAt: now, updatedAt: now },
+        { name: "b", email: "b@example.com", createdAt: now, updatedAt: now },
+      ])
+      .execute();
 
     await db.transaction().execute((trx) => main(trx));
 

package/docs/testing.md

@@ -24,6 +24,7 @@ For anonymous direct calls:
 Platform API mocks under `@tailor-platform/sdk/vitest` (for use with the [`tailor-runtime` Vitest environment](#runtime-environment-emulation-beta) below):
 
 - `mockTailordb` — TailorDB query stubs and call recording
+- `mockTailordbWithPGlite` — TailorDB backed by a real in-memory Postgres (PGlite)
 - `mockWorkflow` — `tailor.workflow` job / wait / resolve mocks
 - `runWorkflowLocally` — local full-chain workflow runner
 - `mockSecretmanager`, `mockAuthconnection`, `mockIdp`, `mockFile`, `mockIconv`, `mockAigateway`, `mockLogger` — corresponding platform API mocks
@@ -63,7 +64,7 @@ export default defineConfig({
 
 ### Acquiring mocks with `using`
 
-Each mock controller (`mockTailordb`, `mockWorkflow`, `mockSecretmanager`, `mockAuthconnection`, `mockIdp`, `mockFile`, `mockIconv`, `mockAigateway`, `mockLogger`) is a **factory function**. Acquire it inside a test with a [`using` declaration](https://github.com/tc39/proposal-explicit-resource-management) — its state is reset automatically when the test scope exits, so you no longer need `beforeEach(() => mock.reset())`:
+Each mock controller (`mockTailordb`, `mockTailordbWithPGlite`, `mockWorkflow`, `mockSecretmanager`, `mockAuthconnection`, `mockIdp`, `mockFile`, `mockIconv`, `mockAigateway`, `mockLogger`) is a **factory function**. Acquire it inside a test with a [`using` declaration](https://github.com/tc39/proposal-explicit-resource-management) — its state is reset automatically when the test scope exits, so you no longer need `beforeEach(() => mock.reset())`:
 
 ```typescript
 import { mockTailordb } from "@tailor-platform/sdk/vitest";
@@ -144,6 +145,81 @@ Within one `mockTailordb()` instance, use either `onQuery()` matchers or a direc
 
 Pass `{ onUnhandled: "error" }` to make an unmatched query fail instead of returning an empty result.
 
+#### Real SQL execution with PGlite (`mockTailordbWithPGlite`)
+
+Instead of staging responses, back TailorDB with [`@electric-sql/pglite`](https://pglite.dev/) — an in-memory PostgreSQL (install it as a devDependency) — so the queries a resolver, executor, or workflow job issues through `getDB()` execute against real data. `getDB(namespace)` needs no test-side swap: acquire the mock, and each namespace you list resolves to its PGlite instance.
+
+Create the tables the test touches with `CREATE TABLE` statements matching the generated Kysely types — `text` for string and enum fields, `timestamptz` for date/datetime, `jsonb` for nested objects. The schema only has to match what your code reads and writes, not TailorDB's storage; relations are not enforced.
+
+```typescript
+import { PGlite } from "@electric-sql/pglite";
+import { mockTailordbWithPGlite } from "@tailor-platform/sdk/vitest";
+import { afterAll, beforeAll, expect, test } from "vitest";
+import { getDB } from "../generated/db";
+import resolver from "./upsertUsers";
+
+const pglite = new PGlite();
+
+beforeAll(async () => {
+  await pglite.exec(`
+    CREATE TABLE "User" (
+      "id" uuid PRIMARY KEY DEFAULT gen_random_uuid(),
+      "name" text NOT NULL,
+      "email" text NOT NULL,
+      "age" integer NOT NULL
+    );
+  `);
+});
+
+afterAll(async () => {
+  await pglite.close();
+});
+
+test("upserts against real rows", async () => {
+  using _db = mockTailordbWithPGlite({ namespaces: { "main-db": pglite } });
+  const db = getDB("main-db");
+  await db
+    .insertInto("User")
+    .values({ name: "Existing", email: "exists@example.com", age: 40 })
+    .execute();
+
+  const result = await resolver.body({
+    input: {
+      users: [
+        { name: "Newcomer", email: "new@example.com", age: 22 },
+        { name: "Existing", email: "exists@example.com", age: 41 },
+      ],
+    },
+    caller: null,
+    invoker: null,
+    env: { appName: "Resolver Template", version: 1 },
+  });
+
+  expect(result).toEqual({ created: 1, updated: 1 });
+  const rows = await db.selectFrom("User").selectAll().orderBy("email", "asc").execute();
+  expect(rows.map((row) => row.age)).toEqual([41, 22]);
+});
+```
+
+A `.serial()` field is omitted from generated `getDB()` inserts, so its PGlite column must generate a value. Use an identity for an integer serial. For a formatted string serial, create a sequence and reproduce the format in its `DEFAULT` expression:
+
+```sql
+CREATE SEQUENCE "invoiceNumberSequence" START WITH 1000;
+CREATE TABLE "Invoice" (
+  "sequentialId" integer GENERATED BY DEFAULT AS IDENTITY (START WITH 1),
+  "invoiceNumber" text NOT NULL
+    DEFAULT ('INV-' || lpad(nextval('"invoiceNumberSequence"')::text, 5, '0'))
+);
+```
+
+PGlite does not apply the TailorDB `.serial()` configuration itself. Match the `start`, `format`, and any limit that the behavior under test relies on.
+
+- The PGlite instance is yours: the mock never closes it, so close it in `afterAll`. Reuse one instance across a suite — creating one per test is slow.
+- Pass the same instance under several namespaces to drive them against one shared database.
+- Seed through `getDB` itself. When a column type rejects a value that only the test must stage, use `createKyselyPGlite<Unmigrated<...>>(pglite)` instead — see [Testing Migrations Locally](./services/tailordb-migration.md#testing-migrations-locally). This only affects test setup; it cannot supply a `.serial()` value for an insert issued by the code under test.
+- Transactions on a shared instance are serialized: while one is open, queries from other `getDB` instances wait. Do not use `test.concurrent` with a shared instance, and do not query the same instance through a second `getDB` from inside a transaction — that waits on itself.
+- PGlite runs full PostgreSQL while TailorDB supports a subset of it, and TailorDB hooks, validations, and permissions do not run here — a test passing on PGlite can still behave differently on the platform. Keep [`mockTailordb`](#tailordb-mock) or [`createKyselyMock`](#kysely-layer-mock-createkyselymock) tests for query shape and error paths, and E2E tests for platform behavior.
+
 ### Workflow Mock
 
 Workflow job `.start()` calls use the platform workflow runtime. Acquire `mockWorkflow()` when you want to provide start responses with `setJobHandler` / `enqueueResult` or assert on `startedJobs`. If no response is configured, the mock throws so missing job mocks fail loudly. Use `job(definition)` or `workflow(definition)` to get a stable, fully typed Vitest mock for one definition:
@@ -592,7 +668,7 @@ describe("upsertUsers resolver", () => {
 });
 ```
 
-Reach for [`mockTailordb`](#mocking-the-tailordb-client) instead when you want to drive the raw query sequence at the `tailordb.Client` level rather than at the Kysely layer.
+Reach for [`mockTailordb`](#mocking-the-tailordb-client) instead when you want to drive the raw query sequence at the `tailordb.Client` level rather than at the Kysely layer, or [`mockTailordbWithPGlite`](#real-sql-execution-with-pglite-mocktailordbwithpglite) to execute the queries against a real in-memory Postgres.
 
 TailorDB migration scripts (`migrate.ts`) are unit-tested the same way: the generated `db.ts` exports the `Database` interface to type the mock, and `tailor tailordb migration script <N> --with-test` scaffolds a ready-to-fill test. To execute a migration script against real rows in an in-memory Postgres, use `createKyselyPGlite` with `@electric-sql/pglite`. See [Testing Migrations Locally](./services/tailordb-migration.md#testing-migrations-locally).
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tailor-platform/sdk",
-  "version": "2.8.0",
+  "version": "2.11.0",
   "description": "Tailor Platform SDK - The SDK to work with Tailor Platform",
   "license": "MIT",
   "repository": {
@@ -155,8 +155,8 @@
     "@bufbuild/protovalidate": "1.2.0",
     "@connectrpc/connect": "2.1.2",
     "@connectrpc/connect-node": "2.1.2",
-    "@inquirer/core": "12.0.0",
-    "@inquirer/prompts": "8.6.0",
+    "@inquirer/core": "12.0.1",
+    "@inquirer/prompts": "8.7.0",
     "@jridgewell/trace-mapping": "0.3.31",
     "@napi-rs/keyring": "1.3.0",
     "@opentelemetry/api": "1.9.1",
@@ -165,17 +165,17 @@
     "@opentelemetry/sdk-trace-node": "2.10.0",
     "@opentelemetry/semantic-conventions": "1.43.0",
     "@oxc-project/types": "0.147.0",
-    "@secretlint/core": "13.0.4",
-    "@secretlint/secretlint-rule-preset-recommend": "13.0.4",
+    "@secretlint/core": "13.0.5",
+    "@secretlint/secretlint-rule-preset-recommend": "13.0.5",
     "@standard-schema/spec": "1.1.0",
     "@tailor-platform/function-kysely-tailordb": "0.1.3",
-    "@toiroakr/lines-db": "0.12.2",
+    "@toiroakr/lines-db": "0.12.5",
     "@toiroakr/read-multiline": "0.4.1",
     "@urql/core": "6.0.3",
     "amaro": "1.1.11",
     "confbox": "0.2.4",
     "date-fns": "4.4.0",
-    "es-toolkit": "1.51.0",
+    "es-toolkit": "1.52.0",
     "find-up-simple": "1.0.1",
     "get-east-asian-width": "1.6.0",
     "get-tsconfig": "4.14.3",
@@ -191,7 +191,7 @@
     "pgsql-ast-parser": "12.0.2",
     "pkg-types": "2.3.1",
     "politty": "0.11.9",
-    "rolldown": "1.2.5",
+    "rolldown": "1.2.6",
     "semver": "7.8.5",
     "sql-highlight": "6.1.0",
     "std-env": "4.2.0",
@@ -242,7 +242,7 @@
   "scripts": {
     "test": "vitest",
     "test:unit": "vitest --project=unit*",
-    "test:e2e": "vitest --project=e2e",
+    "test:e2e": "vitest --project=e2e*",
     "test:coverage": "vitest --coverage",
     "docs:check": "vitest run --project=unit* src/cli/docs.test.ts",
     "docs:update": "POLITTY_DOCS_UPDATE=true vitest run --project=unit* src/cli/docs.test.ts",