@open-mercato/core 0.8.1-develop.7296.1.2111d779db → 0.8.1-develop.7441.1.b42958b98c

package/dist/modules/catalog/lib/bulkCreateCategories.js

@@ -0,0 +1,237 @@
+import { CatalogProductCategory } from "../data/entities.js";
+import { rebuildCategoryHierarchyForOrganization } from "./categoryHierarchy.js";
+import {
+  MAX_CHECKPOINTED_FAILURES,
+  buildFirstRowIndexByKey,
+  encodePriorKeyRows,
+  findRecordCreatedByPreviousAttempt,
+  readCheckpoint,
+  readCheckpointInterval
+} from "./bulkCreateCheckpoint.js";
+const CATALOG_CATEGORY_BULK_CREATE_QUEUE = "catalog-category-bulk-create";
+import { getCatalogQueue } from "./catalogQueue.js";
+function buildCommandContext(scope, container) {
+  return {
+    container,
+    auth: null,
+    organizationScope: {
+      selectedId: scope.organizationId,
+      filterIds: [scope.organizationId],
+      allowedIds: [scope.organizationId],
+      tenantId: scope.tenantId
+    },
+    selectedOrganizationId: scope.organizationId,
+    organizationIds: [scope.organizationId],
+    // The per-row `catalog.categories.create` command normally rebuilds the whole organization's
+    // category tree on every call. At this endpoint's own 10,000-row cap that is O(n^2) — a full
+    // scan-and-rewrite of every category per row. Deferred here to exactly one rebuild after the
+    // batch (see the `finally` block below), which this context is required to run per
+    // `BulkImportSuppression.skipDerivedRebuild`'s contract.
+    bulkImport: { skipDerivedRebuild: true }
+  };
+}
+function normalizeSlugForLookup(slug) {
+  if (typeof slug !== "string") return null;
+  const trimmed = slug.trim().toLowerCase();
+  return trimmed.length ? trimmed : null;
+}
+function slugKey(slug) {
+  return `slug:${slug}`;
+}
+function naturalKeysOfRow(row) {
+  const slug = normalizeSlugForLookup(row.slug ?? null);
+  return slug ? [slugKey(slug)] : [];
+}
+function naturalKeyOfRow(row) {
+  return naturalKeysOfRow(row)[0] ?? null;
+}
+async function createCatalogCategoriesWithProgress(params) {
+  const { container, progressJobId, items, scope } = params;
+  const commandBus = container.resolve("commandBus");
+  const progressService = container.resolve("progressService");
+  const em = container.resolve("em");
+  const progressContext = {
+    tenantId: scope.tenantId,
+    organizationId: scope.organizationId,
+    userId: scope.userId
+  };
+  const existingJob = await progressService.getJob(progressJobId, progressContext);
+  const priorCheckpoint = readCheckpoint(existingJob?.meta);
+  const checkpointInterval = readCheckpointInterval(existingJob?.meta);
+  const startIndex = priorCheckpoint.lastCompletedRowIndex + 1;
+  await progressService.startJob(progressJobId, progressContext);
+  const distinctSlugs = Array.from(new Set(
+    items.map((item) => normalizeSlugForLookup(item.slug ?? null)).filter((value) => value !== null)
+  ));
+  const distinctParentIds = Array.from(new Set(
+    items.map((item) => item.parentId ? String(item.parentId) : null).filter((value) => value !== null)
+  ));
+  const existingKeyIds = /* @__PURE__ */ new Map();
+  const existingSlugs = /* @__PURE__ */ new Set();
+  if (distinctSlugs.length) {
+    const rows = await em.find(CatalogProductCategory, {
+      slug: { $in: distinctSlugs },
+      organizationId: scope.organizationId,
+      tenantId: scope.tenantId,
+      deletedAt: null
+    });
+    for (const category of rows) {
+      const slug = category.slug;
+      existingSlugs.add(slug);
+      existingKeyIds.set(slugKey(slug), category.id);
+    }
+  }
+  const existingParentIds = distinctParentIds.length ? new Set(
+    (await em.find(CatalogProductCategory, {
+      id: { $in: distinctParentIds },
+      organizationId: scope.organizationId,
+      tenantId: scope.tenantId,
+      deletedAt: null
+    })).map((category) => category.id)
+  ) : /* @__PURE__ */ new Set();
+  const isFirstAttempt = priorCheckpoint.priorKeyRows === null;
+  const priorKeyRowIndices = [];
+  if (isFirstAttempt) {
+    items.forEach((item, index) => {
+      if (naturalKeysOfRow(item).some((key) => existingKeyIds.has(key))) priorKeyRowIndices.push(index);
+    });
+  }
+  await progressService.updateProgress(
+    progressJobId,
+    {
+      totalCount: items.length,
+      processedCount: startIndex,
+      ...isFirstAttempt ? { meta: { priorKeyRows: encodePriorKeyRows(priorKeyRowIndices, items.length) } } : {}
+    },
+    progressContext
+  );
+  const resumeIndex = {
+    priorKeyRows: priorCheckpoint.priorKeyRows,
+    existingKeyIds,
+    firstRowIndexByKey: buildFirstRowIndexByKey(items, naturalKeysOfRow)
+  };
+  const reclaimedIds = /* @__PURE__ */ new Set();
+  const commandContext = buildCommandContext(scope, container);
+  const createdIds = [...priorCheckpoint.createdIds];
+  const failedItems = [...priorCheckpoint.failedItems];
+  let createdCount = priorCheckpoint.createdCount;
+  let failedCount = priorCheckpoint.failedCount;
+  const recordFailure = (failure) => {
+    failedItems.push(failure);
+    failedCount += 1;
+  };
+  const buildSummary = () => ({
+    createdCount,
+    failedCount,
+    createdIds,
+    failedItems
+  });
+  const checkpoint = async (index) => {
+    const processedCount = index + 1;
+    if (processedCount % checkpointInterval === 0 || processedCount === items.length) {
+      await progressService.updateProgress(
+        progressJobId,
+        {
+          processedCount,
+          meta: {
+            lastCompletedRowIndex: index,
+            checkpointSummary: {
+              createdCount,
+              failedCount,
+              failedItems: failedItems.slice(0, MAX_CHECKPOINTED_FAILURES)
+            }
+          }
+        },
+        progressContext
+      );
+    }
+  };
+  try {
+    for (let index = startIndex; index < items.length; index += 1) {
+      if ((index - startIndex) % checkpointInterval === 0) {
+        const cancelled = await progressService.isCancellationRequested(
+          progressJobId,
+          scope.tenantId,
+          scope.organizationId
+        );
+        if (cancelled) {
+          const partialSummary = buildSummary();
+          await progressService.updateProgress(
+            progressJobId,
+            { meta: { resultSummary: partialSummary } },
+            progressContext
+          );
+          await progressService.markCancelled(progressJobId, progressContext);
+          return partialSummary;
+        }
+      }
+      const row = items[index];
+      const slug = normalizeSlugForLookup(row.slug ?? null);
+      const reclaimedId = findRecordCreatedByPreviousAttempt(resumeIndex, index, naturalKeyOfRow(row), reclaimedIds);
+      if (reclaimedId) {
+        reclaimedIds.add(reclaimedId);
+        createdIds.push(reclaimedId);
+        createdCount += 1;
+        await checkpoint(index);
+        continue;
+      }
+      if (slug && existingSlugs.has(slug)) {
+        recordFailure({
+          index,
+          name: row.name,
+          code: "slug_taken",
+          message: "Category slug already exists for this organization."
+        });
+        await checkpoint(index);
+        continue;
+      }
+      if (row.parentId && !existingParentIds.has(String(row.parentId))) {
+        recordFailure({
+          index,
+          name: row.name,
+          code: "parent_not_found",
+          message: "Parent category not found or inaccessible."
+        });
+        await checkpoint(index);
+        continue;
+      }
+      try {
+        const { result } = await commandBus.execute("catalog.categories.create", {
+          input: { ...row, organizationId: scope.organizationId, tenantId: scope.tenantId },
+          ctx: commandContext
+        });
+        if (result?.categoryId) {
+          createdIds.push(result.categoryId);
+          createdCount += 1;
+          if (slug) existingSlugs.add(slug);
+        } else {
+          recordFailure({
+            index,
+            name: row.name,
+            code: "command_failed",
+            message: "Category creation returned no category id."
+          });
+        }
+      } catch (error) {
+        recordFailure({
+          index,
+          name: row.name,
+          code: "command_failed",
+          message: error instanceof Error ? error.message : "Category creation failed"
+        });
+      }
+      await checkpoint(index);
+    }
+    const summary = buildSummary();
+    await progressService.completeJob(progressJobId, { resultSummary: summary }, progressContext);
+    return summary;
+  } finally {
+    await rebuildCategoryHierarchyForOrganization(em, scope.organizationId, scope.tenantId);
+  }
+}
+export {
+  CATALOG_CATEGORY_BULK_CREATE_QUEUE,
+  createCatalogCategoriesWithProgress,
+  getCatalogQueue
+};
+//# sourceMappingURL=bulkCreateCategories.js.map

package/dist/modules/catalog/lib/bulkCreateCategories.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/modules/catalog/lib/bulkCreateCategories.ts"],
+  "sourcesContent": ["import type { AwilixContainer } from 'awilix'\nimport type { EntityManager } from '@mikro-orm/postgresql'\nimport type { CommandBus, CommandRuntimeContext } from '@open-mercato/shared/lib/commands'\nimport { CatalogProductCategory } from '../data/entities'\nimport type { CategoryBulkCreateRow } from '../data/validators'\nimport type { ProgressService, ProgressServiceContext } from '../../progress/lib/progressService'\nimport { rebuildCategoryHierarchyForOrganization } from './categoryHierarchy'\nimport {\n  MAX_CHECKPOINTED_FAILURES,\n  buildFirstRowIndexByKey,\n  encodePriorKeyRows,\n  findRecordCreatedByPreviousAttempt,\n  readCheckpoint,\n  readCheckpointInterval,\n} from './bulkCreateCheckpoint'\n\nexport const CATALOG_CATEGORY_BULK_CREATE_QUEUE = 'catalog-category-bulk-create'\n\nexport { getCatalogQueue } from './catalogQueue'\n\nexport type CatalogCategoryBulkCreateFailureCode = 'slug_taken' | 'parent_not_found' | 'command_failed'\n\nexport type CatalogCategoryBulkCreateScope = {\n  organizationId: string\n  tenantId: string\n  userId?: string | null\n}\n\nexport type CatalogCategoryBulkCreateJobPayload = {\n  progressJobId: string\n  items: CategoryBulkCreateRow[]\n  scope: CatalogCategoryBulkCreateScope\n}\n\nexport type CatalogCategoryBulkCreateFailure = {\n  index: number\n  name?: string\n  code: CatalogCategoryBulkCreateFailureCode\n  message: string\n}\n\nexport type CatalogCategoryBulkCreateSummary = {\n  createdCount: number\n  failedCount: number\n  /**\n   * Not a complete list on a resumed run: it covers the rows the final attempt handled, while\n   * `createdCount` covers the whole batch. Iterate it for the ids it does carry, never as a\n   * substitute for `createdCount`.\n   */\n  createdIds: string[]\n  failedItems: CatalogCategoryBulkCreateFailure[]\n}\n\nfunction buildCommandContext(\n  scope: CatalogCategoryBulkCreateScope,\n  container: AwilixContainer,\n): CommandRuntimeContext {\n  return {\n    container,\n    auth: null,\n    organizationScope: {\n      selectedId: scope.organizationId,\n      filterIds: [scope.organizationId],\n      allowedIds: [scope.organizationId],\n      tenantId: scope.tenantId,\n    },\n    selectedOrganizationId: scope.organizationId,\n    organizationIds: [scope.organizationId],\n    // The per-row `catalog.categories.create` command normally rebuilds the whole organization's\n    // category tree on every call. At this endpoint's own 10,000-row cap that is O(n^2) \u2014 a full\n    // scan-and-rewrite of every category per row. Deferred here to exactly one rebuild after the\n    // batch (see the `finally` block below), which this context is required to run per\n    // `BulkImportSuppression.skipDerivedRebuild`'s contract.\n    bulkImport: { skipDerivedRebuild: true },\n  }\n}\n\nfunction normalizeSlugForLookup(slug?: string | null): string | null {\n  if (typeof slug !== 'string') return null\n  const trimmed = slug.trim().toLowerCase()\n  return trimmed.length ? trimmed : null\n}\n\nfunction slugKey(slug: string): string {\n  return `slug:${slug}`\n}\n\n/**\n * Every key the row's category could be found under \u2014 only its slug. `name` + `parentId` is\n * deliberately absent: `CatalogProductCategory` carries no uniqueness on `name`, so matching on it\n * would let one row claim an unrelated category and silently drop itself from the batch.\n */\nfunction naturalKeysOfRow(row: CategoryBulkCreateRow): string[] {\n  const slug = normalizeSlugForLookup(row.slug ?? null)\n  return slug ? [slugKey(slug)] : []\n}\n\n/** The one key a row's record is reclaimed under on a resumed attempt. */\nfunction naturalKeyOfRow(row: CategoryBulkCreateRow): string | null {\n  return naturalKeysOfRow(row)[0] ?? null\n}\n\nexport async function createCatalogCategoriesWithProgress(params: {\n  container: AwilixContainer\n  progressJobId: string\n  items: CategoryBulkCreateRow[]\n  scope: CatalogCategoryBulkCreateScope\n}): Promise<CatalogCategoryBulkCreateSummary> {\n  const { container, progressJobId, items, scope } = params\n  const commandBus = container.resolve('commandBus') as CommandBus\n  const progressService = container.resolve('progressService') as ProgressService\n  const em = container.resolve('em') as EntityManager\n  const progressContext: ProgressServiceContext = {\n    tenantId: scope.tenantId,\n    organizationId: scope.organizationId,\n    userId: scope.userId,\n  }\n\n  const existingJob = await progressService.getJob(progressJobId, progressContext)\n  const priorCheckpoint = readCheckpoint<CatalogCategoryBulkCreateFailure>(existingJob?.meta)\n  const checkpointInterval = readCheckpointInterval(existingJob?.meta)\n  const startIndex = priorCheckpoint.lastCompletedRowIndex + 1\n\n  await progressService.startJob(progressJobId, progressContext)\n\n  // Batch pre-validation: fail rows referencing an already-taken slug or a missing parent before\n  // ever calling the command, saving a DB round-trip for rows that are provably invalid up front.\n  // The slug query also produces the key -> id map a resumed attempt uses to reclaim the records\n  // an interrupted attempt already created, so resume costs no extra query.\n  const distinctSlugs = Array.from(new Set(\n    items\n      .map((item) => normalizeSlugForLookup(item.slug ?? null))\n      .filter((value): value is string => value !== null),\n  ))\n  const distinctParentIds = Array.from(new Set(\n    items\n      .map((item) => (item.parentId ? String(item.parentId) : null))\n      .filter((value): value is string => value !== null),\n  ))\n  const existingKeyIds = new Map<string, string>()\n  const existingSlugs = new Set<string>()\n  if (distinctSlugs.length) {\n    const rows = await em.find(CatalogProductCategory, {\n      slug: { $in: distinctSlugs },\n      organizationId: scope.organizationId,\n      tenantId: scope.tenantId,\n      deletedAt: null,\n    })\n    for (const category of rows) {\n      const slug = category.slug as string\n      existingSlugs.add(slug)\n      existingKeyIds.set(slugKey(slug), category.id)\n    }\n  }\n  const existingParentIds = distinctParentIds.length\n    ? new Set(\n      (await em.find(CatalogProductCategory, {\n        id: { $in: distinctParentIds },\n        organizationId: scope.organizationId,\n        tenantId: scope.tenantId,\n        deletedAt: null,\n      })).map((category) => category.id),\n    )\n    : new Set<string>()\n\n  // Recorded once, on the attempt that starts from row 0, and read back verbatim by every later\n  // attempt: after rows have been created the database can no longer tell which slugs predate the\n  // job. This write rides the attempt's first `updateProgress`, which always persists (a fresh\n  // throttle entry has no last-persisted timestamp to throttle against), so it is durable before\n  // any row is created.\n  const isFirstAttempt = priorCheckpoint.priorKeyRows === null\n  const priorKeyRowIndices: number[] = []\n  if (isFirstAttempt) {\n    items.forEach((item, index) => {\n      if (naturalKeysOfRow(item).some((key) => existingKeyIds.has(key))) priorKeyRowIndices.push(index)\n    })\n  }\n  await progressService.updateProgress(\n    progressJobId,\n    {\n      totalCount: items.length,\n      processedCount: startIndex,\n      ...(isFirstAttempt ? { meta: { priorKeyRows: encodePriorKeyRows(priorKeyRowIndices, items.length) } } : {}),\n    },\n    progressContext,\n  )\n\n  const resumeIndex = {\n    priorKeyRows: priorCheckpoint.priorKeyRows,\n    existingKeyIds,\n    firstRowIndexByKey: buildFirstRowIndexByKey(items, naturalKeysOfRow),\n  }\n  const reclaimedIds = new Set<string>()\n\n  const commandContext = buildCommandContext(scope, container)\n  // Seeded from the previous attempt's checkpoint so a resumed run's summary covers the whole\n  // batch. Counting only from `startIndex` would silently drop every row completed before the\n  // last durable checkpoint, reporting e.g. 40 created for a 100-row batch that fully succeeded.\n  const createdIds: string[] = [...priorCheckpoint.createdIds]\n  const failedItems: CatalogCategoryBulkCreateFailure[] = [...priorCheckpoint.failedItems]\n  let createdCount = priorCheckpoint.createdCount\n  let failedCount = priorCheckpoint.failedCount\n\n  const recordFailure = (failure: CatalogCategoryBulkCreateFailure) => {\n    failedItems.push(failure)\n    failedCount += 1\n  }\n\n  const buildSummary = (): CatalogCategoryBulkCreateSummary => ({\n    createdCount,\n    failedCount,\n    createdIds,\n    failedItems,\n  })\n\n  const checkpoint = async (index: number) => {\n    const processedCount = index + 1\n    if (processedCount % checkpointInterval === 0 || processedCount === items.length) {\n      await progressService.updateProgress(\n        progressJobId,\n        {\n          processedCount,\n          meta: {\n            lastCompletedRowIndex: index,\n            checkpointSummary: {\n              createdCount,\n              failedCount,\n              failedItems: failedItems.slice(0, MAX_CHECKPOINTED_FAILURES),\n            },\n          },\n        },\n        progressContext,\n      )\n    }\n  }\n\n  try {\n    for (let index = startIndex; index < items.length; index += 1) {\n      // Polled at the head of the iteration so a cancel is honored even when every remaining row\n      // is rejected by pre-validation, and only on the checkpoint boundary: this is an\n      // identity-map-bypassing read (`isCancellationRequested` uses `disableIdentityMap`), so a\n      // per-row poll would add one uncached query per row on top of the command's own work.\n      // Cancellation therefore lands within at most `checkpointInterval` rows.\n      if ((index - startIndex) % checkpointInterval === 0) {\n        const cancelled = await progressService.isCancellationRequested(\n          progressJobId,\n          scope.tenantId,\n          scope.organizationId,\n        )\n        if (cancelled) {\n          const partialSummary = buildSummary()\n          await progressService.updateProgress(\n            progressJobId,\n            { meta: { resultSummary: partialSummary } },\n            progressContext,\n          )\n          await progressService.markCancelled(progressJobId, progressContext)\n          return partialSummary\n        }\n      }\n\n      const row = items[index]\n      const slug = normalizeSlugForLookup(row.slug ?? null)\n\n      // Reclaims a record an interrupted attempt of this job already created for this exact row,\n      // so it is neither duplicated nor reported as a conflict against itself. Every other row\n      // falls through to the normal path, including rows the classifier cannot speak for.\n      const reclaimedId = findRecordCreatedByPreviousAttempt(resumeIndex, index, naturalKeyOfRow(row), reclaimedIds)\n      if (reclaimedId) {\n        reclaimedIds.add(reclaimedId)\n        createdIds.push(reclaimedId)\n        createdCount += 1\n        await checkpoint(index)\n        continue\n      }\n\n      if (slug && existingSlugs.has(slug)) {\n        recordFailure({\n          index,\n          name: row.name,\n          code: 'slug_taken',\n          message: 'Category slug already exists for this organization.',\n        })\n        await checkpoint(index)\n        continue\n      }\n      if (row.parentId && !existingParentIds.has(String(row.parentId))) {\n        recordFailure({\n          index,\n          name: row.name,\n          code: 'parent_not_found',\n          message: 'Parent category not found or inaccessible.',\n        })\n        await checkpoint(index)\n        continue\n      }\n\n      try {\n        const { result } = await commandBus.execute<\n          CategoryBulkCreateRow & { organizationId: string; tenantId: string },\n          { categoryId: string }\n        >('catalog.categories.create', {\n          input: { ...row, organizationId: scope.organizationId, tenantId: scope.tenantId },\n          ctx: commandContext,\n        })\n        if (result?.categoryId) {\n          createdIds.push(result.categoryId)\n          createdCount += 1\n          if (slug) existingSlugs.add(slug)\n        } else {\n          // Recorded rather than dropped so `createdCount + failedCount` always accounts for\n          // every row in the batch.\n          recordFailure({\n            index,\n            name: row.name,\n            code: 'command_failed',\n            message: 'Category creation returned no category id.',\n          })\n        }\n      } catch (error) {\n        recordFailure({\n          index,\n          name: row.name,\n          code: 'command_failed',\n          message: error instanceof Error ? error.message : 'Category creation failed',\n        })\n      }\n\n      await checkpoint(index)\n    }\n\n    const summary = buildSummary()\n    await progressService.completeJob(progressJobId, { resultSummary: summary }, progressContext)\n    return summary\n  } finally {\n    // The per-row command deferred its own rebuild (`bulkImport.skipDerivedRebuild`); this is the\n    // one rebuild it is owed, run exactly once regardless of which path above returned or threw \u2014\n    // including an exception that propagates to the worker's `failJob` catch. Unconditional\n    // rather than gated on \"did this attempt write a row\": a hard-killed earlier attempt can\n    // leave rows created but unrebuilt without reaching its own `finally`, and a resumed attempt\n    // that happens to create nothing new (already-reclaimed batch tail) must still heal that\n    // state rather than leave it stale indefinitely. One rebuild per invocation stays O(n) over\n    // the whole batch, so this cannot reintroduce the per-row O(n^2) cost it replaces. Reuses the\n    // same `em` the pre-validation queries above already read through, same as every other read\n    // in this function \u2014 the per-row commands each fork their own, so this one never accumulates\n    // their identity-map entries.\n    await rebuildCategoryHierarchyForOrganization(em, scope.organizationId, scope.tenantId)\n  }\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/modules/catalog/lib/bulkCreateCheckpoint.js

@@ -0,0 +1,82 @@
+const DEFAULT_CHECKPOINT_INTERVAL = 20;
+const MAX_CHECKPOINTED_FAILURES = 200;
+const BITS_PER_BYTE = 8;
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function readStringArray(value) {
+  return Array.isArray(value) ? value.filter((entry) => typeof entry === "string") : [];
+}
+function encodePriorKeyRows(rowIndices, rowCount) {
+  const bytes = new Uint8Array(Math.ceil(Math.max(rowCount, 0) / BITS_PER_BYTE));
+  for (const rowIndex of rowIndices) {
+    if (!Number.isInteger(rowIndex) || rowIndex < 0 || rowIndex >= rowCount) continue;
+    bytes[Math.floor(rowIndex / BITS_PER_BYTE)] |= 1 << rowIndex % BITS_PER_BYTE;
+  }
+  return Buffer.from(bytes).toString("base64");
+}
+function decodePriorKeyRows(value) {
+  if (typeof value !== "string") return null;
+  const bytes = Buffer.from(value, "base64");
+  const rowIndices = /* @__PURE__ */ new Set();
+  bytes.forEach((byte, byteIndex) => {
+    for (let bit = 0; bit < BITS_PER_BYTE; bit += 1) {
+      if (byte & 1 << bit) rowIndices.add(byteIndex * BITS_PER_BYTE + bit);
+    }
+  });
+  return rowIndices;
+}
+function readCheckpointInterval(meta) {
+  const raw = isRecord(meta) ? meta.checkpointInterval : void 0;
+  if (typeof raw !== "number" || !Number.isInteger(raw) || raw < 1) return DEFAULT_CHECKPOINT_INTERVAL;
+  return raw;
+}
+function readCheckpoint(meta) {
+  const empty = {
+    lastCompletedRowIndex: -1,
+    createdCount: 0,
+    failedCount: 0,
+    createdIds: [],
+    failedItems: [],
+    priorKeyRows: null
+  };
+  if (!isRecord(meta)) return empty;
+  const priorKeyRows = decodePriorKeyRows(meta.priorKeyRows);
+  const lastCompletedRowIndex = typeof meta.lastCompletedRowIndex === "number" && Number.isInteger(meta.lastCompletedRowIndex) ? meta.lastCompletedRowIndex : -1;
+  if (lastCompletedRowIndex < 0) return { ...empty, priorKeyRows };
+  const summary = isRecord(meta.checkpointSummary) ? meta.checkpointSummary : null;
+  if (!summary) return { ...empty, lastCompletedRowIndex, priorKeyRows };
+  const createdIds = readStringArray(summary.createdIds);
+  const failedItems = Array.isArray(summary.failedItems) ? summary.failedItems.filter(isRecord) : [];
+  const createdCount = typeof summary.createdCount === "number" && Number.isInteger(summary.createdCount) ? summary.createdCount : createdIds.length;
+  const failedCount = typeof summary.failedCount === "number" && Number.isInteger(summary.failedCount) ? summary.failedCount : failedItems.length;
+  return { lastCompletedRowIndex, createdCount, failedCount, createdIds, failedItems, priorKeyRows };
+}
+function buildFirstRowIndexByKey(items, naturalKeysOf) {
+  const firstRowIndexByKey = /* @__PURE__ */ new Map();
+  items.forEach((item, index) => {
+    for (const key of naturalKeysOf(item)) {
+      if (!firstRowIndexByKey.has(key)) firstRowIndexByKey.set(key, index);
+    }
+  });
+  return firstRowIndexByKey;
+}
+function findRecordCreatedByPreviousAttempt(index, rowIndex, naturalKey, alreadyReclaimedIds) {
+  if (naturalKey === null || index.priorKeyRows === null) return null;
+  if (index.priorKeyRows.has(rowIndex)) return null;
+  if (index.firstRowIndexByKey.get(naturalKey) !== rowIndex) return null;
+  const recordId = index.existingKeyIds.get(naturalKey);
+  if (recordId === void 0 || alreadyReclaimedIds.has(recordId)) return null;
+  return recordId;
+}
+export {
+  DEFAULT_CHECKPOINT_INTERVAL,
+  MAX_CHECKPOINTED_FAILURES,
+  buildFirstRowIndexByKey,
+  decodePriorKeyRows,
+  encodePriorKeyRows,
+  findRecordCreatedByPreviousAttempt,
+  readCheckpoint,
+  readCheckpointInterval
+};
+//# sourceMappingURL=bulkCreateCheckpoint.js.map

package/dist/modules/catalog/lib/bulkCreateCheckpoint.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/modules/catalog/lib/bulkCreateCheckpoint.ts"],
+  "sourcesContent": ["export const DEFAULT_CHECKPOINT_INTERVAL = 20\n\n/**\n * Upper bound on the failure detail carried in `ProgressJob.meta`. `meta` is rewritten on every\n * checkpoint and is part of every broadcast job payload, so an uncapped list would grow the\n * persisted row (and the SSE frame every subscribed progress bar receives) with the batch.\n * `checkpointSummary.failedCount` stays exact regardless of the cap.\n */\nexport const MAX_CHECKPOINTED_FAILURES = 200\n\nconst BITS_PER_BYTE = 8\n\nexport type BulkCreateCheckpoint<TFailure> = {\n  lastCompletedRowIndex: number\n  createdCount: number\n  failedCount: number\n  createdIds: string[]\n  failedItems: TFailure[]\n  /**\n   * The rows whose natural key already existed in the database when this job's first attempt\n   * started, or `null` for a job checkpointed before this field existed. A resumed attempt uses it\n   * to tell a record a previous attempt of this job created from one that was there all along;\n   * without it no such classification is possible and every existing key is a genuine conflict.\n   */\n  priorKeyRows: ReadonlySet<number> | null\n}\n\nfunction isRecord(value: unknown): value is Record<string, unknown> {\n  return typeof value === 'object' && value !== null && !Array.isArray(value)\n}\n\nfunction readStringArray(value: unknown): string[] {\n  return Array.isArray(value) ? value.filter((entry): entry is string => typeof entry === 'string') : []\n}\n\n/**\n * Encodes the snapshot as a base64 bitset over row indices rather than the natural keys\n * themselves. `ProgressJob.meta` is rewritten on every checkpoint and rides every broadcast\n * frame, so the snapshot's size is paid ~`items.length / checkpointInterval` times over: a key\n * list costs the summed length of every conflicting key (hundreds of KB for a large re-import),\n * while one bit per row costs `items.length / 8` bytes whatever the keys look like. The snapshot\n * cannot be capped \u2014 a partial one would let a row claim a record it merely conflicts with \u2014 so\n * it is made small instead.\n */\nexport function encodePriorKeyRows(rowIndices: Iterable<number>, rowCount: number): string {\n  const bytes = new Uint8Array(Math.ceil(Math.max(rowCount, 0) / BITS_PER_BYTE))\n  for (const rowIndex of rowIndices) {\n    if (!Number.isInteger(rowIndex) || rowIndex < 0 || rowIndex >= rowCount) continue\n    bytes[Math.floor(rowIndex / BITS_PER_BYTE)] |= 1 << (rowIndex % BITS_PER_BYTE)\n  }\n  return Buffer.from(bytes).toString('base64')\n}\n\nexport function decodePriorKeyRows(value: unknown): ReadonlySet<number> | null {\n  if (typeof value !== 'string') return null\n  const bytes = Buffer.from(value, 'base64')\n  const rowIndices = new Set<number>()\n  bytes.forEach((byte, byteIndex) => {\n    for (let bit = 0; bit < BITS_PER_BYTE; bit += 1) {\n      if (byte & (1 << bit)) rowIndices.add(byteIndex * BITS_PER_BYTE + bit)\n    }\n  })\n  return rowIndices\n}\n\nexport function readCheckpointInterval(meta: Record<string, unknown> | null | undefined): number {\n  const raw = isRecord(meta) ? meta.checkpointInterval : undefined\n  if (typeof raw !== 'number' || !Number.isInteger(raw) || raw < 1) return DEFAULT_CHECKPOINT_INTERVAL\n  return raw\n}\n\n/**\n * Restores the accumulated batch state a previous attempt persisted, so a resumed run reports\n * a summary covering the whole batch instead of only the rows after the checkpoint. Every field\n * is validated independently: a job whose meta predates this shape, or was hand-edited, resumes\n * from whatever it can prove rather than throwing.\n */\nexport function readCheckpoint<TFailure>(\n  meta: Record<string, unknown> | null | undefined,\n): BulkCreateCheckpoint<TFailure> {\n  const empty: BulkCreateCheckpoint<TFailure> = {\n    lastCompletedRowIndex: -1,\n    createdCount: 0,\n    failedCount: 0,\n    createdIds: [],\n    failedItems: [],\n    priorKeyRows: null,\n  }\n  if (!isRecord(meta)) return empty\n\n  const priorKeyRows = decodePriorKeyRows(meta.priorKeyRows)\n\n  const lastCompletedRowIndex = typeof meta.lastCompletedRowIndex === 'number' && Number.isInteger(meta.lastCompletedRowIndex)\n    ? meta.lastCompletedRowIndex\n    : -1\n  if (lastCompletedRowIndex < 0) return { ...empty, priorKeyRows }\n\n  const summary = isRecord(meta.checkpointSummary) ? meta.checkpointSummary : null\n  if (!summary) return { ...empty, lastCompletedRowIndex, priorKeyRows }\n\n  // `createdIds` is no longer checkpointed (it grew with the batch and was rewritten on every\n  // checkpoint), but a job enqueued before that change can still be mid-flight, so keep reading it.\n  const createdIds = readStringArray(summary.createdIds)\n  const failedItems = Array.isArray(summary.failedItems)\n    ? (summary.failedItems.filter(isRecord) as TFailure[])\n    : []\n  const createdCount = typeof summary.createdCount === 'number' && Number.isInteger(summary.createdCount)\n    ? summary.createdCount\n    : createdIds.length\n  const failedCount = typeof summary.failedCount === 'number' && Number.isInteger(summary.failedCount)\n    ? summary.failedCount\n    : failedItems.length\n\n  return { lastCompletedRowIndex, createdCount, failedCount, createdIds, failedItems, priorKeyRows }\n}\n\nexport type ResumeIndex = {\n  priorKeyRows: ReadonlySet<number> | null\n  existingKeyIds: ReadonlyMap<string, string>\n  firstRowIndexByKey: ReadonlyMap<string, number>\n}\n\n/**\n * Maps each natural key to the first row in the batch that carries it, so a resumed attempt can\n * tell the row that created a record from a later row that merely repeats its key. Every key a\n * row could be identified by is registered, not just the one it is reclaimed under: a record\n * created for a row's SKU is also reachable by that row's handle, and leaving the handle\n * unregistered would let a later handle-only row claim it.\n */\nexport function buildFirstRowIndexByKey<TRow>(\n  items: readonly TRow[],\n  naturalKeysOf: (row: TRow) => readonly string[],\n): Map<string, number> {\n  const firstRowIndexByKey = new Map<string, number>()\n  items.forEach((item, index) => {\n    for (const key of naturalKeysOf(item)) {\n      if (!firstRowIndexByKey.has(key)) firstRowIndexByKey.set(key, index)\n    }\n  })\n  return firstRowIndexByKey\n}\n\n/**\n * Returns the id of the record a previous attempt of this job created for `rowIndex`, or `null`\n * when nothing can be proven and the row must go through the normal creation path.\n *\n * The classification is deliberately conservative \u2014 it never infers one row's outcome from\n * another's, because a row that failed mid-batch leaves nothing behind and would poison any\n * ordering assumption:\n *\n * - Only a resumed attempt reclaims rows at all. The signal is the presence of the snapshot the\n *   first attempt recorded, not the checkpoint cursor: an attempt can persist the snapshot and\n *   then die before any checkpoint lands, and the rows it created in between still have to be\n *   reclaimable.\n * - Only a genuinely unique natural key counts. A row identified by title or name could match an\n *   unrelated record, and skipping it would drop it from the batch entirely.\n * - A row whose key already existed before the first attempt points at somebody else's record: it\n *   is a real conflict and must be reported as one rather than counted as created.\n * - Only the first row carrying a key can claim the record; a later row repeating it is an\n *   intra-batch duplicate and belongs in the conflict path.\n * - A record an earlier row of this batch already claimed is never handed to a second row, so two\n *   rows can never both count the same id as their own creation.\n */\nexport function findRecordCreatedByPreviousAttempt(\n  index: ResumeIndex,\n  rowIndex: number,\n  naturalKey: string | null,\n  alreadyReclaimedIds: ReadonlySet<string>,\n): string | null {\n  if (naturalKey === null || index.priorKeyRows === null) return null\n  if (index.priorKeyRows.has(rowIndex)) return null\n  if (index.firstRowIndexByKey.get(naturalKey) !== rowIndex) return null\n  const recordId = index.existingKeyIds.get(naturalKey)\n  if (recordId === undefined || alreadyReclaimedIds.has(recordId)) return null\n  return recordId\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/modules/catalog/lib/bulkCreateMutationGuards.js

@@ -0,0 +1,39 @@
+import { getAllMutationGuardInstances } from "@open-mercato/shared/lib/crud/mutation-guard-store";
+import {
+  bridgeLegacyGuard,
+  runMutationGuards
+} from "@open-mercato/shared/lib/crud/mutation-guard-registry";
+function resolveUserFeatures(auth) {
+  const features = auth?.features;
+  if (!Array.isArray(features)) return [];
+  return features.filter((value) => typeof value === "string");
+}
+async function runBulkCreateMutationGuards(params) {
+  const legacyGuard = bridgeLegacyGuard(params.container);
+  const guards = [...getAllMutationGuardInstances(), ...legacyGuard ? [legacyGuard] : []];
+  const result = await runMutationGuards(
+    guards,
+    {
+      tenantId: params.tenantId,
+      organizationId: params.organizationId,
+      userId: params.userId,
+      resourceKind: params.resourceKind,
+      resourceId: null,
+      operation: "create",
+      requestMethod: params.request.method,
+      requestHeaders: params.request.headers,
+      mutationPayload: { bulk: true, itemCount: params.itemCount }
+    },
+    { userFeatures: resolveUserFeatures(params.auth) }
+  );
+  if (result.ok) return { ok: true };
+  return {
+    ok: false,
+    body: result.errorBody ?? { error: "[internal] Bulk create blocked by a mutation guard." },
+    status: result.errorStatus ?? 422
+  };
+}
+export {
+  runBulkCreateMutationGuards
+};
+//# sourceMappingURL=bulkCreateMutationGuards.js.map

package/dist/modules/catalog/lib/bulkCreateMutationGuards.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/modules/catalog/lib/bulkCreateMutationGuards.ts"],
+  "sourcesContent": ["import { getAllMutationGuardInstances } from '@open-mercato/shared/lib/crud/mutation-guard-store'\nimport {\n  bridgeLegacyGuard,\n  runMutationGuards,\n} from '@open-mercato/shared/lib/crud/mutation-guard-registry'\nimport type { AwilixContainer } from 'awilix'\n\nexport type BulkCreateGuardDecision =\n  | { ok: true }\n  | { ok: false; body: Record<string, unknown>; status: number }\n\nfunction resolveUserFeatures(auth: unknown): string[] {\n  const features = (auth as { features?: unknown })?.features\n  if (!Array.isArray(features)) return []\n  return features.filter((value): value is string => typeof value === 'string')\n}\n\n/**\n * Runs the registered mutation guards for a bulk-create request before the batch is enqueued,\n * so a guard that would block a single `create` blocks the batch version of the same write.\n *\n * The guarded unit is the batch envelope, not the individual rows: the rows are created later,\n * by a queue worker, from a context that has no request headers and no resource ids to offer a\n * guard. For the same reason `afterSuccess` callbacks are not invoked here \u2014 there is no created\n * record to report at enqueue time, and the request is gone by the time there is one. A guard\n * that needs per-record post-processing has to subscribe to `catalog.product.created` /\n * `catalog.category.created` instead.\n */\nexport async function runBulkCreateMutationGuards(params: {\n  container: AwilixContainer\n  auth: unknown\n  request: Request\n  tenantId: string\n  organizationId: string\n  userId: string\n  resourceKind: string\n  itemCount: number\n}): Promise<BulkCreateGuardDecision> {\n  const legacyGuard = bridgeLegacyGuard(params.container)\n  const guards = [...getAllMutationGuardInstances(), ...(legacyGuard ? [legacyGuard] : [])]\n  const result = await runMutationGuards(\n    guards,\n    {\n      tenantId: params.tenantId,\n      organizationId: params.organizationId,\n      userId: params.userId,\n      resourceKind: params.resourceKind,\n      resourceId: null,\n      operation: 'create',\n      requestMethod: params.request.method,\n      requestHeaders: params.request.headers,\n      mutationPayload: { bulk: true, itemCount: params.itemCount },\n    },\n    { userFeatures: resolveUserFeatures(params.auth) },\n  )\n  if (result.ok) return { ok: true }\n  return {\n    ok: false,\n    body: result.errorBody ?? { error: '[internal] Bulk create blocked by a mutation guard.' },\n    status: result.errorStatus ?? 422,\n  }\n}\n"],
+  "mappings": "AAAA,SAAS,oCAAoC;AAC7C;AAAA,EACE;AAAA,EACA;AAAA,OACK;AAOP,SAAS,oBAAoB,MAAyB;AACpD,QAAM,WAAY,MAAiC;AACnD,MAAI,CAAC,MAAM,QAAQ,QAAQ,EAAG,QAAO,CAAC;AACtC,SAAO,SAAS,OAAO,CAAC,UAA2B,OAAO,UAAU,QAAQ;AAC9E;AAaA,eAAsB,4BAA4B,QASb;AACnC,QAAM,cAAc,kBAAkB,OAAO,SAAS;AACtD,QAAM,SAAS,CAAC,GAAG,6BAA6B,GAAG,GAAI,cAAc,CAAC,WAAW,IAAI,CAAC,CAAE;AACxF,QAAM,SAAS,MAAM;AAAA,IACnB;AAAA,IACA;AAAA,MACE,UAAU,OAAO;AAAA,MACjB,gBAAgB,OAAO;AAAA,MACvB,QAAQ,OAAO;AAAA,MACf,cAAc,OAAO;AAAA,MACrB,YAAY;AAAA,MACZ,WAAW;AAAA,MACX,eAAe,OAAO,QAAQ;AAAA,MAC9B,gBAAgB,OAAO,QAAQ;AAAA,MAC/B,iBAAiB,EAAE,MAAM,MAAM,WAAW,OAAO,UAAU;AAAA,IAC7D;AAAA,IACA,EAAE,cAAc,oBAAoB,OAAO,IAAI,EAAE;AAAA,EACnD;AACA,MAAI,OAAO,GAAI,QAAO,EAAE,IAAI,KAAK;AACjC,SAAO;AAAA,IACL,IAAI;AAAA,IACJ,MAAM,OAAO,aAAa,EAAE,OAAO,sDAAsD;AAAA,IACzF,QAAQ,OAAO,eAAe;AAAA,EAChC;AACF;",
+  "names": []
+}