@porulle/core 0.53.0 → 0.54.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@porulle/core",
-  "version": "0.53.0",
+  "version": "0.54.0",
   "license": "MIT",
   "type": "module",
   "exports": {

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

@@ -24,7 +24,7 @@ import { paginate } from "../../utils/pagination.js";
 import type { JobsAdapter } from "../../kernel/jobs/adapter.js";
 import type { PluginDb } from "../../kernel/database/plugin-types.js";
 import type { CatalogWriteContext, TxContext } from "../../kernel/database/tx-context.js";
-import { isWriteContextTransactional } from "../../kernel/database/tx-context.js";
+import { createTxContext, isWriteContextTransactional } from "../../kernel/database/tx-context.js";
 import { canReadUnpublishedCatalog, isCatalogEntityVisible } from "./read-policy.js";
 import { isValidFieldPath } from "./ownership.js";
 import type {
@@ -519,21 +519,36 @@ export class EntityService {
     try { this.assertSameOrg(entity, actor); } catch (error) { return Err(toCommerceError(error)); }
     const beforeAttr = await this.repo.findAttributeByLocale(entityId, locale, txCtx);
     const changedFieldPaths: string[] = [];
+    let changed = false;
     for (const field of attributeFields) {
       if (attrs[field] === undefined) continue;
       const before = beforeAttr?.[field] ?? null;
       const after = attrs[field] ?? null;
       if (before !== after) {
+        changed = true;
         const path = `attributes.${locale}.${field}`;
         if (isValidFieldPath(path)) changedFieldPaths.push(path);
       }
     }
-    await this.repo.upsertAttribute(entityId, locale, { title: attrs.title, subtitle: attrs.subtitle, description: attrs.description, richDescription: attrs.richDescription, seoTitle: attrs.seoTitle, seoDescription: attrs.seoDescription }, txCtx);
+    // An identical re-set writes nothing and moves nothing: an idempotent save must not look like an
+    // edit to anything that versions the product.
+    if (!changed && beforeAttr) return Ok(undefined);
+
+    // The attribute write and the entity's `updated_at` bump commit together. Consumers version a
+    // product from `sellable_entities.updated_at`; an attribute change that left it unmoved was
+    // invisible to them — a changed title never re-indexed (sim, 2026-09-24).
+    const write = async (writeCtx: TxContext): Promise<SellableEntity | undefined> => {
+      await this.repo.upsertAttribute(entityId, locale, { title: attrs.title, subtitle: attrs.subtitle, description: attrs.description, richDescription: attrs.richDescription, seoTitle: attrs.seoTitle, seoDescription: attrs.seoDescription }, writeCtx);
+      return changed ? this.repo.updateEntity(entityId, {}, writeCtx) : undefined;
+    };
+    const updated = txCtx
+      ? await write(txCtx)
+      : await this.deps.database.transaction((tx) => write(createTxContext(tx, { actor })));
     if (changedFieldPaths.length > 0) {
       const afterHooks = this.deps.hooks.resolve("catalog.afterUpdate") as CatalogUpdateAfterHook[];
       const context = catalogHookContext(this.deps, actor, ctx, "update");
       context.context.changedFieldPaths = changedFieldPaths;
-      await runAfterHooks(afterHooks, entity, entity, "update", context, (hook) => this.deps.hooks.runsInTransaction(hook));
+      await runAfterHooks(afterHooks, entity, updated ?? entity, "update", context, (hook) => this.deps.hooks.runsInTransaction(hook));
     }
     return Ok(undefined);
   }
@@ -563,10 +578,13 @@ export class EntityService {
     const txCtx = isWriteContextTransactional(ctx) ? ctx : undefined;
     const entity = await this.repo.findEntityById(entityId, txCtx);
     if (!entity) return;
+    // The related rows changed, so the entity's `updated_at` moves with them (in the caller's
+    // transaction when it has one) — the same versioning contract as `setAttributes`.
+    const updated = await this.repo.updateEntity(entityId, {}, txCtx);
     const afterHooks = this.deps.hooks.resolve("catalog.afterUpdate") as CatalogUpdateAfterHook[];
     const context = catalogHookContext(this.deps, actor, ctx, "update");
     context.context.changedFieldPaths = [...changedFieldPaths];
-    await runAfterHooks(afterHooks, entity, entity, "update", context, (hook) => this.deps.hooks.runsInTransaction(hook));
+    await runAfterHooks(afterHooks, entity, updated ?? entity, "update", context, (hook) => this.deps.hooks.runsInTransaction(hook));
   }
 
   async getAttributes(entityId: string, locale: string, actor: Actor | null, ctx?: TxContext): Promise<Result<SellableAttribute>> {

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

@@ -1,5 +1,6 @@
 import { eq, and, desc } from "drizzle-orm";
 import type { TxContext } from "../../../kernel/database/tx-context.js";
+import { user } from "../../../auth/auth-schema.js";
 import type {
   DrizzleDatabase,
   DbOrTx,
@@ -51,6 +52,27 @@ export class CustomersRepository {
     return rows[0];
   }
 
+  /**
+   * The auth user's email, when no OTHER customer profile in this organization already holds it
+   * (`customers` is unique on organization + email). Undefined otherwise — the caller then leaves the
+   * profile's email as it is rather than fail the whole profile read on the unique index.
+   */
+  async claimableUserEmail(
+    orgId: string,
+    userId: string,
+    ctx?: TxContext,
+  ): Promise<string | undefined> {
+    const db = this.getDb(ctx);
+    const [account] = await db.select({ email: user.email }).from(user).where(eq(user.id, userId));
+    if (!account?.email) return undefined;
+    const [holder] = await db
+      .select({ userId: customers.userId })
+      .from(customers)
+      .where(and(eq(customers.organizationId, orgId), eq(customers.email, account.email)))
+      .limit(1);
+    return holder === undefined || holder.userId === userId ? account.email : undefined;
+  }
+
   async findByUserId(
     orgId: string,
     userId: string,

package/src/modules/customers/service.ts

@@ -177,16 +177,24 @@ export class CustomerService {
     actor: Actor | null,
     ctx?: TxContext,
   ): Promise<Customer> {
+    // The profile carries the shopper's email: it is the key channel redaction uses, so a profile
+    // without one cannot be erased once its orders have been exported. Filled on creation, and on
+    // the next access of a profile created before this (never overwriting an email it has).
     const existing = await this.repo.findByUserId(orgId, userId, ctx);
     if (existing) {
-      return existing;
+      if (existing.email) return existing;
+      const email = await this.repo.claimableUserEmail(orgId, userId, ctx);
+      if (!email) return existing;
+      return (await this.repo.update(existing.id, { email }, ctx)) ?? existing;
     }
 
+    const email = await this.repo.claimableUserEmail(orgId, userId, ctx);
     const customer = await this.repo.create(
       {
         organizationId: orgId,
         userId,
         metadata: {},
+        ...(email !== undefined ? { email } : {}),
       },
       ctx,
     );