@unifiedcommerce/core 0.0.1

package/src/modules/organization/service.ts

@@ -0,0 +1,191 @@
+/**
+ * OrganizationService — wraps Better Auth's server-side organization API.
+ *
+ * When auth.api is available (server context), uses Better Auth's
+ * createOrganization which properly creates org + member records.
+ *
+ * When auth is not available (kernel-only scripts), falls back to
+ * direct Drizzle insert into the organization table.
+ */
+
+import { eq } from "drizzle-orm";
+import type { PgDatabase, PgQueryResultHKT } from "drizzle-orm/pg-core";
+import { organization, member } from "../../auth/auth-schema";
+import type { AuthInstance } from "../../auth/setup";
+
+type DrizzleDb = PgDatabase<PgQueryResultHKT, Record<string, unknown>>;
+
+interface Result<T> { ok: true; value: T }
+interface ResultErr { ok: false; error: string }
+function Ok<T>(value: T): Result<T> { return { ok: true, value }; }
+function Err(error: string): ResultErr { return { ok: false, error }; }
+
+export interface Organization {
+  id: string;
+  name: string;
+  slug: string;
+  logo?: string | null;
+  metadata?: string | null;
+  createdAt: Date;
+}
+
+export interface OrganizationCreateInput {
+  id?: string;
+  name: string;
+  slug: string;
+  userId?: string;
+  logo?: string;
+  metadata?: Record<string, unknown>;
+}
+
+export class OrganizationService {
+  private auth: AuthInstance | null;
+  private db: DrizzleDb;
+
+  constructor(db: unknown, auth?: AuthInstance | null) {
+    this.db = db as DrizzleDb;
+    this.auth = auth ?? null;
+  }
+
+  /**
+   * Create an organization.
+   *
+   * If auth.api is available, uses Better Auth's createOrganization
+   * which creates both the org and a member record for the creator.
+   *
+   * If auth is not available, falls back to direct Drizzle insert
+   * and manually creates a member record if userId is provided.
+   */
+  async create(input: OrganizationCreateInput): Promise<Result<Organization> | ResultErr> {
+    // Try Better Auth server-side API first
+    if (this.auth) {
+      try {
+        const api = this.auth.api as Record<string, unknown>;
+        if (typeof api.createOrganization === "function") {
+          const result = await (api.createOrganization as (opts: unknown) => Promise<unknown>)({
+            body: {
+              name: input.name,
+              slug: input.slug,
+              logo: input.logo,
+              metadata: input.metadata ? JSON.stringify(input.metadata) : undefined,
+              ...(input.userId ? { userId: input.userId } : {}),
+            },
+          });
+
+          const org = result as Record<string, unknown>;
+          return Ok({
+            id: String(org.id ?? ""),
+            name: String(org.name ?? ""),
+            slug: String(org.slug ?? ""),
+            logo: org.logo as string | null,
+            metadata: org.metadata as string | null,
+            createdAt: org.createdAt instanceof Date ? org.createdAt : new Date(),
+          });
+        }
+      } catch (err) {
+        // If Better Auth throws (e.g., slug conflict), handle gracefully
+        const message = err instanceof Error ? err.message : String(err);
+        if (message.includes("already exists") || message.includes("UNIQUE")) {
+          return Err(`Organization with slug "${input.slug}" already exists`);
+        }
+        // Fall through to Drizzle fallback
+      }
+    }
+
+    // Fallback: direct Drizzle insert
+    const orgId = input.id ?? crypto.randomUUID().replace(/-/g, "").slice(0, 32);
+
+    // Check if already exists
+    const existing = await this.db
+      .select({ id: organization.id })
+      .from(organization)
+      .where(eq(organization.id, orgId));
+
+    if (existing.length > 0) {
+      return Ok({
+        id: existing[0]!.id,
+        name: input.name,
+        slug: input.slug,
+        logo: null,
+        metadata: null,
+        createdAt: new Date(),
+      });
+    }
+
+    const existingSlug = await this.db
+      .select({ id: organization.id })
+      .from(organization)
+      .where(eq(organization.slug, input.slug));
+
+    if (existingSlug.length > 0) {
+      return Ok({
+        id: existingSlug[0]!.id,
+        name: input.name,
+        slug: input.slug,
+        logo: null,
+        metadata: null,
+        createdAt: new Date(),
+      });
+    }
+
+    await this.db.insert(organization).values({
+      id: orgId,
+      name: input.name,
+      slug: input.slug,
+      logo: input.logo,
+      metadata: input.metadata ? JSON.stringify(input.metadata) : undefined,
+      createdAt: new Date(),
+    });
+
+    // Create member record for the creator
+    if (input.userId) {
+      await this.db.insert(member).values({
+        id: crypto.randomUUID().replace(/-/g, "").slice(0, 32),
+        organizationId: orgId,
+        userId: input.userId,
+        role: "owner",
+        createdAt: new Date(),
+      });
+    }
+
+    return Ok({
+      id: orgId,
+      name: input.name,
+      slug: input.slug,
+      logo: input.logo ?? null,
+      metadata: input.metadata ? JSON.stringify(input.metadata) : null,
+      createdAt: new Date(),
+    });
+  }
+
+  async getById(id: string): Promise<Result<Organization> | ResultErr> {
+    const rows = await this.db
+      .select()
+      .from(organization)
+      .where(eq(organization.id, id));
+
+    if (rows.length === 0) return Err("Organization not found");
+
+    const org = rows[0]!;
+    return Ok({
+      id: org.id,
+      name: org.name,
+      slug: org.slug,
+      logo: org.logo,
+      metadata: org.metadata,
+      createdAt: org.createdAt,
+    });
+  }
+
+  async list(): Promise<Result<Organization[]>> {
+    const rows = await this.db.select().from(organization);
+    return Ok(rows.map(org => ({
+      id: org.id,
+      name: org.name,
+      slug: org.slug,
+      logo: org.logo,
+      metadata: org.metadata,
+      createdAt: org.createdAt,
+    })));
+  }
+}

package/src/modules/payments/adapter.ts

@@ -0,0 +1,47 @@
+import type { Result } from "../../kernel/result";
+
+export interface PaymentIntent {
+  id: string;
+  status: string;
+  amount: number;
+  currency: string;
+  clientSecret?: string | null;
+}
+
+export interface PaymentCapture {
+  id: string;
+  status: string;
+  amountCaptured: number;
+}
+
+export interface PaymentRefund {
+  id: string;
+  status: string;
+  amountRefunded: number;
+}
+
+export interface PaymentWebhookEvent {
+  id: string;
+  type: string;
+  data: unknown;
+}
+
+export interface CreatePaymentIntentParams {
+  amount: number;
+  currency: string;
+  orderId: string;
+  customerId?: string;
+  metadata?: Record<string, string>;
+  terminalId?: string;
+}
+
+export interface PaymentAdapter {
+  readonly providerId: string;
+  createPaymentIntent(params: CreatePaymentIntentParams): Promise<Result<PaymentIntent>>;
+  capturePayment(paymentIntentId: string, amount?: number): Promise<Result<PaymentCapture>>;
+  refundPayment(paymentId: string, amount: number, reason?: string): Promise<Result<PaymentRefund>>;
+  cancelPaymentIntent(paymentIntentId: string): Promise<Result<void>>;
+  verifyWebhook(request: Request): Promise<Result<PaymentWebhookEvent>>;
+  /** Optional schema extension: adapter-owned columns prefixed with `providerId_` */
+  extraColumns?(): Record<string, unknown>;
+}

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

@@ -0,0 +1,6 @@
+import type { TxContext } from "../../../kernel/database/tx-context";
+
+export interface PaymentsRepository {
+  // RFC-002 scaffold: module repositories become the only persistence boundary.
+  ping(ctx: TxContext): Promise<void>;
+}

package/src/modules/payments/service.ts

@@ -0,0 +1,107 @@
+import { CommerceValidationError } from "../../kernel/errors";
+import { Err, Ok, type Result } from "../../kernel/result";
+import type {
+  CreatePaymentIntentParams,
+  PaymentAdapter,
+  PaymentCapture,
+  PaymentIntent,
+  PaymentRefund,
+} from "./adapter";
+
+export class PaymentsService {
+  private readonly adapterMap: Map<string, PaymentAdapter>;
+  private readonly defaultAdapter: PaymentAdapter | undefined;
+
+  constructor(adapters: PaymentAdapter[] | undefined) {
+    this.adapterMap = new Map();
+    for (const adapter of adapters ?? []) {
+      this.adapterMap.set(adapter.providerId, adapter);
+    }
+    this.defaultAdapter = adapters?.[0];
+  }
+
+  /**
+   * Resolve a specific adapter by its providerId.
+   * Falls back to the default (first) adapter only when paymentMethodId is omitted.
+   */
+  private resolveAdapter(paymentMethodId?: string): Result<PaymentAdapter> {
+    if (paymentMethodId) {
+      const adapter = this.adapterMap.get(paymentMethodId);
+      if (!adapter) {
+        return Err(
+          new CommerceValidationError(
+            `No payment adapter registered for provider "${paymentMethodId}". ` +
+            `Available: [${[...this.adapterMap.keys()].join(", ")}]`,
+          ),
+        );
+      }
+      return Ok(adapter);
+    }
+    if (!this.defaultAdapter) {
+      return Err(new CommerceValidationError("No payment adapter configured."));
+    }
+    return Ok(this.defaultAdapter);
+  }
+
+  /** Expose registered provider IDs for validation hooks. */
+  get registeredProviderIds(): string[] {
+    return [...this.adapterMap.keys()];
+  }
+
+  async authorize(
+    params: Omit<CreatePaymentIntentParams, "orderId"> & {
+      paymentMethodId?: string;
+      metadata?: Record<string, unknown>;
+    },
+  ): Promise<Result<PaymentIntent>> {
+    const adapter = this.resolveAdapter(params.paymentMethodId);
+    if (!adapter.ok) return adapter;
+
+    return adapter.value.createPaymentIntent({
+      ...params,
+      orderId: String(params.metadata?.orderId ?? "pending-order"),
+      metadata: Object.fromEntries(
+        Object.entries(params.metadata ?? {}).map(([key, value]) => [
+          key,
+          String(value),
+        ]),
+      ),
+    });
+  }
+
+  async capture(
+    paymentIntentId: string,
+    amount?: number,
+    paymentMethodId?: string,
+  ): Promise<Result<PaymentCapture>> {
+    const adapter = this.resolveAdapter(paymentMethodId);
+    if (!adapter.ok) return adapter;
+    return adapter.value.capturePayment(paymentIntentId, amount);
+  }
+
+  async refund(
+    paymentId: string,
+    amount: number,
+    reason?: string,
+    paymentMethodId?: string,
+  ): Promise<Result<PaymentRefund>> {
+    const adapter = this.resolveAdapter(paymentMethodId);
+    if (!adapter.ok) return adapter;
+    return adapter.value.refundPayment(paymentId, amount, reason);
+  }
+
+  async cancel(
+    paymentIntentId: string,
+    paymentMethodId?: string,
+  ): Promise<Result<void>> {
+    const adapter = this.resolveAdapter(paymentMethodId);
+    if (!adapter.ok) return adapter;
+    return adapter.value.cancelPaymentIntent(paymentIntentId);
+  }
+
+  async verifyWebhook(request: Request) {
+    const adapter = this.resolveAdapter();
+    if (!adapter.ok) return adapter;
+    return adapter.value.verifyWebhook(request);
+  }
+}

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

@@ -0,0 +1,291 @@
+import { eq, and, lte, gte, or, isNull } from "drizzle-orm";
+import type { TxContext } from "../../../kernel/database/tx-context";
+import type {
+  DrizzleDatabase,
+  DbOrTx,
+} from "../../../kernel/database/drizzle-db";
+import { prices, priceModifiers } from "../schema";
+
+// Infer types from Drizzle schema
+export type Price = typeof prices.$inferSelect;
+export type PriceInsert = typeof prices.$inferInsert;
+export type PriceModifier = typeof priceModifiers.$inferSelect;
+export type PriceModifierInsert = typeof priceModifiers.$inferInsert;
+
+/**
+ * PricingRepository provides type-safe database operations for pricing.
+ *
+ * This repository manages prices and price modifiers.
+ * All methods support an optional TxContext parameter for transaction participation.
+ */
+export class PricingRepository {
+  constructor(private readonly db: DrizzleDatabase) {}
+
+  private getDb(ctx?: TxContext): DbOrTx {
+    return (ctx?.tx as DbOrTx | undefined) ?? this.db;
+  }
+
+  // ─────────────────────────────────────────────────────────────────────────────
+  // Prices
+  // ─────────────────────────────────────────────────────────────────────────────
+
+  async findPriceById(orgId: string, id: string, ctx?: TxContext): Promise<Price | undefined> {
+    const db = this.getDb(ctx);
+    const rows = await db.select().from(prices).where(
+      and(eq(prices.organizationId, orgId), eq(prices.id, id)),
+    );
+    return rows[0];
+  }
+
+  async findPricesByEntityId(
+    entityId: string,
+    ctx?: TxContext,
+  ): Promise<Price[]> {
+    const db = this.getDb(ctx);
+    return db.select().from(prices).where(eq(prices.entityId, entityId));
+  }
+
+  async findPricesByEntityAndVariant(
+    entityId: string,
+    variantId: string | null,
+    ctx?: TxContext,
+  ): Promise<Price[]> {
+    const db = this.getDb(ctx);
+
+    if (variantId === null) {
+      return db
+        .select()
+        .from(prices)
+        .where(and(eq(prices.entityId, entityId), isNull(prices.variantId)));
+    }
+
+    return db
+      .select()
+      .from(prices)
+      .where(
+        and(eq(prices.entityId, entityId), eq(prices.variantId, variantId)),
+      );
+  }
+
+  async findActivePrices(
+    entityId: string,
+    currency: string,
+    variantId?: string,
+    customerGroupId?: string,
+    quantity?: number,
+    ctx?: TxContext,
+  ): Promise<Price[]> {
+    const db = this.getDb(ctx);
+    const now = new Date();
+
+    const rows = await db
+      .select()
+      .from(prices)
+      .where(
+        and(
+          eq(prices.entityId, entityId),
+          eq(prices.currency, currency),
+          or(isNull(prices.validFrom), lte(prices.validFrom, now)),
+          or(isNull(prices.validUntil), gte(prices.validUntil, now)),
+        ),
+      );
+
+    // Filter by variantId
+    let filtered = rows.filter((p) => {
+      if (variantId === undefined) return p.variantId === null;
+      return p.variantId === variantId || p.variantId === null;
+    });
+
+    // Filter by customerGroupId
+    if (customerGroupId) {
+      filtered = filtered.filter(
+        (p) =>
+          p.customerGroupId === null || p.customerGroupId === customerGroupId,
+      );
+    } else {
+      filtered = filtered.filter((p) => p.customerGroupId === null);
+    }
+
+    // Filter by quantity
+    if (quantity !== undefined) {
+      filtered = filtered.filter((p) => {
+        const minOk = p.minQuantity === null || quantity >= p.minQuantity;
+        const maxOk = p.maxQuantity === null || quantity <= p.maxQuantity;
+        return minOk && maxOk;
+      });
+    }
+
+    return filtered;
+  }
+
+  async createPrice(data: PriceInsert, ctx?: TxContext): Promise<Price> {
+    const db = this.getDb(ctx);
+    const rows = await db.insert(prices).values(data).returning();
+    return rows[0]!;
+  }
+
+  async updatePrice(
+    id: string,
+    data: Partial<Omit<PriceInsert, "id">>,
+    ctx?: TxContext,
+  ): Promise<Price | undefined> {
+    const db = this.getDb(ctx);
+    const rows = await db
+      .update(prices)
+      .set({ ...data, updatedAt: new Date() })
+      .where(eq(prices.id, id))
+      .returning();
+    return rows[0];
+  }
+
+  async deletePrice(id: string, ctx?: TxContext): Promise<boolean> {
+    const db = this.getDb(ctx);
+    const result = await db.delete(prices).where(eq(prices.id, id)).returning();
+    return result.length > 0;
+  }
+
+  async deletePricesByEntityId(
+    entityId: string,
+    ctx?: TxContext,
+  ): Promise<void> {
+    const db = this.getDb(ctx);
+    await db.delete(prices).where(eq(prices.entityId, entityId));
+  }
+
+  // ─────────────────────────────────────────────────────────────────────────────
+  // Price Modifiers
+  // ─────────────────────────────────────────────────────────────────────────────
+
+  async findModifierById(
+    orgId: string,
+    id: string,
+    ctx?: TxContext,
+  ): Promise<PriceModifier | undefined> {
+    const db = this.getDb(ctx);
+    const rows = await db
+      .select()
+      .from(priceModifiers)
+      .where(and(eq(priceModifiers.organizationId, orgId), eq(priceModifiers.id, id)));
+    return rows[0];
+  }
+
+  async findModifiersByEntityId(
+    entityId: string,
+    ctx?: TxContext,
+  ): Promise<PriceModifier[]> {
+    const db = this.getDb(ctx);
+    return db
+      .select()
+      .from(priceModifiers)
+      .where(eq(priceModifiers.entityId, entityId));
+  }
+
+  async findActiveModifiers(
+    entityId: string,
+    variantId?: string,
+    customerGroupId?: string,
+    currency?: string,
+    quantity?: number,
+    ctx?: TxContext,
+  ): Promise<PriceModifier[]> {
+    const db = this.getDb(ctx);
+    const now = new Date();
+
+    const rows = await db
+      .select()
+      .from(priceModifiers)
+      .where(
+        and(
+          or(
+            isNull(priceModifiers.entityId),
+            eq(priceModifiers.entityId, entityId),
+          ),
+          or(
+            isNull(priceModifiers.validFrom),
+            lte(priceModifiers.validFrom, now),
+          ),
+          or(
+            isNull(priceModifiers.validUntil),
+            gte(priceModifiers.validUntil, now),
+          ),
+        ),
+      );
+
+    // Filter by variantId
+    let filtered = rows.filter((m) => {
+      if (m.variantId === null) return true;
+      return m.variantId === variantId;
+    });
+
+    // Filter by customerGroupId
+    if (customerGroupId) {
+      filtered = filtered.filter(
+        (m) =>
+          m.customerGroupId === null || m.customerGroupId === customerGroupId,
+      );
+    } else {
+      filtered = filtered.filter((m) => m.customerGroupId === null);
+    }
+
+    // Filter by currency
+    if (currency) {
+      filtered = filtered.filter(
+        (m) => m.currency === null || m.currency === currency,
+      );
+    }
+
+    // Filter by quantity
+    if (quantity !== undefined) {
+      filtered = filtered.filter((m) => {
+        const minOk = m.minQuantity === null || quantity >= m.minQuantity;
+        const maxOk = m.maxQuantity === null || quantity <= m.maxQuantity;
+        return minOk && maxOk;
+      });
+    }
+
+    // Sort by priority (lower number = higher priority)
+    return filtered.sort((a, b) => a.priority - b.priority);
+  }
+
+  async createModifier(
+    data: PriceModifierInsert,
+    ctx?: TxContext,
+  ): Promise<PriceModifier> {
+    const db = this.getDb(ctx);
+    const rows = await db.insert(priceModifiers).values(data).returning();
+    return rows[0]!;
+  }
+
+  async updateModifier(
+    id: string,
+    data: Partial<Omit<PriceModifierInsert, "id">>,
+    ctx?: TxContext,
+  ): Promise<PriceModifier | undefined> {
+    const db = this.getDb(ctx);
+    const rows = await db
+      .update(priceModifiers)
+      .set({ ...data, updatedAt: new Date() })
+      .where(eq(priceModifiers.id, id))
+      .returning();
+    return rows[0];
+  }
+
+  async deleteModifier(id: string, ctx?: TxContext): Promise<boolean> {
+    const db = this.getDb(ctx);
+    const result = await db
+      .delete(priceModifiers)
+      .where(eq(priceModifiers.id, id))
+      .returning();
+    return result.length > 0;
+  }
+
+  async deleteModifiersByEntityId(
+    entityId: string,
+    ctx?: TxContext,
+  ): Promise<void> {
+    const db = this.getDb(ctx);
+    await db
+      .delete(priceModifiers)
+      .where(eq(priceModifiers.entityId, entityId));
+  }
+}