@porulle/core 0.49.0 → 0.50.0

package/package.json

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

package/src/index.ts

@@ -162,6 +162,15 @@ export type {
   CreatePaymentIntentParams,
 } from "./modules/payments/adapter.js";
 export { defineChannelConnector } from "./modules/channels/adapter.js";
+export {
+  channelCatalogImageSchema,
+  channelCatalogItemSchema,
+  channelCatalogLocalizedAttributesSchema,
+  channelCatalogOptionTypeSchema,
+  channelCatalogPriceSchema,
+  channelCatalogVariantSchema,
+  channelInventoryLevelSchema,
+} from "./modules/channels/catalog-schema.js";
 export type {
   ChannelCatalogImage,
   ChannelCatalogItem,

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;