@unifiedcommerce/core 0.0.1

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

@@ -0,0 +1,327 @@
+import { eq, and } from "drizzle-orm";
+import type { TxContext } from "../../../kernel/database/tx-context";
+import type {
+  DrizzleDatabase,
+  DbOrTx,
+} from "../../../kernel/database/drizzle-db";
+import {
+  customers,
+  customerAddresses,
+  customerGroups,
+  customerGroupMembers,
+} from "../schema";
+
+// Infer types from Drizzle schema
+export type Customer = typeof customers.$inferSelect;
+export type CustomerInsert = typeof customers.$inferInsert;
+export type CustomerAddress = typeof customerAddresses.$inferSelect;
+export type CustomerAddressInsert = typeof customerAddresses.$inferInsert;
+export type CustomerGroup = typeof customerGroups.$inferSelect;
+export type CustomerGroupInsert = typeof customerGroups.$inferInsert;
+export type CustomerGroupMember = typeof customerGroupMembers.$inferSelect;
+export type CustomerGroupMemberInsert =
+  typeof customerGroupMembers.$inferInsert;
+
+/**
+ * CustomersRepository provides type-safe database operations for customers.
+ *
+ * This repository manages customers, addresses, groups, and group memberships.
+ * All methods support an optional TxContext parameter for transaction participation.
+ */
+export class CustomersRepository {
+  constructor(private readonly db: DrizzleDatabase) {}
+
+  private getDb(ctx?: TxContext): DbOrTx {
+    return (ctx?.tx as DbOrTx | undefined) ?? this.db;
+  }
+
+  // ─────────────────────────────────────────────────────────────────────────────
+  // Customers
+  // ─────────────────────────────────────────────────────────────────────────────
+
+  async findById(orgId: string, id: string, ctx?: TxContext): Promise<Customer | undefined> {
+    const db = this.getDb(ctx);
+    const rows = await db
+      .select()
+      .from(customers)
+      .where(and(eq(customers.organizationId, orgId), eq(customers.id, id)));
+    return rows[0];
+  }
+
+  async findByUserId(
+    orgId: string,
+    userId: string,
+    ctx?: TxContext,
+  ): Promise<Customer | undefined> {
+    const db = this.getDb(ctx);
+    const rows = await db
+      .select()
+      .from(customers)
+      .where(and(eq(customers.organizationId, orgId), eq(customers.userId, userId)));
+    return rows[0];
+  }
+
+  async findByEmail(
+    orgId: string,
+    email: string,
+    ctx?: TxContext,
+  ): Promise<Customer | undefined> {
+    const db = this.getDb(ctx);
+    const rows = await db
+      .select()
+      .from(customers)
+      .where(and(eq(customers.organizationId, orgId), eq(customers.email, email)));
+    return rows[0];
+  }
+
+  async findByPosPin(
+    orgId: string,
+    hashedPin: string,
+    ctx?: TxContext,
+  ): Promise<Customer | undefined> {
+    const db = this.getDb(ctx);
+    const rows = await db
+      .select()
+      .from(customers)
+      .where(and(eq(customers.organizationId, orgId), eq(customers.posOperatorPin, hashedPin)));
+    return rows[0];
+  }
+
+  async findAll(orgId: string, ctx?: TxContext): Promise<Customer[]> {
+    const db = this.getDb(ctx);
+    return db
+      .select()
+      .from(customers)
+      .where(eq(customers.organizationId, orgId));
+  }
+
+  async create(data: CustomerInsert, ctx?: TxContext): Promise<Customer> {
+    const db = this.getDb(ctx);
+    const rows = await db.insert(customers).values(data).returning();
+    return rows[0]!;
+  }
+
+  async update(
+    id: string,
+    data: Partial<Omit<CustomerInsert, "id">>,
+    ctx?: TxContext,
+  ): Promise<Customer | undefined> {
+    const db = this.getDb(ctx);
+    const rows = await db
+      .update(customers)
+      .set({ ...data, updatedAt: new Date() })
+      .where(eq(customers.id, id))
+      .returning();
+    return rows[0];
+  }
+
+  async delete(id: string, ctx?: TxContext): Promise<boolean> {
+    const db = this.getDb(ctx);
+    const result = await db
+      .delete(customers)
+      .where(eq(customers.id, id))
+      .returning();
+    return result.length > 0;
+  }
+
+  // ─────────────────────────────────────────────────────────────────────────────
+  // Customer Addresses
+  // ─────────────────────────────────────────────────────────────────────────────
+
+  async findAddressById(
+    id: string,
+    ctx?: TxContext,
+  ): Promise<CustomerAddress | undefined> {
+    const db = this.getDb(ctx);
+    const rows = await db
+      .select()
+      .from(customerAddresses)
+      .where(eq(customerAddresses.id, id));
+    return rows[0];
+  }
+
+  async findAddressesByCustomerId(
+    customerId: string,
+    ctx?: TxContext,
+  ): Promise<CustomerAddress[]> {
+    const db = this.getDb(ctx);
+    return db
+      .select()
+      .from(customerAddresses)
+      .where(eq(customerAddresses.customerId, customerId));
+  }
+
+  async findDefaultAddress(
+    customerId: string,
+    type: "shipping" | "billing",
+    ctx?: TxContext,
+  ): Promise<CustomerAddress | undefined> {
+    const db = this.getDb(ctx);
+    const rows = await db
+      .select()
+      .from(customerAddresses)
+      .where(
+        and(
+          eq(customerAddresses.customerId, customerId),
+          eq(customerAddresses.type, type),
+          eq(customerAddresses.isDefault, true),
+        ),
+      );
+    return rows[0];
+  }
+
+  async createAddress(
+    data: CustomerAddressInsert,
+    ctx?: TxContext,
+  ): Promise<CustomerAddress> {
+    const db = this.getDb(ctx);
+    const rows = await db.insert(customerAddresses).values(data).returning();
+    return rows[0]!;
+  }
+
+  async updateAddress(
+    id: string,
+    data: Partial<Omit<CustomerAddressInsert, "id">>,
+    ctx?: TxContext,
+  ): Promise<CustomerAddress | undefined> {
+    const db = this.getDb(ctx);
+    const rows = await db
+      .update(customerAddresses)
+      .set(data)
+      .where(eq(customerAddresses.id, id))
+      .returning();
+    return rows[0];
+  }
+
+  async deleteAddress(id: string, ctx?: TxContext): Promise<boolean> {
+    const db = this.getDb(ctx);
+    const result = await db
+      .delete(customerAddresses)
+      .where(eq(customerAddresses.id, id))
+      .returning();
+    return result.length > 0;
+  }
+
+  async deleteAddressesByCustomerId(
+    customerId: string,
+    ctx?: TxContext,
+  ): Promise<void> {
+    const db = this.getDb(ctx);
+    await db
+      .delete(customerAddresses)
+      .where(eq(customerAddresses.customerId, customerId));
+  }
+
+  // ─────────────────────────────────────────────────────────────────────────────
+  // Customer Groups
+  // ─────────────────────────────────────────────────────────────────────────────
+
+  async findGroupById(
+    orgId: string,
+    id: string,
+    ctx?: TxContext,
+  ): Promise<CustomerGroup | undefined> {
+    const db = this.getDb(ctx);
+    const rows = await db
+      .select()
+      .from(customerGroups)
+      .where(and(eq(customerGroups.organizationId, orgId), eq(customerGroups.id, id)));
+    return rows[0];
+  }
+
+  async findGroupByName(
+    orgId: string,
+    name: string,
+    ctx?: TxContext,
+  ): Promise<CustomerGroup | undefined> {
+    const db = this.getDb(ctx);
+    const rows = await db
+      .select()
+      .from(customerGroups)
+      .where(and(eq(customerGroups.organizationId, orgId), eq(customerGroups.name, name)));
+    return rows[0];
+  }
+
+  async findAllGroups(orgId: string, ctx?: TxContext): Promise<CustomerGroup[]> {
+    const db = this.getDb(ctx);
+    return db.select().from(customerGroups).where(eq(customerGroups.organizationId, orgId));
+  }
+
+  async createGroup(
+    data: CustomerGroupInsert,
+    ctx?: TxContext,
+  ): Promise<CustomerGroup> {
+    const db = this.getDb(ctx);
+    const rows = await db.insert(customerGroups).values(data).returning();
+    return rows[0]!;
+  }
+
+  async updateGroup(
+    id: string,
+    data: Partial<Omit<CustomerGroupInsert, "id">>,
+    ctx?: TxContext,
+  ): Promise<CustomerGroup | undefined> {
+    const db = this.getDb(ctx);
+    const rows = await db
+      .update(customerGroups)
+      .set(data)
+      .where(eq(customerGroups.id, id))
+      .returning();
+    return rows[0];
+  }
+
+  async deleteGroup(id: string, ctx?: TxContext): Promise<boolean> {
+    const db = this.getDb(ctx);
+    const result = await db
+      .delete(customerGroups)
+      .where(eq(customerGroups.id, id))
+      .returning();
+    return result.length > 0;
+  }
+
+  // ─────────────────────────────────────────────────────────────────────────────
+  // Customer Group Members
+  // ─────────────────────────────────────────────────────────────────────────────
+
+  async findGroupsByCustomerId(
+    customerId: string,
+    ctx?: TxContext,
+  ): Promise<string[]> {
+    const db = this.getDb(ctx);
+    const rows = await db
+      .select({ groupId: customerGroupMembers.groupId })
+      .from(customerGroupMembers)
+      .where(eq(customerGroupMembers.customerId, customerId));
+    return rows.map((r) => r.groupId);
+  }
+
+  async addToGroup(
+    customerId: string,
+    groupId: string,
+    ctx?: TxContext,
+  ): Promise<void> {
+    const db = this.getDb(ctx);
+    await db
+      .insert(customerGroupMembers)
+      .values({ customerId, groupId })
+      .onConflictDoNothing();
+  }
+
+  async removeFromGroup(
+    customerId: string,
+    groupId: string,
+    ctx?: TxContext,
+  ): Promise<boolean> {
+    const db = this.getDb(ctx);
+    const result = await db
+      .delete(customerGroupMembers)
+      .where(
+        and(
+          eq(customerGroupMembers.customerId, customerId),
+          eq(customerGroupMembers.groupId, groupId),
+        ),
+      )
+      .returning();
+    return result.length > 0;
+  }
+}

package/src/modules/customers/schema.ts

@@ -0,0 +1,64 @@
+import { boolean, index, jsonb, pgTable, text, timestamp, uniqueIndex, uuid } from "drizzle-orm/pg-core";
+import { organization } from "../../auth/auth-schema";
+
+export const customers = pgTable("customers", {
+  id: uuid("id").defaultRandom().primaryKey(),
+  organizationId: text("organization_id").notNull().references(() => organization.id, { onDelete: "cascade" }),
+  userId: text("user_id").notNull(),
+  email: text("email"),
+  phone: text("phone"),
+  firstName: text("first_name"),
+  lastName: text("last_name"),
+  metadata: jsonb("metadata").$type<Record<string, unknown>>().default({}),
+  createdAt: timestamp("created_at", { withTimezone: true }).defaultNow().notNull(),
+  updatedAt: timestamp("updated_at", { withTimezone: true }).defaultNow().notNull(),
+  posOperatorPin: text("pos_operator_pin"),
+}, (table) => ({
+  orgIdx: index("idx_customers_org").on(table.organizationId),
+  orgUserIdUnique: uniqueIndex("customers_org_user_id_unique").on(table.organizationId, table.userId),
+  orgEmailUnique: uniqueIndex("customers_org_email_unique").on(table.organizationId, table.email),
+}));
+
+export const customerAddresses = pgTable("customer_addresses", {
+  id: uuid("id").defaultRandom().primaryKey(),
+  customerId: uuid("customer_id")
+    .references(() => customers.id, { onDelete: "cascade" })
+    .notNull(),
+  type: text("type", { enum: ["shipping", "billing"] }).notNull(),
+  isDefault: boolean("is_default").notNull().default(false),
+  firstName: text("first_name").notNull(),
+  lastName: text("last_name").notNull(),
+  line1: text("line1").notNull(),
+  line2: text("line2"),
+  city: text("city").notNull(),
+  state: text("state"),
+  postalCode: text("postal_code"),
+  country: text("country").notNull(),
+  phone: text("phone"),
+}, (table) => [
+  index("idx_customer_addresses_customer_id").on(table.customerId),
+]);
+
+export const customerGroups = pgTable("customer_groups", {
+  id: uuid("id").defaultRandom().primaryKey(),
+  organizationId: text("organization_id").notNull().references(() => organization.id, { onDelete: "cascade" }),
+  name: text("name").notNull(),
+  description: text("description"),
+  metadata: jsonb("metadata").$type<Record<string, unknown>>().default({}),
+}, (table) => ({
+  orgIdx: index("idx_customer_groups_org").on(table.organizationId),
+  orgNameUnique: uniqueIndex("customer_groups_org_name_unique").on(table.organizationId, table.name),
+}));
+
+export const customerGroupMembers = pgTable("customer_group_members", {
+  customerId: uuid("customer_id")
+    .references(() => customers.id, { onDelete: "cascade" })
+    .notNull(),
+  groupId: uuid("group_id")
+    .references(() => customerGroups.id, { onDelete: "cascade" })
+    .notNull(),
+}, (table) => [
+  index("idx_group_members_customer_id").on(table.customerId),
+  index("idx_group_members_group_id").on(table.groupId),
+  uniqueIndex("customer_group_members_customer_group_unique").on(table.customerId, table.groupId),
+]);

package/src/modules/customers/service.ts

@@ -0,0 +1,171 @@
+import { resolveOrgId } from "../../auth/org";
+import type { Actor } from "../../auth/types";
+import { CommerceNotFoundError } from "../../kernel/errors";
+import { Err, Ok, type Result } from "../../kernel/result";
+import type { TxContext } from "../../kernel/database/tx-context";
+import type {
+  CustomersRepository,
+  Customer,
+  CustomerAddress,
+  CustomerAddressInsert,
+} from "./repository";
+
+interface CustomerServiceDeps {
+  repository: CustomersRepository;
+}
+
+export class CustomerService {
+  private readonly repo: CustomersRepository;
+
+  constructor(private deps: CustomerServiceDeps) {
+    this.repo = deps.repository;
+  }
+
+  private async getOrCreateByUserId(
+    orgId: string,
+    userId: string,
+    ctx?: TxContext,
+  ): Promise<Customer> {
+    const existing = await this.repo.findByUserId(orgId, userId, ctx);
+    if (existing) {
+      return existing;
+    }
+
+    const customer = await this.repo.create(
+      {
+        organizationId: orgId,
+        userId,
+        metadata: {},
+      },
+      ctx,
+    );
+
+    return customer;
+  }
+
+  async getById(
+    id: string,
+    actor?: Actor | null,
+    ctx?: TxContext,
+  ): Promise<Result<Customer>> {
+    const orgId = resolveOrgId(actor ?? ctx?.actor ?? null);
+    const customer = await this.repo.findById(orgId, id, ctx);
+    if (!customer) return Err(new CommerceNotFoundError("Customer not found."));
+    return Ok(customer);
+  }
+
+  async getByUserId(
+    userId: string,
+    actor?: Actor | null,
+    ctx?: TxContext,
+  ): Promise<Result<Customer>> {
+    const orgId = resolveOrgId(actor ?? ctx?.actor ?? null);
+    const customer = await this.getOrCreateByUserId(orgId, userId, ctx);
+    return Ok(customer);
+  }
+
+  async updateByUserId(
+    userId: string,
+    updates: Partial<
+      Omit<Customer, "id" | "userId" | "createdAt" | "updatedAt">
+    >,
+    actor?: Actor | null,
+    ctx?: TxContext,
+  ): Promise<Result<Customer>> {
+    const orgId = resolveOrgId(actor ?? ctx?.actor ?? null);
+    const customer = await this.getOrCreateByUserId(orgId, userId, ctx);
+
+    const updated = await this.repo.update(customer.id, updates, ctx);
+    if (!updated) {
+      return Err(new CommerceNotFoundError("Customer not found."));
+    }
+
+    return Ok(updated);
+  }
+
+  async getAddresses(
+    userId: string,
+    actor?: Actor | null,
+    ctx?: TxContext,
+  ): Promise<Result<CustomerAddress[]>> {
+    const orgId = resolveOrgId(actor ?? ctx?.actor ?? null);
+    const customer = await this.getOrCreateByUserId(orgId, userId, ctx);
+    const addresses = await this.repo.findAddressesByCustomerId(
+      customer.id,
+      ctx,
+    );
+    return Ok(addresses);
+  }
+
+  async addAddress(
+    userId: string,
+    input: Omit<CustomerAddressInsert, "id" | "customerId">,
+    actor?: Actor | null,
+    ctx?: TxContext,
+  ): Promise<Result<CustomerAddress>> {
+    const orgId = resolveOrgId(actor ?? ctx?.actor ?? null);
+    const customer = await this.getOrCreateByUserId(orgId, userId, ctx);
+
+    // If new address is default, unset other defaults of same type
+    if (input.isDefault) {
+      const addresses = await this.repo.findAddressesByCustomerId(
+        customer.id,
+        ctx,
+      );
+      for (const addr of addresses) {
+        if (addr.type === input.type && addr.isDefault) {
+          await this.repo.updateAddress(addr.id, { isDefault: false }, ctx);
+        }
+      }
+    }
+
+    const address = await this.repo.createAddress(
+      {
+        ...input,
+        customerId: customer.id,
+      },
+      ctx,
+    );
+
+    return Ok(address);
+  }
+
+  async deleteAddress(
+    userId: string,
+    addressId: string,
+    actor?: Actor | null,
+    ctx?: TxContext,
+  ): Promise<Result<void>> {
+    const orgId = resolveOrgId(actor ?? ctx?.actor ?? null);
+    const customer = await this.getOrCreateByUserId(orgId, userId, ctx);
+    const addresses = await this.repo.findAddressesByCustomerId(
+      customer.id,
+      ctx,
+    );
+
+    const addressExists = addresses.some((addr) => addr.id === addressId);
+    if (!addressExists) {
+      return Err(new CommerceNotFoundError("Address not found."));
+    }
+
+    await this.repo.deleteAddress(addressId, ctx);
+    return Ok(undefined);
+  }
+
+  async findPOSOperatorByPin(
+    hashedPin: string,
+    actor?: Actor | null,
+    ctx?: TxContext,
+  ): Promise<{ id: string; name: string } | null> {
+    const orgId = resolveOrgId(actor ?? ctx?.actor ?? null);
+    const user = await this.repo.findByPosPin(orgId, hashedPin, ctx);
+    if (!user) return null;
+    return {
+      id: user.userId,
+      name:
+        [user.firstName, user.lastName].filter(Boolean).join(" ") ||
+        user.email ||
+        "POS Operator",
+    };
+  }
+}