nexus-ai-pro 2.0.0 → 2.2.0

package/dist-cjs/postgres/migrations.js

@@ -0,0 +1,129 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SchemaMigrationError = exports.migrationChecksum = void 0;
+exports.postgresMigrationStatus = postgresMigrationStatus;
+exports.applyPostgresMigrations = applyPostgresMigrations;
+exports.migrationsTableStatements = migrationsTableStatements;
+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; } });
+const LOCK_NAME = 'migrate';
+const DB_NOW = '(extract(epoch from clock_timestamp()) * 1000)';
+async function postgresMigrationStatus(client, migrations, options = {}) {
+    return (0, schema_migrations_js_1.planMigrations)(migrations, await readApplied(client, options.table ?? schema_migrations_js_1.MIGRATIONS_TABLE));
+}
+async function applyPostgresMigrations(client, migrations, options = {}) {
+    const tableName = options.table ?? schema_migrations_js_1.MIGRATIONS_TABLE;
+    if (options.dryRun) {
+        const status = await postgresMigrationStatus(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 bootstrap(client, tableName);
+    const owner = `migrator-${globalThis.crypto.randomUUID()}`;
+    const lockTtlMs = options.lockTtlMs ?? 600_000;
+    await acquire(client, tableName, owner, lockTtlMs, options.lockTimeoutMs ?? 120_000);
+    try {
+        const status = (0, schema_migrations_js_1.planMigrations)(migrations, await readApplied(client, tableName));
+        (0, schema_migrations_js_1.assertUnchanged)(status);
+        const statements = [];
+        for (const migration of status.pending) {
+            if (!(await claim(client, tableName, owner, lockTtlMs))) {
+                throw new schema_migrations_js_1.SchemaMigrationError('MIGRATION_LOCKED', `The migration lock lapsed before ${(0, schema_migrations_js_1.label)(migration)}`);
+            }
+            const apply = async (connection) => {
+                for (const statement of migration.statements)
+                    await connection.query(statement);
+                await connection.query(`INSERT INTO ${(0, client_js_1.quoteTable)(tableName)} (component, version, name, checksum, applied_at)
+           VALUES ($1, $2, $3, $4, $5) ON CONFLICT (component, version) DO NOTHING`, [
+                    migration.component,
+                    migration.version,
+                    migration.name,
+                    (0, schema_migrations_js_1.migrationChecksum)(migration),
+                    new Date().toISOString(),
+                ]);
+            };
+            if (options.transaction)
+                await options.transaction(apply);
+            else
+                await apply(client);
+            statements.push(...migration.statements);
+        }
+        return { applied: status.pending, statements, dryRun: false };
+    }
+    finally {
+        await client
+            .query(`DELETE FROM ${lockTable(tableName)} WHERE name = $1 AND owner = $2`, [LOCK_NAME, owner])
+            .catch(() => undefined);
+    }
+}
+function migrationsTableStatements(table = schema_migrations_js_1.MIGRATIONS_TABLE) {
+    return [
+        `CREATE TABLE IF NOT EXISTS ${(0, client_js_1.quoteTable)(table)} (
+  component text NOT NULL,
+  version integer NOT NULL,
+  name text NOT NULL,
+  checksum text NOT NULL,
+  applied_at text COLLATE "C" NOT NULL,
+  PRIMARY KEY (component, version)
+)`,
+        `CREATE TABLE IF NOT EXISTS ${lockTable(table)} (
+  name text PRIMARY KEY,
+  owner text NOT NULL,
+  expires_at double precision NOT NULL
+)`,
+    ];
+}
+async function bootstrap(client, table) {
+    for (const statement of migrationsTableStatements(table)) {
+        try {
+            await client.query(statement);
+        }
+        catch (error) {
+            const code = error?.code;
+            if (code !== '23505' && code !== '42P07')
+                throw error;
+        }
+    }
+}
+async function readApplied(client, table) {
+    const { rows: exists } = await client.query('SELECT to_regclass($1) IS NOT NULL AS present', [(0, client_js_1.quoteTable)(table)]);
+    if (!exists[0]?.present)
+        return [];
+    const { rows } = await client.query(`SELECT component, version, name, checksum, applied_at FROM ${(0, client_js_1.quoteTable)(table)} ORDER BY applied_at, component, version`);
+    return rows.map((row) => {
+        const value = row;
+        return {
+            component: String(value.component),
+            version: Number(value.version),
+            name: String(value.name),
+            checksum: String(value.checksum),
+            appliedAt: String(value.applied_at),
+        };
+    });
+}
+async function acquire(client, table, owner, ttlMs, timeoutMs) {
+    const deadline = Date.now() + timeoutMs;
+    let wait = 50;
+    while (!(await claim(client, table, owner, ttlMs))) {
+        if (Date.now() >= deadline) {
+            throw new schema_migrations_js_1.SchemaMigrationError('MIGRATION_LOCKED', `Another migrator held the lock for ${timeoutMs} ms. It is released when that migrator finishes, or when its lease lapses.`);
+        }
+        await (0, schema_migrations_js_1.delay)(wait);
+        wait = Math.min(wait * 2, 1_000);
+    }
+}
+async function claim(client, table, owner, ttlMs) {
+    const lock = lockTable(table);
+    const { rows } = await client.query(`INSERT INTO ${lock} (name, owner, expires_at) VALUES ($1, $2, ${DB_NOW} + $3::double precision)
+     ON CONFLICT (name) DO UPDATE SET owner = EXCLUDED.owner, expires_at = EXCLUDED.expires_at
+     WHERE ${lock}.owner = EXCLUDED.owner OR ${lock}.expires_at < ${DB_NOW}
+     RETURNING owner`, [LOCK_NAME, owner, ttlMs]);
+    return rows.length > 0;
+}
+function lockTable(table) {
+    return (0, client_js_1.quoteTable)(`${table}_lock`);
+}

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

@@ -1,12 +1,20 @@
 import type { OperationRecord, OperationStore, OperationStoreFilter, OperationStoreStats } from '../types/operations.js';
+import type { MigrationResult, SchemaMigration } from '../utils/schema-migrations.js';
 import { type PostgresLikeClient } from './client.js';
+import type { PostgresMigrateOptions } from './migrations.js';
 /** Options for the Postgres operation store. */
 export interface PostgresOperationStoreOptions {
     /** Table name, optionally schema-qualified. Defaults to `nexus_operations`. */
     table?: string;
 }
-/** The schema, as statements. Applied by `migrate()`, `nexus db sql`, or the application's own tooling. */
+/** The schema, as statements: every migration's, in order. For `nexus db sql` or the application's own tooling. */
 export declare function operationStoreMigration(options?: PostgresOperationStoreOptions): string[];
+/**
+ * The versioned schema, which `migrate()` and `nexus db migrate` apply. 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 operationStoreMigrations(options?: PostgresOperationStoreOptions): SchemaMigration[];
 /**
  * Operation records in Postgres.
  *
@@ -25,8 +33,11 @@ export declare class PostgresOperationStore<TResult = unknown> implements Operat
     private readonly options;
     private readonly table;
     constructor(client: PostgresLikeClient, options?: PostgresOperationStoreOptions);
-    /** 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`, under a lock.
+     * Never runs implicitly. Safe on a database an older release created: what exists is kept.
+     */
+    migrate(options?: PostgresMigrateOptions): Promise<MigrationResult>;
     /**
      * Inserts a new record. Throws `OperationDuplicateError` when its idempotency key is already
      * claimed. Refuses records carrying raw bytes.

package/dist-cjs/postgres/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.PostgresOperationStore = void 0;
 exports.operationStoreMigration = operationStoreMigration;
+exports.operationStoreMigrations = operationStoreMigrations;
 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,33 @@ 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 operationStoreMigration(options = {}) {
+    return operationStoreMigrations(options).flatMap((migration) => [...migration.statements]);
+}
+function operationStoreMigrations(options = {}) {
     const name = options.table ?? DEFAULT_TABLE;
     const table = (0, client_js_1.quoteTable)(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 ${(0, client_js_1.quoteDerived)(name, 'queued')} ON ${table} (created_at, id) WHERE status = 'queued'`,
+            ],
+        },
+        {
+            component,
+            version: 3,
+            name: 'index queued work by tenant',
+            statements: [
+                `CREATE INDEX IF NOT EXISTS ${(0, client_js_1.quoteDerived)(name, 'tenant_queued')} ON ${table} ((doc ->> 'tenantId'), created_at, id) WHERE status = 'queued'`,
+            ],
+        },
+    ];
+}
+function createStatements(name, table) {
     return [
         `CREATE TABLE IF NOT EXISTS ${table} (
   id text PRIMARY KEY,
@@ -36,8 +95,9 @@ class PostgresOperationStore {
         this.options = options;
         this.table = (0, client_js_1.quoteTable)(options.table ?? DEFAULT_TABLE);
     }
-    async migrate() {
-        await (0, client_js_1.runStatements)(this.client, operationStoreMigration(this.options));
+    async migrate(options = {}) {
+        const { applyPostgresMigrations } = await Promise.resolve().then(() => __importStar(require('./migrations.js')));
+        return applyPostgresMigrations(this.client, operationStoreMigrations(this.options), options);
     }
     async create(record) {
         (0, serialization_js_1.assertSerializableRecord)(record);
@@ -99,29 +159,21 @@ class PostgresOperationStore {
     }
     async listQueued(limit, filter) {
         const params = [new Date().toISOString(), limit];
-        let kind = '';
-        if (filter?.kindPrefix) {
-            params.push(filter.kindPrefix);
-            kind = ' AND substr(kind, 1, char_length($3)) = $3';
-        }
+        const narrowed = filterSql(filter, params);
         const { rows } = await this.client.query(`SELECT doc::text AS doc FROM ${this.table}
-       WHERE status = 'queued' AND (lease_expires_at IS NULL OR lease_expires_at <= $1)${kind}
+       WHERE status = 'queued' AND (lease_expires_at IS NULL OR lease_expires_at <= $1)${narrowed}
        ORDER BY created_at, id
        LIMIT $2`, params);
         return rows.map((row) => (0, client_js_1.fromJson)(row.doc));
     }
     async stats(now, filter) {
         const params = [now];
-        let kind = '';
-        if (filter?.kindPrefix) {
-            params.push(filter.kindPrefix);
-            kind = ' AND substr(kind, 1, char_length($2)) = $2';
-        }
+        const narrowed = filterSql(filter, params);
         const { rows } = await this.client.query(`SELECT status, count(*)::int AS count,
          min(created_at) FILTER (WHERE status = 'queued') AS oldest,
          count(*) FILTER (WHERE status = 'running' AND (lease_expires_at IS NULL OR lease_expires_at <= $1))::int AS lapsed
        FROM ${this.table}
-       WHERE status NOT IN (${TERMINAL})${kind}
+       WHERE status NOT IN (${TERMINAL})${narrowed}
        GROUP BY status`, params);
         return statsFromRows(rows);
     }
@@ -144,6 +196,18 @@ class PostgresOperationStore {
     }
 }
 exports.PostgresOperationStore = PostgresOperationStore;
+function filterSql(filter, params) {
+    let sql = '';
+    if (filter?.kindPrefix) {
+        params.push(filter.kindPrefix);
+        sql += ` AND substr(kind, 1, char_length($${params.length})) = $${params.length}`;
+    }
+    if (filter?.tenantId !== undefined) {
+        params.push(filter.tenantId);
+        sql += ` AND doc ->> 'tenantId' = $${params.length}`;
+    }
+    return sql;
+}
 function statsFromRows(rows) {
     const byStatus = {};
     let oldestQueuedAt;

package/dist-cjs/postgres/prompts.d.ts

@@ -1,10 +1,16 @@
 import type { PromptHistoryEntry, PromptLabel, PromptStore, PromptVersion } from '../types/prompts.js';
+import type { MigrationResult, SchemaMigration } from '../utils/schema-migrations.js';
 import { type PostgresLikeClient } from './client.js';
+import type { PostgresMigrateOptions } from './migrations.js';
 /** Options for the Postgres prompt store. */
 export interface PostgresPromptStoreOptions {
     /** Table name prefix, optionally schema-qualified. Defaults to `nexus_prompt`, for `nexus_prompt_versions` and so on. */
     table?: string;
 }
+/**
+ * The versioned schema, which `migrate()` and `nexus db migrate` apply. Version 1 is the 2.0 schema.
+ */
+export declare function promptStoreMigrations(options?: PostgresPromptStoreOptions): SchemaMigration[];
 /** The schema for the prompt store, as statements. */
 export declare function promptStoreMigration(options?: PostgresPromptStoreOptions): string[];
 /**
@@ -20,8 +26,11 @@ export declare class PostgresPromptStore implements PromptStore {
     private readonly labels;
     private readonly history;
     constructor(client: PostgresLikeClient, options?: PostgresPromptStoreOptions);
-    /** Creates the prompt tables if they do not exist. Never runs implicitly. */
-    migrate(): Promise<void>;
+    /**
+     * Applies this store's pending migrations, recorded in `nexus_schema_migrations`, under a lock.
+     * Never runs implicitly. Safe on a database an older release created: what exists is kept.
+     */
+    migrate(options?: PostgresMigrateOptions): Promise<MigrationResult>;
     /** Stores a version, unless one with the same content version exists. */
     saveVersion(version: PromptVersion): Promise<void>;
     /** Reads a version. */

package/dist-cjs/postgres/prompts.js

@@ -1,12 +1,56 @@
 "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.PostgresPromptStore = void 0;
+exports.promptStoreMigrations = promptStoreMigrations;
 exports.promptStoreMigration = promptStoreMigration;
 const client_js_1 = require("./client.js");
 function tables(options) {
     const base = options.table ?? 'nexus_prompt';
     return { base, versions: `${base}_versions`, labels: `${base}_labels`, history: `${base}_history` };
 }
+function promptStoreMigrations(options = {}) {
+    return [
+        {
+            component: `prompts:${tables(options).versions}`,
+            version: 1,
+            name: 'create the prompt tables',
+            statements: promptStoreMigration(options),
+        },
+    ];
+}
 function promptStoreMigration(options = {}) {
     const names = tables(options);
     return [
@@ -48,8 +92,9 @@ class PostgresPromptStore {
         this.labels = (0, client_js_1.quoteTable)(names.labels);
         this.history = (0, client_js_1.quoteTable)(names.history);
     }
-    async migrate() {
-        await (0, client_js_1.runStatements)(this.client, promptStoreMigration(this.options));
+    async migrate(options = {}) {
+        const { applyPostgresMigrations } = await Promise.resolve().then(() => __importStar(require('./migrations.js')));
+        return applyPostgresMigrations(this.client, promptStoreMigrations(this.options), options);
     }
     async saveVersion(version) {
         await this.client.query(`INSERT INTO ${this.versions} (name, version, created_at, doc) VALUES ($1, $2, $3, $4::jsonb) ON CONFLICT DO NOTHING`, [version.name, version.version, version.createdAt, JSON.stringify(version)]);

package/dist-cjs/postgres/rollups.d.ts

@@ -0,0 +1,35 @@
+import { type RollupKey, type RollupQuery, type RollupRow, type RollupStore, type RollupTotals } from '../tracing/rollups.js';
+import type { MigrationResult, SchemaMigration } from '../utils/schema-migrations.js';
+import { type PostgresLikeClient } from './client.js';
+import type { PostgresMigrateOptions } from './migrations.js';
+/** Options for the Postgres rollup store. */
+export interface PostgresRollupStoreOptions {
+    /** Table name, optionally schema-qualified. Defaults to `nexus_rollups`. */
+    table?: string;
+}
+/** The schema, as statements: every migration's, in order. */
+export declare function rollupStoreMigration(options?: PostgresRollupStoreOptions): string[];
+/** The versioned schema, which `migrate()` and `nexus db migrate` apply. */
+export declare function rollupStoreMigrations(options?: PostgresRollupStoreOptions): SchemaMigration[];
+/**
+ * Rollup rows in Postgres, so a dashboard's totals live beside its traces and survive a restart.
+ *
+ * Adding to a row is one `INSERT … ON CONFLICT DO UPDATE` that sums every total, latency buckets
+ * included, so two workers finishing runs in the same hour both count. A query reads only the rows
+ * of its range: a month of one tenant is a few hundred rows, however many runs it held.
+ */
+export declare class PostgresRollupStore implements RollupStore {
+    private readonly client;
+    private readonly options;
+    private readonly table;
+    constructor(client: PostgresLikeClient, options?: PostgresRollupStoreOptions);
+    /**
+     * Applies this store's pending migrations, recorded in `nexus_schema_migrations`, under a lock.
+     * Never runs implicitly.
+     */
+    migrate(options?: PostgresMigrateOptions): Promise<MigrationResult>;
+    /** Adds totals to the row for `key`, creating it, in one statement. */
+    add(key: RollupKey, totals: RollupTotals): Promise<void>;
+    /** Rows matching a query, oldest hour first, filtered as the in-memory store filters them. */
+    query(query?: RollupQuery): Promise<RollupRow[]>;
+}

package/dist-cjs/postgres/rollups.js

@@ -0,0 +1,168 @@
+"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.PostgresRollupStore = void 0;
+exports.rollupStoreMigration = rollupStoreMigration;
+exports.rollupStoreMigrations = rollupStoreMigrations;
+const rollups_js_1 = require("../tracing/rollups.js");
+const client_js_1 = require("./client.js");
+const sql_js_1 = require("./sql.js");
+const DEFAULT_TABLE = 'nexus_rollups';
+function rollupStoreMigration(options = {}) {
+    return rollupStoreMigrations(options).flatMap((migration) => [...migration.statements]);
+}
+function rollupStoreMigrations(options = {}) {
+    const name = options.table ?? DEFAULT_TABLE;
+    const table = (0, client_js_1.quoteTable)(name);
+    return [
+        {
+            component: `rollups:${name}`,
+            version: 1,
+            name: 'create the rollups table',
+            statements: [
+                `CREATE TABLE IF NOT EXISTS ${table} (
+  hour text COLLATE "C" NOT NULL,
+  kind text NOT NULL,
+  name text NOT NULL,
+  model text NOT NULL,
+  provider text NOT NULL,
+  tenant text NOT NULL,
+  runs bigint NOT NULL,
+  errors bigint NOT NULL,
+  cost double precision NOT NULL,
+  input_tokens bigint NOT NULL,
+  output_tokens bigint NOT NULL,
+  latency bigint[] NOT NULL,
+  PRIMARY KEY (hour, kind, name, model, provider, tenant)
+)`,
+                `CREATE INDEX IF NOT EXISTS ${(0, client_js_1.quoteDerived)(name, 'tenant_hour')} ON ${table} (tenant, hour)`,
+            ],
+        },
+    ];
+}
+class PostgresRollupStore {
+    client;
+    options;
+    table;
+    constructor(client, options = {}) {
+        this.client = client;
+        this.options = options;
+        this.table = (0, client_js_1.quoteTable)(options.table ?? DEFAULT_TABLE);
+    }
+    async migrate(options = {}) {
+        const { applyPostgresMigrations } = await Promise.resolve().then(() => __importStar(require('./migrations.js')));
+        return applyPostgresMigrations(this.client, rollupStoreMigrations(this.options), options);
+    }
+    async add(key, totals) {
+        const t = this.table;
+        await this.client.query(`INSERT INTO ${t} (hour, kind, name, model, provider, tenant, runs, errors, cost, input_tokens, output_tokens, latency)
+       VALUES ($1, $2, $3, $4, $5, $6, $7::bigint, $8::bigint, $9::double precision, $10::bigint, $11::bigint, $12::bigint[])
+       ON CONFLICT (hour, kind, name, model, provider, tenant) DO UPDATE SET
+         runs = ${t}.runs + EXCLUDED.runs,
+         errors = ${t}.errors + EXCLUDED.errors,
+         cost = ${t}.cost + EXCLUDED.cost,
+         input_tokens = ${t}.input_tokens + EXCLUDED.input_tokens,
+         output_tokens = ${t}.output_tokens + EXCLUDED.output_tokens,
+         latency = ARRAY(
+           SELECT coalesce(stored, 0) + coalesce(added, 0)
+           FROM unnest(${t}.latency, EXCLUDED.latency) WITH ORDINALITY AS bucket(stored, added, position)
+           ORDER BY position
+         )`, [
+            key.hour,
+            key.kind,
+            key.name,
+            key.model,
+            key.provider,
+            key.tenant,
+            totals.runs,
+            totals.errors,
+            totals.cost,
+            totals.inputTokens,
+            totals.outputTokens,
+            `{${bucketsOf(totals.latency).join(',')}}`,
+        ]);
+    }
+    async query(query = {}) {
+        const params = new sql_js_1.SqlParams();
+        const where = [];
+        if (query.since)
+            where.push(`hour >= ${params.add(hourOf(query.since))}`);
+        if (query.until)
+            where.push(`hour <= ${params.add(query.until)}`);
+        if (query.kind !== undefined) {
+            const kinds = Array.isArray(query.kind) ? query.kind : [query.kind];
+            where.push(kinds.length ? `kind IN (${kinds.map((kind) => params.add(kind)).join(', ')})` : 'FALSE');
+        }
+        if (query.model !== undefined)
+            where.push(`model = ${params.add(query.model)}`);
+        if (query.provider !== undefined)
+            where.push(`provider = ${params.add(query.provider)}`);
+        if (query.tenant !== undefined)
+            where.push(`tenant = ${params.add(query.tenant)}`);
+        if (query.name !== undefined)
+            where.push(`name = ${params.add(query.name)}`);
+        const { rows } = await this.client.query(`SELECT hour, kind, name, model, provider, tenant, runs::text AS runs, errors::text AS errors, cost,
+         input_tokens::text AS input_tokens, output_tokens::text AS output_tokens, latency::text AS latency
+       FROM ${this.table}
+       ${where.length ? `WHERE ${where.join(' AND ')}` : ''}
+       ORDER BY hour, kind, name, model, provider, tenant`, params.values);
+        return rows.map((raw) => {
+            const row = raw;
+            return {
+                hour: String(row.hour),
+                kind: row.kind,
+                name: String(row.name),
+                model: String(row.model),
+                provider: String(row.provider),
+                tenant: String(row.tenant),
+                runs: Number(row.runs),
+                errors: Number(row.errors),
+                cost: Number(row.cost),
+                inputTokens: Number(row.input_tokens),
+                outputTokens: Number(row.output_tokens),
+                latency: String(row.latency).replace(/[{}]/g, '').split(',').filter(Boolean).map(Number),
+            };
+        });
+    }
+}
+exports.PostgresRollupStore = PostgresRollupStore;
+function bucketsOf(latency) {
+    return Array.from({ length: rollups_js_1.ROLLUP_LATENCY_BOUNDS_MS.length + 1 }, (_, index) => Math.round(latency[index] ?? 0));
+}
+function hourOf(iso) {
+    const date = new Date(iso);
+    date.setUTCMinutes(0, 0, 0);
+    return date.toISOString();
+}

package/dist-cjs/postgres/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 PostgresLikeClient } from './client.js';
+import type { PostgresMigrateOptions } from './migrations.js';
 /** Options for the Postgres store. */
 export interface PostgresStoreOptions {
     /** Table name, optionally schema-qualified. Defaults to `nexus_store`. */
@@ -15,6 +17,10 @@ export interface PostgresStoreOptions {
     /** Replaces the system clock, for tests. */
     now?: () => Date;
 }
+/**
+ * The versioned schema, which `migrate()` and `nexus db migrate` apply. Version 1 is the 2.0 schema.
+ */
+export declare function storeMigrations(options?: Pick<PostgresStoreOptions, 'table' | 'vectorDimensions'>): SchemaMigration[];
 /** The schema, as statements. With `vectorDimensions`, pgvector's extension is created too. */
 export declare function storeMigration(options?: Pick<PostgresStoreOptions, 'table' | 'vectorDimensions'>): string[];
 /**
@@ -31,8 +37,11 @@ export declare class PostgresStore implements Store {
     private readonly table;
     private readonly now;
     constructor(client: PostgresLikeClient, options?: PostgresStoreOptions);
-    /** Creates the table, indexes, and pgvector extension if configured. Never runs implicitly. */
-    migrate(): Promise<void>;
+    /**
+     * Applies this store's pending migrations, recorded in `nexus_schema_migrations`, under a lock.
+     * Never runs implicitly. Safe on a database an older release created: what exists is kept.
+     */
+    migrate(options?: PostgresMigrateOptions): 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. */