@pipeline-builder/pipeline-data 3.4.114 → 3.4.116

package/lib/database/drizzle-schema.d.ts

@@ -2,6 +2,7 @@ export * from './schema/plugin.js';
 export * from './schema/pipeline.js';
 export * from './schema/pipeline-template.js';
 export * from './schema/message.js';
+export * from './schema/message-attachment.js';
 export * from './schema/compliance.js';
 export * from './schema/dashboard.js';
 export * from './schema/alert.js';
@@ -1757,6 +1758,25 @@ export declare const schema: {
             }, {}, {
                 length: 255;
             }>;
+            recipientUserId: import("drizzle-orm/pg-core").PgColumn<{
+                name: "recipient_user_id";
+                tableName: "messages";
+                dataType: "string";
+                columnType: "PgVarchar";
+                data: string;
+                driverParam: string;
+                notNull: false;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {
+                length: 255;
+            }>;
             messageType: import("drizzle-orm/pg-core").PgColumn<{
                 name: "message_type";
                 tableName: "messages";
@@ -1832,6 +1852,23 @@ export declare const schema: {
                 identity: undefined;
                 generated: undefined;
             }, {}, {}>;
+            editedAt: import("drizzle-orm/pg-core").PgColumn<{
+                name: "edited_at";
+                tableName: "messages";
+                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;
+            }, {}, {}>;
             readBy: import("drizzle-orm/pg-core").PgColumn<{
                 name: "read_by";
                 tableName: "messages";
@@ -1979,6 +2016,174 @@ export declare const schema: {
         };
         dialect: 'pg';
     }>;
+    readonly messageAttachment: import("drizzle-orm/pg-core").PgTableWithColumns<{
+        name: "message_attachments";
+        schema: undefined;
+        columns: {
+            id: import("drizzle-orm/pg-core").PgColumn<{
+                name: "id";
+                tableName: "message_attachments";
+                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;
+            }, {}, {}>;
+            orgId: import("drizzle-orm/pg-core").PgColumn<{
+                name: "org_id";
+                tableName: "message_attachments";
+                dataType: "string";
+                columnType: "PgVarchar";
+                data: string;
+                driverParam: string;
+                notNull: true;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {
+                length: 255;
+            }>;
+            messageId: import("drizzle-orm/pg-core").PgColumn<{
+                name: "message_id";
+                tableName: "message_attachments";
+                dataType: "string";
+                columnType: "PgUUID";
+                data: string;
+                driverParam: string;
+                notNull: false;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            uploadedBy: import("drizzle-orm/pg-core").PgColumn<{
+                name: "uploaded_by";
+                tableName: "message_attachments";
+                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;
+            }, {}, {}>;
+            filename: import("drizzle-orm/pg-core").PgColumn<{
+                name: "filename";
+                tableName: "message_attachments";
+                dataType: "string";
+                columnType: "PgVarchar";
+                data: string;
+                driverParam: string;
+                notNull: true;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {
+                length: 255;
+            }>;
+            contentType: import("drizzle-orm/pg-core").PgColumn<{
+                name: "content_type";
+                tableName: "message_attachments";
+                dataType: "string";
+                columnType: "PgVarchar";
+                data: string;
+                driverParam: string;
+                notNull: true;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {
+                length: 128;
+            }>;
+            sizeBytes: import("drizzle-orm/pg-core").PgColumn<{
+                name: "size_bytes";
+                tableName: "message_attachments";
+                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;
+            }, {}, {}>;
+            storageKey: import("drizzle-orm/pg-core").PgColumn<{
+                name: "storage_key";
+                tableName: "message_attachments";
+                dataType: "string";
+                columnType: "PgVarchar";
+                data: string;
+                driverParam: string;
+                notNull: true;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {
+                length: 512;
+            }>;
+            createdAt: import("drizzle-orm/pg-core").PgColumn<{
+                name: "created_at";
+                tableName: "message_attachments";
+                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';
+    }>;
     readonly pipelineRegistry: import("drizzle-orm/pg-core").PgTableWithColumns<{
         name: "pipeline_registry";
         schema: undefined;

package/lib/database/drizzle-schema.js

@@ -11,12 +11,14 @@ export * from './schema/plugin.js';
 export * from './schema/pipeline.js';
 export * from './schema/pipeline-template.js';
 export * from './schema/message.js';
+export * from './schema/message-attachment.js';
 export * from './schema/compliance.js';
 export * from './schema/dashboard.js';
 export * from './schema/alert.js';
 import { orgAlertDestination, orgAlertRule } from './schema/alert.js';
 import { compliancePolicy, complianceRule, complianceRuleHistory, complianceAuditLog, complianceExemption, complianceRuleSubscription, complianceScan, complianceScanSchedule, complianceNotificationPreference, complianceNotificationLog, complianceRole, complianceReport, complianceReportSchedule, } from './schema/compliance.js';
 import { dashboard, dashboardPanel } from './schema/dashboard.js';
+import { messageAttachment } from './schema/message-attachment.js';
 import { message } from './schema/message.js';
 import { pipelineTemplate } from './schema/pipeline-template.js';
 import { pipeline, pipelineRegistry, pipelineEvent } from './schema/pipeline.js';
@@ -29,6 +31,7 @@ export const schema = {
     pipeline,
     pipelineTemplate,
     message,
+    messageAttachment,
     pipelineRegistry,
     pipelineEvent,
     // Observability dashboards (user-editable replacement for code-defined dashboards)
@@ -53,4 +56,4 @@ export const schema = {
     complianceReport,
     complianceReportSchedule,
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/lib/database/schema/dashboard.js

@@ -74,7 +74,10 @@ export const dashboard = pgTable('dashboards', {
     // Same-org duplicate-name guard. The (orgId, name) tuple is unique among
     // non-deleted rows; soft-deleted rows are excluded so name reuse after
     // deletion works.
-    nameUnique: uniqueIndex('dashboard_org_name_unique').on(table.orgId, table.name),
+    // Partial (live-rows only) to match the deployed DDL + the sibling
+    // orgAlertRule.orgNameUq — a tombstone must not reserve its name, so a live
+    // namesake can coexist (and restore can 409 on collision, handled in the route).
+    nameUnique: uniqueIndex('dashboard_org_name_unique').on(table.orgId, table.name).where(sql `deleted_at IS NULL`),
 }));
 /**
  * A single panel inside a dashboard. The catalog `queryKey` is the only thing
@@ -123,4 +126,4 @@ export const dashboardPanel = pgTable('dashboard_panels', {
     dashboardPositionIdx: index('dashboard_panel_dashboard_position_idx')
         .on(table.dashboardId, table.position),
 }));
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dashboard.js","sourceRoot":"","sources":["../../../src/database/schema/dashboard.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport { SYSTEM_ORG_ID } from '@pipeline-builder/api-core';\nimport { sql } from 'drizzle-orm';\nimport { integer, varchar, pgTable, text, timestamp, uuid, jsonb, index, uniqueIndex } from 'drizzle-orm/pg-core';\n\n/**\n * User-editable observability dashboard. Replaces the code-defined dashboards\n * under `frontend/src/lib/dashboards/*.ts` so operators can add panels and\n * customize layout per-org without a redeploy.\n *\n * `layoutJson` carries the react-grid-layout coordinate set keyed by panel id;\n * `dashboard_panels` holds the panel-content rows so an N-panel dashboard\n * doesn't bloat one row's JSON to several KB. The catalog query is referenced\n * by key only (see platform/src/observability/catalog.ts)  the dashboard\n * record never carries raw PromQL/LogQL, keeping the catalog as the security\n * boundary for upstream query execution.\n *\n * Visibility ladder * - `private`  only the creator can read/write\n * - `org`  anyone in the same org can read; org admins + creator can write\n * - `public`  every authenticated user can read; only sysadmins can write.\n * Used for the 5 default dashboards (`org_id='system'`) so the\n * existing system-org visibility rule covers them by default.\n *\n * @table dashboards\n */\nexport const dashboard = pgTable('dashboards', {\n  id: uuid('id').primaryKey().defaultRandom(),\n\n  // Org + creator\n  orgId: varchar('org_id', { length: 255 })\n    .default(SYSTEM_ORG_ID)\n    .notNull(),\n  createdBy: text('created_by')\n    .default(SYSTEM_ORG_ID)\n    .notNull(),\n  createdAt: timestamp('created_at', { withTimezone: true })\n    .defaultNow()\n    .notNull(),\n  updatedBy: text('updated_by')\n    .default(SYSTEM_ORG_ID)\n    .notNull(),\n  updatedAt: timestamp('updated_at', { withTimezone: true })\n    .defaultNow()\n    .notNull(),\n\n  // Identity\n  name: varchar('name', { length: 150 })\n    .notNull(),\n  description: text('description'),\n\n  // react-grid-layout coordinate set keyed by panel id.\n  // Shape: { [panelId]: { x, y, w, h, minW?, minH? } }\n  layoutJson: jsonb('layout_json')\n    .$type<Record<string, { x: number; y: number; w: number; h: number; minW?: number; minH?: number }>>()\n    .default({})\n    .notNull(),\n\n  // Visibility  see header for ladder semantics. Constrained at the SQL\n  // layer too via a CHECK in postgres-init.sql to keep typos from sneaking\n  // past the application layer.\n  visibility: varchar('visibility', { length: 10 })\n    .$type<'private' | 'org' | 'public'>()\n    .default('private')\n    .notNull(),\n\n  // Soft delete (matches the rest of the schema's convention)\n  deletedAt: timestamp('deleted_at', { withTimezone: true }),\n  deletedBy: text('deleted_by'),\n  // Soft-delete purge deadline: the retention sweep hard-deletes tombstoned\n  // rows once `purge_after` has passed (set on delete alongside deleted_at).\n  purgeAfter: timestamp('purge_after', { withTimezone: true }),\n}, (table) => ({\n  // Partial index over just the tombstones — drives the retention purge sweep.\n  purgeIdx: index('dashboard_purge_idx').on(table.purgeAfter).where(sql`deleted_at IS NOT NULL`),\n  // Listing is org-scoped and visibility-filtered, so both go in the index.\n  orgVisibilityIdx: index('dashboard_org_visibility_idx').on(table.orgId, table.visibility),\n  // Convenience for \"all my dashboards\" listing\n  createdByIdx: index('dashboard_created_by_idx').on(table.createdBy),\n  // Same-org duplicate-name guard. The (orgId, name) tuple is unique among\n  // non-deleted rows; soft-deleted rows are excluded so name reuse after\n  // deletion works.\n  nameUnique: uniqueIndex('dashboard_org_name_unique').on(table.orgId, table.name),\n}));\n\n/**\n * A single panel inside a dashboard. The catalog `queryKey` is the only thing\n * the panel carries from the query side  substitution + execution happens\n * server-side via the existing catalog, so no PromQL/LogQL travels with the\n * panel record.\n *\n * @table dashboard_panels\n */\nexport const dashboardPanel = pgTable('dashboard_panels', {\n  id: uuid('id').primaryKey().defaultRandom(),\n  dashboardId: uuid('dashboard_id')\n    .notNull(),\n  // Catalog key (e.g. `plugin_builds_per_min`). The server validates this\n  // against QUERIES at render time.\n  queryKey: varchar('query_key', { length: 100 })\n    .notNull(),\n  // 'stat' | 'line' | 'table' | 'stacked-bar'  kept stringly-typed for\n  // forward compatibility; the renderer falls back to 'line' on unknown.\n  vizKind: varchar('viz_kind', { length: 30 })\n    .default('line')\n    .notNull(),\n  title: varchar('title', { length: 200 })\n    .notNull(),\n  // Tailwind col-span tier (1-12, but only 3/4/6/8/9/12 are renderable).\n  span: integer('span')\n    .default(6)\n    .notNull(),\n  // Optional: label key for series grouping (e.g. 'status', 'state').\n  groupBy: varchar('group_by', { length: 50 }),\n  // Optional: catalog format key ('percent' | 'seconds' |...).\n  format: varchar('format', { length: 20 }),\n  // 0-based render order within the dashboard. Editor reassigns on drag.\n  position: integer('position')\n    .default(0)\n    .notNull(),\n  // Optional template var values bound at panel level (e.g. `plugin=X` for\n  // the per-plugin drill-down panel). Sanitized server-side via the catalog\n  // substituteVars allow-list.\n  vars: jsonb('vars')\n    .$type<Record<string, string>>()\n    .default({})\n    .notNull(),\n}, (table) => ({\n  // The render path is \"fetch all panels for dashboard X in order\".\n  dashboardPositionIdx: index('dashboard_panel_dashboard_position_idx')\n    .on(table.dashboardId, table.position),\n}));\n\n// Observability dashboards\nexport type Dashboard = typeof dashboard.$inferSelect;\nexport type DashboardInsert = typeof dashboard.$inferInsert;\nexport type DashboardUpdate = Partial<Omit<DashboardInsert, 'id' | 'createdAt' | 'createdBy'>>;\n\nexport type DashboardPanel = typeof dashboardPanel.$inferSelect;\nexport type DashboardPanelInsert = typeof dashboardPanel.$inferInsert;\nexport type DashboardPanelUpdate = Partial<Omit<DashboardPanelInsert, 'id'>>;\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dashboard.js","sourceRoot":"","sources":["../../../src/database/schema/dashboard.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport { SYSTEM_ORG_ID } from '@pipeline-builder/api-core';\nimport { sql } from 'drizzle-orm';\nimport { integer, varchar, pgTable, text, timestamp, uuid, jsonb, index, uniqueIndex } from 'drizzle-orm/pg-core';\n\n/**\n * User-editable observability dashboard. Replaces the code-defined dashboards\n * under `frontend/src/lib/dashboards/*.ts` so operators can add panels and\n * customize layout per-org without a redeploy.\n *\n * `layoutJson` carries the react-grid-layout coordinate set keyed by panel id;\n * `dashboard_panels` holds the panel-content rows so an N-panel dashboard\n * doesn't bloat one row's JSON to several KB. The catalog query is referenced\n * by key only (see platform/src/observability/catalog.ts)  the dashboard\n * record never carries raw PromQL/LogQL, keeping the catalog as the security\n * boundary for upstream query execution.\n *\n * Visibility ladder * - `private`  only the creator can read/write\n * - `org`  anyone in the same org can read; org admins + creator can write\n * - `public`  every authenticated user can read; only sysadmins can write.\n * Used for the 5 default dashboards (`org_id='system'`) so the\n * existing system-org visibility rule covers them by default.\n *\n * @table dashboards\n */\nexport const dashboard = pgTable('dashboards', {\n  id: uuid('id').primaryKey().defaultRandom(),\n\n  // Org + creator\n  orgId: varchar('org_id', { length: 255 })\n    .default(SYSTEM_ORG_ID)\n    .notNull(),\n  createdBy: text('created_by')\n    .default(SYSTEM_ORG_ID)\n    .notNull(),\n  createdAt: timestamp('created_at', { withTimezone: true })\n    .defaultNow()\n    .notNull(),\n  updatedBy: text('updated_by')\n    .default(SYSTEM_ORG_ID)\n    .notNull(),\n  updatedAt: timestamp('updated_at', { withTimezone: true })\n    .defaultNow()\n    .notNull(),\n\n  // Identity\n  name: varchar('name', { length: 150 })\n    .notNull(),\n  description: text('description'),\n\n  // react-grid-layout coordinate set keyed by panel id.\n  // Shape: { [panelId]: { x, y, w, h, minW?, minH? } }\n  layoutJson: jsonb('layout_json')\n    .$type<Record<string, { x: number; y: number; w: number; h: number; minW?: number; minH?: number }>>()\n    .default({})\n    .notNull(),\n\n  // Visibility  see header for ladder semantics. Constrained at the SQL\n  // layer too via a CHECK in postgres-init.sql to keep typos from sneaking\n  // past the application layer.\n  visibility: varchar('visibility', { length: 10 })\n    .$type<'private' | 'org' | 'public'>()\n    .default('private')\n    .notNull(),\n\n  // Soft delete (matches the rest of the schema's convention)\n  deletedAt: timestamp('deleted_at', { withTimezone: true }),\n  deletedBy: text('deleted_by'),\n  // Soft-delete purge deadline: the retention sweep hard-deletes tombstoned\n  // rows once `purge_after` has passed (set on delete alongside deleted_at).\n  purgeAfter: timestamp('purge_after', { withTimezone: true }),\n}, (table) => ({\n  // Partial index over just the tombstones — drives the retention purge sweep.\n  purgeIdx: index('dashboard_purge_idx').on(table.purgeAfter).where(sql`deleted_at IS NOT NULL`),\n  // Listing is org-scoped and visibility-filtered, so both go in the index.\n  orgVisibilityIdx: index('dashboard_org_visibility_idx').on(table.orgId, table.visibility),\n  // Convenience for \"all my dashboards\" listing\n  createdByIdx: index('dashboard_created_by_idx').on(table.createdBy),\n  // Same-org duplicate-name guard. The (orgId, name) tuple is unique among\n  // non-deleted rows; soft-deleted rows are excluded so name reuse after\n  // deletion works.\n  // Partial (live-rows only) to match the deployed DDL + the sibling\n  // orgAlertRule.orgNameUq — a tombstone must not reserve its name, so a live\n  // namesake can coexist (and restore can 409 on collision, handled in the route).\n  nameUnique: uniqueIndex('dashboard_org_name_unique').on(table.orgId, table.name).where(sql`deleted_at IS NULL`),\n}));\n\n/**\n * A single panel inside a dashboard. The catalog `queryKey` is the only thing\n * the panel carries from the query side  substitution + execution happens\n * server-side via the existing catalog, so no PromQL/LogQL travels with the\n * panel record.\n *\n * @table dashboard_panels\n */\nexport const dashboardPanel = pgTable('dashboard_panels', {\n  id: uuid('id').primaryKey().defaultRandom(),\n  dashboardId: uuid('dashboard_id')\n    .notNull(),\n  // Catalog key (e.g. `plugin_builds_per_min`). The server validates this\n  // against QUERIES at render time.\n  queryKey: varchar('query_key', { length: 100 })\n    .notNull(),\n  // 'stat' | 'line' | 'table' | 'stacked-bar'  kept stringly-typed for\n  // forward compatibility; the renderer falls back to 'line' on unknown.\n  vizKind: varchar('viz_kind', { length: 30 })\n    .default('line')\n    .notNull(),\n  title: varchar('title', { length: 200 })\n    .notNull(),\n  // Tailwind col-span tier (1-12, but only 3/4/6/8/9/12 are renderable).\n  span: integer('span')\n    .default(6)\n    .notNull(),\n  // Optional: label key for series grouping (e.g. 'status', 'state').\n  groupBy: varchar('group_by', { length: 50 }),\n  // Optional: catalog format key ('percent' | 'seconds' |...).\n  format: varchar('format', { length: 20 }),\n  // 0-based render order within the dashboard. Editor reassigns on drag.\n  position: integer('position')\n    .default(0)\n    .notNull(),\n  // Optional template var values bound at panel level (e.g. `plugin=X` for\n  // the per-plugin drill-down panel). Sanitized server-side via the catalog\n  // substituteVars allow-list.\n  vars: jsonb('vars')\n    .$type<Record<string, string>>()\n    .default({})\n    .notNull(),\n}, (table) => ({\n  // The render path is \"fetch all panels for dashboard X in order\".\n  dashboardPositionIdx: index('dashboard_panel_dashboard_position_idx')\n    .on(table.dashboardId, table.position),\n}));\n\n// Observability dashboards\nexport type Dashboard = typeof dashboard.$inferSelect;\nexport type DashboardInsert = typeof dashboard.$inferInsert;\nexport type DashboardUpdate = Partial<Omit<DashboardInsert, 'id' | 'createdAt' | 'createdBy'>>;\n\nexport type DashboardPanel = typeof dashboardPanel.$inferSelect;\nexport type DashboardPanelInsert = typeof dashboardPanel.$inferInsert;\nexport type DashboardPanelUpdate = Partial<Omit<DashboardPanelInsert, 'id'>>;\n"]}

package/lib/database/schema/message-attachment.d.ts

@@ -0,0 +1,183 @@
+/**
+ * File/image attachments for messages.
+ *
+ * The blob itself lives in S3-compatible object storage (MinIO); this table
+ * holds only the METADATA + the storage key. A row is created on upload with
+ * `message_id = NULL` (pending) and linked to a message when that message is
+ * sent — so an upload that's never attached is a harmless orphan the retention
+ * sweep can reap. Tenant-scoped by `org_id` (RLS); visibility of the blob is
+ * gated at the API layer by whether the caller can read the parent message.
+ *
+ * @table message_attachments
+ */
+export declare const messageAttachment: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "message_attachments";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: "id";
+            tableName: "message_attachments";
+            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;
+        }, {}, {}>;
+        orgId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "org_id";
+            tableName: "message_attachments";
+            dataType: "string";
+            columnType: "PgVarchar";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: 255;
+        }>;
+        messageId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "message_id";
+            tableName: "message_attachments";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        uploadedBy: import("drizzle-orm/pg-core").PgColumn<{
+            name: "uploaded_by";
+            tableName: "message_attachments";
+            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;
+        }, {}, {}>;
+        filename: import("drizzle-orm/pg-core").PgColumn<{
+            name: "filename";
+            tableName: "message_attachments";
+            dataType: "string";
+            columnType: "PgVarchar";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: 255;
+        }>;
+        contentType: import("drizzle-orm/pg-core").PgColumn<{
+            name: "content_type";
+            tableName: "message_attachments";
+            dataType: "string";
+            columnType: "PgVarchar";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: 128;
+        }>;
+        sizeBytes: import("drizzle-orm/pg-core").PgColumn<{
+            name: "size_bytes";
+            tableName: "message_attachments";
+            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;
+        }, {}, {}>;
+        storageKey: import("drizzle-orm/pg-core").PgColumn<{
+            name: "storage_key";
+            tableName: "message_attachments";
+            dataType: "string";
+            columnType: "PgVarchar";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: 512;
+        }>;
+        createdAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "created_at";
+            tableName: "message_attachments";
+            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';
+}>;
+/** TypeScript row types. */
+export type MessageAttachment = typeof messageAttachment.$inferSelect;
+export type MessageAttachmentInsert = typeof messageAttachment.$inferInsert;

package/lib/database/schema/message-attachment.js

@@ -0,0 +1,40 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+import { varchar, pgTable, text, timestamp, uuid, integer, index } from 'drizzle-orm/pg-core';
+/**
+ * File/image attachments for messages.
+ *
+ * The blob itself lives in S3-compatible object storage (MinIO); this table
+ * holds only the METADATA + the storage key. A row is created on upload with
+ * `message_id = NULL` (pending) and linked to a message when that message is
+ * sent — so an upload that's never attached is a harmless orphan the retention
+ * sweep can reap. Tenant-scoped by `org_id` (RLS); visibility of the blob is
+ * gated at the API layer by whether the caller can read the parent message.
+ *
+ * @table message_attachments
+ */
+export const messageAttachment = pgTable('message_attachments', {
+    id: uuid('id').primaryKey().defaultRandom(),
+    // Tenancy — the uploader's org. RLS-scoped like every other tenant table.
+    orgId: varchar('org_id', { length: 255 }).notNull(),
+    // The message this attachment belongs to. NULL while an upload is pending
+    // (uploaded but not yet attached to a sent message).
+    messageId: uuid('message_id'),
+    // Who uploaded it (user id) — for audit + the pending-upload owner check.
+    uploadedBy: text('uploaded_by').notNull(),
+    // Original client filename (display + Content-Disposition on download).
+    filename: varchar('filename', { length: 255 }).notNull(),
+    // Validated MIME type (allow-list enforced at upload).
+    contentType: varchar('content_type', { length: 128 }).notNull(),
+    // Size in bytes (bounded at upload).
+    sizeBytes: integer('size_bytes').notNull(),
+    // Object key in the attachments bucket (e.g. `<orgId>/<uuid>/<filename>`).
+    storageKey: varchar('storage_key', { length: 512 }).notNull(),
+    createdAt: timestamp('created_at', { withTimezone: true }).defaultNow().notNull(),
+}, (table) => ({
+    // Fetch a message's attachments.
+    messageIdIdx: index('message_attachment_message_id_idx').on(table.messageId),
+    // Tenant scoping + pending-upload lookups by owner.
+    orgIdIdx: index('message_attachment_org_id_idx').on(table.orgId),
+}));
+//# sourceMappingURL=data:application/json;base64,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

package/lib/database/schema/message.d.ts

@@ -163,6 +163,25 @@ export declare const message: import("drizzle-orm/pg-core").PgTableWithColumns<{
         }, {}, {
             length: 255;
         }>;
+        recipientUserId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "recipient_user_id";
+            tableName: "messages";
+            dataType: "string";
+            columnType: "PgVarchar";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: 255;
+        }>;
         messageType: import("drizzle-orm/pg-core").PgColumn<{
             name: "message_type";
             tableName: "messages";
@@ -238,6 +257,23 @@ export declare const message: import("drizzle-orm/pg-core").PgTableWithColumns<{
             identity: undefined;
             generated: undefined;
         }, {}, {}>;
+        editedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "edited_at";
+            tableName: "messages";
+            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;
+        }, {}, {}>;
         readBy: import("drizzle-orm/pg-core").PgColumn<{
             name: "read_by";
             tableName: "messages";