@intx/db 0.1.2 → 0.3.0

package/dist/schema/catalog.js

@@ -0,0 +1,108 @@
+import { sql } from "drizzle-orm";
+import { boolean, check, integer, jsonb, pgTable, text, timestamp, unique, } from "drizzle-orm/pg-core";
+import { credential } from "./credentials.js";
+import { tenant } from "./tenants.js";
+import { wallet } from "./wallets.js";
+export const model = pgTable("model", {
+    id: text("id").primaryKey(),
+    tenantId: text("tenant_id")
+        .notNull()
+        .references(() => tenant.id, { onDelete: "cascade" }),
+    canonicalName: text("canonical_name").notNull(),
+    displayName: text("display_name"),
+    description: text("description"),
+    // Own-row disable. Suppressing an inherited row (a child tenant hiding a
+    // parent's model) is a separate resolution-time mechanism, not this flag.
+    disabled: boolean("disabled").notNull().default(false),
+    createdAt: timestamp("created_at").notNull().defaultNow(),
+    updatedAt: timestamp("updated_at").notNull().defaultNow(),
+}, (t) => [
+    unique("model_tenant_canonical_name").on(t.tenantId, t.canonicalName),
+]);
+export const modelProvider = pgTable("model_provider", {
+    id: text("id").primaryKey(),
+    tenantId: text("tenant_id")
+        .notNull()
+        .references(() => tenant.id, { onDelete: "cascade" }),
+    name: text("name").notNull(),
+    plugin: text("plugin", {
+        enum: ["anthropic", "openai", "openai-compatible", "google-genai"],
+    }).notNull(),
+    baseURL: text("base_url").notNull(),
+    // A provider authenticates via exactly one of credential or wallet (the
+    // check constraint below enforces the XOR). onDelete is "restrict" so a
+    // credential or wallet cannot be deleted out from under a provider that
+    // depends on it — the provider must be repointed or removed first.
+    credentialId: text("credential_id").references(() => credential.id, {
+        onDelete: "restrict",
+    }),
+    walletId: text("wallet_id").references(() => wallet.id, {
+        onDelete: "restrict",
+    }),
+    // Own-row disable. Inherited-row suppression is resolved separately.
+    disabled: boolean("disabled").notNull().default(false),
+    createdAt: timestamp("created_at").notNull().defaultNow(),
+    updatedAt: timestamp("updated_at").notNull().defaultNow(),
+}, (t) => [
+    unique("model_provider_tenant_name").on(t.tenantId, t.name),
+    check("model_provider_auth_xor", sql `(${t.credentialId} is not null) <> (${t.walletId} is not null)`),
+]);
+export const modelOffering = pgTable("model_offering", {
+    id: text("id").primaryKey(),
+    tenantId: text("tenant_id")
+        .notNull()
+        .references(() => tenant.id, { onDelete: "cascade" }),
+    modelId: text("model_id")
+        .notNull()
+        .references(() => model.id, { onDelete: "cascade" }),
+    providerId: text("provider_id")
+        .notNull()
+        .references(() => modelProvider.id, { onDelete: "cascade" }),
+    priority: integer("priority").notNull(),
+    deploymentTags: text("deployment_tags").array().notNull().default([]),
+    // Curated-capability tags. This issue creates the column; the values are
+    // populated by the discovery-support-matrix seeding work.
+    capabilities: text("capabilities").array().notNull().default([]),
+    // Opaque per-deployment bag of provider-specific adapter accommodations
+    // (e.g. OpenAI's forceAssistantReasoningContent). Interpreted and
+    // validated only at the adapter factory, which alone knows the provider
+    // shape. NULL means the factory receives no bag and applies its default
+    // behavior.
+    quirks: jsonb("quirks"),
+    // Own-row disable. Inherited-row suppression is resolved separately.
+    disabled: boolean("disabled").notNull().default(false),
+    createdAt: timestamp("created_at").notNull().defaultNow(),
+    updatedAt: timestamp("updated_at").notNull().defaultNow(),
+}, (t) => [
+    unique("model_offering_tenant_model_provider").on(t.tenantId, t.modelId, t.providerId),
+]);
+export const modelPricing = pgTable("model_pricing", {
+    id: text("id").primaryKey(),
+    tenantId: text("tenant_id")
+        .notNull()
+        .references(() => tenant.id, { onDelete: "cascade" }),
+    offeringId: text("offering_id")
+        .notNull()
+        .references(() => modelOffering.id, { onDelete: "cascade" }),
+    currency: text("currency").notNull(),
+    inputTokenPrice: text("input_token_price"),
+    outputTokenPrice: text("output_token_price"),
+    cacheReadTokenPrice: text("cache_read_token_price"),
+    cacheWriteTokenPrice: text("cache_write_token_price"),
+    thinkingTokenPrice: text("thinking_token_price"),
+    perRequestFee: text("per_request_fee"),
+    perImageFee: text("per_image_fee"),
+    perAudioFee: text("per_audio_fee"),
+    // Append-only. A price change inserts a new row with a later
+    // effective_from; rows are never edited in place, so cost attribution at
+    // a past timestamp stays accurate. withTimezone anchors the as-of
+    // comparison across writers.
+    effectiveFrom: timestamp("effective_from", {
+        withTimezone: true,
+    }).notNull(),
+    createdAt: timestamp("created_at", { withTimezone: true })
+        .notNull()
+        .defaultNow(),
+}, (t) => [
+    unique("model_pricing_offering_currency_effective_from").on(t.offeringId, t.currency, t.effectiveFrom),
+]);

package/dist/schema/column-types.d.ts

@@ -0,0 +1,26 @@
+export declare const bytea: {
+    (): import("drizzle-orm/pg-core").PgCustomColumnBuilder<{
+        name: "";
+        dataType: "custom";
+        columnType: "PgCustomColumn";
+        data: Uint8Array<ArrayBufferLike>;
+        driverParam: Uint8Array<ArrayBufferLike>;
+        enumValues: undefined;
+    }>;
+    <TConfig extends Record<string, any>>(fieldConfig?: TConfig | undefined): import("drizzle-orm/pg-core").PgCustomColumnBuilder<{
+        name: "";
+        dataType: "custom";
+        columnType: "PgCustomColumn";
+        data: Uint8Array<ArrayBufferLike>;
+        driverParam: Uint8Array<ArrayBufferLike>;
+        enumValues: undefined;
+    }>;
+    <TName extends string>(dbName: TName, fieldConfig?: unknown): import("drizzle-orm/pg-core").PgCustomColumnBuilder<{
+        name: TName;
+        dataType: "custom";
+        columnType: "PgCustomColumn";
+        data: Uint8Array<ArrayBufferLike>;
+        driverParam: Uint8Array<ArrayBufferLike>;
+        enumValues: undefined;
+    }>;
+};

package/dist/schema/column-types.js

@@ -0,0 +1,15 @@
+import { customType } from "drizzle-orm/pg-core";
+// Postgres `bytea` mapped to `Uint8Array` on both the app and driver
+// sides, so binary columns (hash digests, raw message frames) round-trip
+// as raw bytes with no encoding layer to keep in sync.
+export const bytea = customType({
+    dataType() {
+        return "bytea";
+    },
+    toDriver(value) {
+        return value;
+    },
+    fromDriver(value) {
+        return new Uint8Array(value);
+    },
+});

package/dist/schema/credentials.d.ts

@@ -0,0 +1,305 @@
+export declare const credential: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "credential";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: "id";
+            tableName: "credential";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        tenantId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "tenant_id";
+            tableName: "credential";
+            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;
+        }, {}, {}>;
+        principalId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "principal_id";
+            tableName: "credential";
+            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;
+        }, {}, {}>;
+        providerId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "provider_id";
+            tableName: "credential";
+            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;
+        }, {}, {}>;
+        oauthClientId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "oauth_client_id";
+            tableName: "credential";
+            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;
+        }, {}, {}>;
+        name: import("drizzle-orm/pg-core").PgColumn<{
+            name: "name";
+            tableName: "credential";
+            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;
+        }, {}, {}>;
+        type: import("drizzle-orm/pg-core").PgColumn<{
+            name: "type";
+            tableName: "credential";
+            dataType: "string";
+            columnType: "PgText";
+            data: "api_key" | "oauth_token" | "certificate" | "other";
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: ["api_key", "oauth_token", "certificate", "other"];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        description: import("drizzle-orm/pg-core").PgColumn<{
+            name: "description";
+            tableName: "credential";
+            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;
+        }, {}, {}>;
+        secret: import("drizzle-orm/pg-core").PgColumn<{
+            name: "secret";
+            tableName: "credential";
+            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;
+        }, {}, {}>;
+        refreshSecret: import("drizzle-orm/pg-core").PgColumn<{
+            name: "refresh_secret";
+            tableName: "credential";
+            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;
+        }, {}, {}>;
+        scopes: import("drizzle-orm/pg-core").PgColumn<{
+            name: "scopes";
+            tableName: "credential";
+            dataType: "array";
+            columnType: "PgArray";
+            data: string[];
+            driverParam: string | string[];
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: import("drizzle-orm").Column<{
+                name: "scopes";
+                tableName: "credential";
+                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;
+            }, {}, {}>;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            baseBuilder: import("drizzle-orm/pg-core").PgColumnBuilder<{
+                name: "scopes";
+                dataType: "string";
+                columnType: "PgText";
+                data: string;
+                enumValues: [string, ...string[]];
+                driverParam: string;
+            }, {}, {}, import("drizzle-orm").ColumnBuilderExtraConfig>;
+            size: undefined;
+        }>;
+        expiresAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "expires_at";
+            tableName: "credential";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        status: import("drizzle-orm/pg-core").PgColumn<{
+            name: "status";
+            tableName: "credential";
+            dataType: "string";
+            columnType: "PgText";
+            data: "active" | "error" | "expired" | "revoked";
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: ["active", "expired", "revoked", "error"];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        metadata: import("drizzle-orm/pg-core").PgColumn<{
+            name: "metadata";
+            tableName: "credential";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: unknown;
+            driverParam: unknown;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        createdAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "created_at";
+            tableName: "credential";
+            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: "credential";
+            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/{src/schema/credentials.ts → dist/schema/credentials.js}

@@ -1,29 +1,25 @@
 import { jsonb, pgTable, text, timestamp, unique } from "drizzle-orm/pg-core";
-
-import { oauthClient } from "./oauth-clients";
-import { principal } from "./principals";
-import { provider } from "./providers";
-import { tenant } from "./tenants";
-
-export const credential = pgTable(
-  "credential",
-  {
+import { oauthClient } from "./oauth-clients.js";
+import { principal } from "./principals.js";
+import { provider } from "./providers.js";
+import { tenant } from "./tenants.js";
+export const credential = pgTable("credential", {
     id: text("id").primaryKey(),
     tenantId: text("tenant_id")
-      .notNull()
-      .references(() => tenant.id, { onDelete: "cascade" }),
+        .notNull()
+        .references(() => tenant.id, { onDelete: "cascade" }),
     principalId: text("principal_id").references(() => principal.id, {
-      onDelete: "set null",
+        onDelete: "set null",
     }),
     providerId: text("provider_id")
-      .notNull()
-      .references(() => provider.id, { onDelete: "cascade" }),
+        .notNull()
+        .references(() => provider.id, { onDelete: "cascade" }),
     oauthClientId: text("oauth_client_id").references(() => oauthClient.id, {
-      onDelete: "set null",
+        onDelete: "set null",
     }),
     name: text("name").notNull(),
     type: text("type", {
-      enum: ["api_key", "oauth_token", "certificate", "other"],
+        enum: ["api_key", "oauth_token", "certificate", "other"],
     }).notNull(),
     description: text("description"),
     secret: text("secret").notNull(),
@@ -31,13 +27,11 @@ export const credential = pgTable(
     scopes: text("scopes").array(),
     expiresAt: timestamp("expires_at"),
     status: text("status", {
-      enum: ["active", "expired", "revoked", "error"],
+        enum: ["active", "expired", "revoked", "error"],
     })
-      .notNull()
-      .default("active"),
+        .notNull()
+        .default("active"),
     metadata: jsonb("metadata"),
     createdAt: timestamp("created_at").notNull().defaultNow(),
     updatedAt: timestamp("updated_at").notNull().defaultNow(),
-  },
-  (t) => [unique("credential_tenant_name").on(t.tenantId, t.name)],
-);
+}, (t) => [unique("credential_tenant_name").on(t.tenantId, t.name)]);