@revealui/db 0.2.0

package/dist/schema/error-events.d.ts

@@ -0,0 +1,223 @@
+/**
+ * Error Events Table - Persistent storage for application errors.
+ *
+ * Append-only table. Captures unhandled errors from CMS (client + server)
+ * and API. Queryable via the CMS admin /admin/errors page.
+ * Supplemented by Axiom log drain for full log search.
+ */
+export declare const errorEvents: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "error_events";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: "id";
+            tableName: "error_events";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: true;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        timestamp: import("drizzle-orm/pg-core").PgColumn<{
+            name: "timestamp";
+            tableName: "error_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;
+        }, {}, {}>;
+        level: import("drizzle-orm/pg-core").PgColumn<{
+            name: "level";
+            tableName: "error_events";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        message: import("drizzle-orm/pg-core").PgColumn<{
+            name: "message";
+            tableName: "error_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;
+        }, {}, {}>;
+        stack: import("drizzle-orm/pg-core").PgColumn<{
+            name: "stack";
+            tableName: "error_events";
+            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;
+        }, {}, {}>;
+        app: import("drizzle-orm/pg-core").PgColumn<{
+            name: "app";
+            tableName: "error_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;
+        }, {}, {}>;
+        context: import("drizzle-orm/pg-core").PgColumn<{
+            name: "context";
+            tableName: "error_events";
+            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;
+        }, {}, {}>;
+        environment: import("drizzle-orm/pg-core").PgColumn<{
+            name: "environment";
+            tableName: "error_events";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        url: import("drizzle-orm/pg-core").PgColumn<{
+            name: "url";
+            tableName: "error_events";
+            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;
+        }, {}, {}>;
+        userId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "user_id";
+            tableName: "error_events";
+            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;
+        }, {}, {}>;
+        requestId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "request_id";
+            tableName: "error_events";
+            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;
+        }, {}, {}>;
+        metadata: import("drizzle-orm/pg-core").PgColumn<{
+            name: "metadata";
+            tableName: "error_events";
+            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;
+        }, {}, {}>;
+    };
+    dialect: "pg";
+}>;
+/** Row type for select queries */
+export type ErrorEventRow = typeof errorEvents.$inferSelect;
+/** Insert type for new records */
+export type ErrorEventInsert = typeof errorEvents.$inferInsert;
+//# sourceMappingURL=error-events.d.ts.map

package/dist/schema/error-events.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"error-events.d.ts","sourceRoot":"","sources":["../../src/schema/error-events.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAQH,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA8CvB,CAAA;AAED,kCAAkC;AAClC,MAAM,MAAM,aAAa,GAAG,OAAO,WAAW,CAAC,YAAY,CAAA;AAE3D,kCAAkC;AAClC,MAAM,MAAM,gBAAgB,GAAG,OAAO,WAAW,CAAC,YAAY,CAAA"}

package/dist/schema/error-events.js

@@ -0,0 +1,44 @@
+/**
+ * Error Events Table - Persistent storage for application errors.
+ *
+ * Append-only table. Captures unhandled errors from CMS (client + server)
+ * and API. Queryable via the CMS admin /admin/errors page.
+ * Supplemented by Axiom log drain for full log search.
+ */
+import { index, jsonb, pgTable, text, timestamp } from 'drizzle-orm/pg-core';
+// =============================================================================
+// Error Events Table
+// =============================================================================
+export const errorEvents = pgTable('error_events', {
+    /** Unique event ID (UUID) */
+    id: text('id')
+        .primaryKey()
+        .$defaultFn(() => crypto.randomUUID()),
+    /** When the error occurred */
+    timestamp: timestamp('timestamp', { withTimezone: true }).defaultNow().notNull(),
+    /** Severity level */
+    level: text('level').notNull().default('error'), // 'error' | 'fatal' | 'warn'
+    /** Error message */
+    message: text('message').notNull(),
+    /** Stack trace (optional — not available for client-side errors without source maps) */
+    stack: text('stack'),
+    /** Which app generated the error */
+    app: text('app').notNull(), // 'cms' | 'api' | 'marketing'
+    /** Runtime context within the app */
+    context: text('context'), // 'server' | 'client' | 'edge'
+    /** Deployment environment */
+    environment: text('environment').notNull().default('production'),
+    /** URL where the error occurred */
+    url: text('url'),
+    /** User ID if authenticated (plain text — no FK, errors outlive users) */
+    userId: text('user_id'),
+    /** Request ID for cross-service correlation */
+    requestId: text('request_id'),
+    /** Additional structured metadata (status codes, headers, etc.) */
+    metadata: jsonb('metadata'),
+}, (table) => [
+    index('error_events_timestamp_idx').on(table.timestamp),
+    index('error_events_app_env_idx').on(table.app, table.environment),
+    index('error_events_level_idx').on(table.level),
+]);
+//# sourceMappingURL=error-events.js.map

package/dist/schema/error-events.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"error-events.js","sourceRoot":"","sources":["../../src/schema/error-events.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,OAAO,EAAE,IAAI,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAA;AAE5E,gFAAgF;AAChF,qBAAqB;AACrB,gFAAgF;AAEhF,MAAM,CAAC,MAAM,WAAW,GAAG,OAAO,CAChC,cAAc,EACd;IACE,6BAA6B;IAC7B,EAAE,EAAE,IAAI,CAAC,IAAI,CAAC;SACX,UAAU,EAAE;SACZ,UAAU,CAAC,GAAG,EAAE,CAAC,MAAM,CAAC,UAAU,EAAE,CAAC;IAExC,8BAA8B;IAC9B,SAAS,EAAE,SAAS,CAAC,WAAW,EAAE,EAAE,YAAY,EAAE,IAAI,EAAE,CAAC,CAAC,UAAU,EAAE,CAAC,OAAO,EAAE;IAEhF,qBAAqB;IACrB,KAAK,EAAE,IAAI,CAAC,OAAO,CAAC,CAAC,OAAO,EAAE,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE,6BAA6B;IAE9E,oBAAoB;IACpB,OAAO,EAAE,IAAI,CAAC,SAAS,CAAC,CAAC,OAAO,EAAE;IAElC,wFAAwF;IACxF,KAAK,EAAE,IAAI,CAAC,OAAO,CAAC;IAEpB,oCAAoC;IACpC,GAAG,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC,OAAO,EAAE,EAAE,8BAA8B;IAE1D,qCAAqC;IACrC,OAAO,EAAE,IAAI,CAAC,SAAS,CAAC,EAAE,+BAA+B;IAEzD,6BAA6B;IAC7B,WAAW,EAAE,IAAI,CAAC,aAAa,CAAC,CAAC,OAAO,EAAE,CAAC,OAAO,CAAC,YAAY,CAAC;IAEhE,mCAAmC;IACnC,GAAG,EAAE,IAAI,CAAC,KAAK,CAAC;IAEhB,0EAA0E;IAC1E,MAAM,EAAE,IAAI,CAAC,SAAS,CAAC;IAEvB,+CAA+C;IAC/C,SAAS,EAAE,IAAI,CAAC,YAAY,CAAC;IAE7B,mEAAmE;IACnE,QAAQ,EAAE,KAAK,CAAC,UAAU,CAAC;CAC5B,EACD,CAAC,KAAK,EAAE,EAAE,CAAC;IACT,KAAK,CAAC,4BAA4B,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,SAAS,CAAC;IACvD,KAAK,CAAC,0BAA0B,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,GAAG,EAAE,KAAK,CAAC,WAAW,CAAC;IAClE,KAAK,CAAC,wBAAwB,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,KAAK,CAAC;CAChD,CACF,CAAA"}

package/dist/schema/index.d.ts

@@ -0,0 +1,130 @@
+/**
+ * @revealui/db/schema - Database Schema (Schema/Server-side)
+ *
+ * Drizzle ORM table definitions derived from @revealui/contracts Zod schemas.
+ * Designed for Neon Postgres with pgvector extension for embeddings.
+ *
+ * The tables mirror the following Zod schemas:
+ * - UserSchema, SessionSchema → users, sessions
+ * - SiteSchema → sites, siteCollaborators
+ * - PageSchema → pages, pageRevisions
+ * - AgentContextSchema, AgentMemorySchema, etc. → agent tables
+ *
+ * This file re-exports both REST and Vector schemas for backward compatibility.
+ * For dual database architecture, use:
+ * - `@revealui/db/schema/rest` for REST API schemas (NeonDB)
+ * - `@revealui/db/schema/vector` for Vector schemas (Supabase)
+ */
+export * from './rest.js';
+export * from './vector.js';
+export declare const usersRelations: import("drizzle-orm").Relations<"users", {
+    sessions: import("drizzle-orm").Many<"sessions">;
+    ownedSites: import("drizzle-orm").Many<"sites">;
+    collaborations: import("drizzle-orm").Many<"site_collaborators">;
+    pageRevisions: import("drizzle-orm").Many<"page_revisions">;
+    conversations: import("drizzle-orm").Many<"conversations">;
+    apiKeys: import("drizzle-orm").Many<"user_api_keys">;
+    providerConfigs: import("drizzle-orm").Many<"tenant_provider_configs">;
+}>;
+export declare const userApiKeysRelations: import("drizzle-orm").Relations<"user_api_keys", {
+    user: import("drizzle-orm").One<"users", true>;
+}>;
+export declare const tenantProviderConfigsRelations: import("drizzle-orm").Relations<"tenant_provider_configs", {
+    user: import("drizzle-orm").One<"users", true>;
+}>;
+export declare const sessionsRelations: import("drizzle-orm").Relations<"sessions", {
+    user: import("drizzle-orm").One<"users", true>;
+}>;
+export declare const passwordResetTokensRelations: import("drizzle-orm").Relations<"password_reset_tokens", {
+    user: import("drizzle-orm").One<"users", true>;
+}>;
+export declare const sitesRelations: import("drizzle-orm").Relations<"sites", {
+    owner: import("drizzle-orm").One<"users", true>;
+    collaborators: import("drizzle-orm").Many<"site_collaborators">;
+    pages: import("drizzle-orm").Many<"pages">;
+}>;
+export declare const siteCollaboratorsRelations: import("drizzle-orm").Relations<"site_collaborators", {
+    site: import("drizzle-orm").One<"sites", true>;
+    user: import("drizzle-orm").One<"users", true>;
+    addedByUser: import("drizzle-orm").One<"users", false>;
+}>;
+export declare const pagesRelations: import("drizzle-orm").Relations<"pages", {
+    site: import("drizzle-orm").One<"sites", true>;
+    parent: import("drizzle-orm").One<"pages", false>;
+    children: import("drizzle-orm").Many<"pages">;
+    revisions: import("drizzle-orm").Many<"page_revisions">;
+}>;
+export declare const pageRevisionsRelations: import("drizzle-orm").Relations<"page_revisions", {
+    page: import("drizzle-orm").One<"pages", true>;
+    createdByUser: import("drizzle-orm").One<"users", false>;
+}>;
+export declare const agentContextsRelations: import("drizzle-orm").Relations<"agent_contexts", {}>;
+export declare const agentMemoriesRelations: import("drizzle-orm").Relations<"agent_memories", {
+    site: import("drizzle-orm").One<"sites", false>;
+    verifiedByUser: import("drizzle-orm").One<"users", false>;
+}>;
+export declare const conversationsRelations: import("drizzle-orm").Relations<"conversations", {
+    user: import("drizzle-orm").One<"users", true>;
+    actions: import("drizzle-orm").Many<"agent_actions">;
+}>;
+export declare const agentActionsRelations: import("drizzle-orm").Relations<"agent_actions", {
+    conversation: import("drizzle-orm").One<"conversations", false>;
+}>;
+export declare const postsRelations: import("drizzle-orm").Relations<"posts", {
+    author: import("drizzle-orm").One<"users", false>;
+    featuredImage: import("drizzle-orm").One<"media", false>;
+}>;
+export declare const mediaRelations: import("drizzle-orm").Relations<"media", {
+    uploadedByUser: import("drizzle-orm").One<"users", false>;
+}>;
+export declare const licensesRelations: import("drizzle-orm").Relations<"licenses", {
+    user: import("drizzle-orm").One<"users", true>;
+}>;
+export declare const auditLogRelations: import("drizzle-orm").Relations<"audit_log", {}>;
+export declare const appLogsRelations: import("drizzle-orm").Relations<"app_logs", {}>;
+export declare const errorEventsRelations: import("drizzle-orm").Relations<"error_events", {}>;
+export declare const yjsDocumentsRelations: import("drizzle-orm").Relations<"yjs_documents", {
+    edits: import("drizzle-orm").Many<"collab_edits">;
+}>;
+export declare const collabEditsRelations: import("drizzle-orm").Relations<"collab_edits", {
+    document: import("drizzle-orm").One<"yjs_documents", true>;
+}>;
+export declare const boardsRelations: import("drizzle-orm").Relations<"boards", {
+    owner: import("drizzle-orm").One<"users", false>;
+    columns: import("drizzle-orm").Many<"board_columns">;
+    tickets: import("drizzle-orm").Many<"tickets">;
+}>;
+export declare const boardColumnsRelations: import("drizzle-orm").Relations<"board_columns", {
+    board: import("drizzle-orm").One<"boards", true>;
+    tickets: import("drizzle-orm").Many<"tickets">;
+}>;
+export declare const ticketsRelations: import("drizzle-orm").Relations<"tickets", {
+    board: import("drizzle-orm").One<"boards", true>;
+    column: import("drizzle-orm").One<"board_columns", false>;
+    assignee: import("drizzle-orm").One<"users", false>;
+    reporter: import("drizzle-orm").One<"users", false>;
+    parent: import("drizzle-orm").One<"tickets", false>;
+    children: import("drizzle-orm").Many<"tickets">;
+    comments: import("drizzle-orm").Many<"ticket_comments">;
+    labelAssignments: import("drizzle-orm").Many<"ticket_label_assignments">;
+}>;
+export declare const ticketCommentsRelations: import("drizzle-orm").Relations<"ticket_comments", {
+    ticket: import("drizzle-orm").One<"tickets", true>;
+    author: import("drizzle-orm").One<"users", false>;
+}>;
+export declare const ticketLabelsRelations: import("drizzle-orm").Relations<"ticket_labels", {
+    assignments: import("drizzle-orm").Many<"ticket_label_assignments">;
+}>;
+export declare const ticketLabelAssignmentsRelations: import("drizzle-orm").Relations<"ticket_label_assignments", {
+    ticket: import("drizzle-orm").One<"tickets", true>;
+    label: import("drizzle-orm").One<"ticket_labels", true>;
+}>;
+export declare const codeProvenanceRelations: import("drizzle-orm").Relations<"code_provenance", {
+    reviewer: import("drizzle-orm").One<"users", false>;
+    reviews: import("drizzle-orm").Many<"code_reviews">;
+}>;
+export declare const codeReviewsRelations: import("drizzle-orm").Relations<"code_reviews", {
+    provenance: import("drizzle-orm").One<"code_provenance", true>;
+    reviewer: import("drizzle-orm").One<"users", false>;
+}>;
+//# sourceMappingURL=index.d.ts.map

package/dist/schema/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/schema/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAGH,cAAc,WAAW,CAAA;AACzB,cAAc,aAAa,CAAA;AAoC3B,eAAO,MAAM,cAAc;;;;;;;;EAQxB,CAAA;AAGH,eAAO,MAAM,oBAAoB;;EAK9B,CAAA;AAEH,eAAO,MAAM,8BAA8B;;EAKxC,CAAA;AAGH,eAAO,MAAM,iBAAiB;;EAK3B,CAAA;AAGH,eAAO,MAAM,4BAA4B;;EAKtC,CAAA;AAKH,eAAO,MAAM,cAAc;;;;EAOxB,CAAA;AAGH,eAAO,MAAM,0BAA0B;;;;EAapC,CAAA;AAGH,eAAO,MAAM,cAAc;;;;;EAcxB,CAAA;AAGH,eAAO,MAAM,sBAAsB;;;EAShC,CAAA;AAGH,eAAO,MAAM,sBAAsB,uDAEhC,CAAA;AAGH,eAAO,MAAM,sBAAsB;;;EAShC,CAAA;AAGH,eAAO,MAAM,sBAAsB;;;EAMhC,CAAA;AAGH,eAAO,MAAM,qBAAqB;;EAK/B,CAAA;AAOH,eAAO,MAAM,cAAc;;;EASxB,CAAA;AAGH,eAAO,MAAM,cAAc;;EAKxB,CAAA;AAMH,eAAO,MAAM,iBAAiB;;EAK3B,CAAA;AASH,eAAO,MAAM,iBAAiB,kDAAkC,CAAA;AAIhE,eAAO,MAAM,gBAAgB,iDAAiC,CAAA;AAI9D,eAAO,MAAM,oBAAoB,qDAAqC,CAAA;AAMtE,eAAO,MAAM,qBAAqB;;EAE/B,CAAA;AAEH,eAAO,MAAM,oBAAoB;;EAK9B,CAAA;AAMH,eAAO,MAAM,eAAe;;;;EAOzB,CAAA;AAEH,eAAO,MAAM,qBAAqB;;;EAM/B,CAAA;AAEH,eAAO,MAAM,gBAAgB;;;;;;;;;EA6B1B,CAAA;AAEH,eAAO,MAAM,uBAAuB;;;EASjC,CAAA;AAEH,eAAO,MAAM,qBAAqB;;EAE/B,CAAA;AAEH,eAAO,MAAM,+BAA+B;;;EASzC,CAAA;AAMH,eAAO,MAAM,uBAAuB;;;EAMjC,CAAA;AAEH,eAAO,MAAM,oBAAoB;;;EAS9B,CAAA"}