@sealkeeper/schema 0.0.1 → 0.4.0

package/dist/db/client.js

@@ -0,0 +1,34 @@
+import { drizzle } from 'drizzle-orm/postgres-js';
+import postgres from 'postgres';
+import { agentRenames } from './agent-renames.js';
+import { agents } from './agents.js';
+import { credentials } from './credentials.js';
+import { deletedOperators } from './deleted-operators.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 { standing } from './standing.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,
+    standing,
+    quotaCounters,
+    feedItems,
+    agentRenames,
+    deletedOperators,
+};
+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/deleted-operators.d.ts

@@ -0,0 +1,75 @@
+export declare const deletedOperators: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "deleted_operators";
+    schema: undefined;
+    columns: {
+        createdAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "created_at";
+            tableName: "deleted_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: "deleted_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;
+        }, {}, {}>;
+        githubId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "github_id";
+            tableName: "deleted_operators";
+            dataType: "number";
+            columnType: "PgBigInt53";
+            data: number;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        deletedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "deleted_at";
+            tableName: "deleted_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;
+        }, {}, {}>;
+    };
+    dialect: 'pg';
+}>;

package/dist/db/deleted-operators.js

@@ -0,0 +1,13 @@
+import { bigint, pgTable, timestamp } from 'drizzle-orm/pg-core';
+import { timestamps } from './timestamps.js';
+// One row per GitHub account whose operator deleted itself. It holds the
+// numeric GitHub id and when, nothing else, so registration and web sign in
+// can refuse the same account for 30 days. The scoring run purges rows
+// older than that. deleted_at is set by the database.
+export const deletedOperators = pgTable('deleted_operators', {
+    githubId: bigint('github_id', { mode: 'number' }).primaryKey(),
+    deletedAt: timestamp('deleted_at', { withTimezone: true })
+        .notNull()
+        .defaultNow(),
+    ...timestamps,
+});

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,34 @@
+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),
+    // Last seen and the activity queries read the newest received_at per
+    // agent. NULLS FIRST is what a plain DESC means in Postgres, so the index
+    // matches order by received_at desc exactly. The column is never null.
+    index('events_agent_id_received_at_idx').on(t.agentId, t.receivedAt.desc().nullsFirst()),
+    // The ingest cap on new versions per day walks an agent's distinct
+    // versions and reads each one's first received_at from here. The
+    // scoring run's first seen per version reads the same pairs.
+    index('events_agent_id_version_received_at_idx').on(t.agentId, t.version, t.receivedAt),
+    // Range reads on the server clock across agents. The stats count of
+    // the last 24 hours and the evidence counts over a window.
+    index('events_received_at_agent_id_idx').on(t.receivedAt, t.agentId),
+]);

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,56 @@
+import type { agentRenames } from './agent-renames.js';
+import type { credentials } from './credentials.js';
+import type { deletedOperators } from './deleted-operators.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 { standing } from './standing.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, max, ne, notInArray, or, sql, } from 'drizzle-orm';
+export { DrizzleQueryError } from 'drizzle-orm/errors';
+export { agentRenames } from './agent-renames.js';
+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 { 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 { type StoredCounts, 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';
+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 StandingRow = typeof standing.$inferSelect;
+export type NewStandingRow = typeof standing.$inferInsert;
+export type QuotaCounter = typeof quotaCounters.$inferSelect;
+export type NewQuotaCounter = typeof quotaCounters.$inferInsert;
+export type AgentRename = typeof agentRenames.$inferSelect;
+export type NewAgentRename = typeof agentRenames.$inferInsert;
+export type FeedItem = typeof feedItems.$inferSelect;
+export type NewFeedItem = typeof feedItems.$inferInsert;
+export type DeletedOperator = typeof deletedOperators.$inferSelect;
+export type NewDeletedOperator = typeof deletedOperators.$inferInsert;