@porulle/plugin-pos-restaurant 0.1.0

package/dist/services/alert-service.js

@@ -0,0 +1,173 @@
+/**
+ * AlertService — Operational red flags and real-time alerts.
+ *
+ * URY: Operational Red Flags & Alerts system:
+ * - Delayed orders and preparation time breaches
+ * - KOT not started after order placement
+ * - Unclosed bills and prolonged table occupancy
+ * - Excessive KOT cancellations and modifications
+ * - Real-time alerts for operational exceptions
+ *
+ * URY implementation: ury_kot_notification.py polls KOTs and creates
+ * system notifications when warning time exceeded. KDS displays timer
+ * in red when threshold breached. kotValidationThread runs every minute.
+ *
+ * Our implementation: AlertService creates persistent alert records,
+ * queryable via API. Alert detection runs on demand (called by scheduler
+ * or via route). Each alert type has configurable thresholds.
+ */
+import { eq, and, sql, desc } from "@porulle/core/drizzle";
+import { Ok, Err } from "@porulle/core";
+import { posRestaurantAlerts, posAlertConfig, kdsTickets, posTables } from "../schema.js";
+export class AlertService {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    // ─── Alert Configuration ───────────────────────────────────────────
+    async setThreshold(orgId, alertType, thresholdMinutes, notifyRoles) {
+        // Upsert: try update, then insert
+        const existing = await this.db
+            .select()
+            .from(posAlertConfig)
+            .where(and(eq(posAlertConfig.organizationId, orgId), eq(posAlertConfig.alertType, alertType)));
+        if (existing.length > 0) {
+            await this.db
+                .update(posAlertConfig)
+                .set({ thresholdMinutes, ...(notifyRoles ? { notifyRoles } : {}), updatedAt: new Date() })
+                .where(eq(posAlertConfig.id, existing[0].id));
+        }
+        else {
+            await this.db.insert(posAlertConfig).values({
+                organizationId: orgId,
+                alertType,
+                thresholdMinutes,
+                notifyRoles: notifyRoles ?? [],
+            });
+        }
+        return Ok({ alertType, thresholdMinutes });
+    }
+    async getConfig(orgId) {
+        const rows = await this.db
+            .select()
+            .from(posAlertConfig)
+            .where(eq(posAlertConfig.organizationId, orgId));
+        return Ok(rows.map((r) => ({ alertType: r.alertType, thresholdMinutes: r.thresholdMinutes, isEnabled: r.isEnabled })));
+    }
+    // ─── Alert Detection ──────────────────────────────────────────────
+    // Scans for conditions that trigger alerts. Called on demand or by scheduler.
+    async detectDelayedOrders(orgId) {
+        const config = await this.getThreshold(orgId, "delayed_order");
+        if (!config)
+            return 0;
+        const threshold = new Date(Date.now() - config.thresholdMinutes * 60 * 1000);
+        // Find pending tickets older than threshold
+        const delayed = await this.db
+            .select({ id: kdsTickets.id, transactionId: kdsTickets.transactionId, stationId: kdsTickets.stationId })
+            .from(kdsTickets)
+            .where(and(eq(kdsTickets.organizationId, orgId), eq(kdsTickets.status, "pending"), sql `${kdsTickets.createdAt} < ${threshold}`));
+        let count = 0;
+        for (const ticket of delayed) {
+            const exists = await this.alertExists(orgId, "delayed_order", ticket.id);
+            if (!exists) {
+                await this.createAlert(orgId, "delayed_order", "kds_ticket", ticket.id, `KDS ticket for transaction ${ticket.transactionId} has been pending for over ${config.thresholdMinutes} minutes`);
+                count++;
+            }
+        }
+        return count;
+    }
+    async detectKotNotStarted(orgId) {
+        const config = await this.getThreshold(orgId, "kot_not_started");
+        if (!config)
+            return 0;
+        const threshold = new Date(Date.now() - config.thresholdMinutes * 60 * 1000);
+        const notStarted = await this.db
+            .select({ id: kdsTickets.id, transactionId: kdsTickets.transactionId })
+            .from(kdsTickets)
+            .where(and(eq(kdsTickets.organizationId, orgId), eq(kdsTickets.status, "pending"), sql `${kdsTickets.firedAt} IS NULL`, sql `${kdsTickets.createdAt} < ${threshold}`));
+        let count = 0;
+        for (const ticket of notStarted) {
+            const exists = await this.alertExists(orgId, "kot_not_started", ticket.id);
+            if (!exists) {
+                await this.createAlert(orgId, "kot_not_started", "kds_ticket", ticket.id, `KOT for transaction ${ticket.transactionId} not started after ${config.thresholdMinutes} minutes`);
+                count++;
+            }
+        }
+        return count;
+    }
+    async detectProlongedOccupancy(orgId) {
+        const config = await this.getThreshold(orgId, "prolonged_occupancy");
+        if (!config)
+            return 0;
+        const threshold = new Date(Date.now() - config.thresholdMinutes * 60 * 1000);
+        const prolonged = await this.db
+            .select({ id: posTables.id, number: posTables.number })
+            .from(posTables)
+            .where(and(eq(posTables.organizationId, orgId), eq(posTables.status, "occupied"), sql `${posTables.updatedAt} < ${threshold}`));
+        let count = 0;
+        for (const table of prolonged) {
+            const exists = await this.alertExists(orgId, "prolonged_occupancy", table.id);
+            if (!exists) {
+                await this.createAlert(orgId, "prolonged_occupancy", "pos_table", table.id, `Table '${table.number}' has been occupied for over ${config.thresholdMinutes} minutes`, "warning");
+                count++;
+            }
+        }
+        return count;
+    }
+    // ─── Alert Queries ─────────────────────────────────────────────────
+    async listAlerts(orgId, options) {
+        const conditions = [eq(posRestaurantAlerts.organizationId, orgId)];
+        if (options?.type)
+            conditions.push(eq(posRestaurantAlerts.type, options.type));
+        if (options?.unresolvedOnly)
+            conditions.push(eq(posRestaurantAlerts.isResolved, false));
+        const rows = await this.db
+            .select()
+            .from(posRestaurantAlerts)
+            .where(and(...conditions))
+            .orderBy(desc(posRestaurantAlerts.createdAt))
+            .limit(options?.limit ?? 100);
+        return Ok(rows);
+    }
+    async resolveAlert(alertId, resolvedBy) {
+        const rows = await this.db
+            .update(posRestaurantAlerts)
+            .set({ isResolved: true, resolvedBy, resolvedAt: new Date() })
+            .where(eq(posRestaurantAlerts.id, alertId))
+            .returning();
+        if (rows.length === 0)
+            return Err("Alert not found");
+        return Ok({ resolved: true });
+    }
+    async runAllDetections(orgId) {
+        const delayed = await this.detectDelayedOrders(orgId);
+        const notStarted = await this.detectKotNotStarted(orgId);
+        const occupancy = await this.detectProlongedOccupancy(orgId);
+        return Ok({ delayed, notStarted, occupancy });
+    }
+    // ─── Helpers ───────────────────────────────────────────────────────
+    async getThreshold(orgId, alertType) {
+        const rows = await this.db
+            .select()
+            .from(posAlertConfig)
+            .where(and(eq(posAlertConfig.organizationId, orgId), eq(posAlertConfig.alertType, alertType), eq(posAlertConfig.isEnabled, true)));
+        return rows[0] ?? null;
+    }
+    async alertExists(orgId, type, referenceId) {
+        const rows = await this.db
+            .select({ id: posRestaurantAlerts.id })
+            .from(posRestaurantAlerts)
+            .where(and(eq(posRestaurantAlerts.organizationId, orgId), eq(posRestaurantAlerts.type, type), eq(posRestaurantAlerts.referenceId, referenceId), eq(posRestaurantAlerts.isResolved, false)));
+        return rows.length > 0;
+    }
+    async createAlert(orgId, type, refType, refId, message, severity = "warning") {
+        await this.db.insert(posRestaurantAlerts).values({
+            organizationId: orgId,
+            type,
+            severity,
+            referenceType: refType,
+            referenceId: refId,
+            message,
+        });
+    }
+}

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

@@ -0,0 +1,60 @@
+/**
+ * RestaurantAnalyticsService — Daily P&L, performance reports, and sales analytics.
+ *
+ * URY: 14 report types + Daily P&L doctype with COGS, direct/indirect expenses,
+ * employee costs, gross/net profit calculation.
+ *
+ * URY reports: Today's Sales, Daywise Sales, Daywise Invoices, Month Wise Sales,
+ * Average Bill Value, Cancelled Invoices, Item Wise Sales, Customer Data,
+ * Repeated Customers, Daywise Customer Details, Employee Sales,
+ * Employee Item Wise Sales, Service Wise Sales, Time Wise Sales.
+ *
+ * Our implementation: P&L CRUD + SQL-based report queries against core order tables.
+ */
+import type { PluginResult } from "@porulle/core";
+import { posDailyPnl, posPnlExpenses } from "../schema.js";
+import type { Db } from "../types.js";
+export declare class RestaurantAnalyticsService {
+    private db;
+    constructor(db: Db);
+    createDailyPnl(orgId: string, input: {
+        date: Date;
+        grossSales: number;
+        netSales: number;
+        costOfGoods: number;
+        directExpenses: number;
+        indirectExpenses: number;
+        employeeCosts: number;
+        transactionCount: number;
+        expenses?: Array<{
+            category: "cogs" | "direct" | "indirect" | "employee";
+            name: string;
+            amount: number;
+            percentage?: number;
+        }>;
+    }): Promise<PluginResult<typeof posDailyPnl.$inferSelect>>;
+    getDailyPnl(orgId: string, date: Date): Promise<PluginResult<{
+        pnl: typeof posDailyPnl.$inferSelect;
+        expenses: Array<typeof posPnlExpenses.$inferSelect>;
+    }>>;
+    listDailyPnl(orgId: string, limit?: number): Promise<PluginResult<Array<typeof posDailyPnl.$inferSelect>>>;
+    getStationPerformance(orgId: string, stationId: string, dateFrom: Date, dateTo: Date): Promise<PluginResult<{
+        totalTickets: number;
+        averagePrepSeconds: number;
+        ticketsByStatus: Array<{
+            status: string;
+            count: number;
+        }>;
+    }>>;
+    getCoursePerformance(orgId: string, dateFrom: Date, dateTo: Date): Promise<PluginResult<Array<{
+        courseName: string;
+        totalItems: number;
+        averagePrepSeconds: number;
+    }>>>;
+    getOperatorPerformance(orgId: string, dateFrom: Date, dateTo: Date): Promise<PluginResult<Array<{
+        operatorName: string;
+        totalTickets: number;
+        averagePrepSeconds: number;
+    }>>>;
+}
+//# sourceMappingURL=analytics-service.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"analytics-service.d.ts","sourceRoot":"","sources":["../../src/services/analytics-service.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAIH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAClD,OAAO,EAAE,WAAW,EAAE,cAAc,EAA8B,MAAM,cAAc,CAAC;AACvF,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,aAAa,CAAC;AAEtC,qBAAa,0BAA0B;IACzB,OAAO,CAAC,EAAE;gBAAF,EAAE,EAAE,EAAE;IAIpB,cAAc,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE;QACzC,IAAI,EAAE,IAAI,CAAC;QACX,UAAU,EAAE,MAAM,CAAC;QACnB,QAAQ,EAAE,MAAM,CAAC;QACjB,WAAW,EAAE,MAAM,CAAC;QACpB,cAAc,EAAE,MAAM,CAAC;QACvB,gBAAgB,EAAE,MAAM,CAAC;QACzB,aAAa,EAAE,MAAM,CAAC;QACtB,gBAAgB,EAAE,MAAM,CAAC;QACzB,QAAQ,CAAC,EAAE,KAAK,CAAC;YAAE,QAAQ,EAAE,MAAM,GAAG,QAAQ,GAAG,UAAU,GAAG,UAAU,CAAC;YAAC,IAAI,EAAE,MAAM,CAAC;YAAC,MAAM,EAAE,MAAM,CAAC;YAAC,UAAU,CAAC,EAAE,MAAM,CAAA;SAAE,CAAC,CAAC;KAChI,GAAG,OAAO,CAAC,YAAY,CAAC,OAAO,WAAW,CAAC,YAAY,CAAC,CAAC;IAqDpD,WAAW,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,IAAI,GAAG,OAAO,CAAC,YAAY,CAAC;QACjE,GAAG,EAAE,OAAO,WAAW,CAAC,YAAY,CAAC;QACrC,QAAQ,EAAE,KAAK,CAAC,OAAO,cAAc,CAAC,YAAY,CAAC,CAAC;KACrD,CAAC,CAAC;IAwBG,YAAY,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,YAAY,CAAC,CAAC,CAAC;IAc1G,qBAAqB,CAAC,KAAK,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,GAAG,OAAO,CAAC,YAAY,CAAC;QAChH,YAAY,EAAE,MAAM,CAAC;QACrB,kBAAkB,EAAE,MAAM,CAAC;QAC3B,eAAe,EAAE,KAAK,CAAC;YAAE,MAAM,EAAE,MAAM,CAAC;YAAC,KAAK,EAAE,MAAM,CAAA;SAAE,CAAC,CAAC;KAC3D,CAAC,CAAC;IA6BG,oBAAoB,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,GAAG,OAAO,CAAC,YAAY,CAAC,KAAK,CAAC;QAClG,UAAU,EAAE,MAAM,CAAC;QACnB,UAAU,EAAE,MAAM,CAAC;QACnB,kBAAkB,EAAE,MAAM,CAAC;KAC5B,CAAC,CAAC,CAAC;IA0CE,sBAAsB,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,GAAG,OAAO,CAAC,YAAY,CAAC,KAAK,CAAC;QACpG,YAAY,EAAE,MAAM,CAAC;QACrB,YAAY,EAAE,MAAM,CAAC;QACrB,kBAAkB,EAAE,MAAM,CAAC;KAC5B,CAAC,CAAC,CAAC;CA6BL"}

package/dist/services/analytics-service.js

@@ -0,0 +1,178 @@
+/**
+ * RestaurantAnalyticsService — Daily P&L, performance reports, and sales analytics.
+ *
+ * URY: 14 report types + Daily P&L doctype with COGS, direct/indirect expenses,
+ * employee costs, gross/net profit calculation.
+ *
+ * URY reports: Today's Sales, Daywise Sales, Daywise Invoices, Month Wise Sales,
+ * Average Bill Value, Cancelled Invoices, Item Wise Sales, Customer Data,
+ * Repeated Customers, Daywise Customer Details, Employee Sales,
+ * Employee Item Wise Sales, Service Wise Sales, Time Wise Sales.
+ *
+ * Our implementation: P&L CRUD + SQL-based report queries against core order tables.
+ */
+import { eq, and, sql, desc } from "@porulle/core/drizzle";
+import { Ok, Err } from "@porulle/core";
+import { posDailyPnl, posPnlExpenses, kdsTickets, kdsTicketItems } from "../schema.js";
+export class RestaurantAnalyticsService {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    // ─── Daily P&L ─────────────────────────────────────────────────────
+    async createDailyPnl(orgId, input) {
+        // Validate P&L inputs
+        if (input.grossSales < 0)
+            return Err("grossSales cannot be negative");
+        if (input.netSales < 0)
+            return Err("netSales cannot be negative");
+        if (input.costOfGoods < 0)
+            return Err("costOfGoods cannot be negative");
+        if (input.directExpenses < 0)
+            return Err("directExpenses cannot be negative");
+        if (input.indirectExpenses < 0)
+            return Err("indirectExpenses cannot be negative");
+        if (input.employeeCosts < 0)
+            return Err("employeeCosts cannot be negative");
+        if (input.transactionCount < 0)
+            return Err("transactionCount cannot be negative");
+        if (input.netSales > input.grossSales)
+            return Err("netSales cannot exceed grossSales");
+        const grossProfit = input.netSales - input.costOfGoods - input.directExpenses;
+        const netProfit = grossProfit - input.indirectExpenses - input.employeeCosts;
+        const averageBillValue = input.transactionCount > 0
+            ? Math.round(input.grossSales / input.transactionCount)
+            : 0;
+        const rows = await this.db
+            .insert(posDailyPnl)
+            .values({
+            organizationId: orgId,
+            date: input.date,
+            grossSales: input.grossSales,
+            netSales: input.netSales,
+            costOfGoods: input.costOfGoods,
+            directExpenses: input.directExpenses,
+            indirectExpenses: input.indirectExpenses,
+            employeeCosts: input.employeeCosts,
+            grossProfit,
+            netProfit,
+            transactionCount: input.transactionCount,
+            averageBillValue,
+        })
+            .returning();
+        const pnl = rows[0];
+        // Insert expense line items
+        if (input.expenses) {
+            for (const exp of input.expenses) {
+                await this.db.insert(posPnlExpenses).values({
+                    pnlId: pnl.id,
+                    category: exp.category,
+                    name: exp.name,
+                    amount: exp.amount,
+                    percentage: exp.percentage,
+                });
+            }
+        }
+        return Ok(pnl);
+    }
+    async getDailyPnl(orgId, date) {
+        const startOfDay = new Date(date.getFullYear(), date.getMonth(), date.getDate());
+        const endOfDay = new Date(startOfDay.getTime() + 24 * 60 * 60 * 1000);
+        const pnls = await this.db
+            .select()
+            .from(posDailyPnl)
+            .where(and(eq(posDailyPnl.organizationId, orgId), sql `${posDailyPnl.date} >= ${startOfDay}`, sql `${posDailyPnl.date} < ${endOfDay}`));
+        if (pnls.length === 0)
+            return Err("No P&L record for this date");
+        const pnl = pnls[0];
+        const expenses = await this.db
+            .select()
+            .from(posPnlExpenses)
+            .where(eq(posPnlExpenses.pnlId, pnl.id));
+        return Ok({ pnl, expenses });
+    }
+    async listDailyPnl(orgId, limit) {
+        const rows = await this.db
+            .select()
+            .from(posDailyPnl)
+            .where(eq(posDailyPnl.organizationId, orgId))
+            .orderBy(desc(posDailyPnl.date))
+            .limit(limit ?? 30);
+        return Ok(rows);
+    }
+    // ─── KDS Performance Metrics ──────────────────────────────────────
+    // Course-wise and station-wise performance from KDS tickets.
+    async getStationPerformance(orgId, stationId, dateFrom, dateTo) {
+        const tickets = await this.db
+            .select()
+            .from(kdsTickets)
+            .where(and(eq(kdsTickets.organizationId, orgId), eq(kdsTickets.stationId, stationId), sql `${kdsTickets.createdAt} >= ${dateFrom}`, sql `${kdsTickets.createdAt} < ${dateTo}`));
+        const totalTickets = tickets.length;
+        const servedTickets = tickets.filter((t) => t.prepDurationSeconds != null);
+        const averagePrepSeconds = servedTickets.length > 0
+            ? Math.round(servedTickets.reduce((sum, t) => sum + (t.prepDurationSeconds ?? 0), 0) / servedTickets.length)
+            : 0;
+        const statusCounts = new Map();
+        for (const t of tickets) {
+            statusCounts.set(t.status, (statusCounts.get(t.status) ?? 0) + 1);
+        }
+        return Ok({
+            totalTickets,
+            averagePrepSeconds,
+            ticketsByStatus: [...statusCounts.entries()].map(([status, count]) => ({ status, count })),
+        });
+    }
+    async getCoursePerformance(orgId, dateFrom, dateTo) {
+        // Get all ticket items with their parent ticket's prep time
+        const tickets = await this.db
+            .select()
+            .from(kdsTickets)
+            .where(and(eq(kdsTickets.organizationId, orgId), sql `${kdsTickets.createdAt} >= ${dateFrom}`, sql `${kdsTickets.createdAt} < ${dateTo}`, eq(kdsTickets.status, "served")));
+        const courseStats = new Map();
+        for (const ticket of tickets) {
+            const items = await this.db
+                .select()
+                .from(kdsTicketItems)
+                .where(eq(kdsTicketItems.ticketId, ticket.id));
+            for (const item of items) {
+                const course = item.courseName ?? "Uncategorized";
+                const existing = courseStats.get(course) ?? { totalItems: 0, totalPrepSeconds: 0, count: 0 };
+                existing.totalItems += item.quantity;
+                if (ticket.prepDurationSeconds != null) {
+                    existing.totalPrepSeconds += ticket.prepDurationSeconds;
+                    existing.count++;
+                }
+                courseStats.set(course, existing);
+            }
+        }
+        return Ok([...courseStats.entries()].map(([courseName, stats]) => ({
+            courseName,
+            totalItems: stats.totalItems,
+            averagePrepSeconds: stats.count > 0 ? Math.round(stats.totalPrepSeconds / stats.count) : 0,
+        })));
+    }
+    // ─── Operator/Staff Performance ───────────────────────────────────
+    // URY: Captain and staff performance tracking.
+    async getOperatorPerformance(orgId, dateFrom, dateTo) {
+        const tickets = await this.db
+            .select()
+            .from(kdsTickets)
+            .where(and(eq(kdsTickets.organizationId, orgId), sql `${kdsTickets.createdAt} >= ${dateFrom}`, sql `${kdsTickets.createdAt} < ${dateTo}`));
+        const operatorStats = new Map();
+        for (const ticket of tickets) {
+            const operator = ticket.operatorName ?? "Unknown";
+            const existing = operatorStats.get(operator) ?? { totalTickets: 0, totalPrepSeconds: 0, servedCount: 0 };
+            existing.totalTickets++;
+            if (ticket.prepDurationSeconds != null) {
+                existing.totalPrepSeconds += ticket.prepDurationSeconds;
+                existing.servedCount++;
+            }
+            operatorStats.set(operator, existing);
+        }
+        return Ok([...operatorStats.entries()].map(([operatorName, stats]) => ({
+            operatorName,
+            totalTickets: stats.totalTickets,
+            averagePrepSeconds: stats.servedCount > 0 ? Math.round(stats.totalPrepSeconds / stats.servedCount) : 0,
+        })));
+    }
+}

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

@@ -0,0 +1,66 @@
+/**
+ * ChecklistService — Pre-billing compliance checklists.
+ *
+ * URY: Pre-billing checklists enforce compliance (stock check, hygiene).
+ * validate_invoice_print() blocks billing until checklist complete.
+ *
+ * Checklists can be of type:
+ * - pre_billing: must complete before printing a bill
+ * - shift_open: must complete when opening a shift
+ * - shift_close: must complete when closing a shift
+ */
+import type { PluginResult } from "@porulle/core";
+import type { Db } from "../types.js";
+type ChecklistType = "pre_billing" | "shift_open" | "shift_close";
+export declare class ChecklistService {
+    private db;
+    constructor(db: Db);
+    createChecklist(orgId: string, input: {
+        name: string;
+        type: ChecklistType;
+        items: Array<{
+            label: string;
+            isRequired?: boolean;
+        }>;
+    }): Promise<PluginResult<{
+        id: string;
+        name: string;
+        type: string;
+        items: Array<{
+            id: string;
+            label: string;
+        }>;
+    }>>;
+    listChecklists(orgId: string, type?: ChecklistType): Promise<PluginResult<Array<{
+        id: string;
+        name: string;
+        type: string;
+        isActive: boolean;
+    }>>>;
+    getChecklistWithItems(checklistId: string, orgId?: string): Promise<PluginResult<{
+        id: string;
+        name: string;
+        type: string;
+        items: Array<{
+            id: string;
+            label: string;
+            isRequired: boolean;
+        }>;
+    }>>;
+    completeChecklist(input: {
+        checklistId: string;
+        referenceType: "transaction" | "shift";
+        referenceId: string;
+        operatorId: string;
+        completedItems: Array<{
+            itemId: string;
+            checked: boolean;
+            note?: string;
+        }>;
+    }): Promise<PluginResult<{
+        completed: boolean;
+    }>>;
+    isChecklistCompleted(checklistId: string, referenceType: string, referenceId: string): Promise<boolean>;
+}
+export {};
+//# sourceMappingURL=checklist-service.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"checklist-service.d.ts","sourceRoot":"","sources":["../../src/services/checklist-service.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAIH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAElD,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,aAAa,CAAC;AAEtC,KAAK,aAAa,GAAG,aAAa,GAAG,YAAY,GAAG,aAAa,CAAC;AAElE,qBAAa,gBAAgB;IACf,OAAO,CAAC,EAAE;gBAAF,EAAE,EAAE,EAAE;IAEpB,eAAe,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE;QAC1C,IAAI,EAAE,MAAM,CAAC;QACb,IAAI,EAAE,aAAa,CAAC;QACpB,KAAK,EAAE,KAAK,CAAC;YAAE,KAAK,EAAE,MAAM,CAAC;YAAC,UAAU,CAAC,EAAE,OAAO,CAAA;SAAE,CAAC,CAAC;KACvD,GAAG,OAAO,CAAC,YAAY,CAAC;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,KAAK,CAAC;YAAE,EAAE,EAAE,MAAM,CAAC;YAAC,KAAK,EAAE,MAAM,CAAA;SAAE,CAAC,CAAA;KAAE,CAAC,CAAC;IA8B5G,cAAc,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,aAAa,GAAG,OAAO,CAAC,YAAY,CAAC,KAAK,CAAC;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,OAAO,CAAA;KAAE,CAAC,CAAC,CAAC;IAahJ,qBAAqB,CAAC,WAAW,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,CAAC;QACrF,EAAE,EAAE,MAAM,CAAC;QACX,IAAI,EAAE,MAAM,CAAC;QACb,IAAI,EAAE,MAAM,CAAC;QACb,KAAK,EAAE,KAAK,CAAC;YAAE,EAAE,EAAE,MAAM,CAAC;YAAC,KAAK,EAAE,MAAM,CAAC;YAAC,UAAU,EAAE,OAAO,CAAA;SAAE,CAAC,CAAC;KAClE,CAAC,CAAC;IAoBG,iBAAiB,CAAC,KAAK,EAAE;QAC7B,WAAW,EAAE,MAAM,CAAC;QACpB,aAAa,EAAE,aAAa,GAAG,OAAO,CAAC;QACvC,WAAW,EAAE,MAAM,CAAC;QACpB,UAAU,EAAE,MAAM,CAAC;QACnB,cAAc,EAAE,KAAK,CAAC;YAAE,MAAM,EAAE,MAAM,CAAC;YAAC,OAAO,EAAE,OAAO,CAAC;YAAC,IAAI,CAAC,EAAE,MAAM,CAAA;SAAE,CAAC,CAAC;KAC5E,GAAG,OAAO,CAAC,YAAY,CAAC;QAAE,SAAS,EAAE,OAAO,CAAA;KAAE,CAAC,CAAC;IA0B3C,oBAAoB,CAAC,WAAW,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;CAW9G"}

package/dist/services/checklist-service.js

@@ -0,0 +1,106 @@
+/**
+ * ChecklistService — Pre-billing compliance checklists.
+ *
+ * URY: Pre-billing checklists enforce compliance (stock check, hygiene).
+ * validate_invoice_print() blocks billing until checklist complete.
+ *
+ * Checklists can be of type:
+ * - pre_billing: must complete before printing a bill
+ * - shift_open: must complete when opening a shift
+ * - shift_close: must complete when closing a shift
+ */
+import { eq, and } from "@porulle/core/drizzle";
+import { Ok, Err } from "@porulle/core";
+import { posChecklists, posChecklistItems, posChecklistCompletions } from "../schema.js";
+export class ChecklistService {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    async createChecklist(orgId, input) {
+        const rows = await this.db
+            .insert(posChecklists)
+            .values({ organizationId: orgId, name: input.name, type: input.type })
+            .returning();
+        const checklist = rows[0];
+        const itemRows = [];
+        for (let i = 0; i < input.items.length; i++) {
+            const item = input.items[i];
+            const inserted = await this.db
+                .insert(posChecklistItems)
+                .values({
+                checklistId: checklist.id,
+                label: item.label,
+                isRequired: item.isRequired ?? true,
+                sortOrder: i,
+            })
+                .returning();
+            itemRows.push(inserted[0]);
+        }
+        return Ok({
+            id: checklist.id,
+            name: checklist.name,
+            type: checklist.type,
+            items: itemRows.map((r) => ({ id: r.id, label: r.label })),
+        });
+    }
+    async listChecklists(orgId, type) {
+        const conditions = [eq(posChecklists.organizationId, orgId)];
+        if (type)
+            conditions.push(eq(posChecklists.type, type));
+        const rows = await this.db
+            .select()
+            .from(posChecklists)
+            .where(and(...conditions))
+            .orderBy(posChecklists.sortOrder);
+        return Ok(rows.map((r) => ({ id: r.id, name: r.name, type: r.type, isActive: r.isActive })));
+    }
+    async getChecklistWithItems(checklistId, orgId) {
+        const conditions = [eq(posChecklists.id, checklistId)];
+        if (orgId)
+            conditions.push(eq(posChecklists.organizationId, orgId));
+        const checklists = await this.db.select().from(posChecklists).where(and(...conditions));
+        if (checklists.length === 0)
+            return Err("Checklist not found");
+        const items = await this.db
+            .select()
+            .from(posChecklistItems)
+            .where(eq(posChecklistItems.checklistId, checklistId))
+            .orderBy(posChecklistItems.sortOrder);
+        return Ok({
+            id: checklists[0].id,
+            name: checklists[0].name,
+            type: checklists[0].type,
+            items: items.map((i) => ({ id: i.id, label: i.label, isRequired: i.isRequired })),
+        });
+    }
+    async completeChecklist(input) {
+        // Validate all required items are checked
+        const items = await this.db
+            .select()
+            .from(posChecklistItems)
+            .where(eq(posChecklistItems.checklistId, input.checklistId));
+        const requiredItems = items.filter((i) => i.isRequired);
+        for (const required of requiredItems) {
+            const completion = input.completedItems.find((c) => c.itemId === required.id);
+            if (!completion || !completion.checked) {
+                return Err(`Required checklist item '${required.label}' is not checked`);
+            }
+        }
+        await this.db.insert(posChecklistCompletions).values({
+            checklistId: input.checklistId,
+            referenceType: input.referenceType,
+            referenceId: input.referenceId,
+            operatorId: input.operatorId,
+            completedItems: input.completedItems,
+        });
+        return Ok({ completed: true });
+    }
+    async isChecklistCompleted(checklistId, referenceType, referenceId) {
+        const rows = await this.db
+            .select()
+            .from(posChecklistCompletions)
+            .where(and(eq(posChecklistCompletions.checklistId, checklistId), eq(posChecklistCompletions.referenceType, referenceType), eq(posChecklistCompletions.referenceId, referenceId)));
+        return rows.length > 0;
+    }
+}

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

@@ -0,0 +1,77 @@
+/**
+ * KDSService — Kitchen Display System station management, ticket generation,
+ * and status tracking.
+ *
+ * Informed by URY's KOT system:
+ * - URY Production Unit: item-group-based routing, per-station printers
+ * - URY KOT: submittable ticket per production unit, type enum, order_status,
+ *   production_time tracking, Socket.IO broadcasting
+ * - URY KOT Items: course (Menu Course link), serve_priority, indicate_course,
+ *   cancelled_qty
+ * - kot_execute(): compares previous vs current items, generates New Order,
+ *   Order Modified, Partially cancelled KOTs per production unit
+ * - multi_print_kot(): production printer > room printer > POS printer cascade
+ *
+ * Improvements over URY:
+ * - Item-level status persisted to DB (not browser localStorage)
+ * - 4-state ticket status (pending -> preparing -> ready -> served)
+ *   instead of URY's 2-state (Ready For Prepare -> Served)
+ * - prep_duration_seconds calculated and stored for analytics
+ * - Structured course priority on ticket items (not just display ordering)
+ */
+import type { Db, KDSStation, KDSStationItemGroup, KDSTicket, KDSTicketItem } from "../types.js";
+import type { PluginResult } from "@porulle/core";
+export declare class KDSService {
+    private db;
+    constructor(db: Db);
+    createStation(orgId: string, input: {
+        name: string;
+        alertThresholdMinutes?: number;
+        metadata?: Record<string, unknown>;
+    }): Promise<PluginResult<KDSStation>>;
+    listStations(orgId: string): Promise<PluginResult<KDSStation[]>>;
+    updateStation(orgId: string, id: string, input: {
+        name?: string;
+        isActive?: boolean;
+        alertThresholdMinutes?: number;
+    }): Promise<PluginResult<KDSStation>>;
+    addItemGroup(stationId: string, itemGroup: string): Promise<PluginResult<KDSStationItemGroup>>;
+    removeItemGroup(stationId: string, itemGroup: string): Promise<PluginResult<{
+        removed: boolean;
+    }>>;
+    getStationItemGroups(stationId: string): Promise<string[]>;
+    generateTickets(orgId: string, input: {
+        transactionId: string;
+        items: Array<{
+            entityId: string;
+            variantId?: string;
+            itemName: string;
+            quantity: number;
+            itemGroup: string;
+            courseName?: string;
+            coursePriority?: number;
+            showCourseLabel?: boolean;
+            modifiers?: Array<{
+                name: string;
+                priceAdjustment: number;
+            }>;
+            notes?: string;
+        }>;
+        tableNumber?: string;
+        orderType?: "dine_in" | "takeaway" | "delivery";
+        operatorName?: string;
+        comments?: string;
+    }): Promise<PluginResult<KDSTicket[]>>;
+    startTicket(id: string): Promise<PluginResult<KDSTicket>>;
+    readyTicket(id: string): Promise<PluginResult<KDSTicket>>;
+    serveTicket(id: string): Promise<PluginResult<KDSTicket>>;
+    private static readonly VALID_TRANSITIONS;
+    private updateTicketStatus;
+    markItemDone(ticketId: string, itemId: string): Promise<PluginResult<KDSTicketItem>>;
+    getTicketById(id: string): Promise<PluginResult<KDSTicket>>;
+    listPendingTickets(orgId: string, stationId: string): Promise<PluginResult<Array<KDSTicket & {
+        items: KDSTicketItem[];
+    }>>>;
+    private generateTicketNumber;
+}
+//# sourceMappingURL=kds-service.d.ts.map