@porulle/plugin-scheduled-orders 0.1.0

package/README.md

@@ -0,0 +1,54 @@
+# @porulle/plugin-scheduled-orders
+
+Defer order execution: schedule future placement and process due schedules in batch.
+
+## Install
+
+```bash
+bun add @porulle/plugin-scheduled-orders
+```
+
+Add to `commerce.config.ts`:
+
+```typescript
+import { scheduledOrdersPlugin } from "@porulle/plugin-scheduled-orders";
+
+export default defineConfig({
+  plugins: [scheduledOrdersPlugin()],
+});
+```
+
+Add to `drizzle.config.ts`:
+
+```typescript
+schema: [
+  "./node_modules/@porulle/plugin-scheduled-orders/src/schema.ts",
+  // ...
+],
+```
+
+## What it does
+
+Persists scheduled orders with `scheduledFor`, cart linkage, and status (`scheduled`, `processing`, `completed`, `cancelled`, `expired`); lists and cancels them and exposes an admin endpoint to process due rows.
+
+## Routes exposed
+
+**`/scheduled-orders`** — `POST /`, `GET /`, `GET /{id}`, `POST /{id}/cancel`, `POST /process-due`
+
+## Hooks
+
+**Emitted:** none.
+
+**Consumed:** none.
+
+## MCP tools
+
+None.
+
+## Configuration options
+
+None (`scheduledOrdersPlugin()` takes no options).
+
+## License
+
+MIT

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export type { Db } from "./types.js";
+export { ScheduledOrderService } from "./services/scheduled-order-service.js";
+export declare function scheduledOrdersPlugin(): import("@porulle/core").CommercePlugin;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAMA,YAAY,EAAE,EAAE,EAAE,MAAM,YAAY,CAAC;AACrC,OAAO,EAAE,qBAAqB,EAAE,MAAM,uCAAuC,CAAC;AAE9E,wBAAgB,qBAAqB,2CAiBpC"}

package/dist/index.js

@@ -0,0 +1,24 @@
+import { defineCommercePlugin } from "@porulle/core";
+import { scheduledOrders } from "./schema.js";
+import { ScheduledOrderService } from "./services/scheduled-order-service.js";
+import { buildScheduledOrderRoutes } from "./routes/scheduled-orders.js";
+export { ScheduledOrderService } from "./services/scheduled-order-service.js";
+export function scheduledOrdersPlugin() {
+    return defineCommercePlugin({
+        id: "scheduled-orders",
+        version: "1.0.0",
+        permissions: [
+            { scope: "scheduled-orders:admin", description: "Process due scheduled orders and admin operations." },
+            { scope: "scheduled-orders:create", description: "Create and cancel scheduled orders." },
+            { scope: "scheduled-orders:read", description: "View scheduled orders." },
+        ],
+        schema: () => ({ scheduledOrders }),
+        hooks: () => [],
+        routes: (ctx) => {
+            const db = ctx.database.db;
+            if (!db)
+                return [];
+            return buildScheduledOrderRoutes(new ScheduledOrderService(db), ctx);
+        },
+    });
+}

package/dist/routes/scheduled-orders.d.ts

@@ -0,0 +1,9 @@
+import type { ScheduledOrderService } from "../services/scheduled-order-service.js";
+import type { PluginRouteRegistration } from "@porulle/core";
+export declare function buildScheduledOrderRoutes(service: ScheduledOrderService, ctx: {
+    services?: Record<string, unknown>;
+    database?: {
+        db: unknown;
+    };
+}): PluginRouteRegistration[];
+//# sourceMappingURL=scheduled-orders.d.ts.map

package/dist/routes/scheduled-orders.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scheduled-orders.d.ts","sourceRoot":"","sources":["../../src/routes/scheduled-orders.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,wCAAwC,CAAC;AACpF,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,eAAe,CAAC;AAG7D,wBAAgB,yBAAyB,CACvC,OAAO,EAAE,qBAAqB,EAC9B,GAAG,EAAE;IAAE,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAAC,QAAQ,CAAC,EAAE;QAAE,EAAE,EAAE,OAAO,CAAA;KAAE,CAAA;CAAE,GACtE,uBAAuB,EAAE,CAyD3B"}

package/dist/routes/scheduled-orders.js

@@ -0,0 +1,55 @@
+import { router } from "@porulle/core";
+import { z } from "@hono/zod-openapi";
+export function buildScheduledOrderRoutes(service, ctx) {
+    const r = router("Scheduled Orders", "/scheduled-orders", ctx);
+    r.post("/").summary("Create scheduled order").permission("scheduled-orders:create")
+        .input(z.object({
+        customerId: z.string().uuid(),
+        cartId: z.string().uuid(),
+        scheduledFor: z.string().datetime(),
+        orderType: z.enum(["pickup", "delivery", "dine_in"]).optional(),
+        pickupLocation: z.string().optional(),
+        deliveryAddress: z.any().optional(),
+        notes: z.string().optional(),
+    }))
+        .handler(async ({ input, orgId }) => {
+        const body = input;
+        const result = await service.create(orgId, body);
+        if (!result.ok)
+            throw new Error(result.error);
+        return result.value;
+    });
+    r.get("/").summary("List scheduled orders").permission("scheduled-orders:read")
+        .query(z.object({ status: z.enum(["scheduled", "processing", "completed", "cancelled", "expired"]).optional() }))
+        .handler(async ({ query, orgId }) => {
+        const q = query;
+        const result = await service.list(orgId, q.status);
+        if (!result.ok)
+            throw new Error(result.error);
+        return result.value;
+    });
+    r.get("/{id}").summary("Get scheduled order by ID").permission("scheduled-orders:read")
+        .handler(async ({ params, orgId }) => {
+        const result = await service.getById(orgId, params.id);
+        if (!result.ok)
+            throw new Error(result.error);
+        return result.value;
+    });
+    r.post("/{id}/cancel").summary("Cancel scheduled order").permission("scheduled-orders:create")
+        .handler(async ({ params, orgId }) => {
+        const result = await service.cancel(orgId, params.id);
+        if (!result.ok)
+            throw new Error(result.error);
+        return result.value;
+    });
+    r.post("/process-due").summary("Process due scheduled orders").permission("scheduled-orders:admin")
+        .input(z.object({ bufferMinutes: z.number().int().min(0).optional() }))
+        .handler(async ({ input, orgId }) => {
+        const body = input;
+        const result = await service.processDue(orgId, body.bufferMinutes);
+        if (!result.ok)
+            throw new Error(result.error);
+        return result.value;
+    });
+    return r.routes();
+}

package/dist/schema.d.ts

@@ -0,0 +1,229 @@
+export declare const scheduledOrders: import("drizzle-orm/pg-core/table").PgTableWithColumns<{
+    name: "scheduled_orders";
+    schema: undefined;
+    columns: {
+        id: import("@porulle/core/drizzle").PgColumn<{
+            name: "id";
+            tableName: "scheduled_orders";
+            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("@porulle/core/drizzle").PgColumn<{
+            name: "organization_id";
+            tableName: "scheduled_orders";
+            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("@porulle/core/drizzle").PgColumn<{
+            name: "customer_id";
+            tableName: "scheduled_orders";
+            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;
+        }, {}, {}>;
+        cartId: import("@porulle/core/drizzle").PgColumn<{
+            name: "cart_id";
+            tableName: "scheduled_orders";
+            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;
+        }, {}, {}>;
+        scheduledFor: import("@porulle/core/drizzle").PgColumn<{
+            name: "scheduled_for";
+            tableName: "scheduled_orders";
+            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;
+        }, {}, {}>;
+        orderType: import("@porulle/core/drizzle").PgColumn<{
+            name: "order_type";
+            tableName: "scheduled_orders";
+            dataType: "string";
+            columnType: "PgText";
+            data: "pickup" | "delivery" | "dine_in";
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: ["pickup", "delivery", "dine_in"];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        status: import("@porulle/core/drizzle").PgColumn<{
+            name: "status";
+            tableName: "scheduled_orders";
+            dataType: "string";
+            columnType: "PgText";
+            data: "scheduled" | "processing" | "completed" | "cancelled" | "expired";
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: ["scheduled", "processing", "completed", "cancelled", "expired"];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        pickupLocation: import("@porulle/core/drizzle").PgColumn<{
+            name: "pickup_location";
+            tableName: "scheduled_orders";
+            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;
+        }, {}, {}>;
+        deliveryAddress: import("@porulle/core/drizzle").PgColumn<{
+            name: "delivery_address";
+            tableName: "scheduled_orders";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: unknown;
+            driverParam: unknown;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        notes: import("@porulle/core/drizzle").PgColumn<{
+            name: "notes";
+            tableName: "scheduled_orders";
+            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;
+        }, {}, {}>;
+        processedAt: import("@porulle/core/drizzle").PgColumn<{
+            name: "processed_at";
+            tableName: "scheduled_orders";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        createdAt: import("@porulle/core/drizzle").PgColumn<{
+            name: "created_at";
+            tableName: "scheduled_orders";
+            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("@porulle/core/drizzle").PgColumn<{
+            name: "updated_at";
+            tableName: "scheduled_orders";
+            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/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../src/schema.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAkBzB,CAAC"}

package/dist/schema.js

@@ -0,0 +1,20 @@
+import { pgTable, uuid, text, timestamp, index, jsonb } from "@porulle/core/drizzle";
+export const scheduledOrders = pgTable("scheduled_orders", {
+    id: uuid("id").defaultRandom().primaryKey(),
+    organizationId: text("organization_id").notNull(),
+    customerId: uuid("customer_id").notNull(),
+    cartId: uuid("cart_id").notNull(),
+    scheduledFor: timestamp("scheduled_for", { withTimezone: true }).notNull(),
+    orderType: text("order_type", { enum: ["pickup", "delivery", "dine_in"] }).notNull().default("pickup"),
+    status: text("status", { enum: ["scheduled", "processing", "completed", "cancelled", "expired"] }).notNull().default("scheduled"),
+    pickupLocation: text("pickup_location"),
+    deliveryAddress: jsonb("delivery_address"),
+    notes: text("notes"),
+    processedAt: timestamp("processed_at", { withTimezone: true }),
+    createdAt: timestamp("created_at", { withTimezone: true }).defaultNow().notNull(),
+    updatedAt: timestamp("updated_at", { withTimezone: true }).defaultNow().notNull(),
+}, (table) => ({
+    orgIdx: index("idx_scheduled_orders_org").on(table.organizationId),
+    statusIdx: index("idx_scheduled_orders_status").on(table.status),
+    scheduledForIdx: index("idx_scheduled_orders_scheduled_for").on(table.scheduledFor),
+}));

package/dist/services/scheduled-order-service.d.ts

@@ -0,0 +1,22 @@
+import type { PluginResult } from "@porulle/core";
+import type { Db, ScheduledOrder, ScheduledOrderStatus, ScheduledOrderType } from "../types.js";
+export declare class ScheduledOrderService {
+    private db;
+    constructor(db: Db);
+    create(orgId: string, input: {
+        customerId: string;
+        cartId: string;
+        scheduledFor: string;
+        orderType?: ScheduledOrderType;
+        pickupLocation?: string;
+        deliveryAddress?: unknown;
+        notes?: string;
+    }): Promise<PluginResult<ScheduledOrder>>;
+    list(orgId: string, status?: ScheduledOrderStatus): Promise<PluginResult<ScheduledOrder[]>>;
+    getById(orgId: string, id: string): Promise<PluginResult<ScheduledOrder>>;
+    cancel(orgId: string, id: string): Promise<PluginResult<ScheduledOrder>>;
+    processDue(orgId: string, bufferMinutes?: number): Promise<PluginResult<ScheduledOrder[]>>;
+    complete(orgId: string, id: string): Promise<PluginResult<ScheduledOrder>>;
+    expireOld(orgId: string, hoursThreshold?: number): Promise<PluginResult<ScheduledOrder[]>>;
+}
+//# sourceMappingURL=scheduled-order-service.d.ts.map

package/dist/services/scheduled-order-service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scheduled-order-service.d.ts","sourceRoot":"","sources":["../../src/services/scheduled-order-service.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAElD,OAAO,KAAK,EAAE,EAAE,EAAE,cAAc,EAAE,oBAAoB,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AAEhG,qBAAa,qBAAqB;IACpB,OAAO,CAAC,EAAE;gBAAF,EAAE,EAAE,EAAE;IAEpB,MAAM,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE;QACjC,UAAU,EAAE,MAAM,CAAC;QACnB,MAAM,EAAE,MAAM,CAAC;QACf,YAAY,EAAE,MAAM,CAAC;QACrB,SAAS,CAAC,EAAE,kBAAkB,CAAC;QAC/B,cAAc,CAAC,EAAE,MAAM,CAAC;QACxB,eAAe,CAAC,EAAE,OAAO,CAAC;QAC1B,KAAK,CAAC,EAAE,MAAM,CAAC;KAChB,GAAG,OAAO,CAAC,YAAY,CAAC,cAAc,CAAC,CAAC;IAcnC,IAAI,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,oBAAoB,GAAG,OAAO,CAAC,YAAY,CAAC,cAAc,EAAE,CAAC,CAAC;IAO3F,OAAO,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,CAAC,cAAc,CAAC,CAAC;IAOzE,MAAM,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,CAAC,cAAc,CAAC,CAAC;IAYxE,UAAU,CAAC,KAAK,EAAE,MAAM,EAAE,aAAa,GAAE,MAAW,GAAG,OAAO,CAAC,YAAY,CAAC,cAAc,EAAE,CAAC,CAAC;IAsB9F,QAAQ,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,CAAC,cAAc,CAAC,CAAC;IAW1E,SAAS,CAAC,KAAK,EAAE,MAAM,EAAE,cAAc,GAAE,MAAW,GAAG,OAAO,CAAC,YAAY,CAAC,cAAc,EAAE,CAAC,CAAC;CAmBrG"}

package/dist/services/scheduled-order-service.js

@@ -0,0 +1,94 @@
+import { eq, and, lte, sql } from "@porulle/core/drizzle";
+import { Ok, Err } from "@porulle/core";
+import { scheduledOrders } from "../schema.js";
+export class ScheduledOrderService {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    async create(orgId, input) {
+        const rows = await this.db.insert(scheduledOrders).values({
+            organizationId: orgId,
+            customerId: input.customerId,
+            cartId: input.cartId,
+            scheduledFor: new Date(input.scheduledFor),
+            orderType: input.orderType ?? "pickup",
+            pickupLocation: input.pickupLocation,
+            deliveryAddress: input.deliveryAddress,
+            notes: input.notes,
+        }).returning();
+        return Ok(rows[0]);
+    }
+    async list(orgId, status) {
+        const conditions = [eq(scheduledOrders.organizationId, orgId)];
+        if (status)
+            conditions.push(eq(scheduledOrders.status, status));
+        const rows = await this.db.select().from(scheduledOrders).where(and(...conditions));
+        return Ok(rows);
+    }
+    async getById(orgId, id) {
+        const rows = await this.db.select().from(scheduledOrders)
+            .where(and(eq(scheduledOrders.organizationId, orgId), eq(scheduledOrders.id, id)));
+        if (rows.length === 0)
+            return Err("Scheduled order not found");
+        return Ok(rows[0]);
+    }
+    async cancel(orgId, id) {
+        const existing = await this.db.select().from(scheduledOrders)
+            .where(and(eq(scheduledOrders.organizationId, orgId), eq(scheduledOrders.id, id)));
+        if (existing.length === 0)
+            return Err("Scheduled order not found");
+        if (existing[0].status !== "scheduled")
+            return Err(`Cannot cancel order with status '${existing[0].status}'`);
+        const rows = await this.db.update(scheduledOrders).set({
+            status: "cancelled",
+            updatedAt: new Date(),
+        }).where(eq(scheduledOrders.id, id)).returning();
+        return Ok(rows[0]);
+    }
+    async processDue(orgId, bufferMinutes = 15) {
+        const cutoff = new Date(Date.now() + bufferMinutes * 60 * 1000).toISOString();
+        const due = await this.db.select().from(scheduledOrders)
+            .where(and(eq(scheduledOrders.organizationId, orgId), eq(scheduledOrders.status, "scheduled"), lte(scheduledOrders.scheduledFor, sql `${cutoff}::timestamptz`)));
+        if (due.length === 0)
+            return Ok([]);
+        const ids = due.map(d => d.id);
+        const updated = [];
+        for (const dueId of ids) {
+            const rows = await this.db.update(scheduledOrders).set({
+                status: "processing",
+                processedAt: new Date(),
+                updatedAt: new Date(),
+            }).where(eq(scheduledOrders.id, dueId)).returning();
+            updated.push(rows[0]);
+        }
+        return Ok(updated);
+    }
+    async complete(orgId, id) {
+        const existing = await this.db.select().from(scheduledOrders)
+            .where(and(eq(scheduledOrders.organizationId, orgId), eq(scheduledOrders.id, id)));
+        if (existing.length === 0)
+            return Err("Scheduled order not found");
+        const rows = await this.db.update(scheduledOrders).set({
+            status: "completed",
+            updatedAt: new Date(),
+        }).where(eq(scheduledOrders.id, id)).returning();
+        return Ok(rows[0]);
+    }
+    async expireOld(orgId, hoursThreshold = 24) {
+        const cutoff = new Date(Date.now() - hoursThreshold * 60 * 60 * 1000).toISOString();
+        const old = await this.db.select().from(scheduledOrders)
+            .where(and(eq(scheduledOrders.organizationId, orgId), eq(scheduledOrders.status, "scheduled"), lte(scheduledOrders.scheduledFor, sql `${cutoff}::timestamptz`)));
+        if (old.length === 0)
+            return Ok([]);
+        const updated = [];
+        for (const item of old) {
+            const rows = await this.db.update(scheduledOrders).set({
+                status: "expired",
+                updatedAt: new Date(),
+            }).where(eq(scheduledOrders.id, item.id)).returning();
+            updated.push(rows[0]);
+        }
+        return Ok(updated);
+    }
+}

package/dist/types.d.ts

@@ -0,0 +1,6 @@
+import type { scheduledOrders } from "./schema.js";
+export type { PluginDb as Db } from "@porulle/core";
+export type ScheduledOrder = typeof scheduledOrders.$inferSelect;
+export type ScheduledOrderStatus = "scheduled" | "processing" | "completed" | "cancelled" | "expired";
+export type ScheduledOrderType = "pickup" | "delivery" | "dine_in";
+//# 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,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAEnD,YAAY,EAAE,QAAQ,IAAI,EAAE,EAAE,MAAM,eAAe,CAAC;AACpD,MAAM,MAAM,cAAc,GAAG,OAAO,eAAe,CAAC,YAAY,CAAC;AACjE,MAAM,MAAM,oBAAoB,GAAG,WAAW,GAAG,YAAY,GAAG,WAAW,GAAG,WAAW,GAAG,SAAS,CAAC;AACtG,MAAM,MAAM,kBAAkB,GAAG,QAAQ,GAAG,UAAU,GAAG,SAAS,CAAC"}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "@porulle/plugin-scheduled-orders",
+  "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",
+    "test": "vitest run"
+  },
+  "dependencies": {
+    "@hono/zod-openapi": "^1.2.2",
+    "@porulle/core": "workspace:*",
+    "hono": "^4.12.5"
+  },
+  "devDependencies": {
+    "@repo/eslint-config": "*",
+    "@repo/typescript-config": "*",
+    "@types/node": "^24.5.2",
+    "typescript": "5.9.2",
+    "vitest": "^3.2.4"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "src",
+    "dist",
+    "README.md"
+  ],
+  "description": "Defer order execution: schedule future placement and process due schedules in batch.",
+  "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-scheduled-orders"
+  },
+  "author": "Porulle contributors"
+}

package/src/index.ts

@@ -0,0 +1,27 @@
+import { defineCommercePlugin } from "@porulle/core";
+import { scheduledOrders } from "./schema.js";
+import { ScheduledOrderService } from "./services/scheduled-order-service.js";
+import { buildScheduledOrderRoutes } from "./routes/scheduled-orders.js";
+import type { Db } from "./types.js";
+
+export type { Db } from "./types.js";
+export { ScheduledOrderService } from "./services/scheduled-order-service.js";
+
+export function scheduledOrdersPlugin() {
+  return defineCommercePlugin({
+    id: "scheduled-orders",
+    version: "1.0.0",
+    permissions: [
+      { scope: "scheduled-orders:admin", description: "Process due scheduled orders and admin operations." },
+      { scope: "scheduled-orders:create", description: "Create and cancel scheduled orders." },
+      { scope: "scheduled-orders:read", description: "View scheduled orders." },
+    ],
+    schema: () => ({ scheduledOrders }),
+    hooks: () => [],
+    routes: (ctx) => {
+      const db = ctx.database.db;
+      if (!db) return [];
+      return buildScheduledOrderRoutes(new ScheduledOrderService(db), ctx);
+    },
+  });
+}

package/src/routes/scheduled-orders.ts

@@ -0,0 +1,67 @@
+import { router } from "@porulle/core";
+import { z } from "@hono/zod-openapi";
+import type { ScheduledOrderService } from "../services/scheduled-order-service.js";
+import type { PluginRouteRegistration } from "@porulle/core";
+import type { ScheduledOrderStatus } from "../types.js";
+
+export function buildScheduledOrderRoutes(
+  service: ScheduledOrderService,
+  ctx: { services?: Record<string, unknown>; database?: { db: unknown } },
+): PluginRouteRegistration[] {
+  const r = router("Scheduled Orders", "/scheduled-orders", ctx);
+
+  r.post("/").summary("Create scheduled order").permission("scheduled-orders:create")
+    .input(z.object({
+      customerId: z.string().uuid(),
+      cartId: z.string().uuid(),
+      scheduledFor: z.string().datetime(),
+      orderType: z.enum(["pickup", "delivery", "dine_in"]).optional(),
+      pickupLocation: z.string().optional(),
+      deliveryAddress: z.any().optional(),
+      notes: z.string().optional(),
+    }))
+    .handler(async ({ input, orgId }) => {
+      const body = input as {
+        customerId: string; cartId: string; scheduledFor: string;
+        orderType?: "pickup" | "delivery" | "dine_in";
+        pickupLocation?: string; deliveryAddress?: unknown; notes?: string;
+      };
+      const result = await service.create(orgId, body);
+      if (!result.ok) throw new Error(result.error);
+      return result.value;
+    });
+
+  r.get("/").summary("List scheduled orders").permission("scheduled-orders:read")
+    .query(z.object({ status: z.enum(["scheduled", "processing", "completed", "cancelled", "expired"]).optional() }))
+    .handler(async ({ query, orgId }) => {
+      const q = query as { status?: ScheduledOrderStatus };
+      const result = await service.list(orgId, q.status);
+      if (!result.ok) throw new Error(result.error);
+      return result.value;
+    });
+
+  r.get("/{id}").summary("Get scheduled order by ID").permission("scheduled-orders:read")
+    .handler(async ({ params, orgId }) => {
+      const result = await service.getById(orgId, params.id!);
+      if (!result.ok) throw new Error(result.error);
+      return result.value;
+    });
+
+  r.post("/{id}/cancel").summary("Cancel scheduled order").permission("scheduled-orders:create")
+    .handler(async ({ params, orgId }) => {
+      const result = await service.cancel(orgId, params.id!);
+      if (!result.ok) throw new Error(result.error);
+      return result.value;
+    });
+
+  r.post("/process-due").summary("Process due scheduled orders").permission("scheduled-orders:admin")
+    .input(z.object({ bufferMinutes: z.number().int().min(0).optional() }))
+    .handler(async ({ input, orgId }) => {
+      const body = input as { bufferMinutes?: number };
+      const result = await service.processDue(orgId, body.bufferMinutes);
+      if (!result.ok) throw new Error(result.error);
+      return result.value;
+    });
+
+  return r.routes();
+}

package/src/schema.ts

@@ -0,0 +1,21 @@
+import { pgTable, uuid, text, timestamp, index, jsonb } from "@porulle/core/drizzle";
+
+export const scheduledOrders = pgTable("scheduled_orders", {
+  id: uuid("id").defaultRandom().primaryKey(),
+  organizationId: text("organization_id").notNull(),
+  customerId: uuid("customer_id").notNull(),
+  cartId: uuid("cart_id").notNull(),
+  scheduledFor: timestamp("scheduled_for", { withTimezone: true }).notNull(),
+  orderType: text("order_type", { enum: ["pickup", "delivery", "dine_in"] }).notNull().default("pickup"),
+  status: text("status", { enum: ["scheduled", "processing", "completed", "cancelled", "expired"] }).notNull().default("scheduled"),
+  pickupLocation: text("pickup_location"),
+  deliveryAddress: jsonb("delivery_address"),
+  notes: text("notes"),
+  processedAt: timestamp("processed_at", { withTimezone: true }),
+  createdAt: timestamp("created_at", { withTimezone: true }).defaultNow().notNull(),
+  updatedAt: timestamp("updated_at", { withTimezone: true }).defaultNow().notNull(),
+}, (table) => ({
+  orgIdx: index("idx_scheduled_orders_org").on(table.organizationId),
+  statusIdx: index("idx_scheduled_orders_status").on(table.status),
+  scheduledForIdx: index("idx_scheduled_orders_scheduled_for").on(table.scheduledFor),
+}));

package/src/services/scheduled-order-service.ts

@@ -0,0 +1,110 @@
+import { eq, and, lte, sql } from "@porulle/core/drizzle";
+import { Ok, Err } from "@porulle/core";
+import type { PluginResult } from "@porulle/core";
+import { scheduledOrders } from "../schema.js";
+import type { Db, ScheduledOrder, ScheduledOrderStatus, ScheduledOrderType } from "../types.js";
+
+export class ScheduledOrderService {
+  constructor(private db: Db) {}
+
+  async create(orgId: string, input: {
+    customerId: string;
+    cartId: string;
+    scheduledFor: string;
+    orderType?: ScheduledOrderType;
+    pickupLocation?: string;
+    deliveryAddress?: unknown;
+    notes?: string;
+  }): Promise<PluginResult<ScheduledOrder>> {
+    const rows = await this.db.insert(scheduledOrders).values({
+      organizationId: orgId,
+      customerId: input.customerId,
+      cartId: input.cartId,
+      scheduledFor: new Date(input.scheduledFor),
+      orderType: input.orderType ?? "pickup",
+      pickupLocation: input.pickupLocation,
+      deliveryAddress: input.deliveryAddress,
+      notes: input.notes,
+    }).returning();
+    return Ok(rows[0]!);
+  }
+
+  async list(orgId: string, status?: ScheduledOrderStatus): Promise<PluginResult<ScheduledOrder[]>> {
+    const conditions = [eq(scheduledOrders.organizationId, orgId)];
+    if (status) conditions.push(eq(scheduledOrders.status, status));
+    const rows = await this.db.select().from(scheduledOrders).where(and(...conditions));
+    return Ok(rows);
+  }
+
+  async getById(orgId: string, id: string): Promise<PluginResult<ScheduledOrder>> {
+    const rows = await this.db.select().from(scheduledOrders)
+      .where(and(eq(scheduledOrders.organizationId, orgId), eq(scheduledOrders.id, id)));
+    if (rows.length === 0) return Err("Scheduled order not found");
+    return Ok(rows[0]!);
+  }
+
+  async cancel(orgId: string, id: string): Promise<PluginResult<ScheduledOrder>> {
+    const existing = await this.db.select().from(scheduledOrders)
+      .where(and(eq(scheduledOrders.organizationId, orgId), eq(scheduledOrders.id, id)));
+    if (existing.length === 0) return Err("Scheduled order not found");
+    if (existing[0]!.status !== "scheduled") return Err(`Cannot cancel order with status '${existing[0]!.status}'`);
+    const rows = await this.db.update(scheduledOrders).set({
+      status: "cancelled",
+      updatedAt: new Date(),
+    }).where(eq(scheduledOrders.id, id)).returning();
+    return Ok(rows[0]!);
+  }
+
+  async processDue(orgId: string, bufferMinutes: number = 15): Promise<PluginResult<ScheduledOrder[]>> {
+    const cutoff = new Date(Date.now() + bufferMinutes * 60 * 1000).toISOString();
+    const due = await this.db.select().from(scheduledOrders)
+      .where(and(
+        eq(scheduledOrders.organizationId, orgId),
+        eq(scheduledOrders.status, "scheduled"),
+        lte(scheduledOrders.scheduledFor, sql`${cutoff}::timestamptz`),
+      ));
+    if (due.length === 0) return Ok([]);
+    const ids = due.map(d => d.id);
+    const updated: ScheduledOrder[] = [];
+    for (const dueId of ids) {
+      const rows = await this.db.update(scheduledOrders).set({
+        status: "processing",
+        processedAt: new Date(),
+        updatedAt: new Date(),
+      }).where(eq(scheduledOrders.id, dueId)).returning();
+      updated.push(rows[0]!);
+    }
+    return Ok(updated);
+  }
+
+  async complete(orgId: string, id: string): Promise<PluginResult<ScheduledOrder>> {
+    const existing = await this.db.select().from(scheduledOrders)
+      .where(and(eq(scheduledOrders.organizationId, orgId), eq(scheduledOrders.id, id)));
+    if (existing.length === 0) return Err("Scheduled order not found");
+    const rows = await this.db.update(scheduledOrders).set({
+      status: "completed",
+      updatedAt: new Date(),
+    }).where(eq(scheduledOrders.id, id)).returning();
+    return Ok(rows[0]!);
+  }
+
+  async expireOld(orgId: string, hoursThreshold: number = 24): Promise<PluginResult<ScheduledOrder[]>> {
+    const cutoff = new Date(Date.now() - hoursThreshold * 60 * 60 * 1000).toISOString();
+    const old = await this.db.select().from(scheduledOrders)
+      .where(and(
+        eq(scheduledOrders.organizationId, orgId),
+        eq(scheduledOrders.status, "scheduled"),
+        lte(scheduledOrders.scheduledFor, sql`${cutoff}::timestamptz`),
+      ));
+    if (old.length === 0) return Ok([]);
+    const updated: ScheduledOrder[] = [];
+    for (const item of old) {
+      const rows = await this.db.update(scheduledOrders).set({
+        status: "expired",
+        updatedAt: new Date(),
+      }).where(eq(scheduledOrders.id, item.id)).returning();
+      updated.push(rows[0]!);
+    }
+    return Ok(updated);
+  }
+}

package/src/types.ts

@@ -0,0 +1,6 @@
+import type { scheduledOrders } from "./schema.js";
+
+export type { PluginDb as Db } from "@porulle/core";
+export type ScheduledOrder = typeof scheduledOrders.$inferSelect;
+export type ScheduledOrderStatus = "scheduled" | "processing" | "completed" | "cancelled" | "expired";
+export type ScheduledOrderType = "pickup" | "delivery" | "dine_in";