@porulle/core 0.48.1 → 0.50.0

package/src/modules/catalog/service.ts

@@ -59,6 +59,7 @@ import type {
 import { EntityService } from "./entity-service.js";
 import { CategoryService } from "./category-service.js";
 import { BrandService } from "./brand-service.js";
+import { CatalogImportService, type ImportProduct, type ImportProductsOptions, type ImportProductsReport } from "./import-service.js";
 
 // ─── Hand-written types (not derivable from a single z.infer) ───────────────
 
@@ -232,6 +233,16 @@ export interface CatalogService {
     actor: Actor | null,
     ctx?: TxContext,
   ): Promise<Result<CatalogEntityHydrated>>;
+  /**
+   * The import fast path: a page of NEW products in one transaction, per-item savepoints, one
+   * revision per item, one `catalog.afterImport` hook per page. See `import-service.ts`.
+   */
+  importProducts(
+    page: ImportProduct[],
+    options: ImportProductsOptions,
+    actor: Actor | null,
+    ctx?: CatalogWriteContext,
+  ): Promise<Result<ImportProductsReport>>;
   discontinue(
     id: string,
     actor: Actor | null,
@@ -445,6 +456,7 @@ export class CatalogServiceImpl implements CatalogService {
   private readonly entities: EntityService;
   private readonly categories: CategoryService;
   private readonly brands: BrandService;
+  private readonly importer: CatalogImportService;
 
   constructor(deps: CatalogServiceDeps) {
     this.repository = deps.repository;
@@ -453,6 +465,7 @@ export class CatalogServiceImpl implements CatalogService {
     this.entities = new EntityService(deps, this.resolveEntityFieldDefinitions.bind(this));
     this.categories = new CategoryService(deps);
     this.brands = new BrandService(deps);
+    this.importer = new CatalogImportService(deps);
   }
 
   private codeFieldDefinition(entityType: string, name: string): EntityFieldDefinition | undefined {
@@ -990,6 +1003,15 @@ export class CatalogServiceImpl implements CatalogService {
     });
   }
 
+  importProducts(
+    page: ImportProduct[],
+    options: ImportProductsOptions,
+    actor: Actor | null,
+    ctx?: CatalogWriteContext,
+  ): Promise<Result<ImportProductsReport>> {
+    return this.importer.importProducts(page, options, actor, ctx);
+  }
+
   archive(id: string, actor: Actor | null, ctx?: TxContext): Promise<Result<CatalogEntityHydrated>> {
     return this.withMutationResult(actor, ctx, async (txCtx) => {
       const result = await this.entities.archive(id, actor, txCtx);

package/src/modules/channels/catalog-schema.ts

@@ -0,0 +1,97 @@
+import { z } from "zod";
+import type {
+  ChannelCatalogImage,
+  ChannelCatalogItem,
+  ChannelCatalogLocalizedAttributes,
+  ChannelCatalogOptionType,
+  ChannelCatalogPrice,
+  ChannelCatalogVariant,
+  ChannelInventoryLevel,
+} from "./adapter.js";
+
+/**
+ * The parser for a catalog item that crossed a trust boundary — a queue message, an R2 object, a
+ * JSON fixture. Import this rather than re-declaring a subset: a consumer's hand-written schema that
+ * kept only the fields it knew about once converged 96 products with no options, prices or
+ * inventory, and a reconcile then "re-converged" all of them. The `Equals` checks at the bottom make
+ * this schema fail to compile the day it and the interfaces disagree.
+ */
+const record = z.record(z.string(), z.unknown());
+
+export const channelCatalogLocalizedAttributesSchema = z.object({
+  locale: z.string(),
+  title: z.string(),
+  subtitle: z.string().exactOptional(),
+  description: z.string().exactOptional(),
+  richDescription: z.unknown().exactOptional(),
+  seoTitle: z.string().exactOptional(),
+  seoDescription: z.string().exactOptional(),
+});
+
+export const channelCatalogImageSchema = z.object({
+  externalId: z.string().exactOptional(),
+  url: z.string(),
+  alt: z.string().exactOptional(),
+  role: z.enum(["primary", "gallery", "thumbnail", "video", "document"]),
+  sortOrder: z.number().exactOptional(),
+  variantExternalIds: z.array(z.string()).exactOptional(),
+});
+
+export const channelCatalogOptionTypeSchema = z.object({
+  name: z.string(),
+  displayName: z.string(),
+  sortOrder: z.number().exactOptional(),
+  values: z.array(z.object({
+    value: z.string(),
+    displayValue: z.string(),
+    sortOrder: z.number().exactOptional(),
+  })),
+});
+
+export const channelCatalogPriceSchema = z.object({
+  currency: z.string(),
+  amount: z.number(),
+  compareAtAmount: z.number().exactOptional(),
+});
+
+export const channelCatalogVariantSchema = z.object({
+  externalId: z.string(),
+  sku: z.string().exactOptional(),
+  barcode: z.string().exactOptional(),
+  metadata: record.exactOptional(),
+  optionValues: z.record(z.string(), z.string()).exactOptional(),
+  prices: z.array(channelCatalogPriceSchema).exactOptional(),
+});
+
+export const channelCatalogItemSchema = z.object({
+  externalId: z.string(),
+  slug: z.string(),
+  title: z.string(),
+  description: z.string().exactOptional(),
+  variants: z.array(channelCatalogVariantSchema),
+  metadata: record.exactOptional(),
+  attributes: z.array(channelCatalogLocalizedAttributesSchema).exactOptional(),
+  images: z.array(channelCatalogImageSchema).exactOptional(),
+  options: z.array(channelCatalogOptionTypeSchema).exactOptional(),
+  tags: z.array(z.string()).exactOptional(),
+  brand: z.string().exactOptional(),
+  categories: z.array(z.string()).exactOptional(),
+  status: z.enum(["draft", "active", "archived", "discontinued"]).exactOptional(),
+});
+
+export const channelInventoryLevelSchema = z.object({
+  externalId: z.string(),
+  available: z.number(),
+});
+
+type Equals<A, B> = (<T>() => T extends A ? 1 : 2) extends (<T>() => T extends B ? 1 : 2) ? true : false;
+type Assert<T extends true> = T;
+export type ChannelCatalogSchemaChecks = [
+  Assert<Equals<z.infer<typeof channelCatalogLocalizedAttributesSchema>, ChannelCatalogLocalizedAttributes>>,
+  Assert<Equals<z.infer<typeof channelCatalogImageSchema>, ChannelCatalogImage>>,
+  Assert<Equals<z.infer<typeof channelCatalogOptionTypeSchema>, ChannelCatalogOptionType>>,
+  Assert<Equals<z.infer<typeof channelCatalogPriceSchema>, ChannelCatalogPrice>>,
+  Assert<Equals<z.infer<typeof channelCatalogVariantSchema>, ChannelCatalogVariant>>,
+  Assert<Equals<z.infer<typeof channelCatalogItemSchema>, ChannelCatalogItem>>,
+  Assert<Equals<z.infer<typeof channelInventoryLevelSchema>, ChannelInventoryLevel>>,
+];

package/src/modules/inventory/service.ts

@@ -503,6 +503,19 @@ export class InventoryService {
       ctx,
     );
 
+    // Already at the quantity: nothing to record. A zero-delta adjust would still write a movement
+    // and fire `inventory.afterAdjust`, and a periodic reconcile then re-announces every level it
+    // walked — 1,243 of them on one sim reconcile, each one a downstream re-projection.
+    // The permission still gates it, so a caller without `inventory:adjust` is refused either way.
+    if (existingLevel && existingLevel.quantityOnHand === input.quantity) {
+      try {
+        assertPermission(actor ?? null, "inventory:adjust");
+      } catch (error) {
+        return Err(toCommerceError(error));
+      }
+      return Ok(existingLevel);
+    }
+
     const currentOnHand = existingLevel?.quantityOnHand ?? 0;
     const delta = input.quantity - currentOnHand;
 

package/src/testing.ts

@@ -7,6 +7,9 @@
  */
 
 export { createTestKernel } from "./test-utils/create-test-kernel.js";
+// The query log is the only honest statement counter: the PGlite logger sees every statement core
+// issues, which a proxy around a plugin's own handle cannot.
+export { createPGliteTestAdapter, type PGliteTestAdapter, type QueryLog } from "./test-utils/create-pglite-adapter.js";
 export { createTestPluginContext } from "./test-utils/create-test-plugin-context.js";
 export { createRepositoryTestHarness } from "./test-utils/create-repository-test-harness.js";
 export { createPluginTestApp, type PluginTestApp, type TestAppEnv } from "./test-utils/create-plugin-test-app.js";