@objectstack/service-messaging 10.2.0 → 11.0.0

package/dist/index.cjs

@@ -963,6 +963,19 @@ function classifyDeliveryAttempt(result, errorClass, attemptsSoFar, now = Date.n
   return { success: false, error: result.error, nextAttemptAt: now + delay };
 }
 
+// src/audit-timestamp.ts
+function toEpochMs(value) {
+  if (typeof value === "number") return value;
+  if (value instanceof Date) return value.getTime();
+  if (typeof value === "string") {
+    const parsed = Date.parse(value);
+    if (Number.isFinite(parsed)) return parsed;
+    const numeric = Number(value);
+    if (Number.isFinite(numeric)) return numeric;
+  }
+  return 0;
+}
+
 // src/sql-outbox.ts
 var DELIVERY_OBJECT = "sys_notification_delivery";
 var SqlNotificationOutbox = class {
@@ -981,7 +994,7 @@ var SqlNotificationOutbox = class {
     const existing = await this.engine.findOne(this.objectName, { where: dedup, fields: ["id"] });
     if (existing?.id) return String(existing.id);
     const id = (0, import_node_crypto.randomUUID)();
-    const now = Date.now();
+    const now = /* @__PURE__ */ new Date();
     const row = {
       id,
       notification_id: input.notificationId,
@@ -1142,8 +1155,8 @@ var SqlNotificationOutbox = class {
       lastAttemptedAt: r.last_attempted_at ?? void 0,
       error: r.error ?? void 0,
       digestKey: r.digest_key ?? void 0,
-      createdAt: r.created_at,
-      updatedAt: r.updated_at
+      createdAt: toEpochMs(r.created_at),
+      updatedAt: toEpochMs(r.updated_at)
     };
   }
 };
@@ -1272,8 +1285,11 @@ var HttpDelivery = import_data.ObjectSchema.create({
     response_code: import_data.Field.number({ label: "HTTP Status", required: false }),
     response_body: import_data.Field.textarea({ label: "Response Body (capped)", required: false }),
     error: import_data.Field.textarea({ label: "Error", required: false }),
-    created_at: import_data.Field.number({ label: "Created At (ms)", required: true }),
-    updated_at: import_data.Field.number({ label: "Updated At (ms)", required: true })
+    // Builtin audit columns are native TIMESTAMP columns (Postgres/MySQL),
+    // so declare them `datetime` and write `Date`s (not epoch-ms numbers,
+    // which a real timestamp column rejects). See SqlHttpOutbox.
+    created_at: import_data.Field.datetime({ label: "Created At", required: true }),
+    updated_at: import_data.Field.datetime({ label: "Updated At", required: true })
   },
   indexes: [
     { fields: ["source", "dedup_key"], unique: true },
@@ -1303,7 +1319,7 @@ var SqlHttpOutbox = class {
     });
     if (existing?.id) return existing.id;
     const id = (0, import_node_crypto2.randomUUID)();
-    const now = Date.now();
+    const now = /* @__PURE__ */ new Date();
     const row = {
       id,
       source: input.source,
@@ -1472,8 +1488,8 @@ var SqlHttpOutbox = class {
       responseCode: r.response_code ?? void 0,
       responseBody: r.response_body ?? void 0,
       error: r.error ?? void 0,
-      createdAt: r.created_at,
-      updatedAt: r.updated_at
+      createdAt: toEpochMs(r.created_at),
+      updatedAt: toEpochMs(r.updated_at)
     };
   }
 };
@@ -1947,10 +1963,10 @@ function stableNodeOffset2(nodeId, partitionCount) {
 // src/retention.ts
 var DEFAULT_NOTIFICATION_RETENTION_DAYS = 90;
 var DEFAULT_RETENTION_TARGETS = [
-  { object: RECEIPT_OBJECT, tsField: "created_at", format: "iso" },
-  { object: INBOX_OBJECT, tsField: "created_at", format: "iso" },
-  { object: DELIVERY_OBJECT, tsField: "created_at", format: "epoch" },
-  { object: NOTIFICATION_EVENT_OBJECT, tsField: "created_at", format: "iso" }
+  { object: RECEIPT_OBJECT, tsField: "created_at" },
+  { object: INBOX_OBJECT, tsField: "created_at" },
+  { object: DELIVERY_OBJECT, tsField: "created_at" },
+  { object: NOTIFICATION_EVENT_OBJECT, tsField: "created_at" }
 ];
 var NotificationRetention = class {
   constructor(opts) {
@@ -1973,14 +1989,15 @@ var NotificationRetention = class {
       this.opts.logger.warn(`[messaging] retention: invalid retentionDays=${retentionDays}; prune skipped`);
       return [];
     }
-    const cutoffMs = this.now() - retentionDays * 864e5;
-    const cutoffIso = new Date(cutoffMs).toISOString();
+    const cutoffIso = new Date(this.now() - retentionDays * 864e5).toISOString();
     const outcomes = [];
     for (const t of this.targets) {
-      const cutoff = t.format === "epoch" ? cutoffMs : cutoffIso;
       try {
         const res = await data.delete(t.object, {
-          where: { [t.tsField]: { $lt: cutoff } },
+          // ISO-8601 cutoff for every target: `created_at` is a native
+          // timestamp column, which rejects a bare epoch-ms number on
+          // Postgres. The driver coerces this per dialect on the way down.
+          where: { [t.tsField]: { $lt: cutoffIso } },
           multi: true,
           // System context: retention is an operator policy that spans
           // tenants, so it must not be scoped by the caller's RLS.
@@ -2332,8 +2349,12 @@ var NotificationDelivery = import_data4.ObjectSchema.create({
     next_attempt_at: import_data4.Field.number({ label: "Next Attempt At (ms)" }),
     last_attempted_at: import_data4.Field.number({ label: "Last Attempted At (ms)" }),
     error: import_data4.Field.textarea({ label: "Error" }),
-    created_at: import_data4.Field.number({ label: "Created At (ms)", readonly: true }),
-    updated_at: import_data4.Field.number({ label: "Updated At (ms)" })
+    // Builtin audit columns: the SQL driver provisions `created_at` /
+    // `updated_at` as native TIMESTAMP columns (Postgres/MySQL), so they are
+    // declared `datetime` and written as `Date`s — a bare epoch-ms number is
+    // rejected by a real timestamp column. See SqlNotificationOutbox.
+    created_at: import_data4.Field.datetime({ label: "Created At", readonly: true }),
+    updated_at: import_data4.Field.datetime({ label: "Updated At" })
   },
   indexes: [
     // Dedup: one delivery per (event, recipient, channel).
@@ -2570,6 +2591,12 @@ var MessagingServicePlugin = class {
         }
       ]
     });
+    if (typeof ctx.hook === "function") {
+      ctx.hook("kernel:ready", async () => {
+        const engine = getData();
+        if (engine) await this.provisionSystemTables(engine, ctx);
+      });
+    }
     if (typeof ctx.hook === "function") {
       const templateStore = new NotificationTemplateStore({ getData });
       const getEmail = () => {
@@ -2652,6 +2679,38 @@ var MessagingServicePlugin = class {
       `[messaging] service registered with channels: ${service.getRegisteredChannels().join(", ") || "(none)"}`
     );
   }
+  /**
+   * Provision the physical tables for this service's system objects up-front.
+   *
+   * These objects are lazy-created on first WRITE (the SQL driver issues DDL
+   * when the first row is inserted), so an env that READS them first — the
+   * Console bell / inbox queries sys_inbox_message + sys_notification_receipt
+   * before any notification has been delivered — hits "no such table", which
+   * the engine logs as a `Find operation failed` ERROR on every page load.
+   * Creating the tables at kernel:ready makes a new env consistent from the
+   * start. Idempotent (the driver only creates a table when absent), so it is
+   * safe on every boot; per-object failures are isolated.
+   */
+  async provisionSystemTables(engine, ctx) {
+    const sync = engine.syncObjectSchema;
+    if (typeof sync !== "function") return;
+    const objects = [
+      InboxMessage,
+      NotificationReceipt,
+      NotificationDelivery,
+      NotificationPreference,
+      NotificationSubscription,
+      NotificationTemplate,
+      HttpDelivery
+    ];
+    for (const obj of objects) {
+      try {
+        await sync.call(engine, obj.name);
+      } catch (err) {
+        ctx.logger.warn(`[messaging] could not provision ${obj.name} storage \u2014 ${err?.message ?? err}`);
+      }
+    }
+  }
   /** Stop the dispatcher loop + retention sweep on shutdown. */
   async stop() {
     await this.dispatcher?.stop();