@sealkeeper/schema 0.0.1 → 0.4.0

package/dist/db/index.js

@@ -0,0 +1,23 @@
+// The query helpers the API needs beyond the relational query API. The API
+// takes them from here so drizzle-orm stays a dependency of this package only.
+export { and, asc, desc, eq, gt, inArray, isNotNull, isNull, lt, lte, max, ne, notInArray, or, sql, } from 'drizzle-orm';
+// What every failed query throws. Its message holds the SQL and every bound
+// param, so the API error log must never print it.
+export { DrizzleQueryError } from 'drizzle-orm/errors';
+export { agentRenames } from './agent-renames.js';
+export { agents } from './agents.js';
+export { createDb } from './client.js';
+export { credentials } from './credentials.js';
+export { deletedOperators } from './deleted-operators.js';
+export { events } from './events.js';
+export { feedItems } from './feed-items.js';
+export { migrationsFolder, runMigrations } from './migrator.js';
+export { operators } from './operators.js';
+export { quotaCounters } from './quota-counters.js';
+export { ratings } from './ratings.js';
+export { scores } from './scores.js';
+export { standing } from './standing.js';
+export { taskOutcomes } from './task-outcomes.js';
+export { tasks } from './tasks.js';
+export { timestamps } from './timestamps.js';
+export { pgArgs } from './url.js';

package/dist/db/migrate.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/db/migrate.js

@@ -0,0 +1,30 @@
+// Applies the SQL migrations in packages/schema/drizzle to DATABASE_URL.
+// This is what the vouched-migrate Cloud Run Job runs, so the image needs
+// drizzle-orm only and not drizzle-kit. Local dev keeps `pnpm db:migrate`.
+// @types/node is a devDependency only for this script, migrator.ts and url.ts.
+/// <reference types="node" />
+import { runMigrations } from './migrator.js';
+const url = process.env.DATABASE_URL;
+if (!url) {
+    console.error('DATABASE_URL is not set');
+    process.exit(1);
+}
+try {
+    await runMigrations(url);
+    console.log(JSON.stringify({ msg: 'migrations applied' }));
+}
+catch (err) {
+    // Log messages and the error code only, never the error object or the URL,
+    // which carry the password. Drizzle wraps connection and auth failures as
+    // a failed query, so the real reason is in err.cause.
+    const msg = err instanceof Error ? err.message : 'unknown error';
+    const cause = err instanceof Error && err.cause instanceof Error ? err.cause : undefined;
+    const code = cause?.code;
+    console.error(JSON.stringify({
+        msg: 'migration failed',
+        error: msg,
+        cause: cause?.message,
+        code,
+    }));
+    process.exit(1);
+}

package/dist/db/migrator.d.ts

@@ -0,0 +1,2 @@
+export declare const migrationsFolder: string;
+export declare function runMigrations(databaseUrl: string): Promise<void>;

package/dist/db/migrator.js

@@ -0,0 +1,20 @@
+// The one drizzle migrator. migrate.ts (the vouched-migrate job) and the API
+// test helper both call runMigrations, so there is a single code path.
+/// <reference types="node" />
+import { fileURLToPath } from 'node:url';
+import { drizzle } from 'drizzle-orm/postgres-js';
+import { migrate } from 'drizzle-orm/postgres-js/migrator';
+import postgres from 'postgres';
+import { pgArgs } from './url.js';
+// Resolves to packages/schema/drizzle from both src/db and dist/db.
+export const migrationsFolder = fileURLToPath(new URL('../../drizzle', import.meta.url));
+export async function runMigrations(databaseUrl) {
+    const [connUrl, options] = pgArgs(databaseUrl);
+    const sql = postgres(connUrl, { ...options, max: 1, onnotice: () => { } });
+    try {
+        await migrate(drizzle(sql), { migrationsFolder });
+    }
+    finally {
+        await sql.end();
+    }
+}

package/dist/db/operators.d.ts

@@ -0,0 +1,109 @@
+export declare const operators: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "operators";
+    schema: undefined;
+    columns: {
+        createdAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "created_at";
+            tableName: "operators";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        updatedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "updated_at";
+            tableName: "operators";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: "id";
+            tableName: "operators";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        githubId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "github_id";
+            tableName: "operators";
+            dataType: "number";
+            columnType: "PgBigInt53";
+            data: number;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        login: import("drizzle-orm/pg-core").PgColumn<{
+            name: "login";
+            tableName: "operators";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        accountCreatedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "account_created_at";
+            tableName: "operators";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: 'pg';
+}>;

package/dist/db/operators.js

@@ -0,0 +1,11 @@
+import { bigint, pgTable, text, timestamp, uuid } from 'drizzle-orm/pg-core';
+import { timestamps } from './timestamps.js';
+export const operators = pgTable('operators', {
+    id: uuid('id').primaryKey().defaultRandom(),
+    githubId: bigint('github_id', { mode: 'number' }).notNull().unique(),
+    login: text('login').notNull(),
+    accountCreatedAt: timestamp('account_created_at', {
+        withTimezone: true,
+    }).notNull(),
+    ...timestamps,
+});

package/dist/db/quota-counters.d.ts

@@ -0,0 +1,109 @@
+export declare const quotaCounters: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "quota_counters";
+    schema: undefined;
+    columns: {
+        createdAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "created_at";
+            tableName: "quota_counters";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        updatedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "updated_at";
+            tableName: "quota_counters";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        key: import("drizzle-orm/pg-core").PgColumn<{
+            name: "key";
+            tableName: "quota_counters";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        windowStart: import("drizzle-orm/pg-core").PgColumn<{
+            name: "window_start";
+            tableName: "quota_counters";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        expiresAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "expires_at";
+            tableName: "quota_counters";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        count: import("drizzle-orm/pg-core").PgColumn<{
+            name: "count";
+            tableName: "quota_counters";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: 'pg';
+}>;

package/dist/db/quota-counters.js

@@ -0,0 +1,17 @@
+import { index, integer, pgTable, primaryKey, text, timestamp, } from 'drizzle-orm/pg-core';
+import { timestamps } from './timestamps.js';
+// Per-agent write quotas. One row per (key, fixed window). The API increments
+// the count with one upsert, so the count survives Cloud Run scaling to zero
+// and is shared by every instance. Windows differ in length between keys, so
+// each row carries the end of its own window in expires_at, and the API
+// deletes rows whose window has ended.
+export const quotaCounters = pgTable('quota_counters', {
+    key: text('key').notNull(),
+    windowStart: timestamp('window_start', { withTimezone: true }).notNull(),
+    expiresAt: timestamp('expires_at', { withTimezone: true }).notNull(),
+    count: integer('count').notNull(),
+    ...timestamps,
+}, (t) => [
+    primaryKey({ columns: [t.key, t.windowStart] }),
+    index('quota_counters_expires_at_idx').on(t.expiresAt),
+]);

package/dist/db/ratings.d.ts

@@ -0,0 +1,160 @@
+export declare const ratings: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "ratings";
+    schema: undefined;
+    columns: {
+        createdAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "created_at";
+            tableName: "ratings";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        updatedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "updated_at";
+            tableName: "ratings";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: "id";
+            tableName: "ratings";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        raterAgentId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "rater_agent_id";
+            tableName: "ratings";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        rateeAgentId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "ratee_agent_id";
+            tableName: "ratings";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        dimension: import("drizzle-orm/pg-core").PgColumn<{
+            name: "dimension";
+            tableName: "ratings";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        value: import("drizzle-orm/pg-core").PgColumn<{
+            name: "value";
+            tableName: "ratings";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        raterScoreAtTime: import("drizzle-orm/pg-core").PgColumn<{
+            name: "rater_score_at_time";
+            tableName: "ratings";
+            dataType: "number";
+            columnType: "PgReal";
+            data: number;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        issuedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "issued_at";
+            tableName: "ratings";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: 'pg';
+}>;

package/dist/db/ratings.js

@@ -0,0 +1,27 @@
+import { sql } from 'drizzle-orm';
+import { check, integer, pgTable, real, text, timestamp, unique, uuid, } from 'drizzle-orm/pg-core';
+import { agents } from './agents.js';
+import { timestamps } from './timestamps.js';
+export const ratings = pgTable('ratings', {
+    id: uuid('id').primaryKey(),
+    raterAgentId: text('rater_agent_id')
+        .notNull()
+        .references(() => agents.id),
+    rateeAgentId: text('ratee_agent_id')
+        .notNull()
+        .references(() => agents.id),
+    dimension: text('dimension').notNull(),
+    value: integer('value').notNull(),
+    raterScoreAtTime: real('rater_score_at_time').notNull(),
+    // The signed issuedAt of the rating that wrote the row. A rating only
+    // replaces the row when it was issued later, so a replayed envelope
+    // changes nothing.
+    issuedAt: timestamp('issued_at', { withTimezone: true }).notNull(),
+    ...timestamps,
+}, (t) => [
+    unique('ratings_rater_ratee_dimension_unique').on(t.raterAgentId, t.rateeAgentId, t.dimension),
+    // Scoring maps value to (value - 1) / 4 and weights it by the rater
+    // score, so a row outside these ranges would push a score past 1.
+    check('ratings_value_range', sql `${t.value} between 1 and 5`),
+    check('ratings_rater_score_range', sql `${t.raterScoreAtTime} between 0 and 1`),
+]);

package/dist/db/scores.d.ts

@@ -0,0 +1,160 @@
+export declare const scores: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "scores";
+    schema: undefined;
+    columns: {
+        createdAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "created_at";
+            tableName: "scores";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        updatedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "updated_at";
+            tableName: "scores";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        agentId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "agent_id";
+            tableName: "scores";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        version: import("drizzle-orm/pg-core").PgColumn<{
+            name: "version";
+            tableName: "scores";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        dimension: import("drizzle-orm/pg-core").PgColumn<{
+            name: "dimension";
+            tableName: "scores";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        value: import("drizzle-orm/pg-core").PgColumn<{
+            name: "value";
+            tableName: "scores";
+            dataType: "number";
+            columnType: "PgReal";
+            data: number;
+            driverParam: string | number;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        windowStart: import("drizzle-orm/pg-core").PgColumn<{
+            name: "window_start";
+            tableName: "scores";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        windowEnd: import("drizzle-orm/pg-core").PgColumn<{
+            name: "window_end";
+            tableName: "scores";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        computedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "computed_at";
+            tableName: "scores";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: 'pg';
+}>;