@unifiedcommerce/core 0.1.0 → 0.2.0

package/src/modules/organization/service.ts

@@ -1,191 +0,0 @@
-/**
- * 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.js";
-import type { AuthInstance } from "../../auth/setup.js";
-
-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

@@ -1,47 +0,0 @@
-import type { Result } from "../../kernel/result.js";
-
-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

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

package/src/modules/payments/service.ts

@@ -1,107 +0,0 @@
-import { CommerceValidationError } from "../../kernel/errors.js";
-import { Err, Ok, type Result } from "../../kernel/result.js";
-import type {
-  CreatePaymentIntentParams,
-  PaymentAdapter,
-  PaymentCapture,
-  PaymentIntent,
-  PaymentRefund,
-} from "./adapter.js";
-
-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

@@ -1,291 +0,0 @@
-import { eq, and, lte, gte, or, isNull } from "drizzle-orm";
-import type { TxContext } from "../../../kernel/database/tx-context.js";
-import type {
-  DrizzleDatabase,
-  DbOrTx,
-} from "../../../kernel/database/drizzle-db.js";
-import { prices, priceModifiers } from "../schema.js";
-
-// 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));
-  }
-}