@rei-standard/amsg-server 2.6.0-next.13 → 2.6.0-next.16

package/dist/{neon-3ASBLLCM.cjs → neon-G3G4TDAY.cjs}

@@ -5,8 +5,16 @@
 
 
 
+var _chunkTFFBMYA2cjs = require('./chunk-TFFBMYA2.cjs');
 
-var _chunkV2SDWGUBcjs = require('./chunk-V2SDWGUB.cjs');
+
+
+
+
+
+
+
+var _chunkOUPM4HAVcjs = require('./chunk-OUPM4HAV.cjs');
 
 // src/server/adapters/neon.js
 var _serverless = require('@neondatabase/serverless');
@@ -25,13 +33,13 @@ var NeonAdapter = class {
   }
   async initSchema() {
     const sql = this._getSql();
-    await sql.query(_chunkV2SDWGUBcjs.TABLE_SQL);
-    await sql.query(_chunkV2SDWGUBcjs.PUSH_SUBSCRIPTION_TABLE_SQL);
-    for (const migration of _chunkV2SDWGUBcjs.MIGRATIONS) {
+    await sql.query(_chunkOUPM4HAVcjs.TABLE_SQL);
+    await sql.query(_chunkOUPM4HAVcjs.PUSH_SUBSCRIPTION_TABLE_SQL);
+    for (const migration of _chunkOUPM4HAVcjs.MIGRATIONS) {
       await sql.query(migration.sql);
     }
     const indexResults = [];
-    for (const index of _chunkV2SDWGUBcjs.INDEXES) {
+    for (const index of _chunkOUPM4HAVcjs.INDEXES) {
       try {
         await sql.query(index.sql);
         indexResults.push({
@@ -57,11 +65,11 @@ var NeonAdapter = class {
         `Critical index creation failed (${failedNames}). Please remove duplicate UUID rows and run initSchema again.`
       );
     }
-    const tableCheck = await sql.query(_chunkV2SDWGUBcjs.VERIFY_TABLE_SQL);
+    const tableCheck = await sql.query(_chunkOUPM4HAVcjs.VERIFY_TABLE_SQL);
     if (tableCheck.length === 0) {
       throw new Error("Table creation verification failed");
     }
-    const columns = await sql.query(_chunkV2SDWGUBcjs.COLUMNS_SQL);
+    const columns = await sql.query(_chunkOUPM4HAVcjs.COLUMNS_SQL);
     return {
       columnsCreated: columns.length,
       indexesCreated: indexResults.filter((r) => r.status === "success").length,
@@ -91,7 +99,7 @@ var NeonAdapter = class {
   async getTaskByUuid(uuid, userId) {
     const sql = this._getSql();
     const rows = await sql.query(
-      `SELECT id, user_id, uuid, encrypted_payload, message_type, next_send_at, status, retry_count, created_at, updated_at
+      `SELECT id, user_id, uuid, encrypted_payload, message_type, next_send_at, status, retry_count, last_error, created_at, updated_at
        FROM scheduled_messages
        WHERE uuid = $1 AND user_id = $2 AND status = 'pending'
        LIMIT 1`,
@@ -110,13 +118,28 @@ var NeonAdapter = class {
     );
     return rows[0] || null;
   }
+  /**
+   * 这条 uuid 现在是什么状态——不限用户，也不限状态（上面那个只看 pending
+   * 行）。`runTask` 用它把「这条已经跑完了」和「压根没这条」分开回报。
+   *
+   * @param {string} uuid
+   * @returns {Promise<{ status: string }|null>}
+   */
+  async getTaskStatusByUuidOnly(uuid) {
+    const sql = this._getSql();
+    const rows = await sql.query(
+      `SELECT status FROM scheduled_messages WHERE uuid = $1 LIMIT 1`,
+      [uuid]
+    );
+    return rows[0] ? { status: rows[0].status } : null;
+  }
   async updateTaskById(taskId, updates) {
     const sql = this._getSql();
     const sets = [];
     const values = [];
     let idx = 1;
     for (const [key, value] of Object.entries(updates)) {
-      if (!_chunkV2SDWGUBcjs.UPDATABLE_COLUMNS.has(key)) {
+      if (!_chunkOUPM4HAVcjs.UPDATABLE_COLUMNS.has(key)) {
         throw new Error(`[amsg-server neon] rejected unknown update column: ${key}`);
       }
       sets.push(`${key} = $${idx}`);
@@ -138,7 +161,7 @@ var NeonAdapter = class {
     let idx = 2;
     if (extraFields) {
       for (const [key, value] of Object.entries(extraFields)) {
-        if (!_chunkV2SDWGUBcjs.UPDATABLE_COLUMNS.has(key)) {
+        if (!_chunkOUPM4HAVcjs.UPDATABLE_COLUMNS.has(key)) {
           throw new Error(`[amsg-server neon] rejected unknown update column: ${key}`);
         }
         sets.push(`${key} = $${idx}`);
@@ -171,7 +194,7 @@ var NeonAdapter = class {
   async getPendingTasks(limit = 50) {
     const sql = this._getSql();
     return sql.query(
-      `SELECT id, user_id, uuid, encrypted_payload, message_type, next_send_at, status, retry_count
+      `SELECT id, user_id, uuid, encrypted_payload, message_type, next_send_at, retry_after, status, retry_count
        FROM scheduled_messages
        WHERE status = 'pending' AND next_send_at <= NOW()
          AND (lease_until IS NULL OR lease_until <= NOW())
@@ -181,65 +204,16 @@ var NeonAdapter = class {
       [limit]
     );
   }
-  /**
-   * 领取一条到点的任务：在 lease_until 上写下「这条归我管到什么时候」，
-   * 本次投递期间别的 tick 领不走它。
-   *
-   * 租约写在自己的列上，next_send_at 全程不动——那一列是用户设的触发时刻，
-   * 任务列表要读它、循环任务推进下一次也要拿它当基准。
-   *
-   * 两个 tick 抢同一行时只有一个改得动，另一个拿不到 RETURNING 行，据此跳
-   * 过。WHERE 里的两个条件各管一件事：
-   *   - lease_until 为空或已过期：没人正在跑这条。领了任务的 tick 中途没了
-   *     也不会把行焊死，租约到期后自然可以被接手。
-   *   - next_send_at 等于读这行时看到的值：读出来之后用户又改了排期的话，
-   *     这一跳就不该再按旧时刻发。
-   *
-   * 不加一个 'sending' 状态来表达「正在跑」：status 上有 CHECK 约束，加值
-   * 要改表。
-   *
-   * 比 next_send_at 时两边都截到毫秒：列是 timestamptz（微秒精度），驱动读
-   * 出来是 JS Date（毫秒精度），原值送回去可能因为亚毫秒差对不上。
-   *
-   * 带 serializeGroup 时多一道分组门：同一分组里已经有别的行拿着未到期的租
-   * 约，这条就领不走（同一分组同时只跑一条）。判定和写租约在同一条 UPDATE
-   * 里完成，「先查再占」的空档天然不存在。分组门只看租约，不看
-   * `retry_after`：等着重试的任务其实闲着，不该把同分组的其他任务一起堵住。
-   *
-   * @param {number} taskId
-   * @param {string|Date} expectedNextSendAt - 读这行时拿到的 next_send_at 原值
-   * @param {string|Date} leaseUntil - 租期末尾
-   * @param {string|null} [serializeGroup] - 串行分组标识；空表示不参与分组串行
-   * @returns {Promise<boolean>} true = 领到了；false = 别人正拿着租约、同分组
-   *   有任务正在跑、排期被改过、或行已不是 pending
-   */
+  // 领取一条到点的任务。SQL 与并发语义在 pg-shared.js（pg / neon 共用一份，
+  // 语义说明也在那里）。
   async claimTask(taskId, expectedNextSendAt, leaseUntil, serializeGroup = null) {
     const sql = this._getSql();
-    const grouped = typeof serializeGroup === "string" && serializeGroup.length > 0;
-    const params = [leaseUntil, taskId, expectedNextSendAt];
-    let setClause = "lease_until = $1, updated_at = NOW()";
-    let groupGuard = "";
-    if (grouped) {
-      params.push(serializeGroup);
-      setClause = "lease_until = $1, serialize_group = $4, updated_at = NOW()";
-      groupGuard = `
-          AND NOT EXISTS (
-            SELECT 1 FROM scheduled_messages busy
-             WHERE busy.serialize_group = $4 AND busy.id <> $2
-               AND busy.status = 'pending' AND busy.lease_until > NOW()
-          )`;
-    }
-    const rows = await sql.query(
-      `UPDATE scheduled_messages
-          SET ${setClause}
-        WHERE id = $2 AND status = 'pending'
-          AND date_trunc('milliseconds', next_send_at)
-            = date_trunc('milliseconds', $3::timestamptz)
-          AND (lease_until IS NULL OR lease_until <= NOW())${groupGuard}
-       RETURNING id`,
-      params
-    );
-    return rows.length > 0;
+    return _chunkTFFBMYA2cjs.claimTask.call(void 0, (text, params) => sql.query(text, params), taskId, expectedNextSendAt, leaseUntil, serializeGroup);
+  }
+  // 投递期间的租约续期（run-tick 心跳；语义见 pg-shared.js）。
+  async renewTaskLease(taskId, leaseUntil) {
+    const sql = this._getSql();
+    return _chunkTFFBMYA2cjs.renewTaskLease.call(void 0, (text, params) => sql.query(text, params), taskId, leaseUntil);
   }
   async listTasks(userId, opts = {}) {
     const sql = this._getSql();
@@ -260,7 +234,7 @@ var NeonAdapter = class {
     const total = parseInt(countRows[0].count, 10);
     const taskParams = [...params, limit, offset];
     const tasks = await sql.query(
-      `SELECT id, user_id, uuid, encrypted_payload, message_type, next_send_at, status, retry_count, created_at, updated_at
+      `SELECT id, user_id, uuid, encrypted_payload, message_type, next_send_at, status, retry_count, last_error, created_at, updated_at
        FROM scheduled_messages
        WHERE ${where}
        ORDER BY next_send_at ASC
@@ -289,57 +263,23 @@ var NeonAdapter = class {
     );
     return rows.length > 0 ? rows[0].status : null;
   }
-  // ── push_subscriptions (user-level Web Push subscription) ──────────────
-  /**
-   * 这个用户当前登记的推送订阅（密文原样返回，解密在上层）。
-   *
-   * @param {string} userId
-   * @returns {Promise<{ subscription: string, updated_at: number }|null>}
-   */
+  // 状态 + 失败摘要（GET /message 对已失败的行透出原因；语义见 pg-shared.js）。
+  async getTaskStatusInfo(uuid, userId) {
+    const sql = this._getSql();
+    return _chunkTFFBMYA2cjs.getTaskStatusInfo.call(void 0, (text, params) => sql.query(text, params), uuid, userId);
+  }
+  // ── push_subscriptions（实现见 pg-shared.js，pg / neon 共用一份）─────────
   async getPushSubscription(userId) {
     const sql = this._getSql();
-    const rows = await sql.query(
-      "SELECT subscription, updated_at FROM push_subscriptions WHERE user_id = $1 LIMIT 1",
-      [userId]
-    );
-    if (rows.length === 0) return null;
-    return { subscription: rows[0].subscription, updated_at: Number(rows[0].updated_at) };
+    return _chunkTFFBMYA2cjs.getPushSubscription.call(void 0, (text, params) => sql.query(text, params), userId);
   }
-  /**
-   * 覆盖写这个用户的订阅。一个用户一行，没有 last-write-wins 之类的比较——
-   * 客户端拿到的新订阅永远比旧的有效，旧的那份只会 410。
-   *
-   * @param {string} userId
-   * @param {string} encryptedSubscription
-   * @param {number} updatedAt - epoch 毫秒
-   * @returns {Promise<boolean>}
-   */
   async upsertPushSubscription(userId, encryptedSubscription, updatedAt) {
     const sql = this._getSql();
-    const rows = await sql.query(
-      `INSERT INTO push_subscriptions (user_id, subscription, updated_at)
-       VALUES ($1, $2, $3)
-       ON CONFLICT (user_id) DO UPDATE SET
-         subscription = EXCLUDED.subscription,
-         updated_at = EXCLUDED.updated_at
-       RETURNING user_id`,
-      [userId, encryptedSubscription, updatedAt]
-    );
-    return rows.length > 0;
+    return _chunkTFFBMYA2cjs.upsertPushSubscription.call(void 0, (text, params) => sql.query(text, params), userId, encryptedSubscription, updatedAt);
   }
-  /**
-   * 删掉这个用户的订阅（设置页「停止接收推送」）。
-   *
-   * @param {string} userId
-   * @returns {Promise<boolean>} true = 确实删掉了一行
-   */
   async deletePushSubscription(userId) {
     const sql = this._getSql();
-    const rows = await sql.query(
-      "DELETE FROM push_subscriptions WHERE user_id = $1 RETURNING user_id",
-      [userId]
-    );
-    return rows.length > 0;
+    return _chunkTFFBMYA2cjs.deletePushSubscription.call(void 0, (text, params) => sql.query(text, params), userId);
   }
 };
 

package/dist/{neon-CUIGAB2T.mjs → neon-GBUF4G76.mjs}

@@ -1,3 +1,11 @@
+import {
+  claimTask,
+  deletePushSubscription,
+  getPushSubscription,
+  getTaskStatusInfo,
+  renewTaskLease,
+  upsertPushSubscription
+} from "./chunk-UYROU4L3.mjs";
 import {
   COLUMNS_SQL,
   INDEXES,
@@ -6,7 +14,7 @@ import {
   TABLE_SQL,
   UPDATABLE_COLUMNS,
   VERIFY_TABLE_SQL
-} from "./chunk-B2FDV7YK.mjs";
+} from "./chunk-34I2YSWE.mjs";
 
 // src/server/adapters/neon.js
 import { neon } from "@neondatabase/serverless";
@@ -91,7 +99,7 @@ var NeonAdapter = class {
   async getTaskByUuid(uuid, userId) {
     const sql = this._getSql();
     const rows = await sql.query(
-      `SELECT id, user_id, uuid, encrypted_payload, message_type, next_send_at, status, retry_count, created_at, updated_at
+      `SELECT id, user_id, uuid, encrypted_payload, message_type, next_send_at, status, retry_count, last_error, created_at, updated_at
        FROM scheduled_messages
        WHERE uuid = $1 AND user_id = $2 AND status = 'pending'
        LIMIT 1`,
@@ -110,6 +118,21 @@ var NeonAdapter = class {
     );
     return rows[0] || null;
   }
+  /**
+   * 这条 uuid 现在是什么状态——不限用户，也不限状态（上面那个只看 pending
+   * 行）。`runTask` 用它把「这条已经跑完了」和「压根没这条」分开回报。
+   *
+   * @param {string} uuid
+   * @returns {Promise<{ status: string }|null>}
+   */
+  async getTaskStatusByUuidOnly(uuid) {
+    const sql = this._getSql();
+    const rows = await sql.query(
+      `SELECT status FROM scheduled_messages WHERE uuid = $1 LIMIT 1`,
+      [uuid]
+    );
+    return rows[0] ? { status: rows[0].status } : null;
+  }
   async updateTaskById(taskId, updates) {
     const sql = this._getSql();
     const sets = [];
@@ -171,7 +194,7 @@ var NeonAdapter = class {
   async getPendingTasks(limit = 50) {
     const sql = this._getSql();
     return sql.query(
-      `SELECT id, user_id, uuid, encrypted_payload, message_type, next_send_at, status, retry_count
+      `SELECT id, user_id, uuid, encrypted_payload, message_type, next_send_at, retry_after, status, retry_count
        FROM scheduled_messages
        WHERE status = 'pending' AND next_send_at <= NOW()
          AND (lease_until IS NULL OR lease_until <= NOW())
@@ -181,65 +204,16 @@ var NeonAdapter = class {
       [limit]
     );
   }
-  /**
-   * 领取一条到点的任务：在 lease_until 上写下「这条归我管到什么时候」，
-   * 本次投递期间别的 tick 领不走它。
-   *
-   * 租约写在自己的列上，next_send_at 全程不动——那一列是用户设的触发时刻，
-   * 任务列表要读它、循环任务推进下一次也要拿它当基准。
-   *
-   * 两个 tick 抢同一行时只有一个改得动，另一个拿不到 RETURNING 行，据此跳
-   * 过。WHERE 里的两个条件各管一件事：
-   *   - lease_until 为空或已过期：没人正在跑这条。领了任务的 tick 中途没了
-   *     也不会把行焊死，租约到期后自然可以被接手。
-   *   - next_send_at 等于读这行时看到的值：读出来之后用户又改了排期的话，
-   *     这一跳就不该再按旧时刻发。
-   *
-   * 不加一个 'sending' 状态来表达「正在跑」：status 上有 CHECK 约束，加值
-   * 要改表。
-   *
-   * 比 next_send_at 时两边都截到毫秒：列是 timestamptz（微秒精度），驱动读
-   * 出来是 JS Date（毫秒精度），原值送回去可能因为亚毫秒差对不上。
-   *
-   * 带 serializeGroup 时多一道分组门：同一分组里已经有别的行拿着未到期的租
-   * 约，这条就领不走（同一分组同时只跑一条）。判定和写租约在同一条 UPDATE
-   * 里完成，「先查再占」的空档天然不存在。分组门只看租约，不看
-   * `retry_after`：等着重试的任务其实闲着，不该把同分组的其他任务一起堵住。
-   *
-   * @param {number} taskId
-   * @param {string|Date} expectedNextSendAt - 读这行时拿到的 next_send_at 原值
-   * @param {string|Date} leaseUntil - 租期末尾
-   * @param {string|null} [serializeGroup] - 串行分组标识；空表示不参与分组串行
-   * @returns {Promise<boolean>} true = 领到了；false = 别人正拿着租约、同分组
-   *   有任务正在跑、排期被改过、或行已不是 pending
-   */
+  // 领取一条到点的任务。SQL 与并发语义在 pg-shared.js（pg / neon 共用一份，
+  // 语义说明也在那里）。
   async claimTask(taskId, expectedNextSendAt, leaseUntil, serializeGroup = null) {
     const sql = this._getSql();
-    const grouped = typeof serializeGroup === "string" && serializeGroup.length > 0;
-    const params = [leaseUntil, taskId, expectedNextSendAt];
-    let setClause = "lease_until = $1, updated_at = NOW()";
-    let groupGuard = "";
-    if (grouped) {
-      params.push(serializeGroup);
-      setClause = "lease_until = $1, serialize_group = $4, updated_at = NOW()";
-      groupGuard = `
-          AND NOT EXISTS (
-            SELECT 1 FROM scheduled_messages busy
-             WHERE busy.serialize_group = $4 AND busy.id <> $2
-               AND busy.status = 'pending' AND busy.lease_until > NOW()
-          )`;
-    }
-    const rows = await sql.query(
-      `UPDATE scheduled_messages
-          SET ${setClause}
-        WHERE id = $2 AND status = 'pending'
-          AND date_trunc('milliseconds', next_send_at)
-            = date_trunc('milliseconds', $3::timestamptz)
-          AND (lease_until IS NULL OR lease_until <= NOW())${groupGuard}
-       RETURNING id`,
-      params
-    );
-    return rows.length > 0;
+    return claimTask((text, params) => sql.query(text, params), taskId, expectedNextSendAt, leaseUntil, serializeGroup);
+  }
+  // 投递期间的租约续期（run-tick 心跳；语义见 pg-shared.js）。
+  async renewTaskLease(taskId, leaseUntil) {
+    const sql = this._getSql();
+    return renewTaskLease((text, params) => sql.query(text, params), taskId, leaseUntil);
   }
   async listTasks(userId, opts = {}) {
     const sql = this._getSql();
@@ -260,7 +234,7 @@ var NeonAdapter = class {
     const total = parseInt(countRows[0].count, 10);
     const taskParams = [...params, limit, offset];
     const tasks = await sql.query(
-      `SELECT id, user_id, uuid, encrypted_payload, message_type, next_send_at, status, retry_count, created_at, updated_at
+      `SELECT id, user_id, uuid, encrypted_payload, message_type, next_send_at, status, retry_count, last_error, created_at, updated_at
        FROM scheduled_messages
        WHERE ${where}
        ORDER BY next_send_at ASC
@@ -289,57 +263,23 @@ var NeonAdapter = class {
     );
     return rows.length > 0 ? rows[0].status : null;
   }
-  // ── push_subscriptions (user-level Web Push subscription) ──────────────
-  /**
-   * 这个用户当前登记的推送订阅（密文原样返回，解密在上层）。
-   *
-   * @param {string} userId
-   * @returns {Promise<{ subscription: string, updated_at: number }|null>}
-   */
+  // 状态 + 失败摘要（GET /message 对已失败的行透出原因；语义见 pg-shared.js）。
+  async getTaskStatusInfo(uuid, userId) {
+    const sql = this._getSql();
+    return getTaskStatusInfo((text, params) => sql.query(text, params), uuid, userId);
+  }
+  // ── push_subscriptions（实现见 pg-shared.js，pg / neon 共用一份）─────────
   async getPushSubscription(userId) {
     const sql = this._getSql();
-    const rows = await sql.query(
-      "SELECT subscription, updated_at FROM push_subscriptions WHERE user_id = $1 LIMIT 1",
-      [userId]
-    );
-    if (rows.length === 0) return null;
-    return { subscription: rows[0].subscription, updated_at: Number(rows[0].updated_at) };
+    return getPushSubscription((text, params) => sql.query(text, params), userId);
   }
-  /**
-   * 覆盖写这个用户的订阅。一个用户一行，没有 last-write-wins 之类的比较——
-   * 客户端拿到的新订阅永远比旧的有效，旧的那份只会 410。
-   *
-   * @param {string} userId
-   * @param {string} encryptedSubscription
-   * @param {number} updatedAt - epoch 毫秒
-   * @returns {Promise<boolean>}
-   */
   async upsertPushSubscription(userId, encryptedSubscription, updatedAt) {
     const sql = this._getSql();
-    const rows = await sql.query(
-      `INSERT INTO push_subscriptions (user_id, subscription, updated_at)
-       VALUES ($1, $2, $3)
-       ON CONFLICT (user_id) DO UPDATE SET
-         subscription = EXCLUDED.subscription,
-         updated_at = EXCLUDED.updated_at
-       RETURNING user_id`,
-      [userId, encryptedSubscription, updatedAt]
-    );
-    return rows.length > 0;
+    return upsertPushSubscription((text, params) => sql.query(text, params), userId, encryptedSubscription, updatedAt);
   }
-  /**
-   * 删掉这个用户的订阅（设置页「停止接收推送」）。
-   *
-   * @param {string} userId
-   * @returns {Promise<boolean>} true = 确实删掉了一行
-   */
   async deletePushSubscription(userId) {
     const sql = this._getSql();
-    const rows = await sql.query(
-      "DELETE FROM push_subscriptions WHERE user_id = $1 RETURNING user_id",
-      [userId]
-    );
-    return rows.length > 0;
+    return deletePushSubscription((text, params) => sql.query(text, params), userId);
   }
 };
 export {