@siteping/adapter-drizzle 0.1.0

package/dist/chunk-6G6UAERF.js

@@ -0,0 +1,814 @@
+// src/shared/replicas.ts
+function primaryOf(db) {
+  return "$primary" in db ? db.$primary : db;
+}
+
+// ../core/src/type-utils.ts
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function hasOwn(value, key) {
+  return isRecord(value) && key in value;
+}
+
+// ../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) {
+    super(message, options);
+    this.name = "StoreNotFoundError";
+  }
+};
+var StoreDuplicateError = class extends Error {
+  code = "STORE_DUPLICATE";
+  constructor(message = "Duplicate record", options) {
+    super(message, options);
+    this.name = "StoreDuplicateError";
+  }
+};
+var StorePersistenceError = class extends Error {
+  code = "STORE_PERSISTENCE";
+  constructor(message = "Failed to persist store mutation", options) {
+    super(message, options);
+    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;
+}
+function isStoreNotFound(error) {
+  if (error instanceof StoreNotFoundError) return true;
+  return hasErrorCode(error, "STORE_NOT_FOUND") || hasErrorCode(error, "P2025");
+}
+function isStoreDuplicate(error) {
+  if (error instanceof StoreDuplicateError) return true;
+  return hasErrorCode(error, "STORE_DUPLICATE") || hasErrorCode(error, "P2002");
+}
+function isStorePersistence(error) {
+  if (error instanceof StorePersistenceError) return true;
+  return hasErrorCode(error, "STORE_PERSISTENCE");
+}
+
+// ../core/src/concurrency.ts
+async function settleWithConcurrencyLimit(items, concurrency, task) {
+  const results = new Array(items.length);
+  let nextIndex = 0;
+  const runWorker = async () => {
+    while (nextIndex < items.length) {
+      const index = nextIndex;
+      nextIndex += 1;
+      try {
+        results[index] = { status: "fulfilled", value: await task(items[index]) };
+      } catch (error) {
+        results[index] = { status: "rejected", reason: error };
+      }
+    }
+  };
+  const workerCount = Math.min(Math.max(1, concurrency), items.length);
+  await Promise.all(Array.from({ length: workerCount }, runWorker));
+  return results;
+}
+
+// ../core/src/filters.ts
+var DEFAULT_PAGE_LIMIT = 50;
+var MAX_PAGE_LIMIT = 100;
+function toPositiveInteger(value, fallback) {
+  return value !== void 0 && Number.isFinite(value) ? Math.max(1, Math.floor(value)) : fallback;
+}
+function clampPagination(query) {
+  const page = toPositiveInteger(query.page, 1);
+  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);
+}
+
+// ../core/src/screenshot-storage.ts
+var SCREENSHOT_DELETE_CONCURRENCY = 32;
+function screenshotMimeType(dataUrl) {
+  return /^data:(image\/(?:jpeg|png|webp))[;,]/i.exec(dataUrl)?.[1]?.toLowerCase() ?? "image/jpeg";
+}
+
+// ../core/src/store-helpers.ts
+function buildAnnotationRecord(input, ctx) {
+  return {
+    id: ctx.id,
+    feedbackId: ctx.feedbackId,
+    cssSelector: input.cssSelector,
+    xpath: input.xpath,
+    textSnippet: input.textSnippet,
+    elementTag: input.elementTag,
+    elementId: input.elementId ?? null,
+    textPrefix: input.textPrefix,
+    textSuffix: input.textSuffix,
+    fingerprint: input.fingerprint,
+    neighborText: input.neighborText,
+    anchorKey: input.anchorKey ?? null,
+    xPct: input.xPct,
+    yPct: input.yPct,
+    wPct: input.wPct,
+    hPct: input.hPct,
+    scrollX: input.scrollX,
+    scrollY: input.scrollY,
+    viewportW: input.viewportW,
+    viewportH: input.viewportH,
+    devicePixelRatio: input.devicePixelRatio,
+    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 {
+    id: ctx.id,
+    type: input.type,
+    message: input.message,
+    status: input.status,
+    projectName: input.projectName,
+    url: input.url,
+    urlPattern: input.urlPattern ?? null,
+    authorName: input.authorName,
+    authorEmail: input.authorEmail,
+    viewport: input.viewport,
+    userAgent: input.userAgent,
+    clientId: input.clientId,
+    resolvedAt: null,
+    createdAt: now,
+    updatedAt: now,
+    annotations: input.annotations.map(
+      (ann) => buildAnnotationRecord(ann, { id: ctx.annotationId(), feedbackId: ctx.id, now })
+    ),
+    screenshotUrl: input.screenshotDataUrl ?? null,
+    screenshotRegion: input.screenshotRegion ?? null,
+    diagnostics: input.diagnostics ?? null
+  };
+}
+
+// src/constants/errors.ts
+var DRIZZLE_STORE_MESSAGE_PREFIX = "[siteping] DrizzleStore";
+var DRIZZLE_QUERY_ERROR_MESSAGE_PREFIX = "Failed query:";
+var FOREIGN_KEY_VIOLATION_SQLSTATE = "23503";
+var DRIVER_ERROR_DIAGNOSTIC_FIELDS = [
+  "code",
+  "errno",
+  "syscall",
+  "severity",
+  "schema",
+  "table",
+  "column",
+  "dataType",
+  "constraint",
+  "routine",
+  "severity_local",
+  "schema_name",
+  "table_name",
+  "column_name",
+  "constraint_name",
+  "extendedCode",
+  "rawCode"
+];
+
+// src/constants/deletes.ts
+var PROJECT_DELETE_CHUNK_SIZE = 500;
+
+// src/constants/screenshots.ts
+var INLINE_SCREENSHOT_URL_PREFIX = "data:";
+var SCREENSHOT_REFERENCE_LOOKUP_BATCH_SIZE = 500;
+var INLINE_SCREENSHOT_URL_LIKE_PATTERN = `${INLINE_SCREENSHOT_URL_PREFIX}%`;
+
+// src/shared/errors.ts
+import { DrizzleQueryError } from "drizzle-orm";
+function isDrizzleQueryError(error) {
+  return error instanceof DrizzleQueryError || error.message.startsWith(DRIZZLE_QUERY_ERROR_MESSAGE_PREFIX);
+}
+function withoutStatement(error, above = []) {
+  if (!(error instanceof Error)) return error;
+  const chain = [...above, error];
+  const keepsCause = error.cause !== void 0 && !chain.includes(error.cause);
+  const cause = keepsCause ? withoutStatement(error.cause, chain) : void 0;
+  if (isDrizzleQueryError(error)) return cause;
+  const copy = new Error(error.message, keepsCause ? { cause } : void 0);
+  const kept = (value) => ({ value, writable: true, configurable: true });
+  Object.defineProperties(copy, { name: kept(error.name), stack: kept(error.stack) });
+  const diagnostics = DRIVER_ERROR_DIAGNOSTIC_FIELDS.map((field) => [field, Reflect.get(error, field)]);
+  return Object.assign(copy, Object.fromEntries(diagnostics.filter(([, value]) => value !== void 0)));
+}
+function withDriverErrors(gateway) {
+  return new Proxy(gateway, {
+    get(target, property, receiver) {
+      const member = Reflect.get(target, property, receiver);
+      if (typeof member !== "function") return member;
+      return async (...args) => {
+        try {
+          return await member.apply(target, args);
+        } catch (error) {
+          throw withoutStatement(error);
+        }
+      };
+    }
+  });
+}
+
+// src/constants/text.ts
+var UNSTORABLE_CODE_UNITS = /\0|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?<![\uD800-\uDBFF])[\uDC00-\uDFFF]/g;
+var REPLACEMENT_CHARACTER = "\uFFFD";
+
+// src/shared/text.ts
+function toStorableText(text) {
+  return text.replace(UNSTORABLE_CODE_UNITS, REPLACEMENT_CHARACTER);
+}
+function isPlainObject(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}
+function toStorableValue(value) {
+  if (typeof value === "string") return toStorableText(value);
+  if (Array.isArray(value)) return value.map(toStorableValue);
+  if (!isPlainObject(value)) return value;
+  return Object.fromEntries(
+    Object.entries(value).map(([key, item]) => [toStorableText(key), toStorableValue(item)])
+  );
+}
+
+// src/shared/store.ts
+var silentLogger = {
+  warn() {
+  }
+};
+var systemClock = () => /* @__PURE__ */ new Date();
+function isStoreContractError(error) {
+  return isStoreNotFound(error) || isStoreDuplicate(error) || isStorePersistence(error);
+}
+async function persistMutation(mutation, identifiers, run) {
+  try {
+    return await run();
+  } catch (error) {
+    if (isStoreContractError(error)) throw error;
+    const context = Object.entries(identifiers).map(([name, value]) => `${name}=${value}`).join(" ");
+    throw new StorePersistenceError(`${DRIZZLE_STORE_MESSAGE_PREFIX}.${mutation} failed (${context})`, {
+      cause: error
+    });
+  }
+}
+function isForeignKeyViolation(error) {
+  const seen = [];
+  for (let current = error; current instanceof Error && !seen.includes(current); current = current.cause) {
+    if (Reflect.get(current, "code") === FOREIGN_KEY_VIOLATION_SQLSTATE) return true;
+    seen.push(current);
+  }
+  return false;
+}
+function groupByFeedback(rows) {
+  const byFeedback = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    const siblings = byFeedback.get(row.feedbackId);
+    if (siblings) siblings.push(row);
+    else byFeedback.set(row.feedbackId, [row]);
+  }
+  return byFeedback;
+}
+function isUploadedScreenshotUrl(url) {
+  return typeof url === "string" && url.length > 0 && !url.startsWith(INLINE_SCREENSHOT_URL_PREFIX);
+}
+var DrizzleSitepingStore = class {
+  gateway;
+  screenshotStorage;
+  logger;
+  now;
+  inlineScreenshotWarned = false;
+  constructor(gateway, options = {}) {
+    this.gateway = withDriverErrors(gateway);
+    this.screenshotStorage = options.screenshotStorage;
+    this.logger = options.logger ?? silentLogger;
+    this.now = options.now ?? systemClock;
+  }
+  async createFeedback(data) {
+    return (await this.createFeedbackIfAbsent(data)).feedback;
+  }
+  /**
+   * Insert the feedback unless a row with the same `clientId` exists. The
+   * unique `client_id` index plus `ON CONFLICT DO NOTHING` make the check
+   * atomic across store instances and processes: of N concurrent calls, only
+   * the one whose insert lands reports `created: true`.
+   *
+   * @throws `StorePersistenceError` when a database call fails: the lookup
+   *   of the `clientId`, the insert, or — when the insert loses the race — the
+   *   read-back of the winning row. If that row was deleted in the meantime,
+   *   an `Error` naming the `clientId` is thrown (the caller may retry the
+   *   submission). On every failure path, the screenshot this attempt uploaded
+   *   is discarded first — no committed row references it.
+   */
+  async createFeedbackIfAbsent(submitted) {
+    const data = toStorableValue(submitted);
+    const identifiers = { clientId: data.clientId };
+    const existing = await persistMutation("createFeedback", identifiers, () => this.findByClientId(data.clientId));
+    if (existing) return { feedback: existing, created: false };
+    const id = crypto.randomUUID();
+    const screenshotUrl = await this.persistScreenshot(data.screenshotDataUrl, {
+      feedbackId: id,
+      clientId: data.clientId
+    });
+    const { annotations, ...feedback } = buildFeedbackRecord(data, {
+      id,
+      annotationId: () => crypto.randomUUID(),
+      // The clock value as is: rows created in the same millisecond — by this
+      // or any other instance — are ordered by the database-wide insertion
+      // ordinal, so a later insert always lists first.
+      now: this.now()
+    });
+    const row = { ...feedback, screenshotUrl };
+    let inserted;
+    try {
+      inserted = await persistMutation(
+        "createFeedback",
+        identifiers,
+        () => this.gateway.insertFeedback(row, annotations)
+      );
+    } catch (error) {
+      await this.discardScreenshots([screenshotUrl], { clientId: data.clientId });
+      throw error;
+    }
+    if (inserted) {
+      return { feedback: { ...row, annotations, comments: [] }, created: true };
+    }
+    let winner;
+    try {
+      winner = await persistMutation("createFeedback", identifiers, () => this.findByClientId(data.clientId));
+    } finally {
+      await this.discardScreenshots([screenshotUrl], { clientId: data.clientId });
+    }
+    if (!winner) {
+      throw new Error(
+        `${DRIZZLE_STORE_MESSAGE_PREFIX}.createFeedbackIfAbsent: clientId ${data.clientId} conflicted but no row was found (the winning row was deleted before it could be read back)`
+      );
+    }
+    return { feedback: winner, created: false };
+  }
+  async getFeedbacks(submittedQuery) {
+    const query = toStorableValue(submittedQuery);
+    const { limit, skip } = clampPagination(query);
+    const filter = { projectName: query.projectName };
+    if (query.type) filter.type = query.type;
+    if (query.statuses && query.statuses.length > 0) filter.statuses = query.statuses;
+    else if (query.status) filter.statuses = [query.status];
+    if (query.url) filter.url = query.url;
+    if (query.urlPattern) filter.urlPattern = query.urlPattern;
+    if (query.search) filter.search = query.search;
+    if (isUnreachableOffset(skip)) {
+      return { feedbacks: [], total: await this.gateway.countFeedbacks(filter) };
+    }
+    const { rows, total } = await this.gateway.findFeedbacks(filter, { limit, offset: skip });
+    return { feedbacks: await this.withRelations(rows), total };
+  }
+  async findByClientId(clientId) {
+    const row = await this.gateway.findByClientId(toStorableText(clientId));
+    return row ? (await this.withRelations([row]))[0] ?? null : null;
+  }
+  /**
+   * Update a feedback's status. Its annotations and thread are read before the
+   * update — annotations never change after the insert, and the thread is the
+   * one at the time of the update: once the update commits, no database call
+   * is left that could fail and make the caller retry an applied update.
+   *
+   * @throws `StoreNotFoundError` when no row has that id.
+   * @throws `StorePersistenceError` when reading the annotations, the thread
+   *   or the update fails — a failed read leaves the row untouched.
+   */
+  async updateFeedback(submittedId, data) {
+    const id = toStorableText(submittedId);
+    const { relationsOf, row } = await persistMutation("updateFeedback", { id }, async () => {
+      const relationsOf2 = await this.readRelations([id]);
+      const row2 = await this.gateway.updateStatus(id, {
+        status: data.status,
+        resolvedAt: data.resolvedAt,
+        updatedAt: this.now()
+      });
+      return { relationsOf: relationsOf2, row: row2 };
+    });
+    if (!row) throw new StoreNotFoundError();
+    return { ...row, ...relationsOf(id) };
+  }
+  async deleteFeedback(submittedId) {
+    const id = toStorableText(submittedId);
+    const deleted = await persistMutation(
+      "deleteFeedback",
+      { id },
+      () => this.gateway.deleteById(id, this.deleteOptions())
+    );
+    if (!deleted) throw new StoreNotFoundError();
+    await this.discardScreenshots(deleted.screenshotUrls);
+  }
+  /**
+   * Delete every feedback of a project. Rows go first, storage second: orphaned
+   * objects are acceptable, rows pointing at deleted screenshots are not.
+   *
+   * Without a `ScreenshotStorage.delete` hook, one atomic statement (or batch)
+   * removes the project and reads nothing back. With one, the removed URLs are
+   * needed for cleanup, so rows go in chunks of
+   * {@link PROJECT_DELETE_CHUNK_SIZE}, each deleted atomically and its
+   * screenshots cleaned up before the next one: every driver response and the
+   * URLs held in memory stay bounded however large the project. The call
+   * returns once the project has no row left, whatever deletes run alongside.
+   *
+   * @throws `StorePersistenceError` when a chunk fails. The chunks before it
+   *   stay deleted and their screenshots are already cleaned up; the delete is
+   *   idempotent, so retrying it removes the remaining rows. When the failing
+   *   chunk committed although the driver reported an error, its rows are gone
+   *   and their screenshots are left in the storage as orphans. Also thrown
+   *   when the database keeps rows it is told to delete (a row-level security
+   *   policy or a trigger that skips deletes), instead of retrying forever.
+   */
+  async deleteAllFeedbacks(submittedProjectName) {
+    const projectName = toStorableText(submittedProjectName);
+    if (!this.deleteOptions().collectScreenshotUrls) {
+      await persistMutation("deleteAllFeedbacks", { projectName }, () => this.gateway.deleteByProject(projectName));
+      return;
+    }
+    let remainingAfterEmptyChunk = Number.POSITIVE_INFINITY;
+    for (; ; ) {
+      const deleted = await persistMutation(
+        "deleteAllFeedbacks",
+        { projectName },
+        () => this.gateway.deleteProjectChunk(projectName, PROJECT_DELETE_CHUNK_SIZE)
+      );
+      if (deleted.deletedCount > 0) {
+        remainingAfterEmptyChunk = Number.POSITIVE_INFINITY;
+        await this.discardScreenshots(deleted.screenshotUrls);
+        continue;
+      }
+      const remaining = await persistMutation(
+        "deleteAllFeedbacks",
+        { projectName },
+        () => this.gateway.countFeedbacks({ projectName })
+      );
+      if (remaining === 0) return;
+      if (remaining >= remainingAfterEmptyChunk) {
+        throw new StorePersistenceError(
+          `${DRIZZLE_STORE_MESSAGE_PREFIX}.deleteAllFeedbacks: the database kept ${remaining} rows it was told to delete (projectName=${projectName})`
+        );
+      }
+      remainingAfterEmptyChunk = remaining;
+    }
+  }
+  async verifyProjectOwnership(id, projectName) {
+    return await this.gateway.findProjectName(toStorableText(id)) === toStorableText(projectName);
+  }
+  /**
+   * Add a comment as the last of its thread, in one statement that also
+   * checks the feedback, the cap on `client` comments and the `clientId` —
+   * atomic across store instances and processes, except that posts racing
+   * for the last free slot may overshoot the cap by the ones that run
+   * concurrently.
+   *
+   * @throws `StoreNotFoundError` when the feedback does not exist, including
+   *   when it is deleted while the comment is being inserted.
+   * @throws `StoreLimitError` when a `client` comment meets a thread already holding `MAX_COMMENTS_PER_FEEDBACK` of them.
+   * @throws `StorePersistenceError` when a database call fails.
+   */
+  async addComment(submittedFeedbackId, submitted) {
+    const feedbackId = toStorableText(submittedFeedbackId);
+    const data = toStorableValue(submitted);
+    const comment = buildCommentRecord(data, { id: crypto.randomUUID(), feedbackId, now: this.now() });
+    const identifiers = { feedbackId, clientId: data.clientId };
+    let inserted;
+    try {
+      inserted = await persistMutation(
+        "addComment",
+        identifiers,
+        () => this.gateway.insertComment(comment, MAX_COMMENTS_PER_FEEDBACK)
+      );
+    } catch (error) {
+      if (!isForeignKeyViolation(error)) throw error;
+      const feedbackGone = await this.gateway.findProjectName(feedbackId).then(
+        (projectName2) => projectName2 === null,
+        () => false
+      );
+      if (feedbackGone) throw new StoreNotFoundError();
+      throw error;
+    }
+    if (inserted) return comment;
+    const replayed = await persistMutation(
+      "addComment",
+      identifiers,
+      () => this.gateway.findCommentByClientId(data.clientId)
+    );
+    if (replayed) return replayed;
+    const projectName = await persistMutation(
+      "addComment",
+      identifiers,
+      () => this.gateway.findProjectName(feedbackId)
+    );
+    if (projectName === null) throw new StoreNotFoundError();
+    throw new StoreLimitError(`A thread holds at most ${MAX_COMMENTS_PER_FEEDBACK} client comments`);
+  }
+  async deleteComment(submittedFeedbackId, submittedCommentId) {
+    const feedbackId = toStorableText(submittedFeedbackId);
+    const commentId = toStorableText(submittedCommentId);
+    const deleted = await persistMutation(
+      "deleteComment",
+      { feedbackId, commentId },
+      () => this.gateway.deleteComment(feedbackId, commentId)
+    );
+    if (!deleted) throw new StoreNotFoundError();
+  }
+  /**
+   * Deletes read the removed screenshot URLs back only when a
+   * `ScreenshotStorage.delete` hook can clean them up: without one there is
+   * nothing to do with them, and inline data URLs would be materialized for
+   * every deleted row.
+   */
+  deleteOptions() {
+    return { collectScreenshotUrls: typeof this.screenshotStorage?.delete === "function" };
+  }
+  async withRelations(rows) {
+    if (rows.length === 0) return [];
+    const relationsOf = await this.readRelations(rows.map((row) => row.id));
+    return rows.map((row) => ({ ...row, ...relationsOf(row.id) }));
+  }
+  /** Read the annotations and threads of `feedbackIds`, then hand out each feedback's. */
+  async readRelations(feedbackIds) {
+    const [annotations, comments] = await Promise.all([
+      this.gateway.findAnnotations(feedbackIds),
+      this.gateway.findComments(feedbackIds)
+    ]);
+    const annotationsOf = groupByFeedback(annotations);
+    const commentsOf = groupByFeedback(comments);
+    return (feedbackId) => ({
+      annotations: annotationsOf.get(feedbackId) ?? [],
+      comments: commentsOf.get(feedbackId) ?? []
+    });
+  }
+  /**
+   * Value to persist on `screenshotUrl`: the storage URL, `null` when the
+   * upload fails (an inline fallback would bloat the database unnoticed
+   * during a storage outage), or the inline data URL without storage.
+   *
+   * @param dataUrl - Screenshot submitted with the feedback, if any.
+   * @param attempt - `feedbackId` is the id this create attempt will insert
+   *   the row under — unique per attempt and never client-supplied — so
+   *   racing attempts on one `clientId` never write the same object;
+   *   `clientId` is only reported in logs.
+   */
+  async persistScreenshot(dataUrl, { feedbackId, clientId }) {
+    if (!dataUrl) return null;
+    if (this.screenshotStorage) {
+      try {
+        const { url } = await this.screenshotStorage.upload(dataUrl, {
+          feedbackId,
+          mimeType: screenshotMimeType(dataUrl)
+        });
+        return url;
+      } catch (error) {
+        this.logger.warn(
+          "[siteping] DrizzleStore: screenshotStorage.upload failed \u2014 feedback saved without screenshot",
+          { clientId, feedbackId, error }
+        );
+        return null;
+      }
+    }
+    if (!this.inlineScreenshotWarned) {
+      this.inlineScreenshotWarned = true;
+      this.logger.warn(
+        "[siteping] DrizzleStore: no screenshotStorage configured \u2014 screenshots are stored inline as base64. Configure a ScreenshotStorage for production.",
+        {}
+      );
+    }
+    return dataUrl;
+  }
+  /**
+   * Best-effort cleanup through `ScreenshotStorage.delete` of the screenshots
+   * no stored feedback references any more; inline data URLs were never
+   * uploaded and are skipped.
+   *
+   * The `ScreenshotStorage` contract makes every URL unique to the feedback id
+   * it was uploaded for, and each create attempt uploads under a fresh id, so
+   * a URL passed here belongs to one row only and no concurrent create can
+   * acquire it: deleting it after the reference check cannot race with a new
+   * reference. The check still runs because the owning row may exist after
+   * all — an insert that committed although the driver reported a failure —
+   * and, as defense in depth, it keeps objects a contract-breaking storage
+   * shares across rows (a concurrent create that reuses such a URL after the
+   * check is outside the contract and not covered). When the check itself
+   * fails, every object is kept (an orphan is acceptable, a row pointing at a
+   * deleted screenshot is not).
+   *
+   * Deletes run through a pool of at most {@link SCREENSHOT_DELETE_CONCURRENCY}
+   * concurrent calls, so a project delete freeing thousands of objects does not
+   * flood the storage. Failures are logged, never thrown. Each delete runs
+   * inside its own promise, so a hook that throws synchronously is settled like
+   * a rejection: it neither fails an already committed delete nor skips the
+   * remaining objects.
+   *
+   * @param urls - `screenshotUrl` values of removed rows or of a discarded upload.
+   * @param context - Identifiers added to the log lines (never payload data).
+   */
+  async discardScreenshots(urls, context = {}) {
+    const remove = this.screenshotStorage?.delete?.bind(this.screenshotStorage);
+    if (!remove) return;
+    const candidates = [...new Set(urls.filter(isUploadedScreenshotUrl))];
+    if (candidates.length === 0) return;
+    let referenced;
+    try {
+      referenced = await this.findReferencedScreenshotUrls(candidates);
+    } catch (lookupError) {
+      this.logger.warn(
+        `${DRIZZLE_STORE_MESSAGE_PREFIX}: screenshot references could not be checked \u2014 screenshots kept`,
+        { ...context, screenshotUrls: candidates, error: lookupError }
+      );
+      return;
+    }
+    const unreferenced = candidates.filter((url) => !referenced.has(url));
+    const results = await settleWithConcurrencyLimit(
+      unreferenced,
+      SCREENSHOT_DELETE_CONCURRENCY,
+      async (url) => remove(url)
+    );
+    results.forEach((result, index) => {
+      if (result.status === "rejected") {
+        this.logger.warn(`${DRIZZLE_STORE_MESSAGE_PREFIX}: screenshotStorage.delete failed \u2014 object left in place`, {
+          ...context,
+          screenshotUrl: unreferenced[index],
+          error: result.reason
+        });
+      }
+    });
+  }
+  /**
+   * The URLs among `screenshotUrls` that a stored row still references, looked
+   * up in batches of {@link SCREENSHOT_REFERENCE_LOOKUP_BATCH_SIZE}.
+   *
+   * @param screenshotUrls - Distinct uploaded screenshot URLs.
+   */
+  async findReferencedScreenshotUrls(screenshotUrls) {
+    const referenced = /* @__PURE__ */ new Set();
+    for (let start = 0; start < screenshotUrls.length; start += SCREENSHOT_REFERENCE_LOOKUP_BATCH_SIZE) {
+      const batch = screenshotUrls.slice(start, start + SCREENSHOT_REFERENCE_LOOKUP_BATCH_SIZE);
+      for (const url of await this.gateway.findReferencedScreenshotUrls(batch)) referenced.add(url);
+    }
+    return referenced;
+  }
+};
+
+// src/constants/search.ts
+var LIKE_ESCAPE_CHARACTER = "\\";
+var LIKE_SPECIAL_CHARACTERS = /[\\%_]/g;
+var FOLDED_TEXT_LIKE_OPERATOR = "LIKE";
+var CASE_INSENSITIVE_LIKE_OPERATOR = {
+  postgres: "ILIKE",
+  sqlite: "LIKE"
+};
+
+// src/constants/sql.ts
+var GREATEST_VALUE_FUNCTION = {
+  postgres: "GREATEST",
+  sqlite: "MAX"
+};
+var INSERTED_FEEDBACK_CTE_ALIAS = "siteping_inserted_feedback";
+var INSERTED_ANNOTATIONS_CTE_ALIAS = "siteping_inserted_annotations";
+var VALUES_LIST_ALIAS = "siteping_values";
+var POSTGRES_IDENTIFIER_MAX_BYTES = 63;
+
+// src/shared/comments.ts
+import { sql } from "drizzle-orm";
+function guardedCommentInsert({ feedbacks, comments }, comment, maxComments) {
+  const inThread = sql`${comments.feedbackId} = ${comment.feedbackId}`;
+  const exists = sql`EXISTS (SELECT 1 FROM ${feedbacks} WHERE ${feedbacks.id} = ${comment.feedbackId})`;
+  return {
+    values: {
+      ...comment,
+      position: sql`(SELECT COALESCE(MAX(${comments.position}) + 1, 0) FROM ${comments} WHERE ${inThread})`
+    },
+    condition: comment.authorRole === "client" ? sql`${exists} AND (SELECT COUNT(*) FROM ${comments} WHERE ${inThread} AND ${comments.authorRole} = 'client') < ${maxComments}` : exists
+  };
+}
+
+// src/shared/deletes.ts
+import { sql as sql2 } from "drizzle-orm";
+function uploadedScreenshotUrl(screenshotUrl) {
+  return sql2`CASE WHEN ${screenshotUrl} LIKE ${INLINE_SCREENSHOT_URL_LIKE_PATTERN} THEN NULL ELSE ${screenshotUrl} END`;
+}
+function deletedFeedbackColumns(columns, { collectScreenshotUrls }) {
+  return collectScreenshotUrls ? { id: columns.id, screenshotUrl: uploadedScreenshotUrl(columns.screenshotUrl) } : { id: columns.id };
+}
+function toDeletedFeedbacks(rows) {
+  return {
+    deletedCount: rows.length,
+    screenshotUrls: rows.flatMap(
+      (row) => "screenshotUrl" in row ? [typeof row.screenshotUrl === "string" ? row.screenshotUrl : null] : []
+    )
+  };
+}
+
+// src/shared/feedbacks.ts
+import { desc } from "drizzle-orm";
+function feedbackRecordColumns(columns) {
+  const { creationSequence: _creationSequence, messageSearch: _messageSearch, ...recordColumns2 } = columns;
+  return recordColumns2;
+}
+function newestFeedbackFirst(createdAt, insertionOrder) {
+  return [desc(createdAt), desc(insertionOrder)];
+}
+
+// src/shared/filters.ts
+import { and, eq, inArray, isNull, sql as sql3 } from "drizzle-orm";
+function toContainsPattern(search) {
+  const escaped = search.replace(LIKE_SPECIAL_CHARACTERS, (character) => `${LIKE_ESCAPE_CHARACTER}${character}`);
+  return `%${escaped}%`;
+}
+function toSearchableText(text) {
+  return text.toLowerCase();
+}
+function containsCondition(target, likeOperator, search) {
+  return sql3`${target} ${sql3.raw(likeOperator)} ${toContainsPattern(search)} ESCAPE ${LIKE_ESCAPE_CHARACTER}`;
+}
+function withSearchableMessage(feedback) {
+  return { ...feedback, messageSearch: toSearchableText(feedback.message) };
+}
+function messageContainsCondition(columns, fallbackLikeOperator, search) {
+  const foldedSearch = toSearchableText(search);
+  const foldedMatch = containsCondition(columns.messageSearch, FOLDED_TEXT_LIKE_OPERATOR, foldedSearch);
+  const fallbackMatch = containsCondition(columns.message, fallbackLikeOperator, foldedSearch);
+  return sql3`(${foldedMatch} OR (${isNull(columns.messageSearch)} AND ${fallbackMatch}))`;
+}
+function buildFeedbackWhere(columns, filter, fallbackLikeOperator) {
+  const conditions = [eq(columns.projectName, filter.projectName)];
+  if (filter.type) conditions.push(eq(columns.type, filter.type));
+  if (filter.statuses) conditions.push(inArray(columns.status, [...filter.statuses]));
+  if (filter.url) conditions.push(eq(columns.url, filter.url));
+  if (filter.urlPattern) conditions.push(eq(columns.urlPattern, filter.urlPattern));
+  if (filter.search) conditions.push(messageContainsCondition(columns, fallbackLikeOperator, filter.search));
+  return and(...conditions);
+}
+
+// src/shared/rows.ts
+import { getTableColumns, is, SQL, sql as sql4 } from "drizzle-orm";
+var keepParamAsIs = (param) => param;
+function recordColumns(columns) {
+  const { position: _position, ...record } = columns;
+  return record;
+}
+function selectValues(table, rows, condition, encodeParam = keepParamAsIs) {
+  const columns = Object.entries(getTableColumns(table));
+  const tuples = rows.map((row) => {
+    const values = columns.map(([key, column]) => {
+      const value = row[key];
+      return is(value, SQL) ? value : encodeParam(sql4`${sql4.param(value ?? null, column)}`, column);
+    });
+    return sql4`(${sql4.join(values, sql4`, `)})`;
+  });
+  return sql4`SELECT * FROM (VALUES ${sql4.join(tuples, sql4`, `)}) AS ${sql4.identifier(VALUES_LIST_ALIAS)} WHERE ${condition}`;
+}
+
+// src/shared/timestamps.ts
+import { sql as sql5 } from "drizzle-orm";
+function monotonicUpdatedAt(table, updatedAt, greatestFunction) {
+  return sql5`${sql5.raw(greatestFunction)}(${sql5.param(updatedAt, table.updatedAt)}, ${table.createdAt}, ${table.updatedAt})`;
+}
+
+export {
+  primaryOf,
+  StoreNotFoundError,
+  StoreDuplicateError,
+  StorePersistenceError,
+  StoreLimitError,
+  isStorePersistence,
+  DRIZZLE_STORE_MESSAGE_PREFIX,
+  DrizzleSitepingStore,
+  CASE_INSENSITIVE_LIKE_OPERATOR,
+  GREATEST_VALUE_FUNCTION,
+  INSERTED_FEEDBACK_CTE_ALIAS,
+  INSERTED_ANNOTATIONS_CTE_ALIAS,
+  POSTGRES_IDENTIFIER_MAX_BYTES,
+  guardedCommentInsert,
+  deletedFeedbackColumns,
+  toDeletedFeedbacks,
+  feedbackRecordColumns,
+  newestFeedbackFirst,
+  withSearchableMessage,
+  buildFeedbackWhere,
+  recordColumns,
+  selectValues,
+  monotonicUpdatedAt
+};
+//# sourceMappingURL=chunk-6G6UAERF.js.map