@porulle/plugin-pos-restaurant 0.1.0

package/dist/services/recipe-deduction-service.js

@@ -0,0 +1,144 @@
+/**
+ * RecipeDeductionService -- resolves recipe ingredient inventory deductions
+ * when a POS transaction completes.
+ *
+ * For each sold item:
+ *   1. Look up the entity's active recipe
+ *   2. For each ingredient with an entityId, calculate deduction quantity
+ *   3. Deduct via inventory service (preferred) or raw SQL (fallback)
+ *
+ * When the ServiceRegistry is provided (normal plugin boot), deductions
+ * go through kernel.services.inventory.adjust() which creates proper
+ * movements, fires hooks, and respects audit trail.
+ *
+ * When the ServiceRegistry is not available (standalone tests, scripts),
+ * falls back to raw SQL with the same atomic guard.
+ */
+import { eq, and, sql } from "@porulle/core/drizzle";
+import { Ok } from "@porulle/core";
+import { posRecipes, posRecipeIngredients } from "../schema.js";
+export class RecipeDeductionService {
+    db;
+    inventorySvc;
+    constructor(db, services) {
+        this.db = db;
+        // Extract inventory service if available
+        if (services?.inventory && typeof services.inventory.adjust === "function") {
+            this.inventorySvc = services.inventory;
+        }
+    }
+    /**
+     * Resolve all recipe ingredient deductions for a list of sold items.
+     * Pure query -- no mutations. Returns a flat list to pass to applyDeductions().
+     */
+    async resolveDeductions(orgId, items) {
+        const deductions = [];
+        for (const item of items) {
+            const recipes = await this.db
+                .select()
+                .from(posRecipes)
+                .where(and(eq(posRecipes.organizationId, orgId), eq(posRecipes.entityId, item.entityId), eq(posRecipes.isActive, true)));
+            if (recipes.length === 0)
+                continue;
+            const recipe = recipes[0];
+            const ingredients = await this.db
+                .select()
+                .from(posRecipeIngredients)
+                .where(eq(posRecipeIngredients.recipeId, recipe.id));
+            for (const ing of ingredients) {
+                if (ing.entityId == null)
+                    continue;
+                const deductQty = Math.ceil((ing.quantity * item.quantity) / recipe.yieldQuantity);
+                deductions.push({
+                    entityId: ing.entityId,
+                    variantId: ing.variantId ?? null,
+                    quantity: deductQty,
+                    unit: ing.unit,
+                    itemName: ing.ingredientName,
+                    reason: `Recipe: ${deductQty}${ing.unit} ${ing.ingredientName} for ${item.quantity}x ${recipe.name}`,
+                });
+            }
+        }
+        return Ok(deductions);
+    }
+    /**
+     * Apply deductions to inventory.
+     *
+     * Strategy 1 (preferred): Use inventory.adjust() via ServiceRegistry.
+     *   - Creates proper inventory_movements with audit trail
+     *   - Fires hooks (e.g., low-stock alerts)
+     *   - Respects the inventory service's stock guard logic
+     *
+     * Strategy 2 (fallback): Raw SQL with atomic WHERE guard.
+     *   - Used when services are not available (standalone scripts, tests)
+     *   - Same oversell protection via UPDATE ... WHERE quantity_on_hand >= N
+     */
+    async applyDeductions(tx, deductions, warehouseId, referenceType, referenceId, performedBy) {
+        if (this.inventorySvc) {
+            return this.applyViaService(deductions, warehouseId, performedBy);
+        }
+        return this.applyViaRawSQL(tx, deductions, warehouseId, referenceType, referenceId, performedBy);
+    }
+    /**
+     * Strategy 1: Deduct via kernel.services.inventory.adjust().
+     * Each deduction becomes a negative adjustment with a reason.
+     */
+    async applyViaService(deductions, warehouseId, performedBy) {
+        const inventory = this.inventorySvc;
+        const systemActor = {
+            type: "system",
+            userId: performedBy,
+            email: null,
+            name: "Recipe Deduction",
+            vendorId: null,
+            organizationId: null,
+            role: "system",
+            permissions: ["inventory:adjust"],
+        };
+        let applied = 0;
+        for (const d of deductions) {
+            const result = await inventory.adjust({
+                entityId: d.entityId,
+                warehouseId,
+                adjustment: -d.quantity,
+                reason: d.reason,
+            }, systemActor);
+            if (result.ok) {
+                applied++;
+            }
+            // If adjust fails (insufficient stock), it returns ok: false
+            // and the deduction is skipped -- same behavior as raw SQL guard
+        }
+        return Ok(applied);
+    }
+    /**
+     * Strategy 2: Raw SQL fallback with atomic oversell guard.
+     * Used when ServiceRegistry is not available.
+     */
+    async applyViaRawSQL(tx, deductions, warehouseId, referenceType, referenceId, performedBy) {
+        let applied = 0;
+        // PluginDb (PgDatabase) has .execute() — no cast needed
+        const exec = tx;
+        for (const d of deductions) {
+            const variantClause = d.variantId != null
+                ? sql `variant_id = ${d.variantId}`
+                : sql `variant_id IS NULL`;
+            // Atomic guard: only deduct if sufficient stock
+            const updateResult = await exec.execute(sql `UPDATE inventory_levels
+            SET quantity_on_hand = quantity_on_hand - ${d.quantity}, updated_at = NOW()
+            WHERE entity_id = ${d.entityId} AND warehouse_id = ${warehouseId} AND ${variantClause}
+              AND quantity_on_hand >= ${d.quantity}
+            RETURNING quantity_on_hand`);
+            const rows = Array.isArray(updateResult) ? updateResult : updateResult.rows;
+            if (rows.length === 0) {
+                await exec.execute(sql `INSERT INTO inventory_movements (entity_id, variant_id, warehouse_id, type, quantity, reference_type, reference_id, reason, performed_by)
+              VALUES (${d.entityId}, ${d.variantId}, ${warehouseId}, 'sale', ${0}, ${referenceType}, ${referenceId}, ${"SKIPPED: insufficient stock for " + d.reason}, ${performedBy})`);
+                continue;
+            }
+            await exec.execute(sql `INSERT INTO inventory_movements (entity_id, variant_id, warehouse_id, type, quantity, reference_type, reference_id, reason, performed_by)
+            VALUES (${d.entityId}, ${d.variantId}, ${warehouseId}, 'sale', ${-d.quantity}, ${referenceType}, ${referenceId}, ${d.reason}, ${performedBy})`);
+            applied++;
+        }
+        return Ok(applied);
+    }
+}

package/dist/services/recipe-service.d.ts

@@ -0,0 +1,43 @@
+/**
+ * RecipeService — Recipe/BOM management and COGS calculation.
+ *
+ * URY: Recipe mapping using Bill of Materials (BOM). Links menu items
+ * to raw ingredients for COGS calculation in Daily P&L.
+ * URY uses ERPNext's BOM doctype + Item Price for buying cost.
+ *
+ * Our implementation: pos_recipes + pos_recipe_ingredients tables.
+ * COGS = sum(ingredient.quantity * ingredient.costPerUnit) / yieldQuantity.
+ */
+import type { PluginResult } from "@porulle/core";
+import { posRecipes, posRecipeIngredients } from "../schema.js";
+import type { Db } from "../types.js";
+export declare class RecipeService {
+    private db;
+    constructor(db: Db);
+    createRecipe(orgId: string, input: {
+        entityId: string;
+        name: string;
+        yieldQuantity?: number;
+        ingredients: Array<{
+            ingredientName: string;
+            quantity: number;
+            unit: string;
+            costPerUnit: number;
+            entityId?: string;
+            variantId?: string;
+        }>;
+    }): Promise<PluginResult<{
+        id: string;
+        name: string;
+        costPerUnit: number;
+    }>>;
+    getRecipeWithIngredients(recipeId: string): Promise<PluginResult<{
+        recipe: typeof posRecipes.$inferSelect;
+        ingredients: Array<typeof posRecipeIngredients.$inferSelect>;
+        totalCost: number;
+        costPerUnit: number;
+    }>>;
+    calculateCOGS(orgId: string, entityId: string, quantity: number): Promise<number>;
+    listRecipes(orgId: string): Promise<PluginResult<Array<typeof posRecipes.$inferSelect>>>;
+}
+//# sourceMappingURL=recipe-service.d.ts.map

package/dist/services/recipe-service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"recipe-service.d.ts","sourceRoot":"","sources":["../../src/services/recipe-service.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAIH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAClD,OAAO,EAAE,UAAU,EAAE,oBAAoB,EAAE,MAAM,cAAc,CAAC;AAChE,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,aAAa,CAAC;AAEtC,qBAAa,aAAa;IACZ,OAAO,CAAC,EAAE;gBAAF,EAAE,EAAE,EAAE;IAEpB,YAAY,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE;QACvC,QAAQ,EAAE,MAAM,CAAC;QACjB,IAAI,EAAE,MAAM,CAAC;QACb,aAAa,CAAC,EAAE,MAAM,CAAC;QACvB,WAAW,EAAE,KAAK,CAAC;YACjB,cAAc,EAAE,MAAM,CAAC;YACvB,QAAQ,EAAE,MAAM,CAAC;YACjB,IAAI,EAAE,MAAM,CAAC;YACb,WAAW,EAAE,MAAM,CAAC;YACpB,QAAQ,CAAC,EAAE,MAAM,CAAC;YAClB,SAAS,CAAC,EAAE,MAAM,CAAC;SACpB,CAAC,CAAC;KACJ,GAAG,OAAO,CAAC,YAAY,CAAC;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,WAAW,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAkCtE,wBAAwB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,CAAC;QACrE,MAAM,EAAE,OAAO,UAAU,CAAC,YAAY,CAAC;QACvC,WAAW,EAAE,KAAK,CAAC,OAAO,oBAAoB,CAAC,YAAY,CAAC,CAAC;QAC7D,SAAS,EAAE,MAAM,CAAC;QAClB,WAAW,EAAE,MAAM,CAAC;KACrB,CAAC,CAAC;IAiBG,aAAa,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAmBjF,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,CAAC,KAAK,CAAC,OAAO,UAAU,CAAC,YAAY,CAAC,CAAC,CAAC;CAO/F"}

package/dist/services/recipe-service.js

@@ -0,0 +1,85 @@
+/**
+ * RecipeService — Recipe/BOM management and COGS calculation.
+ *
+ * URY: Recipe mapping using Bill of Materials (BOM). Links menu items
+ * to raw ingredients for COGS calculation in Daily P&L.
+ * URY uses ERPNext's BOM doctype + Item Price for buying cost.
+ *
+ * Our implementation: pos_recipes + pos_recipe_ingredients tables.
+ * COGS = sum(ingredient.quantity * ingredient.costPerUnit) / yieldQuantity.
+ */
+import { eq, and } from "@porulle/core/drizzle";
+import { Ok, Err } from "@porulle/core";
+import { posRecipes, posRecipeIngredients } from "../schema.js";
+export class RecipeService {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    async createRecipe(orgId, input) {
+        const rows = await this.db
+            .insert(posRecipes)
+            .values({
+            organizationId: orgId,
+            entityId: input.entityId,
+            name: input.name,
+            yieldQuantity: input.yieldQuantity ?? 1,
+        })
+            .returning();
+        const recipe = rows[0];
+        let totalCost = 0;
+        for (let i = 0; i < input.ingredients.length; i++) {
+            const ing = input.ingredients[i];
+            await this.db.insert(posRecipeIngredients).values({
+                recipeId: recipe.id,
+                ingredientName: ing.ingredientName,
+                quantity: ing.quantity,
+                unit: ing.unit,
+                costPerUnit: ing.costPerUnit,
+                entityId: ing.entityId,
+                variantId: ing.variantId,
+                sortOrder: i,
+            });
+            totalCost += ing.quantity * ing.costPerUnit;
+        }
+        const costPerUnit = Math.round(totalCost / (input.yieldQuantity ?? 1));
+        return Ok({ id: recipe.id, name: recipe.name, costPerUnit });
+    }
+    async getRecipeWithIngredients(recipeId) {
+        const recipes = await this.db.select().from(posRecipes).where(eq(posRecipes.id, recipeId));
+        if (recipes.length === 0)
+            return Err("Recipe not found");
+        const recipe = recipes[0];
+        const ingredients = await this.db
+            .select()
+            .from(posRecipeIngredients)
+            .where(eq(posRecipeIngredients.recipeId, recipeId))
+            .orderBy(posRecipeIngredients.sortOrder);
+        const totalCost = ingredients.reduce((sum, i) => sum + i.quantity * i.costPerUnit, 0);
+        const costPerUnit = Math.round(totalCost / recipe.yieldQuantity);
+        return Ok({ recipe, ingredients, totalCost, costPerUnit });
+    }
+    async calculateCOGS(orgId, entityId, quantity) {
+        const recipes = await this.db
+            .select()
+            .from(posRecipes)
+            .where(and(eq(posRecipes.organizationId, orgId), eq(posRecipes.entityId, entityId), eq(posRecipes.isActive, true)));
+        if (recipes.length === 0)
+            return 0;
+        const recipe = recipes[0];
+        const ingredients = await this.db
+            .select()
+            .from(posRecipeIngredients)
+            .where(eq(posRecipeIngredients.recipeId, recipe.id));
+        const costPerYield = ingredients.reduce((sum, i) => sum + i.quantity * i.costPerUnit, 0);
+        const costPerUnit = costPerYield / recipe.yieldQuantity;
+        return Math.round(costPerUnit * quantity);
+    }
+    async listRecipes(orgId) {
+        const rows = await this.db
+            .select()
+            .from(posRecipes)
+            .where(eq(posRecipes.organizationId, orgId));
+        return Ok(rows);
+    }
+}

package/dist/services/table-service.d.ts

@@ -0,0 +1,61 @@
+/**
+ * TableService — Table CRUD, status management, assignment, and transfer.
+ *
+ * Informed by URY's table management patterns:
+ * - URY Table: room-based (restaurant_room), binary occupied flag, floor plan layout,
+ *   shape (Circle/Square/Rectangle), is_take_away
+ * - table_transfer(): validates same room, target not occupied, updates KOT links
+ * - captain_transfer(): reassigns waiter, validates room access in multi-cashier mode
+ * - restrict_existing_order(): prevents double-booking (no 2 draft invoices on 1 table)
+ *
+ * Improvements over URY:
+ * - 4-state status machine (available -> occupied -> bill_requested -> cleaning)
+ *   instead of binary occupied flag
+ * - Multi-table assignments (large party across 2+ tables) via pos_table_assignments
+ * - Server section assignment (assignedOperatorId) as first-class field
+ * - Zone-based grouping instead of room doctype FK
+ */
+import type { PluginResult } from "@porulle/core";
+import type { Db, Table, TableAssignment, TableStatus } from "../types.js";
+export declare class TableService {
+    private db;
+    constructor(db: Db);
+    create(orgId: string, input: {
+        number: string;
+        zone: string;
+        capacity?: number;
+        minimumSeats?: number;
+        shape?: "rectangle" | "square" | "circle";
+        isTakeaway?: boolean;
+        layoutX?: number;
+        layoutY?: number;
+    }): Promise<PluginResult<Table>>;
+    list(orgId: string, zone?: string): Promise<PluginResult<Table[]>>;
+    getById(orgId: string, id: string): Promise<PluginResult<Table>>;
+    update(orgId: string, id: string, input: {
+        number?: string;
+        zone?: string;
+        capacity?: number;
+        shape?: "rectangle" | "square" | "circle";
+        assignedOperatorId?: string | null;
+        metadata?: Record<string, unknown>;
+    }): Promise<PluginResult<Table>>;
+    setStatus(orgId: string, id: string, newStatus: TableStatus): Promise<PluginResult<Table>>;
+    assignToTransaction(orgId: string, tableId: string, transactionId: string): Promise<PluginResult<TableAssignment>>;
+    clear(orgId: string, tableId: string): Promise<PluginResult<Table>>;
+    transfer(orgId: string, fromTableId: string, toTableId: string): Promise<PluginResult<{
+        from: Table;
+        to: Table;
+    }>>;
+    updateLayout(orgId: string, id: string, layout: {
+        layoutX?: number;
+        layoutY?: number;
+        layoutWidth?: number;
+        layoutHeight?: number;
+    }): Promise<PluginResult<Table>>;
+    listZones(orgId: string): Promise<PluginResult<Array<{
+        zone: string;
+        count: number;
+    }>>>;
+}
+//# sourceMappingURL=table-service.d.ts.map

package/dist/services/table-service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"table-service.d.ts","sourceRoot":"","sources":["../../src/services/table-service.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAIH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAElD,OAAO,KAAK,EAAE,EAAE,EAAE,KAAK,EAAE,eAAe,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAS3E,qBAAa,YAAY;IACX,OAAO,CAAC,EAAE;gBAAF,EAAE,EAAE,EAAE;IAIpB,MAAM,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE;QACjC,MAAM,EAAE,MAAM,CAAC;QACf,IAAI,EAAE,MAAM,CAAC;QACb,QAAQ,CAAC,EAAE,MAAM,CAAC;QAClB,YAAY,CAAC,EAAE,MAAM,CAAC;QACtB,KAAK,CAAC,EAAE,WAAW,GAAG,QAAQ,GAAG,QAAQ,CAAC;QAC1C,UAAU,CAAC,EAAE,OAAO,CAAC;QACrB,OAAO,CAAC,EAAE,MAAM,CAAC;QACjB,OAAO,CAAC,EAAE,MAAM,CAAC;KAClB,GAAG,OAAO,CAAC,YAAY,CAAC,KAAK,CAAC,CAAC;IA2B1B,IAAI,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,CAAC,KAAK,EAAE,CAAC,CAAC;IAalE,OAAO,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,CAAC,KAAK,CAAC,CAAC;IAUhE,MAAM,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE;QAC7C,MAAM,CAAC,EAAE,MAAM,CAAC;QAChB,IAAI,CAAC,EAAE,MAAM,CAAC;QACd,QAAQ,CAAC,EAAE,MAAM,CAAC;QAClB,KAAK,CAAC,EAAE,WAAW,GAAG,QAAQ,GAAG,QAAQ,CAAC;QAC1C,kBAAkB,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;QACnC,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;KACpC,GAAG,OAAO,CAAC,YAAY,CAAC,KAAK,CAAC,CAAC;IAa1B,SAAS,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,SAAS,EAAE,WAAW,GAAG,OAAO,CAAC,YAAY,CAAC,KAAK,CAAC,CAAC;IAuB1F,mBAAmB,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,CAAC,eAAe,CAAC,CAAC;IAgClH,KAAK,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,CAAC,KAAK,CAAC,CAAC;IAsBnE,QAAQ,CAAC,KAAK,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,CAAC;QAAE,IAAI,EAAE,KAAK,CAAC;QAAC,EAAE,EAAE,KAAK,CAAA;KAAE,CAAC,CAAC;IAqClH,YAAY,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,MAAM,EAAE;QACpD,OAAO,CAAC,EAAE,MAAM,CAAC;QACjB,OAAO,CAAC,EAAE,MAAM,CAAC;QACjB,WAAW,CAAC,EAAE,MAAM,CAAC;QACrB,YAAY,CAAC,EAAE,MAAM,CAAC;KACvB,GAAG,OAAO,CAAC,YAAY,CAAC,KAAK,CAAC,CAAC;IAa1B,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,CAAC,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC,CAAC;CAY9F"}

package/dist/services/table-service.js

@@ -0,0 +1,206 @@
+/**
+ * TableService — Table CRUD, status management, assignment, and transfer.
+ *
+ * Informed by URY's table management patterns:
+ * - URY Table: room-based (restaurant_room), binary occupied flag, floor plan layout,
+ *   shape (Circle/Square/Rectangle), is_take_away
+ * - table_transfer(): validates same room, target not occupied, updates KOT links
+ * - captain_transfer(): reassigns waiter, validates room access in multi-cashier mode
+ * - restrict_existing_order(): prevents double-booking (no 2 draft invoices on 1 table)
+ *
+ * Improvements over URY:
+ * - 4-state status machine (available -> occupied -> bill_requested -> cleaning)
+ *   instead of binary occupied flag
+ * - Multi-table assignments (large party across 2+ tables) via pos_table_assignments
+ * - Server section assignment (assignedOperatorId) as first-class field
+ * - Zone-based grouping instead of room doctype FK
+ */
+import { eq, and, sql } from "@porulle/core/drizzle";
+import { Ok, Err } from "@porulle/core";
+import { posTables, posTableAssignments } from "../schema.js";
+const VALID_TRANSITIONS = {
+    available: ["occupied"],
+    occupied: ["bill_requested", "available"],
+    bill_requested: ["cleaning", "available"],
+    cleaning: ["available"],
+};
+export class TableService {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    // ─── CRUD ──────────────────────────────────────────────────────────
+    async create(orgId, input) {
+        // Check for duplicate number in org
+        const existing = await this.db
+            .select()
+            .from(posTables)
+            .where(and(eq(posTables.organizationId, orgId), eq(posTables.number, input.number)));
+        if (existing.length > 0)
+            return Err(`Table '${input.number}' already exists`);
+        const rows = await this.db
+            .insert(posTables)
+            .values({
+            organizationId: orgId,
+            number: input.number,
+            zone: input.zone,
+            capacity: input.capacity ?? 4,
+            minimumSeats: input.minimumSeats ?? 1,
+            shape: input.shape ?? "rectangle",
+            isTakeaway: input.isTakeaway ?? false,
+            layoutX: input.layoutX ?? 0,
+            layoutY: input.layoutY ?? 0,
+        })
+            .returning();
+        return Ok(rows[0]);
+    }
+    async list(orgId, zone) {
+        const conditions = [eq(posTables.organizationId, orgId)];
+        if (zone)
+            conditions.push(eq(posTables.zone, zone));
+        const rows = await this.db
+            .select()
+            .from(posTables)
+            .where(and(...conditions))
+            .orderBy(posTables.number);
+        return Ok(rows);
+    }
+    async getById(orgId, id) {
+        const rows = await this.db
+            .select()
+            .from(posTables)
+            .where(and(eq(posTables.id, id), eq(posTables.organizationId, orgId)));
+        if (rows.length === 0)
+            return Err("Table not found");
+        return Ok(rows[0]);
+    }
+    async update(orgId, id, input) {
+        const rows = await this.db
+            .update(posTables)
+            .set({ ...input, updatedAt: new Date() })
+            .where(and(eq(posTables.id, id), eq(posTables.organizationId, orgId)))
+            .returning();
+        if (rows.length === 0)
+            return Err("Table not found");
+        return Ok(rows[0]);
+    }
+    // ─── Status Management ─────────────────────────────────────────────
+    async setStatus(orgId, id, newStatus) {
+        const table = await this.getById(orgId, id);
+        if (!table.ok)
+            return table;
+        const current = table.value.status;
+        const allowed = VALID_TRANSITIONS[current];
+        if (!allowed?.includes(newStatus)) {
+            return Err(`Cannot transition table from '${current}' to '${newStatus}'`);
+        }
+        const rows = await this.db
+            .update(posTables)
+            .set({ status: newStatus, updatedAt: new Date() })
+            .where(eq(posTables.id, id))
+            .returning();
+        return Ok(rows[0]);
+    }
+    // ─── Assignment ────────────────────────────────────────────────────
+    // Links a table to a POS transaction. Sets table status to "occupied".
+    // URY equivalent: sync_order() setting occupied=1 + latest_invoice_time.
+    async assignToTransaction(orgId, tableId, transactionId) {
+        // Lock the table row to prevent concurrent double-seating
+        const locked = await this.db
+            .select()
+            .from(posTables)
+            .where(and(eq(posTables.id, tableId), eq(posTables.organizationId, orgId)))
+            .for("update");
+        if (locked.length === 0)
+            return Err("Table not found");
+        const table = locked[0];
+        if (table.status !== "available") {
+            return Err(`Table '${table.number}' is not available (current: ${table.status})`);
+        }
+        // Set table to occupied (under lock — no race condition)
+        await this.db
+            .update(posTables)
+            .set({ status: "occupied", updatedAt: new Date() })
+            .where(eq(posTables.id, tableId));
+        // Create assignment
+        const rows = await this.db
+            .insert(posTableAssignments)
+            .values({ tableId, transactionId, seatedAt: new Date() })
+            .returning();
+        return Ok(rows[0]);
+    }
+    // ─── Clear ─────────────────────────────────────────────────────────
+    // Clears a table: removes assignments and sets status to "available".
+    async clear(orgId, tableId) {
+        // Delete assignments
+        await this.db
+            .delete(posTableAssignments)
+            .where(eq(posTableAssignments.tableId, tableId));
+        // Set available
+        const rows = await this.db
+            .update(posTables)
+            .set({ status: "available", updatedAt: new Date() })
+            .where(and(eq(posTables.id, tableId), eq(posTables.organizationId, orgId)))
+            .returning();
+        if (rows.length === 0)
+            return Err("Table not found");
+        return Ok(rows[0]);
+    }
+    // ─── Transfer ──────────────────────────────────────────────────────
+    // Moves a transaction from one table to another.
+    // URY equivalent: table_transfer() — validates same room, target not occupied.
+    // We validate same zone (our equivalent of URY's room).
+    async transfer(orgId, fromTableId, toTableId) {
+        const fromTable = await this.getById(orgId, fromTableId);
+        if (!fromTable.ok)
+            return fromTable;
+        const toTable = await this.getById(orgId, toTableId);
+        if (!toTable.ok)
+            return toTable;
+        // Same zone required (URY: same room)
+        if (fromTable.value.zone !== toTable.value.zone) {
+            return Err(`Cannot transfer between different zones ('${fromTable.value.zone}' -> '${toTable.value.zone}')`);
+        }
+        // Target must be available
+        if (toTable.value.status !== "available") {
+            return Err(`Target table '${toTable.value.number}' is not available`);
+        }
+        // Move assignments
+        await this.db
+            .update(posTableAssignments)
+            .set({ tableId: toTableId })
+            .where(eq(posTableAssignments.tableId, fromTableId));
+        // Update statuses
+        await this.db.update(posTables).set({ status: "available", updatedAt: new Date() }).where(eq(posTables.id, fromTableId));
+        await this.db.update(posTables).set({ status: "occupied", updatedAt: new Date() }).where(eq(posTables.id, toTableId));
+        const updatedFrom = (await this.getById(orgId, fromTableId)).ok ? (await this.getById(orgId, fromTableId)) : fromTable;
+        const updatedTo = (await this.getById(orgId, toTableId)).ok ? (await this.getById(orgId, toTableId)) : toTable;
+        if (!updatedFrom.ok || !updatedTo.ok)
+            return Err("Transfer failed");
+        return Ok({ from: updatedFrom.value, to: updatedTo.value });
+    }
+    // ─── Layout ────────────────────────────────────────────────────────
+    // Updates floor plan position. URY equivalent: updateTableLayout() in table-api.ts.
+    async updateLayout(orgId, id, layout) {
+        const rows = await this.db
+            .update(posTables)
+            .set({ ...layout, updatedAt: new Date() })
+            .where(and(eq(posTables.id, id), eq(posTables.organizationId, orgId)))
+            .returning();
+        if (rows.length === 0)
+            return Err("Table not found");
+        return Ok(rows[0]);
+    }
+    // ─── Zones ─────────────────────────────────────────────────────────
+    async listZones(orgId) {
+        const rows = await this.db
+            .select({
+            zone: posTables.zone,
+            count: sql `COUNT(*)`.as("count"),
+        })
+            .from(posTables)
+            .where(eq(posTables.organizationId, orgId))
+            .groupBy(posTables.zone);
+        return Ok(rows.map((r) => ({ zone: r.zone, count: Number(r.count) })));
+    }
+}

package/dist/types.d.ts

@@ -0,0 +1,35 @@
+export type { PluginDb as Db } from "@porulle/core";
+import type { posModifierGroups, posModifierOptions, posTables, posTableAssignments, kdsStations, kdsStationItemGroups, kdsTickets, kdsTicketItems } from "./schema.js";
+export type ModifierGroup = typeof posModifierGroups.$inferSelect;
+export type ModifierGroupInsert = typeof posModifierGroups.$inferInsert;
+export type ModifierOption = typeof posModifierOptions.$inferSelect;
+export type ModifierOptionInsert = typeof posModifierOptions.$inferInsert;
+export type Table = typeof posTables.$inferSelect;
+export type TableInsert = typeof posTables.$inferInsert;
+export type TableAssignment = typeof posTableAssignments.$inferSelect;
+export type TableAssignmentInsert = typeof posTableAssignments.$inferInsert;
+export type TableStatus = "available" | "occupied" | "bill_requested" | "cleaning";
+export type TableShape = "rectangle" | "square" | "circle";
+export type KDSStation = typeof kdsStations.$inferSelect;
+export type KDSStationInsert = typeof kdsStations.$inferInsert;
+export type KDSStationItemGroup = typeof kdsStationItemGroups.$inferSelect;
+export type KDSTicket = typeof kdsTickets.$inferSelect;
+export type KDSTicketInsert = typeof kdsTickets.$inferInsert;
+export type KDSTicketItem = typeof kdsTicketItems.$inferSelect;
+export type KDSTicketItemInsert = typeof kdsTicketItems.$inferInsert;
+export type TicketType = "new_order" | "modified" | "cancelled" | "partially_cancelled";
+export type TicketStatus = "pending" | "preparing" | "ready" | "served";
+export type TicketItemStatus = "pending" | "preparing" | "done";
+export type OrderType = "dine_in" | "takeaway" | "delivery";
+export interface POSRestaurantPluginOptions {
+    /** Enable kitchen display system. Default: true */
+    enableKDS?: boolean;
+    /** Enable tip collection on payments. Default: true */
+    enableTips?: boolean;
+    /** Enable item modifiers. Default: true */
+    enableModifiers?: boolean;
+    /** Minutes before KDS ticket turns red. Default: 15 */
+    kdsAlertMinutes?: number;
+}
+export declare const DEFAULT_RESTAURANT_OPTIONS: Required<POSRestaurantPluginOptions>;
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,QAAQ,IAAI,EAAE,EAAE,MAAM,eAAe,CAAC;AACpD,OAAO,KAAK,EACV,iBAAiB,EACjB,kBAAkB,EAClB,SAAS,EACT,mBAAmB,EACnB,WAAW,EACX,oBAAoB,EACpB,UAAU,EACV,cAAc,EACf,MAAM,aAAa,CAAC;AAIrB,MAAM,MAAM,aAAa,GAAG,OAAO,iBAAiB,CAAC,YAAY,CAAC;AAClE,MAAM,MAAM,mBAAmB,GAAG,OAAO,iBAAiB,CAAC,YAAY,CAAC;AACxE,MAAM,MAAM,cAAc,GAAG,OAAO,kBAAkB,CAAC,YAAY,CAAC;AACpE,MAAM,MAAM,oBAAoB,GAAG,OAAO,kBAAkB,CAAC,YAAY,CAAC;AAI1E,MAAM,MAAM,KAAK,GAAG,OAAO,SAAS,CAAC,YAAY,CAAC;AAClD,MAAM,MAAM,WAAW,GAAG,OAAO,SAAS,CAAC,YAAY,CAAC;AACxD,MAAM,MAAM,eAAe,GAAG,OAAO,mBAAmB,CAAC,YAAY,CAAC;AACtE,MAAM,MAAM,qBAAqB,GAAG,OAAO,mBAAmB,CAAC,YAAY,CAAC;AAE5E,MAAM,MAAM,WAAW,GAAG,WAAW,GAAG,UAAU,GAAG,gBAAgB,GAAG,UAAU,CAAC;AACnF,MAAM,MAAM,UAAU,GAAG,WAAW,GAAG,QAAQ,GAAG,QAAQ,CAAC;AAI3D,MAAM,MAAM,UAAU,GAAG,OAAO,WAAW,CAAC,YAAY,CAAC;AACzD,MAAM,MAAM,gBAAgB,GAAG,OAAO,WAAW,CAAC,YAAY,CAAC;AAC/D,MAAM,MAAM,mBAAmB,GAAG,OAAO,oBAAoB,CAAC,YAAY,CAAC;AAC3E,MAAM,MAAM,SAAS,GAAG,OAAO,UAAU,CAAC,YAAY,CAAC;AACvD,MAAM,MAAM,eAAe,GAAG,OAAO,UAAU,CAAC,YAAY,CAAC;AAC7D,MAAM,MAAM,aAAa,GAAG,OAAO,cAAc,CAAC,YAAY,CAAC;AAC/D,MAAM,MAAM,mBAAmB,GAAG,OAAO,cAAc,CAAC,YAAY,CAAC;AAErE,MAAM,MAAM,UAAU,GAAG,WAAW,GAAG,UAAU,GAAG,WAAW,GAAG,qBAAqB,CAAC;AACxF,MAAM,MAAM,YAAY,GAAG,SAAS,GAAG,WAAW,GAAG,OAAO,GAAG,QAAQ,CAAC;AACxE,MAAM,MAAM,gBAAgB,GAAG,SAAS,GAAG,WAAW,GAAG,MAAM,CAAC;AAChE,MAAM,MAAM,SAAS,GAAG,SAAS,GAAG,UAAU,GAAG,UAAU,CAAC;AAI5D,MAAM,WAAW,0BAA0B;IACzC,mDAAmD;IACnD,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,uDAAuD;IACvD,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,2CAA2C;IAC3C,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,uDAAuD;IACvD,eAAe,CAAC,EAAE,MAAM,CAAC;CAC1B;AAED,eAAO,MAAM,0BAA0B,EAAE,QAAQ,CAAC,0BAA0B,CAK3E,CAAC"}

package/dist/types.js

@@ -0,0 +1,6 @@
+export const DEFAULT_RESTAURANT_OPTIONS = {
+    enableKDS: true,
+    enableTips: true,
+    enableModifiers: true,
+    kdsAlertMinutes: 15,
+};

package/package.json

@@ -0,0 +1,61 @@
+{
+  "name": "@porulle/plugin-pos-restaurant",
+  "version": "0.1.0",
+  "license": "MIT",
+  "type": "module",
+  "exports": {
+    ".": {
+      "bun": "./src/index.ts",
+      "import": "./dist/index.js",
+      "types": "./src/index.ts"
+    },
+    "./schema": {
+      "bun": "./src/schema.ts",
+      "import": "./dist/schema.js",
+      "require": "./dist/schema.js",
+      "types": "./src/schema.ts"
+    }
+  },
+  "scripts": {
+    "build": "rm -rf dist tsconfig.build.tsbuildinfo && tsc -p tsconfig.build.json",
+    "check-types": "tsc --noEmit",
+    "lint": "eslint . --max-warnings 1000",
+    "test": "vitest run"
+  },
+  "dependencies": {
+    "@hono/zod-openapi": "^1.2.2",
+    "@porulle/core": "workspace:*",
+    "@porulle/plugin-pos": "workspace:*",
+    "hono": "^4.12.5"
+  },
+  "devDependencies": {
+    "@repo/eslint-config": "*",
+    "@repo/typescript-config": "*",
+    "@types/node": "^24.5.2",
+    "eslint": "^9.39.1",
+    "typescript": "5.9.2",
+    "vitest": "^3.2.4"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "src",
+    "dist",
+    "README.md"
+  ],
+  "peerDependencies": {
+    "zod": ">=4.0.0"
+  },
+  "description": "Restaurant layer on top of @porulle/plugin-pos: tables, floor zones, optional modifiers and KDS, checklists, alerts, recipes (food BOM), and analytics.",
+  "homepage": "https://porulle-docs.vercel.app",
+  "bugs": {
+    "url": "https://github.com/asyncdotengineering/porulle/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/asyncdotengineering/porulle.git",
+    "directory": "packages/plugins/plugin-pos-restaurant"
+  },
+  "author": "Porulle contributors"
+}