@porulle/core 0.8.0 → 0.10.0

package/src/modules/catalog/schema.ts

@@ -1,4 +1,5 @@
 import type { AnyPgColumn } from "drizzle-orm/pg-core";
+import { sql } from "drizzle-orm";
 import {
   boolean,
   index,
@@ -17,6 +18,8 @@ export const sellableEntities = pgTable(
   {
     id: uuid("id").defaultRandom().primaryKey(),
     organizationId: text("organization_id").notNull().references(() => organization.id, { onDelete: "cascade" }),
+    // Connected-store id when externally sourced; null means platform-native.
+    sourceStoreId: text("source_store_id"),
     type: text("type").notNull(),
     slug: text("slug").notNull(),
     status: text("status", {
@@ -179,24 +182,36 @@ export const optionValues = pgTable("option_values", {
   metadata: jsonb("metadata").$type<Record<string, unknown>>().default({}),
 });
 
-export const variants = pgTable("variants", {
-  id: uuid("id").defaultRandom().primaryKey(),
-  entityId: uuid("entity_id")
-    .references(() => sellableEntities.id, { onDelete: "cascade" })
-    .notNull(),
-  sku: text("sku").unique(),
-  barcode: text("barcode"),
-  // Overrides the entity's taxClass when set (issue #57).
-  taxClass: text("tax_class"),
-  status: text("status", { enum: ["active", "discontinued"] })
-    .notNull()
-    .default("active"),
-  sortOrder: integer("sort_order").notNull().default(0),
-  metadata: jsonb("metadata").$type<Record<string, unknown>>().default({}),
-}, (table) => ({
-  barcodeIdx: index("idx_variants_barcode").on(table.barcode),
-  skuIdx: index("idx_variants_sku").on(table.sku),
-}));
+export const variants = pgTable(
+  "variants",
+  {
+    id: uuid("id").defaultRandom().primaryKey(),
+    entityId: uuid("entity_id")
+      .references(() => sellableEntities.id, { onDelete: "cascade" })
+      .notNull(),
+    organizationId: text("organization_id").notNull().references(() => organization.id, { onDelete: "cascade" }),
+    sourceStoreId: text("source_store_id"),
+    sku: text("sku"),
+    barcode: text("barcode"),
+    // Overrides the entity's taxClass when set (issue #57).
+    taxClass: text("tax_class"),
+    status: text("status", { enum: ["active", "discontinued"] })
+      .notNull()
+      .default("active"),
+    sortOrder: integer("sort_order").notNull().default(0),
+    metadata: jsonb("metadata").$type<Record<string, unknown>>().default({}),
+  },
+  (table) => ({
+    barcodeIdx: index("idx_variants_barcode").on(table.barcode),
+    skuIdx: index("idx_variants_sku").on(table.sku),
+    nativeSkuUnique: uniqueIndex("variants_native_org_sku_unique")
+      .on(table.organizationId, table.sku)
+      .where(sql`${table.sourceStoreId} IS NULL AND ${table.sku} IS NOT NULL`),
+    sourceSkuUnique: uniqueIndex("variants_source_store_sku_unique")
+      .on(table.sourceStoreId, table.sku)
+      .where(sql`${table.sourceStoreId} IS NOT NULL AND ${table.sku} IS NOT NULL`),
+  }),
+);
 
 export const variantOptionValues = pgTable("variant_option_values", {
   variantId: uuid("variant_id")

package/src/modules/catalog/schemas.ts

@@ -92,7 +92,9 @@ export const GenerateVariantsBodySchema = z
 
 // ─── Derived Input Types ─────────────────────────────────────────────────────
 
-export type CreateEntityInput = z.infer<typeof CreateEntityBodySchema>;
+export type CreateEntityInput = z.infer<typeof CreateEntityBodySchema> & {
+  sourceStoreId?: string;
+};
 
 export type UpdateEntityInput = z.infer<typeof UpdateEntityBodySchema>;
 

package/src/modules/channels/adapter.ts

@@ -0,0 +1,139 @@
+import type { Result } from "../../kernel/result.js";
+
+export interface ChannelConnectorError {
+  code: string;
+  message: string;
+  retriable?: boolean;
+}
+
+export interface ChannelConnectorCapabilities {
+  readonly importCatalog: boolean;
+  readonly importInventory: boolean;
+  readonly pushOrder: boolean;
+  readonly receiveWebhooks: boolean;
+  readonly reserve?: boolean;
+}
+
+export interface ChannelStore {
+  id: string;
+  organizationId: string;
+  provider: string;
+  credentials: Record<string, unknown>;
+  storeDomain: string;
+  status: "connected" | "disconnected" | "error";
+  webhookSecret: string | null;
+}
+
+export interface ChannelCatalogVariant {
+  externalId: string;
+  sku?: string;
+  barcode?: string;
+  metadata?: Record<string, unknown>;
+}
+
+export interface ChannelCatalogItem {
+  externalId: string;
+  slug: string;
+  title: string;
+  description?: string;
+  variants: ChannelCatalogVariant[];
+  metadata?: Record<string, unknown>;
+}
+
+export interface ChannelCatalogPage {
+  items: ChannelCatalogItem[];
+  nextCursor?: string | null;
+}
+
+export interface ChannelInventoryLevel {
+  externalId: string;
+  available: number;
+}
+
+export interface ChannelOrderLine {
+  externalVariantId: string;
+  sku?: string;
+  title: string;
+  quantity: number;
+  unitPrice: number;
+  totalPrice: number;
+}
+
+export interface ChannelOrderSlice {
+  orderId: string;
+  currency: string;
+  grandTotal: number;
+  lines: ChannelOrderLine[];
+  customer: {
+    name: string;
+    email: string;
+    shippingAddress: Record<string, unknown>;
+  };
+}
+
+export interface ChannelPushOrderResult {
+  remoteOrderId: string;
+  remoteUrl?: string;
+}
+
+export interface ChannelOrderStatus {
+  status: "pending" | "confirmed" | "failed" | "cancelled" | "fulfilled";
+}
+
+export interface ChannelWebhookEvent {
+  id: string;
+  type: string;
+  data: unknown;
+}
+
+export interface ChannelReservation {
+  id: string;
+  expiresAt?: Date;
+}
+
+export interface ChannelRefundResult {
+  remoteRefundId: string;
+  status: string;
+}
+
+export interface ChannelConnector {
+  readonly providerId: string;
+  readonly capabilities: ChannelConnectorCapabilities;
+  buildAuthUrl?(params: {
+    storeDomain: string;
+    state: string;
+    redirectUri: string;
+    callbackUri: string;
+    scopes: string[];
+  }): Result<string, ChannelConnectorError>;
+  completeAuth?(
+    request: Request,
+    ctx: { storeDomain: string },
+  ): Promise<Result<{ credentials: Record<string, unknown>; storeDomain: string }, ChannelConnectorError>>;
+  importCatalog(store: ChannelStore, cursor?: string): Promise<Result<ChannelCatalogPage>>;
+  fetchInventory(store: ChannelStore, ids?: string[]): Promise<Result<ChannelInventoryLevel[]>>;
+  pushOrder(store: ChannelStore, slice: ChannelOrderSlice): Promise<Result<ChannelPushOrderResult, ChannelConnectorError>>;
+  fetchOrderStatus(store: ChannelStore, remoteId: string): Promise<Result<ChannelOrderStatus, ChannelConnectorError>>;
+  verifyWebhook(store: ChannelStore, request: Request): Promise<Result<ChannelWebhookEvent>>;
+  verifyAppWebhook?(
+    request: Request,
+  ): Promise<Result<{ topic: string; shopDomain: string; data: unknown }, ChannelConnectorError>>;
+  registerWebhooks?(
+    store: ChannelStore,
+    topics: string[],
+    callbackUrl: string,
+  ): Promise<Result<{ registered: number }, ChannelConnectorError>>;
+  reserve?(
+    store: ChannelStore,
+    lines: ChannelOrderLine[],
+  ): Promise<Result<ChannelReservation>>;
+  refundExecute(
+    store: ChannelStore,
+    slice: ChannelOrderSlice,
+    amount: number,
+  ): Promise<Result<ChannelRefundResult>>;
+}
+
+export function defineChannelConnector<T extends ChannelConnector>(connector: T): T {
+  return connector;
+}

package/src/modules/customers/service.ts

@@ -241,6 +241,12 @@ export class CustomerService {
     ctx?: TxContext,
     options?: { replaceMetadata?: boolean },
   ): Promise<Result<Customer>> {
+    try {
+      assertPermission(actor ?? null, "customers:update");
+    } catch (error) {
+      return Err(toCommerceError(error));
+    }
+
     const orgId = resolveOrgId(actor ?? ctx?.actor ?? null);
     const existing = await this.repo.findById(orgId, id, ctx);
     if (!existing) return Err(new CommerceNotFoundError("Customer not found."));

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

@@ -1,5 +1,5 @@
 import { eq, and, inArray, isNull, sql } from "drizzle-orm";
-import { CommerceValidationError } from "../../../kernel/errors.js";
+import { CommerceValidationError, INVENTORY_RECORD_NOT_FOUND_MESSAGE } from "../../../kernel/errors.js";
 import type { TxContext } from "../../../kernel/database/tx-context.js";
 import type {
   DrizzleDatabase,
@@ -495,7 +495,7 @@ export class InventoryRepository {
     if (!level) {
       return {
         ok: false,
-        reason: "No inventory record found for this entity.",
+        reason: INVENTORY_RECORD_NOT_FOUND_MESSAGE,
       };
     }
 
@@ -550,7 +550,7 @@ export class InventoryRepository {
     if (!level) {
       return {
         ok: false,
-        reason: "No inventory record found for this entity.",
+        reason: INVENTORY_RECORD_NOT_FOUND_MESSAGE,
       };
     }
 
@@ -600,7 +600,7 @@ export class InventoryRepository {
     if (!level) {
       return {
         ok: false,
-        reason: "No inventory record found for this entity.",
+        reason: INVENTORY_RECORD_NOT_FOUND_MESSAGE,
       };
     }
 

package/src/modules/inventory/service.ts

@@ -3,8 +3,10 @@ import { assertPermission } from "../../auth/permissions.js";
 import type { Actor } from "../../auth/types.js";
 import type { CommerceConfig } from "../../config/types.js";
 import {
+  CommerceInventoryRecordNotFoundError,
   CommerceNotFoundError,
   CommerceValidationError,
+  INVENTORY_RECORD_NOT_FOUND_MESSAGE,
   toCommerceError,
 } from "../../kernel/errors.js";
 import { runAfterHooks } from "../../kernel/hooks/executor.js";
@@ -232,7 +234,11 @@ export class InventoryService {
       );
 
       if (!reserveResult.ok) {
-        return Err(new CommerceValidationError(reserveResult.reason));
+        return Err(
+          reserveResult.reason === INVENTORY_RECORD_NOT_FOUND_MESSAGE
+            ? new CommerceInventoryRecordNotFoundError()
+            : new CommerceValidationError(reserveResult.reason),
+        );
       }
 
       await this.repo.createMovement(
@@ -281,7 +287,11 @@ export class InventoryService {
       );
 
       if (!releaseResult.ok) {
-        return Err(new CommerceValidationError(releaseResult.reason));
+        return Err(
+          releaseResult.reason === INVENTORY_RECORD_NOT_FOUND_MESSAGE
+            ? new CommerceInventoryRecordNotFoundError()
+            : new CommerceValidationError(releaseResult.reason),
+        );
       }
 
       await this.repo.createMovement(

package/src/modules/orders/schema.ts

@@ -50,6 +50,10 @@ export const orderLineItems = pgTable("order_line_items", {
   quantity: integer("quantity").notNull(),
   unitPrice: integer("unit_price").notNull(),
   totalPrice: integer("total_price").notNull(),
+  // Price provenance (matches Medusa's `is_custom_price`): true when a staff
+  // actor with `orders:manage` supplied an explicit override price rather than
+  // the server-derived catalog price. Audit + reporting signal.
+  isCustomPrice: boolean("is_custom_price").notNull().default(false),
   taxAmount: integer("tax_amount").notNull().default(0),
   discountAmount: integer("discount_amount").notNull().default(0),
   // Units already refunded on this line (issue #52) — line-level refund REST