nexus-ai-pro 2.0.0 → 2.2.0

package/dist-cjs/server/runs.js

@@ -12,6 +12,8 @@ const state_js_1 = require("./state.js");
 const THREADS = ['nexus', 'server', 'threads'];
 const RUNS = state_js_1.RUNS_NAMESPACE;
 const KIND_PREFIX = 'assistant:';
+const THREAD_CLAIM = 'nexus-thread:';
+const UNRECORDED_CLAIM_MS = 60_000;
 const DEFAULT_CONCURRENCY = 10;
 const DEFAULT_POLL_MS = 1_000;
 const DEFAULT_RECOVER_MS = 30_000;
@@ -29,6 +31,8 @@ class RunManager {
     store;
     local = new Map();
     slots = new Set();
+    controls = new Map();
+    drainedRuns = new Set();
     state;
     events;
     now;
@@ -121,12 +125,22 @@ class RunManager {
     }
     async start(options) {
         const base = this.assistant(options.assistant);
+        const runId = `run-${randomId()}`;
         let thread;
         if (options.threadId) {
             thread = await this.thread(options.threadId, options.principal);
-            thread = await this.settleBusyThread(thread, options);
+            thread = await this.settleBusyThread(thread, options, runId);
         }
-        const runId = `run-${randomId()}`;
+        try {
+            return await this.startClaimed(runId, base, thread, options);
+        }
+        catch (error) {
+            if (thread)
+                await this.releaseClaim(thread.id, runId).catch((cause) => this.report(cause, { runId }));
+            throw error;
+        }
+    }
+    async startClaimed(runId, base, thread, options) {
         let assistant = base;
         let revision;
         if (base.route) {
@@ -220,11 +234,18 @@ class RunManager {
     async drain(options = {}) {
         this.draining = true;
         this.stopWorking();
+        if (this.options.queue) {
+            for (const control of this.controls.values()) {
+                control.draining = true;
+                control.reason = 'replica draining';
+            }
+        }
         const running = [...this.slots];
         const deadline = Date.now() + (options.timeoutMs ?? 25_000);
         while (this.slots.size > 0 && Date.now() < deadline)
             await pause(Math.min(50, deadline - Date.now()));
-        const released = [];
+        const released = [...this.drainedRuns];
+        this.drainedRuns.clear();
         if (this.options.queue) {
             for (const id of [...this.slots]) {
                 if (this.runner.release(id))
@@ -344,6 +365,8 @@ class RunManager {
             acceptedId = (await this.runner.enqueue(submit)).id;
         }
         if (acceptedId !== runId) {
+            if (thread)
+                await this.releaseClaim(thread.id, runId);
             await this.state.delete(RUNS, runId);
             await this.releaseTenant(runId, options.principal?.tenantId);
             return (await this.state.get(RUNS, acceptedId)) ?? run;
@@ -377,14 +400,18 @@ class RunManager {
     async execute(plan, context) {
         const runId = context.operationId;
         let cost = 0;
+        const control = { draining: false };
         const runContext = {
             runId,
             threadId: plan.threadId,
             signal: context.signal,
+            control,
             principal: plan.principal,
             metadata: plan.metadata,
             attempt: context.attempt,
             ...(plan.revision ? { revision: plan.revision.id } : {}),
+            saveProgress: (details) => context.heartbeat(details),
+            ...(context.previousHeartbeat === undefined ? {} : { progress: context.previousHeartbeat }),
             recordCost: async (usd) => {
                 if (!Number.isFinite(usd) || usd <= 0)
                     return;
@@ -414,6 +441,7 @@ class RunManager {
                 ? plan.assistant.resume(plan.threadId, plan.resume, runContext)
                 : plan.assistant.stream(plan.input, runContext));
         let last;
+        this.controls.set(runId, control);
         try {
             for await (const event of stream) {
                 last = event;
@@ -422,6 +450,8 @@ class RunManager {
             }
         }
         catch (error) {
+            if (control.draining && isDrained(error) && this.runner.release(runId))
+                this.drainedRuns.add(runId);
             if (context.signal.aborted && context.signal.reason instanceof errors_js_1.OperationReleasedError) {
                 await this.record(runId, 'status', { status: 'queued', reason: 'handed to another worker' });
                 await this.settle(runId, 'queued', { addCost: cost });
@@ -442,6 +472,9 @@ class RunManager {
             await this.releaseTenant(runId, plan.principal?.tenantId);
             throw error;
         }
+        finally {
+            this.controls.delete(runId);
+        }
         const interrupt = interruptOf(last);
         const status = interrupt ? 'awaiting_input' : 'succeeded';
         const output = outputOf(last);
@@ -520,21 +553,21 @@ class RunManager {
         const pollMs = this.options.queue?.pollMs ?? DEFAULT_POLL_MS;
         this.schedule(claimed > 0 && this.freeSlots() > 0 ? 0 : Math.min(pollMs, this.options.recoverEveryMs ?? pollMs));
     }
-    async settleBusyThread(thread, options) {
+    async settleBusyThread(thread, options, runId) {
         const policy = options.onBusy ?? this.options.onBusy ?? 'reject';
         let current = thread;
-        for (let attempt = 0; attempt < 2; attempt += 1) {
-            const activeId = current.activeRunId;
+        const deadline = this.now().getTime() + (this.options.queueTimeoutMs ?? 30_000);
+        for (let attempt = 0; attempt < 4 || (policy === 'enqueue' && this.now().getTime() < deadline); attempt += 1) {
+            const activeId = await this.claimThread(current, runId);
             if (!activeId)
                 return current;
             const active = await this.state.get(RUNS, activeId);
-            if (!active || isFinished(active.status)) {
-                current = { ...current, activeRunId: undefined };
-                await this.state.put(THREADS, current.id, current);
-                return current;
-            }
             if (policy === 'reject')
                 throw new errors_js_2.ThreadBusyError(current.id, activeId);
+            if (!active) {
+                await delay(50);
+                continue;
+            }
             if (policy === 'enqueue') {
                 await this.waitForRun(activeId);
                 current = await this.thread(current.id, options.principal);
@@ -551,9 +584,67 @@ class RunManager {
             }
             current = { ...current, activeRunId: undefined };
             await this.state.put(THREADS, current.id, current);
-            return current;
         }
-        return current;
+        throw new errors_js_2.ThreadBusyError(current.id, current.activeRunId ?? 'another run');
+    }
+    async claimThread(thread, runId) {
+        if (!this.store.findByIdempotencyKey) {
+            const activeId = thread.activeRunId;
+            return activeId && !(await this.runIsFree(activeId, undefined)) ? activeId : undefined;
+        }
+        const key = `${THREAD_CLAIM}${thread.id}`;
+        for (let attempt = 0; attempt < 8; attempt += 1) {
+            const claim = await this.store.findByIdempotencyKey(key);
+            const at = this.now().toISOString();
+            if (!claim) {
+                try {
+                    await this.store.create({
+                        id: `${key}:${runId}`,
+                        status: 'succeeded',
+                        attempt: 1,
+                        maxAttempts: 1,
+                        sequence: 0,
+                        createdAt: at,
+                        updatedAt: at,
+                        kind: 'server.thread',
+                        idempotencyKey: key,
+                        result: { runId },
+                    });
+                    return undefined;
+                }
+                catch (error) {
+                    if (error instanceof errors_js_1.OperationDuplicateError)
+                        continue;
+                    throw error;
+                }
+            }
+            const holder = claim.result?.runId;
+            if (holder === runId)
+                return undefined;
+            if (holder && !(await this.runIsFree(holder, claim.updatedAt)))
+                return holder;
+            const taken = await this.store.update({ ...claim, result: { runId }, sequence: claim.sequence + 1, updatedAt: at }, claim.sequence);
+            if (taken)
+                return undefined;
+        }
+        const holder = (await this.store.findByIdempotencyKey(key))?.result?.runId;
+        return holder ?? 'another run';
+    }
+    async runIsFree(runId, claimedAt) {
+        const run = await this.state.get(RUNS, runId);
+        if (run)
+            return isFinished(run.status);
+        if (claimedAt === undefined)
+            return true;
+        return this.now().getTime() - Date.parse(claimedAt) > UNRECORDED_CLAIM_MS;
+    }
+    async releaseClaim(threadId, runId) {
+        if (!this.store.findByIdempotencyKey)
+            return;
+        const claim = await this.store.findByIdempotencyKey(`${THREAD_CLAIM}${threadId}`);
+        if (!claim || claim.result?.runId !== runId)
+            return;
+        await this.store.update({ ...claim, result: {}, sequence: claim.sequence + 1, updatedAt: this.now().toISOString() }, claim.sequence);
     }
     async waitForRun(runId) {
         const deadline = this.now().getTime() + (this.options.queueTimeoutMs ?? 30_000);
@@ -570,6 +661,7 @@ class RunManager {
     async releaseThread(threadId, runId) {
         if (!threadId)
             return;
+        await this.releaseClaim(threadId, runId).catch((error) => this.report(error, { runId }));
         const thread = await this.state.get(THREADS, threadId);
         if (!thread || thread.activeRunId !== runId)
             return;
@@ -664,3 +756,7 @@ function delay(ms) {
             timer.unref?.();
     });
 }
+function isDrained(error) {
+    const code = typeof error === 'object' && error !== null ? error.code : undefined;
+    return code === 'GRAPH_DRAINED' || code === 'RUN_HANDED_OFF';
+}

package/dist-cjs/sqlite/index.d.ts

@@ -1,4 +1,17 @@
+import type { SchemaMigration } from '../utils/schema-migrations.js';
+export { type AppliedMigration, type MigrationResult, type MigrationStatus, migrationChecksum, type SchemaMigration, SchemaMigrationError, } from '../utils/schema-migrations.js';
 export { fromLibsql, fromSqliteDatabase, type LibsqlLikeClient, type SqliteDatabaseLike, type SqliteLikeClient, type SqliteValue, } from './client.js';
-export { SqliteOperationStore, type SqliteOperationStoreOptions, sqliteOperationStoreMigration } from './operations.js';
-export { SqliteStore, type SqliteStoreOptions, sqliteStoreMigration } from './store.js';
-export { SqliteVectorStore, type SqliteVectorStoreOptions, sqliteVectorStoreMigration } from './vectors.js';
+export { applySqliteMigrations, type SqliteMigrateOptions, sqliteMigrationStatus } from './migrations.js';
+export { SqliteOperationStore, type SqliteOperationStoreOptions, sqliteOperationStoreMigration, sqliteOperationStoreMigrations, } from './operations.js';
+export { SqliteStore, type SqliteStoreOptions, sqliteStoreMigration, sqliteStoreMigrations } from './store.js';
+export { SqliteVectorStore, type SqliteVectorStoreOptions, sqliteVectorStoreMigration, sqliteVectorStoreMigrations, } from './vectors.js';
+/** The SQLite adapters a migration can include. */
+export type SqliteAdapter = 'operations' | 'store' | 'vectors';
+/**
+ * The versioned migrations of the chosen adapters on their default tables, for
+ * `applySqliteMigrations()`, `sqliteMigrationStatus()`, and `nexus db migrate`. Defaults to every
+ * adapter. A store on a custom table migrates through its own `migrate()`.
+ */
+export declare function sqliteMigrations(options?: {
+    adapters?: readonly SqliteAdapter[];
+}): SchemaMigration[];

package/dist-cjs/sqlite/index.js

@@ -1,15 +1,36 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.sqliteVectorStoreMigration = exports.SqliteVectorStore = exports.sqliteStoreMigration = exports.SqliteStore = exports.sqliteOperationStoreMigration = exports.SqliteOperationStore = exports.fromSqliteDatabase = exports.fromLibsql = void 0;
+exports.sqliteVectorStoreMigrations = exports.sqliteVectorStoreMigration = exports.SqliteVectorStore = exports.sqliteStoreMigrations = exports.sqliteStoreMigration = exports.SqliteStore = exports.sqliteOperationStoreMigrations = exports.sqliteOperationStoreMigration = exports.SqliteOperationStore = exports.sqliteMigrationStatus = exports.applySqliteMigrations = exports.fromSqliteDatabase = exports.fromLibsql = exports.SchemaMigrationError = exports.migrationChecksum = void 0;
+exports.sqliteMigrations = sqliteMigrations;
+const operations_js_1 = require("./operations.js");
+const store_js_1 = require("./store.js");
+const vectors_js_1 = require("./vectors.js");
+var schema_migrations_js_1 = require("../utils/schema-migrations.js");
+Object.defineProperty(exports, "migrationChecksum", { enumerable: true, get: function () { return schema_migrations_js_1.migrationChecksum; } });
+Object.defineProperty(exports, "SchemaMigrationError", { enumerable: true, get: function () { return schema_migrations_js_1.SchemaMigrationError; } });
 var client_js_1 = require("./client.js");
 Object.defineProperty(exports, "fromLibsql", { enumerable: true, get: function () { return client_js_1.fromLibsql; } });
 Object.defineProperty(exports, "fromSqliteDatabase", { enumerable: true, get: function () { return client_js_1.fromSqliteDatabase; } });
-var operations_js_1 = require("./operations.js");
-Object.defineProperty(exports, "SqliteOperationStore", { enumerable: true, get: function () { return operations_js_1.SqliteOperationStore; } });
-Object.defineProperty(exports, "sqliteOperationStoreMigration", { enumerable: true, get: function () { return operations_js_1.sqliteOperationStoreMigration; } });
-var store_js_1 = require("./store.js");
-Object.defineProperty(exports, "SqliteStore", { enumerable: true, get: function () { return store_js_1.SqliteStore; } });
-Object.defineProperty(exports, "sqliteStoreMigration", { enumerable: true, get: function () { return store_js_1.sqliteStoreMigration; } });
-var vectors_js_1 = require("./vectors.js");
-Object.defineProperty(exports, "SqliteVectorStore", { enumerable: true, get: function () { return vectors_js_1.SqliteVectorStore; } });
-Object.defineProperty(exports, "sqliteVectorStoreMigration", { enumerable: true, get: function () { return vectors_js_1.sqliteVectorStoreMigration; } });
+var migrations_js_1 = require("./migrations.js");
+Object.defineProperty(exports, "applySqliteMigrations", { enumerable: true, get: function () { return migrations_js_1.applySqliteMigrations; } });
+Object.defineProperty(exports, "sqliteMigrationStatus", { enumerable: true, get: function () { return migrations_js_1.sqliteMigrationStatus; } });
+var operations_js_2 = require("./operations.js");
+Object.defineProperty(exports, "SqliteOperationStore", { enumerable: true, get: function () { return operations_js_2.SqliteOperationStore; } });
+Object.defineProperty(exports, "sqliteOperationStoreMigration", { enumerable: true, get: function () { return operations_js_2.sqliteOperationStoreMigration; } });
+Object.defineProperty(exports, "sqliteOperationStoreMigrations", { enumerable: true, get: function () { return operations_js_2.sqliteOperationStoreMigrations; } });
+var store_js_2 = require("./store.js");
+Object.defineProperty(exports, "SqliteStore", { enumerable: true, get: function () { return store_js_2.SqliteStore; } });
+Object.defineProperty(exports, "sqliteStoreMigration", { enumerable: true, get: function () { return store_js_2.sqliteStoreMigration; } });
+Object.defineProperty(exports, "sqliteStoreMigrations", { enumerable: true, get: function () { return store_js_2.sqliteStoreMigrations; } });
+var vectors_js_2 = require("./vectors.js");
+Object.defineProperty(exports, "SqliteVectorStore", { enumerable: true, get: function () { return vectors_js_2.SqliteVectorStore; } });
+Object.defineProperty(exports, "sqliteVectorStoreMigration", { enumerable: true, get: function () { return vectors_js_2.sqliteVectorStoreMigration; } });
+Object.defineProperty(exports, "sqliteVectorStoreMigrations", { enumerable: true, get: function () { return vectors_js_2.sqliteVectorStoreMigrations; } });
+function sqliteMigrations(options = {}) {
+    const adapters = new Set(options.adapters ?? ['operations', 'store', 'vectors']);
+    return [
+        ...(adapters.has('operations') ? (0, operations_js_1.sqliteOperationStoreMigrations)() : []),
+        ...(adapters.has('store') ? (0, store_js_1.sqliteStoreMigrations)() : []),
+        ...(adapters.has('vectors') ? (0, vectors_js_1.sqliteVectorStoreMigrations)() : []),
+    ];
+}

package/dist-cjs/sqlite/migrations.d.ts

@@ -0,0 +1,26 @@
+import { type MigrationResult, type MigrationStatus, type SchemaMigration } from '../utils/schema-migrations.js';
+import { type SqliteDatabaseLike, type SqliteLikeClient } from './client.js';
+export { type AppliedMigration, type MigrationResult, type MigrationStatus, migrationChecksum, type SchemaMigration, SchemaMigrationError, } from '../utils/schema-migrations.js';
+/** Options for applying or inspecting SQLite migrations. */
+export interface SqliteMigrateOptions {
+    /** Plans without writing anything, not even the table that records migrations. */
+    dryRun?: boolean;
+    /** The table that records applied migrations. Defaults to `nexus_schema_migrations`. */
+    table?: string;
+}
+/**
+ * Where a SQLite database stands against a list of migrations. Reads only: on a database that has
+ * never been migrated, everything is pending.
+ */
+export declare function sqliteMigrationStatus(database: SqliteLikeClient | SqliteDatabaseLike, migrations: readonly SchemaMigration[], options?: Pick<SqliteMigrateOptions, 'table'>): Promise<MigrationStatus>;
+/**
+ * Applies the pending migrations in order, recording each with a checksum.
+ *
+ * Each migration runs inside `BEGIN IMMEDIATE`, which takes SQLite's write lock: its statements and
+ * the row recording it land together or not at all, and a second process migrating the same file
+ * waits for the first instead of interleaving with it. A migration whose statements changed after it
+ * ran is refused before anything is written.
+ */
+export declare function applySqliteMigrations(database: SqliteLikeClient | SqliteDatabaseLike, migrations: readonly SchemaMigration[], options?: SqliteMigrateOptions): Promise<MigrationResult>;
+/** The statement that creates the migrations table, which `migrate()` runs first. */
+export declare function sqliteMigrationsTableStatement(table?: string): string;

package/dist-cjs/sqlite/migrations.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SchemaMigrationError = exports.migrationChecksum = void 0;
+exports.sqliteMigrationStatus = sqliteMigrationStatus;
+exports.applySqliteMigrations = applySqliteMigrations;
+exports.sqliteMigrationsTableStatement = sqliteMigrationsTableStatement;
+const schema_migrations_js_1 = require("../utils/schema-migrations.js");
+const client_js_1 = require("./client.js");
+var schema_migrations_js_2 = require("../utils/schema-migrations.js");
+Object.defineProperty(exports, "migrationChecksum", { enumerable: true, get: function () { return schema_migrations_js_2.migrationChecksum; } });
+Object.defineProperty(exports, "SchemaMigrationError", { enumerable: true, get: function () { return schema_migrations_js_2.SchemaMigrationError; } });
+async function sqliteMigrationStatus(database, migrations, options = {}) {
+    return (0, schema_migrations_js_1.planMigrations)(migrations, await readApplied((0, client_js_1.toSqliteClient)(database), options.table ?? schema_migrations_js_1.MIGRATIONS_TABLE));
+}
+async function applySqliteMigrations(database, migrations, options = {}) {
+    const client = (0, client_js_1.toSqliteClient)(database);
+    const tableName = options.table ?? schema_migrations_js_1.MIGRATIONS_TABLE;
+    if (options.dryRun) {
+        const status = await sqliteMigrationStatus(client, migrations, options);
+        (0, schema_migrations_js_1.assertUnchanged)(status);
+        return { applied: status.pending, statements: status.pending.flatMap((m) => [...m.statements]), dryRun: true };
+    }
+    (0, schema_migrations_js_1.planMigrations)(migrations, []);
+    await client.exec(sqliteMigrationsTableStatement(tableName));
+    const status = (0, schema_migrations_js_1.planMigrations)(migrations, await readApplied(client, tableName));
+    (0, schema_migrations_js_1.assertUnchanged)(status);
+    const table = (0, client_js_1.quoteSqliteTable)(tableName);
+    const statements = [];
+    for (const migration of status.pending) {
+        const record = `INSERT OR IGNORE INTO ${table} (component, version, name, checksum, applied_at) VALUES (${(0, schema_migrations_js_1.sqlLiteral)(migration.component)}, ${migration.version}, ${(0, schema_migrations_js_1.sqlLiteral)(migration.name)}, ${(0, schema_migrations_js_1.sqlLiteral)((0, schema_migrations_js_1.migrationChecksum)(migration))}, ${(0, schema_migrations_js_1.sqlLiteral)(new Date().toISOString())})`;
+        const script = ['BEGIN IMMEDIATE', ...migration.statements, record, 'COMMIT'].join(';\n');
+        try {
+            await client.exec(`${script};`);
+        }
+        catch (error) {
+            try {
+                await client.exec('ROLLBACK');
+            }
+            catch {
+            }
+            throw error;
+        }
+        statements.push(...migration.statements);
+    }
+    return { applied: status.pending, statements, dryRun: false };
+}
+function sqliteMigrationsTableStatement(table = schema_migrations_js_1.MIGRATIONS_TABLE) {
+    return `CREATE TABLE IF NOT EXISTS ${(0, client_js_1.quoteSqliteTable)(table)} (
+  component TEXT NOT NULL,
+  version INTEGER NOT NULL,
+  name TEXT NOT NULL,
+  checksum TEXT NOT NULL,
+  applied_at TEXT NOT NULL,
+  PRIMARY KEY (component, version)
+)`;
+}
+async function readApplied(client, table) {
+    const exists = (await client.all(`SELECT name FROM sqlite_master WHERE type = 'table' AND name = ?`, [
+        table,
+    ]));
+    if (exists.length === 0)
+        return [];
+    const rows = (await client.all(`SELECT component, version, name, checksum, applied_at FROM ${(0, client_js_1.quoteSqliteTable)(table)} ORDER BY applied_at, component, version`, []));
+    return rows.map((row) => ({
+        component: String(row.component),
+        version: Number(row.version),
+        name: String(row.name),
+        checksum: String(row.checksum),
+        appliedAt: String(row.applied_at),
+    }));
+}

package/dist-cjs/sqlite/operations.d.ts

@@ -1,12 +1,20 @@
 import { type OperationRecord, type OperationStore, type OperationStoreFilter, type OperationStoreStats } from '../types/operations.js';
+import type { MigrationResult, SchemaMigration } from '../utils/schema-migrations.js';
 import { type SqliteDatabaseLike, type SqliteLikeClient } from './client.js';
+import type { SqliteMigrateOptions } from './migrations.js';
 /** Options for the SQLite operation store. */
 export interface SqliteOperationStoreOptions {
     /** Table name. Defaults to `nexus_operations`. */
     table?: string;
 }
-/** The schema, as statements. Applied by `migrate()`, or by the application's own tooling. */
+/** The schema, as statements: every migration's, in order. For the application's own tooling. */
 export declare function sqliteOperationStoreMigration(options?: SqliteOperationStoreOptions): string[];
+/**
+ * The versioned schema, which `migrate()` applies. Version 1 is the 2.0 table; version 2 indexes
+ * queued work by age, so a claim reads the oldest few rows instead of sorting the queue; version 3
+ * indexes queued work by tenant.
+ */
+export declare function sqliteOperationStoreMigrations(options?: SqliteOperationStoreOptions): SchemaMigration[];
 /**
  * Operation records in SQLite: durable operations, and — through `OperationStoreCheckpointer` — graph
  * and workflow checkpoints, on one machine with no server to run.
@@ -20,8 +28,11 @@ export declare class SqliteOperationStore<TResult = unknown> implements Operatio
     private readonly client;
     private readonly table;
     constructor(database: SqliteLikeClient | SqliteDatabaseLike, options?: SqliteOperationStoreOptions);
-    /** Creates the table and indexes if they do not exist. Never runs implicitly. */
-    migrate(): Promise<void>;
+    /**
+     * Applies this store's pending migrations, recorded in `nexus_schema_migrations`, each inside
+     * `BEGIN IMMEDIATE`. Never runs implicitly. Safe on a file an older release created.
+     */
+    migrate(options?: SqliteMigrateOptions): Promise<MigrationResult>;
     /**
      * Inserts a new record. Throws `OperationDuplicateError` when its idempotency key is already
      * claimed. Refuses records carrying raw bytes.

package/dist-cjs/sqlite/operations.js

@@ -1,7 +1,41 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SqliteOperationStore = void 0;
 exports.sqliteOperationStoreMigration = sqliteOperationStoreMigration;
+exports.sqliteOperationStoreMigrations = sqliteOperationStoreMigrations;
 const errors_js_1 = require("../operations/errors.js");
 const serialization_js_1 = require("../operations/serialization.js");
 const operations_js_1 = require("../types/operations.js");
@@ -9,8 +43,31 @@ const client_js_1 = require("./client.js");
 const DEFAULT_TABLE = 'nexus_operations';
 const TERMINAL = operations_js_1.TERMINAL_OPERATION_STATUSES.map((status) => `'${status}'`).join(', ');
 function sqliteOperationStoreMigration(options = {}) {
+    return sqliteOperationStoreMigrations(options).flatMap((migration) => [...migration.statements]);
+}
+function sqliteOperationStoreMigrations(options = {}) {
     const name = options.table ?? DEFAULT_TABLE;
     const table = (0, client_js_1.quoteSqliteTable)(name);
+    const component = `operations:${name}`;
+    return [
+        { component, version: 1, name: 'create the operations table', statements: createStatements(name, table) },
+        {
+            component,
+            version: 2,
+            name: 'index queued work by age',
+            statements: [`CREATE INDEX IF NOT EXISTS "${name}_queued" ON ${table} (status, created_at, id)`],
+        },
+        {
+            component,
+            version: 3,
+            name: 'index queued work by tenant',
+            statements: [
+                `CREATE INDEX IF NOT EXISTS "${name}_tenant_queued" ON ${table} (status, json_extract(doc, '$.tenantId'), created_at, id)`,
+            ],
+        },
+    ];
+}
+function createStatements(name, table) {
     return [
         `CREATE TABLE IF NOT EXISTS ${table} (
   id TEXT PRIMARY KEY,
@@ -36,9 +93,9 @@ class SqliteOperationStore {
         this.client = (0, client_js_1.toSqliteClient)(database);
         this.table = (0, client_js_1.quoteSqliteTable)(options.table ?? DEFAULT_TABLE);
     }
-    async migrate() {
-        for (const statement of sqliteOperationStoreMigration(this.options))
-            await this.client.exec(statement);
+    async migrate(options = {}) {
+        const { applySqliteMigrations } = await Promise.resolve().then(() => __importStar(require('./migrations.js')));
+        return applySqliteMigrations(this.client, sqliteOperationStoreMigrations(this.options), options);
     }
     async create(record) {
         (0, serialization_js_1.assertSerializableRecord)(record);
@@ -103,29 +160,21 @@ class SqliteOperationStore {
     }
     async listQueued(limit, filter) {
         const params = [new Date().toISOString()];
-        let kind = '';
-        if (filter?.kindPrefix) {
-            params.push(filter.kindPrefix, filter.kindPrefix);
-            kind = ' AND substr(kind, 1, length(?)) = ?';
-        }
+        const narrowed = filterSql(filter, params);
         params.push(limit);
         return this.many(`SELECT doc FROM ${this.table}
-       WHERE status = 'queued' AND (lease_expires_at IS NULL OR lease_expires_at <= ?)${kind}
+       WHERE status = 'queued' AND (lease_expires_at IS NULL OR lease_expires_at <= ?)${narrowed}
        ORDER BY created_at, id
        LIMIT ?`, params);
     }
     async stats(now, filter) {
         const params = [now];
-        let kind = '';
-        if (filter?.kindPrefix) {
-            params.push(filter.kindPrefix, filter.kindPrefix);
-            kind = ' AND substr(kind, 1, length(?)) = ?';
-        }
+        const narrowed = filterSql(filter, params);
         const rows = (await this.client.all(`SELECT status, count(*) AS count,
          min(CASE WHEN status = 'queued' THEN created_at END) AS oldest,
          sum(CASE WHEN status = 'running' AND (lease_expires_at IS NULL OR lease_expires_at <= ?) THEN 1 ELSE 0 END) AS lapsed
        FROM ${this.table}
-       WHERE status NOT IN (${TERMINAL})${kind}
+       WHERE status NOT IN (${TERMINAL})${narrowed}
        GROUP BY status`, params));
         const byStatus = {};
         let oldestQueuedAt;
@@ -151,3 +200,15 @@ class SqliteOperationStore {
     }
 }
 exports.SqliteOperationStore = SqliteOperationStore;
+function filterSql(filter, params) {
+    let sql = '';
+    if (filter?.kindPrefix) {
+        params.push(filter.kindPrefix, filter.kindPrefix);
+        sql += ' AND substr(kind, 1, length(?)) = ?';
+    }
+    if (filter?.tenantId !== undefined) {
+        params.push(filter.tenantId);
+        sql += " AND json_extract(doc, '$.tenantId') = ?";
+    }
+    return sql;
+}

package/dist-cjs/sqlite/store.d.ts

@@ -1,5 +1,7 @@
 import type { Store, StoreIndexOptions, StoreItem, StoreNamespace, StorePutOptions, StoreSearchOptions } from '../types/store.js';
+import type { MigrationResult, SchemaMigration } from '../utils/schema-migrations.js';
 import { type SqliteDatabaseLike, type SqliteLikeClient } from './client.js';
+import type { SqliteMigrateOptions } from './migrations.js';
 /** Options for the SQLite store. */
 export interface SqliteStoreOptions {
     /** Table name. Defaults to `nexus_store`. */
@@ -11,6 +13,8 @@ export interface SqliteStoreOptions {
 }
 /** The schema, as statements. */
 export declare function sqliteStoreMigration(options?: Pick<SqliteStoreOptions, 'table'>): string[];
+/** The versioned schema, which `migrate()` applies. Version 1 is the 2.0 schema. */
+export declare function sqliteStoreMigrations(options?: Pick<SqliteStoreOptions, 'table'>): SchemaMigration[];
 /**
  * Long-term memory in SQLite, for one machine that needs memory to survive a restart.
  *
@@ -25,8 +29,11 @@ export declare class SqliteStore implements Store {
     private readonly table;
     private readonly now;
     constructor(database: SqliteLikeClient | SqliteDatabaseLike, options?: SqliteStoreOptions);
-    /** Creates the table and indexes if they do not exist. Never runs implicitly. */
-    migrate(): Promise<void>;
+    /**
+     * Applies this store's pending migrations, recorded in `nexus_schema_migrations`, each inside
+     * `BEGIN IMMEDIATE`. Never runs implicitly. Safe on a file an older release created.
+     */
+    migrate(options?: SqliteMigrateOptions): Promise<MigrationResult>;
     /** Stores an item, keeping its original `createdAt` when it replaces one. */
     put<V>(namespace: StoreNamespace, key: string, value: V, options?: StorePutOptions): Promise<void>;
     /** Reads an item, or `undefined` when it does not exist or has expired. */