@blamejs/blamejs-shop 0.4.20 → 0.4.22

package/lib/support-tickets.js

@@ -435,11 +435,18 @@ function create(opts) {
       return await _refresh(id);
     },
 
-    // Append a message to the ticket thread. Operator replies flip
-    // `new -> in_progress` and stamp `first_response_at` if unset.
-    // Operator replies also bump `last_action_at`; customer replies
-    // do NOT advance the SLA clock (the clock measures operator
-    // responsiveness, not customer chatter).
+    // Append a message to the ticket thread.
+    //   * A CUSTOMER-VISIBLE operator reply (internal=false) flips
+    //     `new -> in_progress`, stamps `first_response_at` if unset, and
+    //     bumps `last_action_at`. An INTERNAL operator note (internal=true)
+    //     is operator-to-operator: append-only, no status flip, no
+    //     first-response stamp (the customer never sees it, so it can't
+    //     satisfy the response SLA).
+    //   * A customer reply doesn't advance `last_action_at` on the
+    //     operator's-clock states, but DOES requeue the ticket: a reply to
+    //     `waiting_customer` returns it to `in_progress`, and a reply to a
+    //     `resolved` ticket reopens it (`resolved -> reopened`, with a
+    //     fresh SLA clock) so the operator's pushback never goes unseen.
     reply: async function (input) {
       if (!input || typeof input !== "object") {
         throw new TypeError("supportTickets.reply: input object required");
@@ -479,30 +486,57 @@ function create(opts) {
       );
 
       if (author === "operator") {
-        // Operator reply flips `new -> in_progress` automatically.
-        // Other states keep their status; SLA timer + first-response
-        // stamp still advance.
-        var newStatus = ticket.status;
-        if (ticket.status === "new") {
-          newStatus = "in_progress";
-          await _writeStatusHistory(ticketId, ticket.status, newStatus, "operator-reply", ts);
+        // Only a CUSTOMER-VISIBLE operator reply counts as a first
+        // response or advances the workflow. An INTERNAL note (internal=1)
+        // is operator-to-operator — the customer never sees it, so
+        // stamping first_response_at off it would satisfy the SLA with
+        // content that never reached the person waiting. An internal note
+        // is append-only here: no status flip, no first_response_at, no
+        // last_action_at bump (it isn't operator responsiveness TO the
+        // customer). The message row was already inserted above.
+        if (!internal) {
+          // A customer-visible operator reply flips `new -> in_progress`
+          // automatically; other states keep their status. The
+          // first-response stamp + SLA timer advance only on this path.
+          var newStatus = ticket.status;
+          if (ticket.status === "new") {
+            newStatus = "in_progress";
+            await _writeStatusHistory(ticketId, ticket.status, newStatus, "operator-reply", ts);
+          }
+          var firstResp = ticket.first_response_at == null ? ts : ticket.first_response_at;
+          await query(
+            "UPDATE support_tickets SET status = ?1, first_response_at = ?2, last_action_at = ?3 WHERE id = ?4",
+            [newStatus, firstResp, ts, ticketId],
+          );
         }
-        var firstResp = ticket.first_response_at == null ? ts : ticket.first_response_at;
-        await query(
-          "UPDATE support_tickets SET status = ?1, first_response_at = ?2, last_action_at = ?3 WHERE id = ?4",
-          [newStatus, firstResp, ts, ticketId],
-        );
       } else if (author === "customer") {
-        // Customer replies don't advance last_action_at — that
-        // would mask SLA breach. They DO move the ticket out of
-        // `waiting_customer` back into `in_progress` because the
-        // operator now owes the next move.
+        // Customer replies don't advance last_action_at on the
+        // operator's-clock states — that would mask an SLA breach. They DO
+        // move the ticket back into a queue the operator owes the next
+        // move on:
+        //   * waiting_customer -> in_progress (the customer answered)
+        //   * resolved        -> reopened     (the customer pushed back; an
+        //                                       FSM-legal edge, resolved ->
+        //                                       reopened). Without this, a
+        //                                       reply to a resolved ticket
+        //                                       was silently dropped from
+        //                                       every operator queue.
+        // last_action_at bumps ONLY on the resolved->reopened move so the
+        // reopened ticket surfaces with a fresh SLA clock (the operator now
+        // owes a response); the waiting_customer->in_progress move keeps the
+        // existing clock (the operator's responsiveness window never paused).
         if (ticket.status === "waiting_customer") {
           await _writeStatusHistory(ticketId, ticket.status, "in_progress", "customer-reply", ts);
           await query(
             "UPDATE support_tickets SET status = 'in_progress' WHERE id = ?1",
             [ticketId],
           );
+        } else if (ticket.status === "resolved") {
+          await _writeStatusHistory(ticketId, ticket.status, "reopened", "customer-reply", ts);
+          await query(
+            "UPDATE support_tickets SET status = 'reopened', last_action_at = ?1 WHERE id = ?2",
+            [ts, ticketId],
+          );
         }
       }
       // system author: append-only; no state mutation.
@@ -596,56 +630,82 @@ function create(opts) {
       return await _refresh(ticketId);
     },
 
+    // Add a tag. The mutation is a SINGLE atomic JSON1 statement —
+    // `json_insert(..., '$[#]', ?)` appends only when the tag isn't
+    // already present (the json_each NOT-EXISTS guard) AND the ticket is
+    // under the cap (json_array_length guard). A prior read-modify-write
+    // (decode -> push in JS -> write the whole array back) lost one of two
+    // concurrent addTag writes: both read the same array, both appended
+    // their own tag, the last write clobbered the other. Doing the append
+    // inside SQLite removes the read-then-write window entirely. The read
+    // that remains exists ONLY to classify a zero-row update (idempotent
+    // dup vs cap-exceeded error) — it never feeds the write.
     addTag: async function (input) {
       if (!input || typeof input !== "object") {
         throw new TypeError("supportTickets.addTag: input object required");
       }
       var ticketId = _uuid(input.ticket_id, "ticket_id");
       var tag      = _singleTag(input.tag);
-      var ticket = await _getRaw(ticketId);
-      if (!ticket) {
-        var err = new Error("supportTickets.addTag: ticket " + ticketId + " not found");
-        err.code = "SUPPORT_TICKET_NOT_FOUND";
-        throw err;
-      }
-      var tags;
-      try { tags = JSON.parse(ticket.tags_json || "[]"); }
-      catch (_e) { tags = []; }
-      if (tags.indexOf(tag) === -1) {
-        if (tags.length >= MAX_TAG_COUNT) {
+      var res = await query(
+        "UPDATE support_tickets " +
+        "SET tags_json = json_insert(COALESCE(tags_json, '[]'), '$[#]', ?1) " +
+        "WHERE id = ?2 " +
+        "  AND (SELECT COUNT(*) FROM json_each(COALESCE(tags_json, '[]')) WHERE value = ?1) = 0 " +
+        "  AND json_array_length(COALESCE(tags_json, '[]')) < ?3",
+        [tag, ticketId, MAX_TAG_COUNT],
+      );
+      if (Number((res && res.rowCount) || 0) === 0) {
+        // The atomic UPDATE matched no row. Read once to classify: a
+        // missing ticket is a hard error; an already-present tag is an
+        // idempotent no-op; otherwise the ticket is at the tag cap.
+        var ticket = await _getRaw(ticketId);
+        if (!ticket) {
+          var err = new Error("supportTickets.addTag: ticket " + ticketId + " not found");
+          err.code = "SUPPORT_TICKET_NOT_FOUND";
+          throw err;
+        }
+        var tags;
+        try { tags = JSON.parse(ticket.tags_json || "[]"); }
+        catch (_e) { tags = []; }
+        if (tags.indexOf(tag) === -1 && tags.length >= MAX_TAG_COUNT) {
           throw new TypeError("supportTickets.addTag: ticket already has " + MAX_TAG_COUNT + " tags");
         }
-        tags.push(tag);
-        await query(
-          "UPDATE support_tickets SET tags_json = ?1 WHERE id = ?2",
-          [JSON.stringify(tags), ticketId],
-        );
+        // else: tag already present — idempotent success, nothing to do.
       }
       return await _refresh(ticketId);
     },
 
+    // Remove a tag. Single atomic JSON1 statement — rebuild the array
+    // from `json_each` minus the target value. Same lost-update hazard as
+    // addTag if done read-modify-write; doing it in SQLite removes the
+    // window. Idempotent: a tag that isn't present matches no row in the
+    // EXISTS guard and the update is a no-op. A missing ticket is read
+    // back only to raise the not-found error (the update wrote nothing).
     removeTag: async function (input) {
       if (!input || typeof input !== "object") {
         throw new TypeError("supportTickets.removeTag: input object required");
       }
       var ticketId = _uuid(input.ticket_id, "ticket_id");
       var tag      = _singleTag(input.tag);
-      var ticket = await _getRaw(ticketId);
-      if (!ticket) {
-        var err = new Error("supportTickets.removeTag: ticket " + ticketId + " not found");
-        err.code = "SUPPORT_TICKET_NOT_FOUND";
-        throw err;
-      }
-      var tags;
-      try { tags = JSON.parse(ticket.tags_json || "[]"); }
-      catch (_e) { tags = []; }
-      var idx = tags.indexOf(tag);
-      if (idx !== -1) {
-        tags.splice(idx, 1);
-        await query(
-          "UPDATE support_tickets SET tags_json = ?1 WHERE id = ?2",
-          [JSON.stringify(tags), ticketId],
-        );
+      var res = await query(
+        "UPDATE support_tickets " +
+        "SET tags_json = (" +
+        "  SELECT COALESCE(json_group_array(value), '[]') " +
+        "  FROM json_each(COALESCE(tags_json, '[]')) WHERE value <> ?1" +
+        ") " +
+        "WHERE id = ?2 " +
+        "  AND EXISTS (SELECT 1 FROM json_each(COALESCE(tags_json, '[]')) WHERE value = ?1)",
+        [tag, ticketId],
+      );
+      if (Number((res && res.rowCount) || 0) === 0) {
+        // No row changed — either the ticket is missing (hard error) or
+        // the tag simply wasn't present (idempotent no-op).
+        var ticket = await _getRaw(ticketId);
+        if (!ticket) {
+          var err = new Error("supportTickets.removeTag: ticket " + ticketId + " not found");
+          err.code = "SUPPORT_TICKET_NOT_FOUND";
+          throw err;
+        }
       }
       return await _refresh(ticketId);
     },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blamejs/blamejs-shop",
-  "version": "0.4.20",
+  "version": "0.4.22",
   "description": "Open-source framework built on blamejs. Vendored stack, zero npm runtime deps, PQC-first crypto, security-on by default.",
   "main": "lib/index.js",
   "scripts": {