@pipeline-builder/pipeline-data 3.4.115 → 3.4.117

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/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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWVzc2FnZS1hdHRhY2htZW50LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL2RhdGFiYXNlL3NjaGVtYS9tZXNzYWdlLWF0dGFjaG1lbnQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsK0NBQStDO0FBQy9DLHNDQUFzQztBQUV0QyxPQUFPLEVBQUUsT0FBTyxFQUFFLE9BQU8sRUFBRSxJQUFJLEVBQUUsU0FBUyxFQUFFLElBQUksRUFBRSxPQUFPLEVBQUUsS0FBSyxFQUFFLE1BQU0scUJBQXFCLENBQUM7QUFFOUY7Ozs7Ozs7Ozs7O0dBV0c7QUFDSCxNQUFNLENBQUMsTUFBTSxpQkFBaUIsR0FBRyxPQUFPLENBQUMscUJBQXFCLEVBQUU7SUFDOUQsRUFBRSxFQUFFLElBQUksQ0FBQyxJQUFJLENBQUMsQ0FBQyxVQUFVLEVBQUUsQ0FBQyxhQUFhLEVBQUU7SUFFM0MsMEVBQTBFO0lBQzFFLEtBQUssRUFBRSxPQUFPLENBQUMsUUFBUSxFQUFFLEVBQUUsTUFBTSxFQUFFLEdBQUcsRUFBRSxDQUFDLENBQUMsT0FBTyxFQUFFO0lBRW5ELDBFQUEwRTtJQUMxRSxxREFBcUQ7SUFDckQsU0FBUyxFQUFFLElBQUksQ0FBQyxZQUFZLENBQUM7SUFFN0IsMEVBQTBFO0lBQzFFLFVBQVUsRUFBRSxJQUFJLENBQUMsYUFBYSxDQUFDLENBQUMsT0FBTyxFQUFFO0lBRXpDLHdFQUF3RTtJQUN4RSxRQUFRLEVBQUUsT0FBTyxDQUFDLFVBQVUsRUFBRSxFQUFFLE1BQU0sRUFBRSxHQUFHLEVBQUUsQ0FBQyxDQUFDLE9BQU8sRUFBRTtJQUV4RCx1REFBdUQ7SUFDdkQsV0FBVyxFQUFFLE9BQU8sQ0FBQyxjQUFjLEVBQUUsRUFBRSxNQUFNLEVBQUUsR0FBRyxFQUFFLENBQUMsQ0FBQyxPQUFPLEVBQUU7SUFFL0QscUNBQXFDO0lBQ3JDLFNBQVMsRUFBRSxPQUFPLENBQUMsWUFBWSxDQUFDLENBQUMsT0FBTyxFQUFFO0lBRTFDLDJFQUEyRTtJQUMzRSxVQUFVLEVBQUUsT0FBTyxDQUFDLGFBQWEsRUFBRSxFQUFFLE1BQU0sRUFBRSxHQUFHLEVBQUUsQ0FBQyxDQUFDLE9BQU8sRUFBRTtJQUU3RCxTQUFTLEVBQUUsU0FBUyxDQUFDLFlBQVksRUFBRSxFQUFFLFlBQVksRUFBRSxJQUFJLEVBQUUsQ0FBQyxDQUFDLFVBQVUsRUFBRSxDQUFDLE9BQU8sRUFBRTtDQUNsRixFQUFFLENBQUMsS0FBSyxFQUFFLEVBQUUsQ0FBQyxDQUFDO0lBQ2IsaUNBQWlDO0lBQ2pDLFlBQVksRUFBRSxLQUFLLENBQUMsbUNBQW1DLENBQUMsQ0FBQyxFQUFFLENBQUMsS0FBSyxDQUFDLFNBQVMsQ0FBQztJQUM1RSxvREFBb0Q7SUFDcEQsUUFBUSxFQUFFLEtBQUssQ0FBQywrQkFBK0IsQ0FBQyxDQUFDLEVBQUUsQ0FBQyxLQUFLLENBQUMsS0FBSyxDQUFDO0NBQ2pFLENBQUMsQ0FBQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLy8gQ29weXJpZ2h0IDIwMjYgUGlwZWxpbmUgQnVpbGRlciBDb250cmlidXRvcnNcbi8vIFNQRFgtTGljZW5zZS1JZGVudGlmaWVyOiBBcGFjaGUtMi4wXG5cbmltcG9ydCB7IHZhcmNoYXIsIHBnVGFibGUsIHRleHQsIHRpbWVzdGFtcCwgdXVpZCwgaW50ZWdlciwgaW5kZXggfSBmcm9tICdkcml6emxlLW9ybS9wZy1jb3JlJztcblxuLyoqXG4gKiBGaWxlL2ltYWdlIGF0dGFjaG1lbnRzIGZvciBtZXNzYWdlcy5cbiAqXG4gKiBUaGUgYmxvYiBpdHNlbGYgbGl2ZXMgaW4gUzMtY29tcGF0aWJsZSBvYmplY3Qgc3RvcmFnZSAoTWluSU8pOyB0aGlzIHRhYmxlXG4gKiBob2xkcyBvbmx5IHRoZSBNRVRBREFUQSArIHRoZSBzdG9yYWdlIGtleS4gQSByb3cgaXMgY3JlYXRlZCBvbiB1cGxvYWQgd2l0aFxuICogYG1lc3NhZ2VfaWQgPSBOVUxMYCAocGVuZGluZykgYW5kIGxpbmtlZCB0byBhIG1lc3NhZ2Ugd2hlbiB0aGF0IG1lc3NhZ2UgaXNcbiAqIHNlbnQg4oCUIHNvIGFuIHVwbG9hZCB0aGF0J3MgbmV2ZXIgYXR0YWNoZWQgaXMgYSBoYXJtbGVzcyBvcnBoYW4gdGhlIHJldGVudGlvblxuICogc3dlZXAgY2FuIHJlYXAuIFRlbmFudC1zY29wZWQgYnkgYG9yZ19pZGAgKFJMUyk7IHZpc2liaWxpdHkgb2YgdGhlIGJsb2IgaXNcbiAqIGdhdGVkIGF0IHRoZSBBUEkgbGF5ZXIgYnkgd2hldGhlciB0aGUgY2FsbGVyIGNhbiByZWFkIHRoZSBwYXJlbnQgbWVzc2FnZS5cbiAqXG4gKiBAdGFibGUgbWVzc2FnZV9hdHRhY2htZW50c1xuICovXG5leHBvcnQgY29uc3QgbWVzc2FnZUF0dGFjaG1lbnQgPSBwZ1RhYmxlKCdtZXNzYWdlX2F0dGFjaG1lbnRzJywge1xuICBpZDogdXVpZCgnaWQnKS5wcmltYXJ5S2V5KCkuZGVmYXVsdFJhbmRvbSgpLFxuXG4gIC8vIFRlbmFuY3kg4oCUIHRoZSB1cGxvYWRlcidzIG9yZy4gUkxTLXNjb3BlZCBsaWtlIGV2ZXJ5IG90aGVyIHRlbmFudCB0YWJsZS5cbiAgb3JnSWQ6IHZhcmNoYXIoJ29yZ19pZCcsIHsgbGVuZ3RoOiAyNTUgfSkubm90TnVsbCgpLFxuXG4gIC8vIFRoZSBtZXNzYWdlIHRoaXMgYXR0YWNobWVudCBiZWxvbmdzIHRvLiBOVUxMIHdoaWxlIGFuIHVwbG9hZCBpcyBwZW5kaW5nXG4gIC8vICh1cGxvYWRlZCBidXQgbm90IHlldCBhdHRhY2hlZCB0byBhIHNlbnQgbWVzc2FnZSkuXG4gIG1lc3NhZ2VJZDogdXVpZCgnbWVzc2FnZV9pZCcpLFxuXG4gIC8vIFdobyB1cGxvYWRlZCBpdCAodXNlciBpZCkg4oCUIGZvciBhdWRpdCArIHRoZSBwZW5kaW5nLXVwbG9hZCBvd25lciBjaGVjay5cbiAgdXBsb2FkZWRCeTogdGV4dCgndXBsb2FkZWRfYnknKS5ub3ROdWxsKCksXG5cbiAgLy8gT3JpZ2luYWwgY2xpZW50IGZpbGVuYW1lIChkaXNwbGF5ICsgQ29udGVudC1EaXNwb3NpdGlvbiBvbiBkb3dubG9hZCkuXG4gIGZpbGVuYW1lOiB2YXJjaGFyKCdmaWxlbmFtZScsIHsgbGVuZ3RoOiAyNTUgfSkubm90TnVsbCgpLFxuXG4gIC8vIFZhbGlkYXRlZCBNSU1FIHR5cGUgKGFsbG93LWxpc3QgZW5mb3JjZWQgYXQgdXBsb2FkKS5cbiAgY29udGVudFR5cGU6IHZhcmNoYXIoJ2NvbnRlbnRfdHlwZScsIHsgbGVuZ3RoOiAxMjggfSkubm90TnVsbCgpLFxuXG4gIC8vIFNpemUgaW4gYnl0ZXMgKGJvdW5kZWQgYXQgdXBsb2FkKS5cbiAgc2l6ZUJ5dGVzOiBpbnRlZ2VyKCdzaXplX2J5dGVzJykubm90TnVsbCgpLFxuXG4gIC8vIE9iamVjdCBrZXkgaW4gdGhlIGF0dGFjaG1lbnRzIGJ1Y2tldCAoZS5nLiBgPG9yZ0lkPi88dXVpZD4vPGZpbGVuYW1lPmApLlxuICBzdG9yYWdlS2V5OiB2YXJjaGFyKCdzdG9yYWdlX2tleScsIHsgbGVuZ3RoOiA1MTIgfSkubm90TnVsbCgpLFxuXG4gIGNyZWF0ZWRBdDogdGltZXN0YW1wKCdjcmVhdGVkX2F0JywgeyB3aXRoVGltZXpvbmU6IHRydWUgfSkuZGVmYXVsdE5vdygpLm5vdE51bGwoKSxcbn0sICh0YWJsZSkgPT4gKHtcbiAgLy8gRmV0Y2ggYSBtZXNzYWdlJ3MgYXR0YWNobWVudHMuXG4gIG1lc3NhZ2VJZElkeDogaW5kZXgoJ21lc3NhZ2VfYXR0YWNobWVudF9tZXNzYWdlX2lkX2lkeCcpLm9uKHRhYmxlLm1lc3NhZ2VJZCksXG4gIC8vIFRlbmFudCBzY29waW5nICsgcGVuZGluZy11cGxvYWQgbG9va3VwcyBieSBvd25lci5cbiAgb3JnSWRJZHg6IGluZGV4KCdtZXNzYWdlX2F0dGFjaG1lbnRfb3JnX2lkX2lkeCcpLm9uKHRhYmxlLm9yZ0lkKSxcbn0pKTtcblxuLyoqIFR5cGVTY3JpcHQgcm93IHR5cGVzLiAqL1xuZXhwb3J0IHR5cGUgTWVzc2FnZUF0dGFjaG1lbnQgPSB0eXBlb2YgbWVzc2FnZUF0dGFjaG1lbnQuJGluZmVyU2VsZWN0O1xuZXhwb3J0IHR5cGUgTWVzc2FnZUF0dGFjaG1lbnRJbnNlcnQgPSB0eXBlb2YgbWVzc2FnZUF0dGFjaG1lbnQuJGluZmVySW5zZXJ0O1xuIl19

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";

package/lib/database/schema/message.js

@@ -40,6 +40,12 @@ export const message = pgTable('messages', {
     // Message routing
     recipientOrgId: varchar('recipient_org_id', { length: 255 })
         .notNull(),
+    // Optional per-user targeting WITHIN the recipient org. NULL (default) = the
+    // whole recipient org sees it — the original, backward-compatible behavior.
+    // When set, only this user (a member of `recipientOrgId`) sees it, enforced in
+    // `buildMessageConditions` against the viewer's userId. Announcement broadcasts
+    // (`recipientOrgId = '*'`) never set this — they are org-wide by definition.
+    recipientUserId: varchar('recipient_user_id', { length: 255 }),
     // Message content
     messageType: varchar('message_type', { length: 20 })
         .$type()
@@ -52,6 +58,10 @@ export const message = pgTable('messages', {
         .notNull(),
     content: text('content')
         .notNull(),
+    // Set when the author edits the content after sending (NULL = never edited).
+    // Distinct from `updatedAt`, which also moves on read-receipt/system updates;
+    // `editedAt` marks a human CONTENT edit so the UI can show an "edited" hint.
+    editedAt: timestamp('edited_at', { withTimezone: true }),
     // Status
     // `readBy` is the per-participant read-receipt map: orgId → ISO timestamp.
     // Recipient marking the thread does NOT flip sender's view. Empty `{}`
@@ -95,7 +105,10 @@ export const message = pgTable('messages', {
     // Composite index for inbox queries (recipient + active + created)
     recipientActiveCreatedIdx: index('message_recipient_active_created_idx')
         .on(table.recipientOrgId, table.isActive, table.createdAt),
+    // Composite index for per-user targeted inbox lookups (recipient org + user).
+    recipientUserIdx: index('message_recipient_user_idx')
+        .on(table.recipientOrgId, table.recipientUserId, table.isActive),
     // Composite index for org inbox (orgId + active)
     orgActiveIdx: index('message_org_active_idx').on(table.orgId, table.isActive),
 }));
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"message.js","sourceRoot":"","sources":["../../../src/database/schema/message.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport { AccessModifier, SYSTEM_ORG_ID } from '@pipeline-builder/api-core';\nimport { sql } from 'drizzle-orm';\nimport { boolean, varchar, pgTable, text, timestamp, uuid, jsonb, index } from 'drizzle-orm/pg-core';\n\n/**\n * Message type identifiers\n */\nexport type MessageType = 'announcement' | 'conversation';\n\n/**\n * Message priority levels\n */\nexport type MessagePriority = 'normal' | 'high' | 'urgent';\n\n/**\n * Table for storing internal messages between organizations and the system org.\n *\n * Features * - Announcements: System org broadcasts to all orgs (recipientOrgId = '*')\n * - Conversations: Two-way threaded messaging between an org and system org\n * - Thread support via threadId (null for root messages, references root for replies)\n * - Read tracking per message\n * - Priority levels (normal, high, urgent)\n * - Soft delete support\n *\n * @table messages\n */\nexport const message = pgTable('messages', {\n  // Primary key\n  id: uuid('id').primaryKey().defaultRandom(),\n\n  // Organization and access control\n  orgId: varchar('org_id', { length: 255 })\n    .default(SYSTEM_ORG_ID)\n    .notNull(),\n\n  // Audit fields\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  // Threading\n  threadId: uuid('thread_id'),\n\n  // Message routing\n  recipientOrgId: varchar('recipient_org_id', { length: 255 })\n    .notNull(),\n\n  // Message content\n  messageType: varchar('message_type', { length: 20 })\n    .$type<MessageType>()\n    .default('conversation' as MessageType)\n    .notNull(),\n  // Logical channel/inbox bucket — 'support', 'help', etc. Nullable so\n  // org-to-org conversations (which aren't channel-scoped) can omit it.\n  channel: varchar('channel', { length: 50 }),\n  subject: varchar('subject', { length: 500 })\n    .notNull(),\n  content: text('content')\n    .notNull(),\n\n  // Status\n  // `readBy` is the per-participant read-receipt map: orgId → ISO timestamp.\n  // Recipient marking the thread does NOT flip sender's view. Empty `{}`\n  // means nobody has read it yet.\n  readBy: jsonb('read_by')\n    .$type<Record<string, string>>()\n    .default({})\n    .notNull(),\n  priority: varchar('priority', { length: 20 })\n    .$type<MessagePriority>()\n    .default('normal' as MessagePriority)\n    .notNull(),\n\n  // Access and visibility\n  accessModifier: varchar('access_modifier', { length: 10 })\n    .$type<AccessModifier>()\n    .default('private' as AccessModifier)\n    .notNull(),\n  isDefault: boolean('is_default')\n    .default(false)\n    .notNull(),\n  isActive: boolean('is_active')\n    .default(true)\n    .notNull(),\n\n  // Deletion tracking (soft delete)\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('message_purge_idx').on(table.purgeAfter).where(sql`deleted_at IS NOT NULL`),\n  // Indexes for common queries\n  orgIdIdx: index('message_org_id_idx').on(table.orgId),\n  recipientOrgIdIdx: index('message_recipient_org_id_idx').on(table.recipientOrgId),\n  threadIdIdx: index('message_thread_id_idx').on(table.threadId),\n  messageTypeIdx: index('message_message_type_idx').on(table.messageType),\n  channelIdx: index('message_channel_idx').on(table.channel),\n  createdAtIdx: index('message_created_at_idx').on(table.createdAt),\n  activeIdx: index('message_active_idx').on(table.isActive),\n\n  // Composite index for inbox queries (recipient + active + created)\n  recipientActiveCreatedIdx: index('message_recipient_active_created_idx')\n    .on(table.recipientOrgId, table.isActive, table.createdAt),\n\n  // Composite index for org inbox (orgId + active)\n  orgActiveIdx: index('message_org_active_idx').on(table.orgId, table.isActive),\n}));\n\n/**\n * TypeScript types representing database rows\n */\nexport type Message = typeof message.$inferSelect;\nexport type MessageInsert = typeof message.$inferInsert;\n\n/**\n * Helper types for working with partial updates\n */\nexport type MessageUpdate = Partial<Omit<MessageInsert, 'id' | 'createdAt' | 'createdBy'>>;\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"message.js","sourceRoot":"","sources":["../../../src/database/schema/message.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport { AccessModifier, SYSTEM_ORG_ID } from '@pipeline-builder/api-core';\nimport { sql } from 'drizzle-orm';\nimport { boolean, varchar, pgTable, text, timestamp, uuid, jsonb, index } from 'drizzle-orm/pg-core';\n\n/**\n * Message type identifiers\n */\nexport type MessageType = 'announcement' | 'conversation';\n\n/**\n * Message priority levels\n */\nexport type MessagePriority = 'normal' | 'high' | 'urgent';\n\n/**\n * Table for storing internal messages between organizations and the system org.\n *\n * Features * - Announcements: System org broadcasts to all orgs (recipientOrgId = '*')\n * - Conversations: Two-way threaded messaging between an org and system org\n * - Thread support via threadId (null for root messages, references root for replies)\n * - Read tracking per message\n * - Priority levels (normal, high, urgent)\n * - Soft delete support\n *\n * @table messages\n */\nexport const message = pgTable('messages', {\n  // Primary key\n  id: uuid('id').primaryKey().defaultRandom(),\n\n  // Organization and access control\n  orgId: varchar('org_id', { length: 255 })\n    .default(SYSTEM_ORG_ID)\n    .notNull(),\n\n  // Audit fields\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  // Threading\n  threadId: uuid('thread_id'),\n\n  // Message routing\n  recipientOrgId: varchar('recipient_org_id', { length: 255 })\n    .notNull(),\n\n  // Optional per-user targeting WITHIN the recipient org. NULL (default) = the\n  // whole recipient org sees it — the original, backward-compatible behavior.\n  // When set, only this user (a member of `recipientOrgId`) sees it, enforced in\n  // `buildMessageConditions` against the viewer's userId. Announcement broadcasts\n  // (`recipientOrgId = '*'`) never set this — they are org-wide by definition.\n  recipientUserId: varchar('recipient_user_id', { length: 255 }),\n\n  // Message content\n  messageType: varchar('message_type', { length: 20 })\n    .$type<MessageType>()\n    .default('conversation' as MessageType)\n    .notNull(),\n  // Logical channel/inbox bucket — 'support', 'help', etc. Nullable so\n  // org-to-org conversations (which aren't channel-scoped) can omit it.\n  channel: varchar('channel', { length: 50 }),\n  subject: varchar('subject', { length: 500 })\n    .notNull(),\n  content: text('content')\n    .notNull(),\n  // Set when the author edits the content after sending (NULL = never edited).\n  // Distinct from `updatedAt`, which also moves on read-receipt/system updates;\n  // `editedAt` marks a human CONTENT edit so the UI can show an \"edited\" hint.\n  editedAt: timestamp('edited_at', { withTimezone: true }),\n\n  // Status\n  // `readBy` is the per-participant read-receipt map: orgId → ISO timestamp.\n  // Recipient marking the thread does NOT flip sender's view. Empty `{}`\n  // means nobody has read it yet.\n  readBy: jsonb('read_by')\n    .$type<Record<string, string>>()\n    .default({})\n    .notNull(),\n  priority: varchar('priority', { length: 20 })\n    .$type<MessagePriority>()\n    .default('normal' as MessagePriority)\n    .notNull(),\n\n  // Access and visibility\n  accessModifier: varchar('access_modifier', { length: 10 })\n    .$type<AccessModifier>()\n    .default('private' as AccessModifier)\n    .notNull(),\n  isDefault: boolean('is_default')\n    .default(false)\n    .notNull(),\n  isActive: boolean('is_active')\n    .default(true)\n    .notNull(),\n\n  // Deletion tracking (soft delete)\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('message_purge_idx').on(table.purgeAfter).where(sql`deleted_at IS NOT NULL`),\n  // Indexes for common queries\n  orgIdIdx: index('message_org_id_idx').on(table.orgId),\n  recipientOrgIdIdx: index('message_recipient_org_id_idx').on(table.recipientOrgId),\n  threadIdIdx: index('message_thread_id_idx').on(table.threadId),\n  messageTypeIdx: index('message_message_type_idx').on(table.messageType),\n  channelIdx: index('message_channel_idx').on(table.channel),\n  createdAtIdx: index('message_created_at_idx').on(table.createdAt),\n  activeIdx: index('message_active_idx').on(table.isActive),\n\n  // Composite index for inbox queries (recipient + active + created)\n  recipientActiveCreatedIdx: index('message_recipient_active_created_idx')\n    .on(table.recipientOrgId, table.isActive, table.createdAt),\n\n  // Composite index for per-user targeted inbox lookups (recipient org + user).\n  recipientUserIdx: index('message_recipient_user_idx')\n    .on(table.recipientOrgId, table.recipientUserId, table.isActive),\n\n  // Composite index for org inbox (orgId + active)\n  orgActiveIdx: index('message_org_active_idx').on(table.orgId, table.isActive),\n}));\n\n/**\n * TypeScript types representing database rows\n */\nexport type Message = typeof message.$inferSelect;\nexport type MessageInsert = typeof message.$inferInsert;\n\n/**\n * Helper types for working with partial updates\n */\nexport type MessageUpdate = Partial<Omit<MessageInsert, 'id' | 'createdAt' | 'createdBy'>>;\n"]}