@porulle/core 0.7.0 → 0.9.0

package/src/modules/orders/stale-order-cleanup.ts

@@ -1,6 +1,20 @@
-import { eq, and, lt, sql } from "drizzle-orm";
+import { eq, and, lt } from "drizzle-orm";
+import type { Actor } from "../../auth/types.js";
 import { orders } from "./schema.js";
-import type { TaskDefinition, TaskContext } from "../../kernel/jobs/types.js";
+import type { TaskDefinition } from "../../kernel/jobs/types.js";
+
+function systemActorForOrg(organizationId: string): Actor {
+  return {
+    type: "user",
+    userId: "system",
+    email: null,
+    name: "System",
+    vendorId: null,
+    organizationId,
+    role: "admin",
+    permissions: ["*:*"],
+  };
+}
 
 /**
  * Stale Order Cleanup Task
@@ -46,14 +60,14 @@ export const staleOrderCleanupTask: TaskDefinition<
 
     // Cancel each stale order via the service (triggers inventory release + payment refund)
     const orderService = ctx.services.orders as {
-      cancel(orderId: string, actor: null, reason: string): Promise<unknown>;
+      cancel(orderId: string, actor: Actor | null, reason: string): Promise<unknown>;
     };
 
     for (const order of staleOrders) {
       try {
         await orderService.cancel(
           order.id,
-          null,
+          systemActorForOrg(order.organizationId),
           `Auto-cancelled: pending for >${thresholdHours}h`,
         );
         cancelledIds.push(order.id);

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

@@ -211,15 +211,14 @@ export class PricingService {
       );
     }
 
-    const entity = await this.catalogRepo.findEntityById(input.entityId, ctx);
+    const orgId = resolveOrgId(actor ?? ctx?.actor ?? null);
+    const entity = await this.catalogRepo.findEntityById(input.entityId, ctx, orgId);
     if (!entity) {
       return Err(
         new CommerceNotFoundError("Entity not found for price assignment."),
       );
     }
 
-    const orgId = resolveOrgId(actor ?? ctx?.actor ?? null);
-
     const priceData: PriceInsert = {
       organizationId: orgId,
       entityId: input.entityId,
@@ -333,6 +332,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;
@@ -402,7 +472,8 @@ export class PricingService {
     actor?: Actor | null,
     ctx?: TxContext,
   ): Promise<Result<ResolvedPrice>> {
-    const entity = await this.catalogRepo.findEntityById(input.entityId, ctx);
+    const orgId = resolveOrgId(actor ?? ctx?.actor ?? null);
+    const entity = await this.catalogRepo.findEntityById(input.entityId, ctx, orgId);
     if (!entity) {
       return Err(
         new CommerceNotFoundError(`Entity ${input.entityId} not found.`),
@@ -421,8 +492,7 @@ export class PricingService {
     const currency = normalizeCurrency(input.currency);
     const groupSet = toGroupSet(input);
 
-    // Get matching prices from repository
-    const orgId = resolveOrgId(actor ?? ctx?.actor ?? null);
+    // Get matching prices from repository (orgId resolved above)
     const allPrices = await this.repo.findPricesByEntityId(
       orgId,
       input.entityId,

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),
+}));