@porulle/core 0.50.2 → 0.51.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@porulle/core",
-  "version": "0.50.2",
+  "version": "0.51.0",
   "license": "MIT",
   "type": "module",
   "exports": {
@@ -62,8 +62,8 @@
     "eslint": "^9.39.1",
     "typescript": "5.9.2",
     "vitest": "^3.2.4",
-    "@porulle/eslint-config": "0.1.0",
-    "@porulle/typescript-config": "0.1.0"
+    "@porulle/typescript-config": "0.1.0",
+    "@porulle/eslint-config": "0.1.0"
   },
   "publishConfig": {
     "access": "public"

package/src/modules/catalog/import-service.ts

@@ -139,6 +139,9 @@ export interface ImportProductsReport extends Record<string, unknown> {
 
 type Writer = Pick<PluginDb, "insert" | "select">;
 
+/** The drizzle handle a transaction context carries (typed `unknown` on the context). */
+const writerOf = (txCtx: TxContext): PluginDb => txCtx.tx as PluginDb;
+
 type Failure = { code: ImportRowFailureCode; error: string };
 
 function failed(ref: string, code: ImportRowFailureCode, error: string): ImportProductRowResult {
@@ -473,9 +476,18 @@ export class CatalogImportService {
     if (errorPolicy === "reject-everything" && memoryFailures.size > 0) return Ok(rejectAll());
 
     try {
+      const candidates = page.map((item, index) => ({ item, index })).filter(({ index }) => !memoryFailures.has(index));
+      // The shared vocabulary is resolved in its OWN short transaction, never in the page's, and
+      // never in a caller's (no ctx is passed on purpose). Inside the page transaction a newly
+      // inserted tag's unique key stayed uncommitted for the whole page, so every other page naming
+      // it — another store's, or this store's next one — waited on that index until this page
+      // committed: 36.6 s behind one 89 s page on the sim, 2026-09-24. The cost is that a page
+      // rejected afterwards can leave new vocabulary behind; it is organization-wide and reusable.
+      const taxonomy = await this.withTransaction(actor, undefined, (txCtx) =>
+        resolveTaxonomy(writerOf(txCtx), orgId, candidates.map(({ item }) => item)));
+
       const report = await this.withTransaction(actor, ctx, async (txCtx): Promise<ImportProductsReport> => {
-        const tx = txCtx.tx as PluginDb;
-        const candidates = page.map((item, index) => ({ item, index })).filter(({ index }) => !memoryFailures.has(index));
+        const tx = writerOf(txCtx);
 
         // Page-level reads: the slugs already taken, then the shared vocabulary.
         const slugs = candidates.map(({ item }) => item.slug);
@@ -495,7 +507,6 @@ export class CatalogImportService {
         if (errorPolicy === "reject-everything" && writable.length < candidates.length) {
           throw new RejectEverything();
         }
-        const taxonomy = await resolveTaxonomy(tx, orgId, writable.map(({ item }) => item));
 
         const written: Array<{ index: number; write: ItemWrite }> = [];
         for (const { item, index } of writable) {

package/src/modules/catalog/repository/index.ts

@@ -1,4 +1,4 @@
-import { eq, and, asc, count, desc, gt, inArray, isNull, lt, max, ne, or, type SQL } from "drizzle-orm";
+import { eq, and, asc, count, desc, gt, inArray, isNull, lt, max, ne, or, sql, type SQL } from "drizzle-orm";
 import type { TxContext } from "../../../kernel/database/tx-context.js";
 import { CommerceNotFoundError } from "../../../kernel/errors.js";
 import type {
@@ -1290,12 +1290,29 @@ export class CatalogRepository {
     const db = this.getDb(ctx);
     const rows = await db
       .update(variants)
-      .set(data)
+      .set({ ...data, updatedAt: sql`now()` })
       .where(eq(variants.id, id))
       .returning();
     return rows[0];
   }
 
+  /**
+   * Run a write to variants' option values and bump those variants' `updated_at` in ONE
+   * transaction (a savepoint when the caller already holds one). A bump that could commit without
+   * its write, or a write without its bump, is exactly the version drift the column exists to end.
+   */
+  private async touchingVariants(
+    variantIds: readonly string[],
+    ctx: TxContext | undefined,
+    write: (db: DbOrTx) => Promise<void>,
+  ): Promise<void> {
+    if (variantIds.length === 0) return;
+    await this.getDb(ctx).transaction(async (tx) => {
+      await write(tx);
+      await tx.update(variants).set({ updatedAt: sql`now()` }).where(inArray(variants.id, [...new Set(variantIds)]));
+    });
+  }
+
   async deleteVariantsByEntityId(
     entityId: string,
     ctx?: TxContext,
@@ -1324,32 +1341,33 @@ export class CatalogRepository {
     ctx?: TxContext,
   ): Promise<void> {
     if (data.length === 0) return;
-    const db = this.getDb(ctx);
-    await db.insert(variantOptionValues).values(data).onConflictDoNothing();
+    await this.touchingVariants(data.map((row) => row.variantId), ctx, async (db) => {
+      await db.insert(variantOptionValues).values(data).onConflictDoNothing();
+    });
   }
 
   async deleteVariantOptionValuesByVariantId(
     variantId: string,
     ctx?: TxContext,
   ): Promise<void> {
-    const db = this.getDb(ctx);
-    await db
-      .delete(variantOptionValues)
-      .where(eq(variantOptionValues.variantId, variantId));
+    await this.touchingVariants([variantId], ctx, async (db) => {
+      await db
+        .delete(variantOptionValues)
+        .where(eq(variantOptionValues.variantId, variantId));
+    });
   }
 
   async deleteVariantOptionValuesByEntityId(
     entityId: string,
     ctx?: TxContext,
   ): Promise<void> {
-    const db = this.getDb(ctx);
     // Get all variant IDs for this entity first
     const entityVariants = await this.findVariantsByEntityId(entityId, ctx);
     const variantIds = entityVariants.map((v) => v.id);
-    if (variantIds.length > 0) {
+    await this.touchingVariants(variantIds, ctx, async (db) => {
       await db
         .delete(variantOptionValues)
         .where(inArray(variantOptionValues.variantId, variantIds));
-    }
+    });
   }
 }

package/src/modules/catalog/schema.ts

@@ -337,6 +337,10 @@ export const variants = pgTable(
       .default("active"),
     sortOrder: integer("sort_order").notNull().default(0),
     metadata: jsonb("metadata").$type<Record<string, unknown>>().default({}),
+    // Bumped on EVERY write to the variant or its option values, so a variant-only change is
+    // visible to anything that versions a product from its timestamps (the entity row is not
+    // touched by a variant write).
+    updatedAt: timestamp("updated_at", { withTimezone: true }).defaultNow().notNull(),
   },
   (table) => ({
     barcodeIdx: index("idx_variants_barcode").on(table.barcode),