@beezping/adapter-memory 0.6.0 → 0.7.0

package/dist/index.js

@@ -9,28 +9,21 @@ function clampPagination(query) {
   const limit = Math.min(toPositiveInteger(query.limit, DEFAULT_PAGE_LIMIT), MAX_PAGE_LIMIT);
   return { page, limit, skip: (page - 1) * limit };
 }
-function isUnreachableOffset(skip) {
-  return !Number.isSafeInteger(skip);
+function sortTime(record) {
+  const time = record.createdAt.getTime();
+  return Number.isNaN(time) ? Number.MIN_SAFE_INTEGER : time;
+}
+function matchesFeedbackQuery(record, query) {
+  const { type, status, statuses, url, urlPattern, search } = query;
+  return record.projectName === query.projectName && (!type || record.type === type) && // `statuses` (bucket / any-of) wins over the exact `status` filter when
+  // both are present; an empty array is treated as absent.
+  (statuses && statuses.length > 0 ? statuses.includes(record.status) : !status || record.status === status) && (!url || record.url === url) && (!urlPattern || record.urlPattern === urlPattern) && (!search || record.message.toLowerCase().includes(search.toLowerCase()));
 }
 function applyFeedbackFilters(items, query) {
-  let results = items.filter((f) => f.projectName === query.projectName);
-  if (query.type) results = results.filter((f) => f.type === query.type);
-  if (query.statuses && query.statuses.length > 0) {
-    const allowed = query.statuses;
-    results = results.filter((f) => allowed.includes(f.status));
-  } else if (query.status) {
-    results = results.filter((f) => f.status === query.status);
-  }
-  if (query.url) results = results.filter((f) => f.url === query.url);
-  if (query.urlPattern) results = results.filter((f) => f.urlPattern === query.urlPattern);
-  if (query.search) {
-    const s = query.search.toLowerCase();
-    results = results.filter((f) => f.message.toLowerCase().includes(s));
-  }
-  results.sort((a, b) => b.createdAt.getTime() - a.createdAt.getTime());
+  const results = items.filter((f) => matchesFeedbackQuery(f, query));
+  results.sort((a, b) => sortTime(b) - sortTime(a));
   const total = results.length;
   const { limit, skip } = clampPagination(query);
-  if (isUnreachableOffset(skip)) return { feedbacks: [], total };
   return { feedbacks: results.slice(skip, skip + limit), total };
 }
 
@@ -43,6 +36,7 @@ function hasOwn(value, key) {
 }
 
 // ../core/src/types.ts
+var MAX_COMMENTS_PER_FEEDBACK = 100;
 var StoreNotFoundError = class extends Error {
   code = "STORE_NOT_FOUND";
   constructor(message = "Record not found", options) {
@@ -64,6 +58,13 @@ var StorePersistenceError = class extends Error {
     this.name = "StorePersistenceError";
   }
 };
+var StoreLimitError = class extends Error {
+  code = "STORE_LIMIT";
+  constructor(message = "Store limit reached", options) {
+    super(message, options);
+    this.name = "StoreLimitError";
+  }
+};
 function hasErrorCode(error, code) {
   return hasOwn(error, "code") && error.code === code;
 }
@@ -99,6 +100,18 @@ function buildAnnotationRecord(input, ctx) {
     createdAt: ctx.now
   };
 }
+function buildCommentRecord(input, ctx) {
+  return {
+    id: ctx.id,
+    feedbackId: ctx.feedbackId,
+    body: input.body,
+    authorName: input.authorName,
+    authorEmail: input.authorEmail,
+    authorRole: input.authorRole,
+    clientId: input.clientId,
+    createdAt: ctx.now ?? /* @__PURE__ */ new Date()
+  };
+}
 function buildFeedbackRecord(input, ctx) {
   const now = ctx.now ?? /* @__PURE__ */ new Date();
   return {
@@ -126,23 +139,24 @@ function buildFeedbackRecord(input, ctx) {
   };
 }
 function createCollectionStore(backend) {
-  let mutationQueueTail = Promise.resolve();
-  const runSerializedMutation = (mutation) => {
-    const mutationResult = mutationQueueTail.then(mutation);
-    mutationQueueTail = mutationResult.then(
-      () => void 0,
-      () => void 0
-    );
-    return mutationResult;
-  };
-  const insertFeedbackIfAbsent = async (data) => {
-    const feedbacks = await backend.load();
+  let tail = Promise.resolve();
+  function mutate(mutation) {
+    const result = tail.then(() => {
+      const loaded = backend.load();
+      return Array.isArray(loaded) ? mutation(loaded) : loaded.then(mutation);
+    });
+    tail = result.catch(() => {
+    });
+    return result;
+  }
+  const createFeedbackIfAbsent = (data) => mutate(async (feedbacks) => {
     const existing = feedbacks.find((f) => f.clientId === data.clientId);
     if (existing) return { feedback: existing, created: false };
     const record = buildFeedbackRecord(data, {
       id: backend.generateId(),
       annotationId: () => backend.generateId()
     });
+    if (backend.comments) record.comments = [];
     const next = [record, ...feedbacks];
     try {
       await backend.persist(next);
@@ -152,9 +166,8 @@ function createCollectionStore(backend) {
       await backend.persist(next);
     }
     return { feedback: record, created: true };
-  };
-  const createFeedbackIfAbsent = (data) => runSerializedMutation(() => insertFeedbackIfAbsent(data));
-  return {
+  });
+  const store = {
     createFeedbackIfAbsent,
     async createFeedback(data) {
       return (await createFeedbackIfAbsent(data)).feedback;
@@ -165,39 +178,55 @@ function createCollectionStore(backend) {
     async findByClientId(clientId) {
       return (await backend.load()).find((f) => f.clientId === clientId) ?? null;
     },
-    updateFeedback(id, data) {
-      return runSerializedMutation(async () => {
-        const feedbacks = await backend.load();
-        const current = feedbacks.find((f) => f.id === id);
-        if (!current) throw new StoreNotFoundError();
-        const updated = {
-          ...current,
-          status: data.status,
-          resolvedAt: data.resolvedAt,
-          updatedAt: /* @__PURE__ */ new Date()
-        };
-        await backend.persist(feedbacks.map((f) => f === current ? updated : f));
-        return updated;
-      });
-    },
-    deleteFeedback(id) {
-      return runSerializedMutation(async () => {
-        const feedbacks = await backend.load();
-        if (!feedbacks.some((f) => f.id === id)) throw new StoreNotFoundError();
-        await backend.persist(feedbacks.filter((f) => f.id !== id));
-      });
-    },
-    deleteAllFeedbacks(projectName) {
-      return runSerializedMutation(async () => {
-        const feedbacks = await backend.load();
-        await backend.persist(feedbacks.filter((f) => f.projectName !== projectName));
-      });
-    },
+    updateFeedback: (id, data) => mutate(async (feedbacks) => {
+      const current = feedbacks.find((f) => f.id === id);
+      if (!current) throw new StoreNotFoundError();
+      const updated = {
+        ...current,
+        status: data.status,
+        resolvedAt: data.resolvedAt,
+        updatedAt: /* @__PURE__ */ new Date()
+      };
+      await backend.persist(feedbacks.map((f) => f === current ? updated : f));
+      return updated;
+    }),
+    deleteFeedback: (id) => mutate(async (feedbacks) => {
+      if (!feedbacks.some((f) => f.id === id)) throw new StoreNotFoundError();
+      await backend.persist(feedbacks.filter((f) => f.id !== id));
+    }),
+    deleteAllFeedbacks: (projectName) => mutate(async (feedbacks) => {
+      await backend.persist(feedbacks.filter((f) => f.projectName !== projectName));
+    }),
     async verifyProjectOwnership(id, projectName) {
       const fb = (await backend.load()).find((f) => f.id === id);
       return fb !== void 0 && fb.projectName === projectName;
     }
   };
+  if (!backend.comments) return store;
+  return {
+    ...store,
+    addComment: (feedbackId, data) => mutate(async (feedbacks) => {
+      const existing = feedbacks.flatMap((f) => f.comments ?? []).find((c) => c.clientId === data.clientId);
+      if (existing) return existing;
+      const current = feedbacks.find((f) => f.id === feedbackId);
+      if (!current) throw new StoreNotFoundError();
+      const thread = current.comments ?? [];
+      if (data.authorRole === "client" && thread.filter((c) => c.authorRole === "client").length >= MAX_COMMENTS_PER_FEEDBACK) {
+        throw new StoreLimitError(`A thread holds at most ${MAX_COMMENTS_PER_FEEDBACK} client comments`);
+      }
+      const comment = buildCommentRecord(data, { id: backend.generateId(), feedbackId });
+      const updated = { ...current, comments: [...thread, comment] };
+      await backend.persist(feedbacks.map((f) => f === current ? updated : f));
+      return comment;
+    }),
+    deleteComment: (feedbackId, commentId) => mutate(async (feedbacks) => {
+      const current = feedbacks.find((f) => f.id === feedbackId);
+      const thread = current?.comments ?? [];
+      if (!current || !thread.some((c) => c.id === commentId)) throw new StoreNotFoundError();
+      const updated = { ...current, comments: thread.filter((c) => c.id !== commentId) };
+      await backend.persist(feedbacks.map((f) => f === current ? updated : f));
+    })
+  };
 }
 
 // src/index.ts
@@ -209,7 +238,9 @@ var MemoryStore = class {
     persist: (next) => {
       this.feedbacks = next;
     },
-    generateId: () => `mem-${this.idCounter++}-${Date.now().toString(36)}`
+    generateId: () => `mem-${this.idCounter++}-${Date.now().toString(36)}`,
+    // Records live in memory: comment dates stay Dates.
+    comments: true
   });
   createFeedback(data) {
     return this.engine.createFeedback(data);
@@ -235,6 +266,12 @@ var MemoryStore = class {
   verifyProjectOwnership(id, projectName) {
     return this.engine.verifyProjectOwnership(id, projectName);
   }
+  addComment(feedbackId, data) {
+    return this.engine.addComment(feedbackId, data);
+  }
+  deleteComment(feedbackId, commentId) {
+    return this.engine.deleteComment(feedbackId, commentId);
+  }
   /** Remove all data from this store instance. */
   clear() {
     this.feedbacks = [];
@@ -244,6 +281,7 @@ var MemoryStore = class {
 export {
   MemoryStore,
   StoreDuplicateError,
+  StoreLimitError,
   StoreNotFoundError,
   StorePersistenceError,
   isStorePersistence