@porulle/core 0.1.0

package/dist/modules/cart/repository/index.js

@@ -0,0 +1,158 @@
+import { eq, and, lt } from "drizzle-orm";
+import { carts, cartLineItems } from "../schema.js";
+/**
+ * CartRepository provides type-safe database operations for shopping carts.
+ *
+ * This repository manages carts and cart line items.
+ * All methods support an optional TxContext parameter for transaction participation.
+ */
+export class CartRepository {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    getDb(ctx) {
+        return ctx?.tx ?? this.db;
+    }
+    // ─────────────────────────────────────────────────────────────────────────────
+    // Carts
+    // ─────────────────────────────────────────────────────────────────────────────
+    async findById(orgId, id, ctx) {
+        const db = this.getDb(ctx);
+        const rows = await db
+            .select()
+            .from(carts)
+            .where(and(eq(carts.organizationId, orgId), eq(carts.id, id)));
+        return rows[0];
+    }
+    async findByCustomerId(orgId, customerId, ctx) {
+        const db = this.getDb(ctx);
+        const rows = await db
+            .select()
+            .from(carts)
+            .where(and(eq(carts.organizationId, orgId), eq(carts.customerId, customerId), eq(carts.status, "active")));
+        return rows[0];
+    }
+    async findActiveByCustomerId(orgId, customerId, ctx) {
+        const db = this.getDb(ctx);
+        const rows = await db
+            .select()
+            .from(carts)
+            .where(and(eq(carts.organizationId, orgId), eq(carts.customerId, customerId), eq(carts.status, "active")));
+        return rows[0];
+    }
+    async findExpiredCarts(ctx) {
+        const db = this.getDb(ctx);
+        return db
+            .select()
+            .from(carts)
+            .where(and(eq(carts.status, "active"), lt(carts.expiresAt, new Date())));
+    }
+    async create(data, ctx) {
+        const db = this.getDb(ctx);
+        const rows = await db.insert(carts).values(data).returning();
+        return rows[0];
+    }
+    async update(id, data, ctx) {
+        const db = this.getDb(ctx);
+        const rows = await db
+            .update(carts)
+            .set({ ...data, updatedAt: new Date() })
+            .where(eq(carts.id, id))
+            .returning();
+        return rows[0];
+    }
+    async updateStatus(id, status, ctx) {
+        return this.update(id, { status }, ctx);
+    }
+    /**
+     * Atomically transitions a cart from "active" to "checking_out".
+     * Returns the updated cart if the transition succeeded, or undefined if
+     * the cart was not in "active" status (e.g., a concurrent checkout already
+     * claimed it). This prevents TOCTOU race conditions on double-checkout.
+     */
+    async transitionToCheckingOut(id, ctx) {
+        const db = this.getDb(ctx);
+        const rows = await db
+            .update(carts)
+            .set({ status: "checking_out", updatedAt: new Date() })
+            .where(and(eq(carts.id, id), eq(carts.status, "active")))
+            .returning();
+        return rows[0];
+    }
+    async delete(id, ctx) {
+        const db = this.getDb(ctx);
+        const result = await db.delete(carts).where(eq(carts.id, id)).returning();
+        return result.length > 0;
+    }
+    // ─────────────────────────────────────────────────────────────────────────────
+    // Cart Line Items
+    // ─────────────────────────────────────────────────────────────────────────────
+    async findLineItemById(id, ctx) {
+        const db = this.getDb(ctx);
+        const rows = await db
+            .select()
+            .from(cartLineItems)
+            .where(eq(cartLineItems.id, id));
+        return rows[0];
+    }
+    async findLineItemsByCartId(cartId, ctx) {
+        const db = this.getDb(ctx);
+        return db
+            .select()
+            .from(cartLineItems)
+            .where(eq(cartLineItems.cartId, cartId));
+    }
+    async findLineItemByEntity(cartId, entityId, variantId, ctx) {
+        const db = this.getDb(ctx);
+        const conditions = [
+            eq(cartLineItems.cartId, cartId),
+            eq(cartLineItems.entityId, entityId),
+        ];
+        if (variantId !== undefined) {
+            conditions.push(eq(cartLineItems.variantId, variantId));
+        }
+        const rows = await db
+            .select()
+            .from(cartLineItems)
+            .where(and(...conditions));
+        // Filter for exact variantId match
+        return rows.find((r) => r.variantId === (variantId ?? null));
+    }
+    async createLineItem(data, ctx) {
+        const db = this.getDb(ctx);
+        const rows = await db.insert(cartLineItems).values(data).returning();
+        return rows[0];
+    }
+    async updateLineItem(id, data, ctx) {
+        const db = this.getDb(ctx);
+        const rows = await db
+            .update(cartLineItems)
+            .set(data)
+            .where(eq(cartLineItems.id, id))
+            .returning();
+        return rows[0];
+    }
+    async deleteLineItem(id, ctx) {
+        const db = this.getDb(ctx);
+        const result = await db
+            .delete(cartLineItems)
+            .where(eq(cartLineItems.id, id))
+            .returning();
+        return result.length > 0;
+    }
+    async deleteLineItemsByCartId(cartId, ctx) {
+        const db = this.getDb(ctx);
+        await db.delete(cartLineItems).where(eq(cartLineItems.cartId, cartId));
+    }
+    // ─────────────────────────────────────────────────────────────────────────────
+    // Cart with Line Items (Aggregate)
+    // ─────────────────────────────────────────────────────────────────────────────
+    async findWithLineItems(orgId, id, ctx) {
+        const cart = await this.findById(orgId, id, ctx);
+        if (!cart)
+            return undefined;
+        const lineItems = await this.findLineItemsByCartId(id, ctx);
+        return { cart, lineItems };
+    }
+}

package/dist/modules/cart/schema.d.ts

@@ -0,0 +1,359 @@
+export declare const carts: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "carts";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: "id";
+            tableName: "carts";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        organizationId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "organization_id";
+            tableName: "carts";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        customerId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "customer_id";
+            tableName: "carts";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        status: import("drizzle-orm/pg-core").PgColumn<{
+            name: "status";
+            tableName: "carts";
+            dataType: "string";
+            columnType: "PgText";
+            data: "active" | "checking_out" | "merged" | "checked_out" | "abandoned";
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: ["active", "checking_out", "merged", "checked_out", "abandoned"];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        currency: import("drizzle-orm/pg-core").PgColumn<{
+            name: "currency";
+            tableName: "carts";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        secret: import("drizzle-orm/pg-core").PgColumn<{
+            name: "secret";
+            tableName: "carts";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        metadata: import("drizzle-orm/pg-core").PgColumn<{
+            name: "metadata";
+            tableName: "carts";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: Record<string, unknown>;
+            driverParam: unknown;
+            notNull: false;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            $type: Record<string, unknown>;
+        }>;
+        expiresAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "expires_at";
+            tableName: "carts";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        createdAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "created_at";
+            tableName: "carts";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        updatedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "updated_at";
+            tableName: "carts";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: "pg";
+}>;
+export declare const cartLineItems: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "cart_line_items";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: "id";
+            tableName: "cart_line_items";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        cartId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "cart_id";
+            tableName: "cart_line_items";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        entityId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "entity_id";
+            tableName: "cart_line_items";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        variantId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "variant_id";
+            tableName: "cart_line_items";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        quantity: import("drizzle-orm/pg-core").PgColumn<{
+            name: "quantity";
+            tableName: "cart_line_items";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        unitPriceSnapshot: import("drizzle-orm/pg-core").PgColumn<{
+            name: "unit_price_snapshot";
+            tableName: "cart_line_items";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        currency: import("drizzle-orm/pg-core").PgColumn<{
+            name: "currency";
+            tableName: "cart_line_items";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        notes: import("drizzle-orm/pg-core").PgColumn<{
+            name: "notes";
+            tableName: "cart_line_items";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        metadata: import("drizzle-orm/pg-core").PgColumn<{
+            name: "metadata";
+            tableName: "cart_line_items";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: Record<string, unknown>;
+            driverParam: unknown;
+            notNull: false;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            $type: Record<string, unknown>;
+        }>;
+        addedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "added_at";
+            tableName: "cart_line_items";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: "pg";
+}>;
+//# sourceMappingURL=schema.d.ts.map

package/dist/modules/cart/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../src/modules/cart/schema.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAoBf,CAAC;AAEJ,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAexB,CAAC"}

package/dist/modules/cart/schema.js

@@ -0,0 +1,40 @@
+import { index, integer, jsonb, pgTable, text, timestamp, uuid } from "drizzle-orm/pg-core";
+import { organization } from "../../auth/auth-schema.js";
+import { sellableEntities, variants } from "../catalog/schema.js";
+export const carts = pgTable("carts", {
+    id: uuid("id").defaultRandom().primaryKey(),
+    organizationId: text("organization_id").notNull().references(() => organization.id, { onDelete: "cascade" }),
+    customerId: uuid("customer_id"),
+    status: text("status", {
+        enum: ["active", "checking_out", "merged", "checked_out", "abandoned"],
+    })
+        .notNull()
+        .default("active"),
+    currency: text("currency").notNull().default("USD"),
+    secret: text("secret"),
+    metadata: jsonb("metadata").$type().default({}),
+    expiresAt: timestamp("expires_at", { withTimezone: true }).notNull(),
+    createdAt: timestamp("created_at", { withTimezone: true }).defaultNow().notNull(),
+    updatedAt: timestamp("updated_at", { withTimezone: true }).defaultNow().notNull(),
+}, (table) => ({
+    orgIdx: index("idx_carts_org").on(table.organizationId),
+    customerIdIdx: index("idx_carts_customer_id").on(table.customerId),
+    statusIdx: index("idx_carts_status").on(table.status),
+    expiresAtIdx: index("idx_carts_expires_at").on(table.expiresAt),
+}));
+export const cartLineItems = pgTable("cart_line_items", {
+    id: uuid("id").defaultRandom().primaryKey(),
+    cartId: uuid("cart_id")
+        .references(() => carts.id, { onDelete: "cascade" })
+        .notNull(),
+    entityId: uuid("entity_id").references(() => sellableEntities.id).notNull(),
+    variantId: uuid("variant_id").references(() => variants.id),
+    quantity: integer("quantity").notNull().default(1),
+    unitPriceSnapshot: integer("unit_price_snapshot").notNull(),
+    currency: text("currency").notNull(),
+    notes: text("notes"),
+    metadata: jsonb("metadata").$type().default({}),
+    addedAt: timestamp("added_at", { withTimezone: true }).defaultNow().notNull(),
+}, (table) => [
+    index("idx_cart_line_items_cart_id").on(table.cartId),
+]);

package/dist/modules/cart/schemas.d.ts

@@ -0,0 +1,29 @@
+import { z } from "@hono/zod-openapi";
+export declare const CreateCartBodySchema: z.ZodObject<{
+    customerId: z.ZodOptional<z.ZodString>;
+    currency: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const AddCartItemBodySchema: z.ZodObject<{
+    entityId: z.ZodString;
+    variantId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    quantity: z.ZodNumber;
+}, z.core.$strip>;
+export declare const UpdateCartItemQuantityBodySchema: z.ZodObject<{
+    quantity: z.ZodNumber;
+}, z.core.$strip>;
+export type CreateCartInput = z.infer<typeof CreateCartBodySchema> & {
+    metadata?: Record<string, unknown>;
+};
+export type AddCartItemInput = z.infer<typeof AddCartItemBodySchema> & {
+    cartId: string;
+    unitPriceSnapshot?: number;
+    currency?: string;
+    metadata?: Record<string, unknown>;
+};
+/** Hand-written: all fields come from path params + body; schema only has quantity. */
+export interface UpdateCartItemInput {
+    cartId: string;
+    itemId: string;
+    quantity: number;
+}
+//# sourceMappingURL=schemas.d.ts.map

package/dist/modules/cart/schemas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../../src/modules/cart/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,mBAAmB,CAAC;AAItC,eAAO,MAAM,oBAAoB;;;iBAGF,CAAC;AAEhC,eAAO,MAAM,qBAAqB;;;;iBAIF,CAAC;AAEjC,eAAO,MAAM,gCAAgC;;iBAEF,CAAC;AAI5C,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,GAAG;IACnE,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACpC,CAAC;AAEF,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,GAAG;IACrE,MAAM,EAAE,MAAM,CAAC;IACf,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACpC,CAAC;AAEF,uFAAuF;AACvF,MAAM,WAAW,mBAAmB;IAClC,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;CAClB"}

package/dist/modules/cart/schemas.js

@@ -0,0 +1,14 @@
+import { z } from "@hono/zod-openapi";
+// ─── Cart Body Schemas (single source of truth) ─────────────────────────────
+export const CreateCartBodySchema = z.object({
+    customerId: z.string().optional().openapi({ example: "customer-uuid" }),
+    currency: z.string().length(3).optional().openapi({ example: "USD" }),
+}).openapi("CreateCartRequest");
+export const AddCartItemBodySchema = z.object({
+    entityId: z.string().openapi({ example: "product-uuid" }),
+    variantId: z.string().nullable().optional().openapi({ example: "variant-uuid" }),
+    quantity: z.number().int().min(1).max(9999).openapi({ example: 1 }),
+}).openapi("AddCartItemRequest");
+export const UpdateCartItemQuantityBodySchema = z.object({
+    quantity: z.number().int().min(1).max(9999).openapi({ example: 2 }),
+}).openapi("UpdateCartItemQuantityRequest");