@porulle/core 0.1.0

package/src/modules/organization/module.ts

@@ -0,0 +1,11 @@
+import { member, organization } from "../../auth/auth-schema.js";
+import type { DrizzleDatabase } from "../../kernel/database/drizzle-db.js";
+import { defineModule } from "../../kernel/module/index.js";
+import { OrganizationService } from "./service.js";
+
+export const organizationModule = defineModule({
+  id: "organization",
+  schema: () => ({ organization, member }),
+  service: (deps) =>
+    new OrganizationService(deps.db.db as DrizzleDatabase),
+});

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.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

@@ -0,0 +1,45 @@
+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>>;
+}

package/src/modules/payments/module.ts

@@ -0,0 +1,14 @@
+import type { CommerceConfig } from "../../config/types.js";
+import { defineModule } from "../../kernel/module/index.js";
+import { PaymentsService } from "./service.js";
+
+export const paymentsModule = defineModule<
+  Record<string, never>,
+  PaymentsService,
+  Record<string, never>
+>({
+  id: "payments",
+  schema: () => ({}),
+  service: (deps) =>
+    new PaymentsService((deps.config as CommerceConfig).payments),
+});

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

@@ -0,0 +1,6 @@
+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

@@ -0,0 +1,107 @@
+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/index.ts

@@ -0,0 +1 @@
+export { pricingModule } from "./module.js";

package/src/modules/pricing/module.ts

@@ -0,0 +1,30 @@
+import type { DrizzleDatabase } from "../../kernel/database/drizzle-db.js";
+import { defineModule } from "../../kernel/module/index.js";
+import type { CatalogRepository } from "../catalog/repository/index.js";
+import { PricingRepository } from "./repository/index.js";
+import { PricingService } from "./service.js";
+import { priceModifiers, prices } from "./schema.js";
+
+type PricingModuleDeps = {
+  catalog: {
+    repository: CatalogRepository;
+  };
+};
+
+export const pricingModule = defineModule<
+  { prices: typeof prices; priceModifiers: typeof priceModifiers },
+  PricingService,
+  PricingModuleDeps
+>({
+  id: "pricing",
+  dependencies: ["catalog"],
+  schema: () => ({ prices, priceModifiers }),
+  service: (deps) =>
+    new PricingService({
+      repository: new PricingRepository(deps.db.db as DrizzleDatabase),
+      catalogRepository: deps.services.catalog.repository,
+      hooks: deps.hooks,
+      services: deps.services,
+      database: deps.db,
+    }),
+});