@vouched-dev/schema 0.1.0

package/dist/db/client.js

@@ -0,0 +1,28 @@
+import { drizzle } from 'drizzle-orm/postgres-js';
+import postgres from 'postgres';
+import { agents } from './agents.js';
+import { credentials } from './credentials.js';
+import { events } from './events.js';
+import { feedItems } from './feed-items.js';
+import { operators } from './operators.js';
+import { quotaCounters } from './quota-counters.js';
+import { ratings } from './ratings.js';
+import { scores } from './scores.js';
+import { taskOutcomes } from './task-outcomes.js';
+import { tasks } from './tasks.js';
+import { pgArgs } from './url.js';
+const schema = {
+    operators,
+    agents,
+    events,
+    tasks,
+    taskOutcomes,
+    ratings,
+    credentials,
+    scores,
+    quotaCounters,
+    feedItems,
+};
+export function createDb(url) {
+    return drizzle(postgres(...pgArgs(url)), { schema });
+}

package/dist/db/credentials.d.ts

@@ -0,0 +1,143 @@
+export declare const credentials: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "credentials";
+    schema: undefined;
+    columns: {
+        createdAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "created_at";
+            tableName: "credentials";
+            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: "credentials";
+            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: "credentials";
+            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;
+        }, {}, {}>;
+        agentId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "agent_id";
+            tableName: "credentials";
+            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;
+        }, {}, {}>;
+        kid: import("drizzle-orm/pg-core").PgColumn<{
+            name: "kid";
+            tableName: "credentials";
+            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;
+        }, {}, {}>;
+        jws: import("drizzle-orm/pg-core").PgColumn<{
+            name: "jws";
+            tableName: "credentials";
+            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;
+        }, {}, {}>;
+        issuedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "issued_at";
+            tableName: "credentials";
+            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: "credentials";
+            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/credentials.js

@@ -0,0 +1,16 @@
+import { index, pgTable, text, timestamp, uuid } from 'drizzle-orm/pg-core';
+import { agents } from './agents.js';
+import { timestamps } from './timestamps.js';
+export const credentials = pgTable('credentials', {
+    id: uuid('id').primaryKey(),
+    agentId: text('agent_id')
+        .notNull()
+        .references(() => agents.id),
+    kid: text('kid').notNull(),
+    jws: text('jws').notNull(),
+    issuedAt: timestamp('issued_at', { withTimezone: true }).notNull(),
+    expiresAt: timestamp('expires_at', { withTimezone: true }).notNull(),
+    ...timestamps,
+}, (t) => [
+    index('credentials_agent_id_expires_at_idx').on(t.agentId, t.expiresAt),
+]);

package/dist/db/events.d.ts

@@ -0,0 +1,160 @@
+export declare const events: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "events";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: "id";
+            tableName: "events";
+            dataType: "number";
+            columnType: "PgBigInt53";
+            data: number;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: "always";
+            generated: undefined;
+        }, {}, {}>;
+        agentId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "agent_id";
+            tableName: "events";
+            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;
+        }, {}, {}>;
+        eventId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "event_id";
+            tableName: "events";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        type: import("drizzle-orm/pg-core").PgColumn<{
+            name: "type";
+            tableName: "events";
+            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: "events";
+            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;
+        }, {}, {}>;
+        payload: import("drizzle-orm/pg-core").PgColumn<{
+            name: "payload";
+            tableName: "events";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: unknown;
+            driverParam: unknown;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        envelope: import("drizzle-orm/pg-core").PgColumn<{
+            name: "envelope";
+            tableName: "events";
+            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;
+        }, {}, {}>;
+        occurredAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "occurred_at";
+            tableName: "events";
+            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;
+        }, {}, {}>;
+        receivedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "received_at";
+            tableName: "events";
+            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;
+        }, {}, {}>;
+    };
+    dialect: 'pg';
+}>;

package/dist/db/events.js

@@ -0,0 +1,23 @@
+import { bigint, index, jsonb, pgTable, text, timestamp, unique, uuid, } from 'drizzle-orm/pg-core';
+import { agents } from './agents.js';
+// Append only. No created_at or updated_at, received_at is the server timestamp.
+export const events = pgTable('events', {
+    id: bigint('id', { mode: 'number' })
+        .primaryKey()
+        .generatedAlwaysAsIdentity(),
+    agentId: text('agent_id')
+        .notNull()
+        .references(() => agents.id),
+    eventId: uuid('event_id').notNull(),
+    type: text('type').notNull(),
+    version: text('version').notNull(),
+    payload: jsonb('payload').notNull(),
+    envelope: text('envelope').notNull(),
+    occurredAt: timestamp('occurred_at', { withTimezone: true }).notNull(),
+    receivedAt: timestamp('received_at', { withTimezone: true })
+        .notNull()
+        .defaultNow(),
+}, (t) => [
+    unique('events_agent_id_event_id_unique').on(t.agentId, t.eventId),
+    index('events_agent_id_occurred_at_idx').on(t.agentId, t.occurredAt),
+]);

package/dist/db/feed-items.d.ts

@@ -0,0 +1,109 @@
+export declare const feedItems: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "feed_items";
+    schema: undefined;
+    columns: {
+        createdAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "created_at";
+            tableName: "feed_items";
+            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: "feed_items";
+            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: "feed_items";
+            dataType: "number";
+            columnType: "PgBigInt53";
+            data: number;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: "always";
+            generated: undefined;
+        }, {}, {}>;
+        kind: import("drizzle-orm/pg-core").PgColumn<{
+            name: "kind";
+            tableName: "feed_items";
+            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;
+        }, {}, {}>;
+        agentId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "agent_id";
+            tableName: "feed_items";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        payload: import("drizzle-orm/pg-core").PgColumn<{
+            name: "payload";
+            tableName: "feed_items";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: unknown;
+            driverParam: unknown;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: 'pg';
+}>;

package/dist/db/feed-items.js

@@ -0,0 +1,16 @@
+import { bigint, index, jsonb, pgTable, text } from 'drizzle-orm/pg-core';
+import { agents } from './agents.js';
+import { timestamps } from './timestamps.js';
+// The public feed. One row per public fact, written in the same transaction
+// as the change it describes. The identity id is the SSE event id, so a
+// client resumes with Last-Event-ID. The payload holds public facts only,
+// shaped by FeedItem in api.ts.
+export const feedItems = pgTable('feed_items', {
+    id: bigint('id', { mode: 'number' })
+        .primaryKey()
+        .generatedAlwaysAsIdentity(),
+    kind: text('kind').notNull(),
+    agentId: text('agent_id').references(() => agents.id),
+    payload: jsonb('payload').notNull(),
+    ...timestamps,
+}, (t) => [index('feed_items_created_at_idx').on(t.createdAt)]);

package/dist/db/index.d.ts

@@ -0,0 +1,43 @@
+import type { credentials } from './credentials.js';
+import type { events } from './events.js';
+import type { feedItems } from './feed-items.js';
+import type { operators } from './operators.js';
+import type { quotaCounters } from './quota-counters.js';
+import type { ratings } from './ratings.js';
+import type { scores } from './scores.js';
+import type { taskOutcomes } from './task-outcomes.js';
+import type { tasks } from './tasks.js';
+export { and, asc, desc, eq, gt, inArray, isNotNull, isNull, lt, lte, ne, notInArray, or, sql, } from 'drizzle-orm';
+export type { Agent, NewAgent } from './agents.js';
+export { agents } from './agents.js';
+export { createDb, type Db, type Tx } from './client.js';
+export { credentials } from './credentials.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 { taskOutcomes } from './task-outcomes.js';
+export { tasks } from './tasks.js';
+export { timestamps } from './timestamps.js';
+export { pgArgs } from './url.js';
+export type Operator = typeof operators.$inferSelect;
+export type NewOperator = typeof operators.$inferInsert;
+export type Event = typeof events.$inferSelect;
+export type NewEvent = typeof events.$inferInsert;
+export type Task = typeof tasks.$inferSelect;
+export type NewTask = typeof tasks.$inferInsert;
+export type TaskOutcome = typeof taskOutcomes.$inferSelect;
+export type NewTaskOutcome = typeof taskOutcomes.$inferInsert;
+export type Rating = typeof ratings.$inferSelect;
+export type NewRating = typeof ratings.$inferInsert;
+export type Credential = typeof credentials.$inferSelect;
+export type NewCredential = typeof credentials.$inferInsert;
+export type Score = typeof scores.$inferSelect;
+export type NewScore = typeof scores.$inferInsert;
+export type QuotaCounter = typeof quotaCounters.$inferSelect;
+export type NewQuotaCounter = typeof quotaCounters.$inferInsert;
+export type FeedItem = typeof feedItems.$inferSelect;
+export type NewFeedItem = typeof feedItems.$inferInsert;

package/dist/db/index.js

@@ -0,0 +1,17 @@
+// 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, ne, notInArray, or, sql, } from 'drizzle-orm';
+export { agents } from './agents.js';
+export { createDb } from './client.js';
+export { credentials } from './credentials.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 { 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();
+    }
+}