@porulle/core 0.6.0 → 0.8.0

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

@@ -192,6 +192,40 @@ export class PricingRepository {
       );
   }
 
+  async findModifiers(
+    orgId: string,
+    filter?: { entityId?: string; currency?: string; activeAt?: Date },
+    ctx?: TxContext,
+  ): Promise<PriceModifier[]> {
+    const db = this.getDb(ctx);
+    const conditions = [eq(priceModifiers.organizationId, orgId)];
+    if (filter?.entityId) {
+      conditions.push(eq(priceModifiers.entityId, filter.entityId));
+    }
+    if (filter?.currency) {
+      conditions.push(eq(priceModifiers.currency, filter.currency));
+    }
+    if (filter?.activeAt) {
+      conditions.push(
+        or(
+          isNull(priceModifiers.validFrom),
+          lte(priceModifiers.validFrom, filter.activeAt),
+        )!,
+      );
+      conditions.push(
+        or(
+          isNull(priceModifiers.validUntil),
+          gte(priceModifiers.validUntil, filter.activeAt),
+        )!,
+      );
+    }
+    const rows = await db
+      .select()
+      .from(priceModifiers)
+      .where(and(...conditions));
+    return rows.sort((a, b) => a.priority - b.priority);
+  }
+
   async findActiveModifiers(
     orgId: string,
     entityId: string,

package/src/modules/pricing/service.ts

@@ -129,6 +129,11 @@ function quantityRangeWidth(
   return Number.MAX_SAFE_INTEGER;
 }
 
+function sameNaturalKeyDate(a: Date | null | undefined, b: Date | null | undefined): boolean {
+  if (a == null || b == null) return (a ?? null) === (b ?? null);
+  return a.getTime() === b.getTime();
+}
+
 function compareBasePriceSpecificity(
   a: Price,
   b: Price,
@@ -229,7 +234,30 @@ export class PricingService {
       validUntil: input.validUntil ?? null,
     };
 
-    const record = await this.repo.createPrice(priceData, ctx);
+    // Upsert on the natural key. "Set base price" is idempotent per
+    // (org, entity, variant, currency, customerGroup, qty range, validity):
+    // a repeat call replaces the existing row's amount instead of appending a
+    // shadow row that the resolver would then tie-break on createdAt.
+    const existing = (
+      await this.repo.findPricesByEntityId(orgId, input.entityId, ctx)
+    ).find(
+      (p) =>
+        p.currency === priceData.currency &&
+        p.variantId === (priceData.variantId ?? null) &&
+        p.customerGroupId === (priceData.customerGroupId ?? null) &&
+        p.minQuantity === (priceData.minQuantity ?? null) &&
+        p.maxQuantity === (priceData.maxQuantity ?? null) &&
+        sameNaturalKeyDate(p.validFrom, priceData.validFrom ?? null) &&
+        sameNaturalKeyDate(p.validUntil, priceData.validUntil ?? null),
+    );
+
+    const record = existing
+      ? (await this.repo.updatePrice(
+          existing.id,
+          { amount: priceData.amount, metadata: priceData.metadata },
+          ctx,
+        )) ?? existing
+      : await this.repo.createPrice(priceData, ctx);
 
     const afterHooks = this.deps.hooks.resolve(
       "pricing.afterCreate",
@@ -305,6 +333,77 @@ export class PricingService {
     return Ok(modifier);
   }
 
+  async listModifiers(
+    filter?: { entityId?: string; active?: boolean; currency?: string },
+    actor?: Actor | null,
+    ctx?: TxContext,
+  ): Promise<Result<PriceModifier[]>> {
+    const orgId = resolveOrgId(actor ?? ctx?.actor ?? null);
+    const rows = await this.repo.findModifiers(
+      orgId,
+      {
+        ...(filter?.entityId !== undefined ? { entityId: filter.entityId } : {}),
+        ...(filter?.currency !== undefined
+          ? { currency: normalizeCurrency(filter.currency) }
+          : {}),
+        ...(filter?.active ? { activeAt: new Date() } : {}),
+      },
+      ctx,
+    );
+    return Ok(rows);
+  }
+
+  async updateModifier(
+    id: string,
+    patch: {
+      name?: string | undefined;
+      value?: number | undefined;
+      priority?: number | undefined;
+      validFrom?: Date | null | undefined;
+      validUntil?: Date | null | undefined;
+      minQuantity?: number | null | undefined;
+      maxQuantity?: number | null | undefined;
+      metadata?: Record<string, unknown> | undefined;
+    },
+    actor?: Actor | null,
+    ctx?: TxContext,
+  ): Promise<Result<PriceModifier>> {
+    const orgId = resolveOrgId(actor ?? ctx?.actor ?? null);
+    const existing = await this.repo.findModifierById(orgId, id, ctx);
+    if (!existing) {
+      return Err(new CommerceNotFoundError("Price modifier not found."));
+    }
+    const updated = await this.repo.updateModifier(
+      id,
+      {
+        ...(patch.name !== undefined ? { name: patch.name } : {}),
+        ...(patch.value !== undefined ? { value: patch.value } : {}),
+        ...(patch.priority !== undefined ? { priority: patch.priority } : {}),
+        ...(patch.validFrom !== undefined ? { validFrom: patch.validFrom } : {}),
+        ...(patch.validUntil !== undefined ? { validUntil: patch.validUntil } : {}),
+        ...(patch.minQuantity !== undefined ? { minQuantity: patch.minQuantity } : {}),
+        ...(patch.maxQuantity !== undefined ? { maxQuantity: patch.maxQuantity } : {}),
+        ...(patch.metadata !== undefined ? { metadata: patch.metadata } : {}),
+      },
+      ctx,
+    );
+    return Ok(updated!);
+  }
+
+  async deleteModifier(
+    id: string,
+    actor?: Actor | null,
+    ctx?: TxContext,
+  ): Promise<Result<{ deleted: true }>> {
+    const orgId = resolveOrgId(actor ?? ctx?.actor ?? null);
+    const existing = await this.repo.findModifierById(orgId, id, ctx);
+    if (!existing) {
+      return Err(new CommerceNotFoundError("Price modifier not found."));
+    }
+    await this.repo.deleteModifier(id, ctx);
+    return Ok({ deleted: true });
+  }
+
   async listPrices(
     filter?: {
       entityId?: string;

package/src/modules/settings/module.ts

@@ -0,0 +1,18 @@
+import type { DrizzleDatabase } from "../../kernel/database/drizzle-db.js";
+import { defineModule } from "../../kernel/module/index.js";
+import { SettingsRepository } from "./repository/index.js";
+import { storeSettings } from "./schema.js";
+import { SettingsService } from "./service.js";
+
+export const settingsModule = defineModule<
+  { storeSettings: typeof storeSettings },
+  SettingsService,
+  Record<string, never>
+>({
+  id: "settings",
+  schema: () => ({ storeSettings }),
+  service: (deps) =>
+    new SettingsService({
+      repository: new SettingsRepository(deps.db.db as DrizzleDatabase),
+    }),
+});

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

@@ -0,0 +1,59 @@
+import { and, eq } from "drizzle-orm";
+import type { TxContext } from "../../../kernel/database/tx-context.js";
+import type {
+  DrizzleDatabase,
+  DbOrTx,
+} from "../../../kernel/database/drizzle-db.js";
+import { storeSettings } from "../schema.js";
+
+export type StoreSetting = typeof storeSettings.$inferSelect;
+
+/**
+ * Persistence for org-scoped runtime settings (issue #49).
+ */
+export class SettingsRepository {
+  constructor(private readonly db: DrizzleDatabase) {}
+
+  private getDb(ctx?: TxContext): DbOrTx {
+    return (ctx?.tx as DbOrTx | undefined) ?? this.db;
+  }
+
+  async findByGroup(
+    orgId: string,
+    group: string,
+    ctx?: TxContext,
+  ): Promise<StoreSetting | undefined> {
+    const db = this.getDb(ctx);
+    const rows = await db
+      .select()
+      .from(storeSettings)
+      .where(and(eq(storeSettings.organizationId, orgId), eq(storeSettings.group, group)));
+    return rows[0];
+  }
+
+  async findAll(orgId: string, ctx?: TxContext): Promise<StoreSetting[]> {
+    const db = this.getDb(ctx);
+    return db
+      .select()
+      .from(storeSettings)
+      .where(eq(storeSettings.organizationId, orgId));
+  }
+
+  async upsert(
+    orgId: string,
+    group: string,
+    value: Record<string, unknown>,
+    ctx?: TxContext,
+  ): Promise<StoreSetting> {
+    const db = this.getDb(ctx);
+    const rows = await db
+      .insert(storeSettings)
+      .values({ organizationId: orgId, group, value })
+      .onConflictDoUpdate({
+        target: [storeSettings.organizationId, storeSettings.group],
+        set: { value, updatedAt: new Date() },
+      })
+      .returning();
+    return rows[0]!;
+  }
+}

package/src/modules/settings/schema.ts

@@ -0,0 +1,25 @@
+import { index, jsonb, pgTable, text, timestamp, uniqueIndex, uuid } from "drizzle-orm/pg-core";
+import { organization } from "../../auth/auth-schema.js";
+
+/**
+ * Org-scoped runtime settings (issue #49).
+ *
+ * One row per (organization, group). Groups are shallow JSON objects —
+ * `general` (currency, timezone, locale), `branding` (receipt header/footer,
+ * store name, logo), `policies` (free-form policy knobs), plus any custom
+ * group a plugin namespaces for itself. PATCH semantics are shallow merge
+ * with `null` deleting a key.
+ */
+export const storeSettings = pgTable("store_settings", {
+  id: uuid("id").defaultRandom().primaryKey(),
+  organizationId: text("organization_id")
+    .notNull()
+    .references(() => organization.id, { onDelete: "cascade" }),
+  group: text("group").notNull(),
+  value: jsonb("value").$type<Record<string, unknown>>().notNull().default({}),
+  createdAt: timestamp("created_at", { withTimezone: true }).defaultNow().notNull(),
+  updatedAt: timestamp("updated_at", { withTimezone: true }).defaultNow().notNull(),
+}, (table) => ({
+  orgGroupUnique: uniqueIndex("store_settings_org_group_unique").on(table.organizationId, table.group),
+  orgIdx: index("idx_store_settings_org").on(table.organizationId),
+}));

package/src/modules/settings/service.ts

@@ -0,0 +1,82 @@
+import { resolveOrgId } from "../../auth/org.js";
+import type { Actor } from "../../auth/types.js";
+import type { TxContext } from "../../kernel/database/tx-context.js";
+import { CommerceValidationError } from "../../kernel/errors.js";
+import { Err, Ok, type Result } from "../../kernel/result.js";
+import type { SettingsRepository } from "./repository/index.js";
+
+const GROUP_NAME_RE = /^[a-z][a-z0-9_-]*$/;
+
+interface SettingsServiceDeps {
+  repository: SettingsRepository;
+}
+
+/**
+ * Org-scoped runtime settings (issue #49).
+ *
+ * REST-facing methods resolve the org from the actor; `read()` is the
+ * plugin/hook-facing API — an orgId-keyed lookup with no actor requirement so
+ * policy values can be consumed at request time inside any service or hook.
+ */
+export class SettingsService {
+  private repository: SettingsRepository;
+
+  constructor(deps: SettingsServiceDeps) {
+    this.repository = deps.repository;
+  }
+
+  /** Runtime read for plugins/hooks. Unset groups read as `{}`. */
+  async read(
+    orgId: string,
+    group: string,
+    ctx?: TxContext,
+  ): Promise<Record<string, unknown>> {
+    const row = await this.repository.findByGroup(orgId, group, ctx);
+    return row?.value ?? {};
+  }
+
+  async getGroup(
+    group: string,
+    actor?: Actor | null,
+    ctx?: TxContext,
+  ): Promise<Result<Record<string, unknown>>> {
+    const orgId = resolveOrgId(actor ?? ctx?.actor ?? null);
+    return Ok(await this.read(orgId, group, ctx));
+  }
+
+  async getAll(
+    actor?: Actor | null,
+    ctx?: TxContext,
+  ): Promise<Result<Record<string, Record<string, unknown>>>> {
+    const orgId = resolveOrgId(actor ?? ctx?.actor ?? null);
+    const rows = await this.repository.findAll(orgId, ctx);
+    const all: Record<string, Record<string, unknown>> = {};
+    for (const row of rows) all[row.group] = row.value;
+    return Ok(all);
+  }
+
+  /** Shallow merge: keys in `patch` overwrite, `null` deletes the key. */
+  async updateGroup(
+    group: string,
+    patch: Record<string, unknown>,
+    actor?: Actor | null,
+    ctx?: TxContext,
+  ): Promise<Result<Record<string, unknown>>> {
+    if (!GROUP_NAME_RE.test(group)) {
+      return Err(
+        new CommerceValidationError(
+          "Settings group must match [a-z][a-z0-9_-]* (e.g. general, branding, policies).",
+        ),
+      );
+    }
+    const orgId = resolveOrgId(actor ?? ctx?.actor ?? null);
+    const current = await this.read(orgId, group, ctx);
+    const next: Record<string, unknown> = { ...current };
+    for (const [key, value] of Object.entries(patch)) {
+      if (value === null) delete next[key];
+      else next[key] = value;
+    }
+    const row = await this.repository.upsert(orgId, group, next, ctx);
+    return Ok(row.value);
+  }
+}

package/src/modules/shipping/calculator.ts

@@ -117,6 +117,33 @@ function resolveStrategy(config: CommerceConfig): ShippingStrategy {
   };
 }
 
+/**
+ * Total weight (grams) of the shippable line items — used by both the
+ * code-config strategy and runtime zone rates with weight bands.
+ */
+export async function computeShippableWeightGrams(
+  config: CommerceConfig,
+  catalogRepo: CatalogRepository,
+  lineItems: ShippingLineItem[],
+  ctx?: TxContext,
+): Promise<number> {
+  const flags = await Promise.all(
+    lineItems.map((lineItem) =>
+      isShippableEntity(config, catalogRepo, lineItem.entityId, ctx),
+    ),
+  );
+  const shippable = lineItems.filter((_, i) => flags[i]);
+  const weights = await Promise.all(
+    shippable.map((lineItem) =>
+      resolveWeightGrams(catalogRepo, lineItem.entityId, lineItem.variantId, ctx),
+    ),
+  );
+  return shippable.reduce(
+    (sum, lineItem, i) => sum + (weights[i] ?? 0) * lineItem.quantity,
+    0,
+  );
+}
+
 export async function calculateShippingCost(
   config: CommerceConfig,
   catalogRepo: CatalogRepository,

package/src/modules/shipping/module.ts

@@ -1,6 +1,9 @@
 import type { CommerceConfig } from "../../config/types.js";
+import type { DrizzleDatabase } from "../../kernel/database/drizzle-db.js";
 import { defineModule } from "../../kernel/module/index.js";
 import type { CatalogServiceImpl } from "../catalog/service.js";
+import { ShippingConfigRepository } from "./repository/index.js";
+import { shippingZones, shippingRates } from "./schema.js";
 import { ShippingService } from "./service.js";
 
 type ShippingModuleDeps = {
@@ -8,16 +11,17 @@ type ShippingModuleDeps = {
 };
 
 export const shippingModule = defineModule<
-  Record<string, never>,
+  { shippingZones: typeof shippingZones; shippingRates: typeof shippingRates },
   ShippingService,
   ShippingModuleDeps
 >({
   id: "shipping",
   dependencies: ["catalog"],
-  schema: () => ({}),
+  schema: () => ({ shippingZones, shippingRates }),
   service: (deps) =>
     new ShippingService({
       config: deps.config as CommerceConfig,
       catalogRepository: deps.services.catalog.repository,
+      repository: new ShippingConfigRepository(deps.db.db as DrizzleDatabase),
     }),
 });

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

@@ -1,5 +1,139 @@
+import { eq, and, asc } from "drizzle-orm";
 import type { TxContext } from "../../../kernel/database/tx-context.js";
+import type {
+  DrizzleDatabase,
+  DbOrTx,
+} from "../../../kernel/database/drizzle-db.js";
+import { shippingZones, shippingRates } from "../schema.js";
 
-export interface ShippingRepository {
-  ping(ctx: TxContext): Promise<void>;
+export type ShippingZone = typeof shippingZones.$inferSelect;
+export type ShippingZoneInsert = typeof shippingZones.$inferInsert;
+export type ShippingRate = typeof shippingRates.$inferSelect;
+export type ShippingRateInsert = typeof shippingRates.$inferInsert;
+
+/**
+ * Persistence for runtime shipping zones & rates (issue #45).
+ */
+export class ShippingConfigRepository {
+  constructor(private readonly db: DrizzleDatabase) {}
+
+  private getDb(ctx?: TxContext): DbOrTx {
+    return (ctx?.tx as DbOrTx | undefined) ?? this.db;
+  }
+
+  // ── Zones ──────────────────────────────────────────────────────────────
+
+  async findZoneById(orgId: string, id: string, ctx?: TxContext): Promise<ShippingZone | undefined> {
+    const db = this.getDb(ctx);
+    const rows = await db
+      .select()
+      .from(shippingZones)
+      .where(and(eq(shippingZones.organizationId, orgId), eq(shippingZones.id, id)));
+    return rows[0];
+  }
+
+  async findZones(orgId: string, ctx?: TxContext): Promise<ShippingZone[]> {
+    const db = this.getDb(ctx);
+    return db
+      .select()
+      .from(shippingZones)
+      .where(eq(shippingZones.organizationId, orgId))
+      .orderBy(asc(shippingZones.priority));
+  }
+
+  async findActiveZones(orgId: string, ctx?: TxContext): Promise<ShippingZone[]> {
+    const db = this.getDb(ctx);
+    return db
+      .select()
+      .from(shippingZones)
+      .where(and(eq(shippingZones.organizationId, orgId), eq(shippingZones.isActive, true)))
+      .orderBy(asc(shippingZones.priority));
+  }
+
+  async createZone(data: ShippingZoneInsert, ctx?: TxContext): Promise<ShippingZone> {
+    const db = this.getDb(ctx);
+    const rows = await db.insert(shippingZones).values(data).returning();
+    return rows[0]!;
+  }
+
+  async updateZone(
+    id: string,
+    data: Partial<Omit<ShippingZoneInsert, "id" | "organizationId">>,
+    ctx?: TxContext,
+  ): Promise<ShippingZone | undefined> {
+    const db = this.getDb(ctx);
+    const rows = await db
+      .update(shippingZones)
+      .set({ ...data, updatedAt: new Date() })
+      .where(eq(shippingZones.id, id))
+      .returning();
+    return rows[0];
+  }
+
+  async deleteZone(id: string, ctx?: TxContext): Promise<boolean> {
+    const db = this.getDb(ctx);
+    const rows = await db.delete(shippingZones).where(eq(shippingZones.id, id)).returning();
+    return rows.length > 0;
+  }
+
+  // ── Rates ──────────────────────────────────────────────────────────────
+
+  async findRateById(orgId: string, id: string, ctx?: TxContext): Promise<ShippingRate | undefined> {
+    const db = this.getDb(ctx);
+    const rows = await db
+      .select()
+      .from(shippingRates)
+      .where(and(eq(shippingRates.organizationId, orgId), eq(shippingRates.id, id)));
+    return rows[0];
+  }
+
+  async findRates(
+    orgId: string,
+    filter?: { zoneId?: string },
+    ctx?: TxContext,
+  ): Promise<ShippingRate[]> {
+    const db = this.getDb(ctx);
+    const conditions = [eq(shippingRates.organizationId, orgId)];
+    if (filter?.zoneId) conditions.push(eq(shippingRates.zoneId, filter.zoneId));
+    return db
+      .select()
+      .from(shippingRates)
+      .where(and(...conditions))
+      .orderBy(asc(shippingRates.amount));
+  }
+
+  async findActiveRatesByZoneId(zoneId: string, ctx?: TxContext): Promise<ShippingRate[]> {
+    const db = this.getDb(ctx);
+    return db
+      .select()
+      .from(shippingRates)
+      .where(and(eq(shippingRates.zoneId, zoneId), eq(shippingRates.isActive, true)))
+      .orderBy(asc(shippingRates.amount));
+  }
+
+  async createRate(data: ShippingRateInsert, ctx?: TxContext): Promise<ShippingRate> {
+    const db = this.getDb(ctx);
+    const rows = await db.insert(shippingRates).values(data).returning();
+    return rows[0]!;
+  }
+
+  async updateRate(
+    id: string,
+    data: Partial<Omit<ShippingRateInsert, "id" | "organizationId">>,
+    ctx?: TxContext,
+  ): Promise<ShippingRate | undefined> {
+    const db = this.getDb(ctx);
+    const rows = await db
+      .update(shippingRates)
+      .set({ ...data, updatedAt: new Date() })
+      .where(eq(shippingRates.id, id))
+      .returning();
+    return rows[0];
+  }
+
+  async deleteRate(id: string, ctx?: TxContext): Promise<boolean> {
+    const db = this.getDb(ctx);
+    const rows = await db.delete(shippingRates).where(eq(shippingRates.id, id)).returning();
+    return rows.length > 0;
+  }
 }

package/src/modules/shipping/schema.ts

@@ -0,0 +1,58 @@
+import { boolean, index, integer, jsonb, pgTable, text, timestamp, uuid } from "drizzle-orm/pg-core";
+import { organization } from "../../auth/auth-schema.js";
+
+/**
+ * Runtime shipping configuration (issue #45).
+ *
+ * Zones match a destination (country + optional state); rates belong to a
+ * zone and carry a flat amount with optional subtotal/weight bands and a
+ * free-shipping threshold. When zones exist for an organization they take
+ * precedence over the code-config strategy in `defineConfig({ shipping })`,
+ * which remains the fallback.
+ */
+export const shippingZones = pgTable("shipping_zones", {
+  id: uuid("id").defaultRandom().primaryKey(),
+  organizationId: text("organization_id")
+    .notNull()
+    .references(() => organization.id, { onDelete: "cascade" }),
+  name: text("name").notNull(),
+  // ISO 3166-1 alpha-2 codes, uppercase. "*" matches any country.
+  countries: jsonb("countries").$type<string[]>().notNull().default([]),
+  // Optional state/province codes; empty array = the whole country.
+  states: jsonb("states").$type<string[]>().notNull().default([]),
+  priority: integer("priority").notNull().default(100),
+  isActive: boolean("is_active").notNull().default(true),
+  createdAt: timestamp("created_at", { withTimezone: true }).defaultNow().notNull(),
+  updatedAt: timestamp("updated_at", { withTimezone: true }).defaultNow().notNull(),
+}, (table) => ({
+  orgIdx: index("idx_shipping_zones_org").on(table.organizationId),
+  priorityIdx: index("idx_shipping_zones_priority").on(table.priority),
+}));
+
+export const shippingRates = pgTable("shipping_rates", {
+  id: uuid("id").defaultRandom().primaryKey(),
+  organizationId: text("organization_id")
+    .notNull()
+    .references(() => organization.id, { onDelete: "cascade" }),
+  zoneId: uuid("zone_id")
+    .notNull()
+    .references(() => shippingZones.id, { onDelete: "cascade" }),
+  name: text("name").notNull(),
+  currency: text("currency").notNull().default("USD"),
+  // Flat cost in minor units
+  amount: integer("amount").notNull(),
+  // Price bands (subtotal after discount, minor units) — nulls are open-ended
+  minSubtotal: integer("min_subtotal"),
+  maxSubtotal: integer("max_subtotal"),
+  // Weight bands (grams) — nulls are open-ended
+  minWeightGrams: integer("min_weight_grams"),
+  maxWeightGrams: integer("max_weight_grams"),
+  // Subtotal at or above which shipping is free for this rate
+  freeShippingThreshold: integer("free_shipping_threshold"),
+  isActive: boolean("is_active").notNull().default(true),
+  createdAt: timestamp("created_at", { withTimezone: true }).defaultNow().notNull(),
+  updatedAt: timestamp("updated_at", { withTimezone: true }).defaultNow().notNull(),
+}, (table) => ({
+  zoneIdx: index("idx_shipping_rates_zone").on(table.zoneId),
+  orgIdx: index("idx_shipping_rates_org").on(table.organizationId),
+}));