@madebylars.com/mbl-order 0.1.0

package/README.md

@@ -0,0 +1,289 @@
+# mbl-order
+
+[![npm version][npm-version-src]][npm-version-href]
+[![npm downloads][npm-downloads-src]][npm-downloads-href]
+[![License][license-src]][license-href]
+[![Nuxt][nuxt-src]][nuxt-href]
+
+Transport-vertical order management module for the [MadeByLars](https://madebylars.com) Nuxt 4 ecosystem.
+
+Handles the full lifecycle: **Quote → Order → Dispatch → Delivery → Invoice**
+
+- [✨ Release Notes](/CHANGELOG.md)
+
+---
+
+## Features
+
+- **Two order types** — transport (A→B jobs) and storage (recurring warehouse rental)
+- **Full status lifecycle** — per order type, enforced via Supabase RLS
+- **Role-based access** — customer / driver / dispatcher / admin extending `mbl-auth` RBAC
+- **Invoice generation** — draft invoices with VAT line items; accounting export is a future phase
+- **Fleet view** — active drivers with last-known GPS position (integrates with `mbl-whereabout`)
+- **i18n built-in** — English (en-GB) and Swedish (sv-SE); integrates with `@nuxtjs/i18n` if present
+- **Composables-only API** — no UI components; you build the interface
+
+---
+
+## Requirements
+
+| Peer dependency | Required |
+|---|---|
+| `nuxt` | ≥ 4.0.0 |
+| `@nuxtjs/supabase` | ≥ 1.0.0 |
+| `@nuxtjs/i18n` | optional |
+| `@madebylars.com/mbl-auth` | optional, recommended |
+| `@madebylars.com/mbl-whereabout` | optional |
+| `@madebylars.com/mbl-graph` | optional |
+| `@madebylars.com/mbl-mapman` | optional |
+
+---
+
+## Setup
+
+### 1. Install
+
+```bash
+npm install @madebylars.com/mbl-order
+```
+
+### 2. Register in `nuxt.config.ts`
+
+```ts
+export default defineNuxtConfig({
+  modules: [
+    '@nuxtjs/supabase',
+    '@madebylars.com/mbl-order',
+  ],
+
+  mblOrder: {
+    supabaseSchema: 'transport', // default
+    locale: 'en',                // 'en' | 'sv'
+    currency: 'GBP',             // 'GBP' | 'SEK'
+    vatRates: {
+      standard: 0.20,            // UK: 0.20  Sweden: 0.25
+      reduced: 0.05,             // UK: 0.05  Sweden: 0.12
+      zero: 0,
+    },
+    invoiceTrigger: 'on_delivery', // 'on_delivery' | 'manual' | 'periodic'
+    periodicBillingDay: 1,
+  },
+})
+```
+
+### 3. Run the database migration
+
+Apply `src/runtime/server/migrations/001_transport_schema.sql` to your Supabase project.
+
+**Via Supabase CLI:**
+```bash
+supabase db push
+```
+
+**Or paste directly** into the Supabase SQL editor.
+
+The migration creates a dedicated `transport` schema with seven tables, indexes, RLS policies, and a role helper function. It is safe to run on a fresh project; it will fail if the schema already exists.
+
+> **Important:** The RLS policies rely on `mbl-auth` storing the user role in `auth.users.app_metadata` as `{ "role": "customer" | "driver" | "dispatcher" | "admin" }`. Confirm this matches your `mbl-auth` setup before running.
+
+---
+
+## Module options
+
+| Option | Type | Default | Description |
+|---|---|---|---|
+| `supabaseSchema` | `string` | `'transport'` | Supabase schema name |
+| `locale` | `'en' \| 'sv'` | `'en'` | Default locale |
+| `currency` | `'GBP' \| 'SEK'` | `'GBP'` | Currency for invoices and formatting |
+| `vatRates.standard` | `number` | `0.20` | Standard VAT rate (UK: 0.20, Sweden: 0.25) |
+| `vatRates.reduced` | `number` | `0.05` | Reduced VAT rate (UK: 0.05, Sweden: 0.12) |
+| `vatRates.zero` | `number` | `0` | Zero-rate VAT |
+| `invoiceTrigger` | `'on_delivery' \| 'manual' \| 'periodic'` | `'on_delivery'` | When to auto-generate invoices |
+| `periodicBillingDay` | `number` | `1` | Day of month for storage billing |
+
+---
+
+## Composable API
+
+All data composables return the standard Nuxt `AsyncData` shape — `{ data, pending, error, refresh }`.
+
+### Orders
+
+```ts
+const { data: orders } = await useOrders(filters?)
+const { data: order }  = await useOrder(id)
+const { createOrder, updateStatus, assignDriver, cancelOrder } = useOrderActions()
+```
+
+### Quotes
+
+```ts
+const { data: quote } = await useQuote(orderId)
+const { createQuote, acceptQuote, expireQuote } = useQuoteActions()
+```
+
+### Invoices
+
+```ts
+const { data: invoice } = await useInvoice(orderId)
+const { generateInvoice, markPaid } = useInvoiceActions()
+// Note: syncToAccounting() is not available in the POC — accounting export is a future phase
+```
+
+### Storage
+
+```ts
+const { data: period } = await useStoragePeriod(orderId)
+const { extendPeriod, endPeriod } = useStorageActions()
+```
+
+### Fleet (dispatcher / admin)
+
+```ts
+const { data: fleet }  = await useFleet()
+const { data: orders } = await useDriverOrders(driverId)
+```
+
+### Locale
+
+```ts
+const { t, formatCurrency, formatDate, locale } = useOrderLocale()
+
+t('mblOrder.status.in_transit')  // → 'In transit' or 'Under transport'
+formatCurrency(1250)              // → '£1,250.00' or '1 250,00 kr'
+formatDate('2026-06-10')         // → '10 June 2026' or '10 juni 2026'
+```
+
+### KPIs (for `mbl-graph`)
+
+```ts
+const { data: kpis } = await useOrderKpis(filters?)
+// Returns: totalOrders, activeOrders, totalRevenue, fleetUtilisationPercent, …
+```
+
+### Config
+
+```ts
+const config = useOrderConfig()
+// Returns: supabaseSchema, locale, currency, vatRates, invoiceTrigger, periodicBillingDay
+```
+
+---
+
+## Order types and statuses
+
+### Transport order
+
+Single A→B job. Billing: per km / per hour / per weight / fixed.
+
+```
+draft → quoted → confirmed → assigned → collected → in_transit → delivered → invoiced
+```
+
+Integrates with `mbl-whereabout` for real-time driver GPS during active jobs.
+
+### Storage order
+
+Recurring warehouse rental. Billing: per m² / per pallet / per period / fixed subscription.
+
+```
+draft → quoted → active → extended → ended → invoiced
+```
+
+Supports periodic invoice generation (monthly or custom interval via `periodicBillingDay`).
+
+---
+
+## Roles
+
+| Role | Capabilities |
+|---|---|
+| `customer` | Create orders, accept quotes, track delivery, view invoices |
+| `driver` | View assigned jobs, update job status |
+| `dispatcher` | Assign jobs, manage queue, live fleet view |
+| `admin` | Full access, invoice generation, KPIs |
+
+Roles extend the `mbl-auth` RBAC system. The JWT `app_metadata.role` field is used by Supabase RLS to enforce access at the database level.
+
+---
+
+## i18n
+
+The module ships English and Swedish translations namespaced under `mblOrder.*`.
+
+If `@nuxtjs/i18n` is installed, translations are registered automatically via the `i18n:registerModule` hook and become available through `useI18n().t()`.
+
+If `@nuxtjs/i18n` is absent, use `useOrderLocale()` directly — it works standalone with no extra dependencies.
+
+---
+
+## Ecosystem integration
+
+| Module | Integration |
+|---|---|
+| `mbl-auth` | Session + RBAC — role checks in RLS and composables |
+| `mbl-whereabout` | Driver GPS stream merged into `useFleet()` results |
+| `mbl-graph` | `useOrderKpis()` feeds directly into graph datasets |
+| `mbl-mapman` | Driver markers via `useFleet()` — marker API compatible |
+| `mbl-payment` | Integration point reserved; not implemented in POC |
+
+---
+
+## Database schema
+
+Seven tables in the `transport` Supabase schema:
+
+| Table | Purpose |
+|---|---|
+| `transport.orders` | Core order record |
+| `transport.order_lines` | Line items with VAT |
+| `transport.quotes` | Quote linked to an order |
+| `transport.storage_periods` | Active/historical storage periods |
+| `transport.invoices` | Generated invoices |
+| `transport.drivers` | Driver profiles linked to auth users |
+| `transport.vehicles` | Vehicle registry |
+
+All tables have RLS enabled. See the migration file for full column definitions, indexes, and policies.
+
+---
+
+## Contributing
+
+```bash
+# Install dependencies
+npm install
+
+# Generate type stubs (required once before development)
+npm run dev:prepare
+
+# Develop with the playground
+npm run dev
+
+# Build the playground
+npm run dev:build
+
+# Lint
+npm run lint
+
+# Test
+npm run test
+npm run test:watch
+
+# Release
+npm run release
+```
+
+---
+
+<!-- Badges -->
+[npm-version-src]: https://img.shields.io/npm/v/@madebylars.com/mbl-order/latest.svg?style=flat&colorA=020420&colorB=00DC82
+[npm-version-href]: https://npmjs.com/package/@madebylars.com/mbl-order
+
+[npm-downloads-src]: https://img.shields.io/npm/dm/@madebylars.com/mbl-order.svg?style=flat&colorA=020420&colorB=00DC82
+[npm-downloads-href]: https://npm.chart.dev/@madebylars.com/mbl-order
+
+[license-src]: https://img.shields.io/npm/l/@madebylars.com/mbl-order.svg?style=flat&colorA=020420&colorB=00DC82
+[license-href]: https://npmjs.com/package/@madebylars.com/mbl-order
+
+[nuxt-src]: https://img.shields.io/badge/Nuxt-020420?logo=nuxt
+[nuxt-href]: https://nuxt.com

package/dist/module.d.mts

@@ -0,0 +1,24 @@
+import * as _nuxt_schema from '@nuxt/schema';
+
+interface MblOrderOptions {
+    /** Supabase schema name. Default: 'transport' */
+    supabaseSchema: string;
+    /** Default locale. Default: 'en' */
+    locale?: 'en' | 'sv';
+    /** ISO 4217 currency code. Default: 'GBP' */
+    currency?: 'GBP' | 'SEK';
+    vatRates?: {
+        /** UK default: 0.20 / Sweden: 0.25 */
+        standard: number;
+        /** UK default: 0.05 / Sweden: 0.12 */
+        reduced: number;
+        zero: number;
+    };
+    invoiceTrigger?: 'on_delivery' | 'manual' | 'periodic';
+    /** Day of month for periodic storage billing. Default: 1 */
+    periodicBillingDay?: number;
+}
+declare const _default: _nuxt_schema.NuxtModule<MblOrderOptions, MblOrderOptions, false>;
+
+export { _default as default };
+export type { MblOrderOptions };

package/dist/module.json

@@ -0,0 +1,9 @@
+{
+  "name": "mbl-order",
+  "configKey": "mblOrder",
+  "version": "0.1.0",
+  "builder": {
+    "@nuxt/module-builder": "1.0.2",
+    "unbuild": "3.6.1"
+  }
+}

package/dist/module.mjs

@@ -0,0 +1,46 @@
+import { defineNuxtModule, createResolver, addImportsDir } from '@nuxt/kit';
+
+const module$1 = defineNuxtModule({
+  meta: {
+    name: "mbl-order",
+    configKey: "mblOrder"
+  },
+  defaults: {
+    supabaseSchema: "transport",
+    locale: "en",
+    currency: "GBP",
+    vatRates: {
+      standard: 0.2,
+      reduced: 0.05,
+      zero: 0
+    },
+    invoiceTrigger: "on_delivery",
+    periodicBillingDay: 1
+  },
+  setup(options, nuxt) {
+    const resolver = createResolver(import.meta.url);
+    nuxt.options.runtimeConfig.public.mblOrder = {
+      supabaseSchema: options.supabaseSchema,
+      locale: options.locale ?? "en",
+      currency: options.currency ?? "GBP",
+      vatRates: options.vatRates ?? { standard: 0.2, reduced: 0.05, zero: 0 },
+      invoiceTrigger: options.invoiceTrigger ?? "on_delivery",
+      periodicBillingDay: options.periodicBillingDay ?? 1
+    };
+    nuxt.hook(
+      "i18n:registerModule",
+      (register) => {
+        register({
+          langDir: resolver.resolve("./runtime/locales"),
+          locales: [
+            { code: "en", file: "en.ts" },
+            { code: "sv", file: "sv.ts" }
+          ]
+        });
+      }
+    );
+    addImportsDir(resolver.resolve("./runtime/composables"));
+  }
+});
+
+export { module$1 as default };

package/dist/runtime/composables/useDriverOrders.d.ts

@@ -0,0 +1 @@
+export declare function useDriverOrders(driverId: string): any;

package/dist/runtime/composables/useDriverOrders.js

@@ -0,0 +1,10 @@
+export function useDriverOrders(driverId) {
+  return useAsyncData(`mbl-order:driver-orders:${driverId}`, async () => {
+    const client = useSupabaseClient();
+    const config = useRuntimeConfig();
+    const schema = config.public.mblOrder.supabaseSchema;
+    const { data, error } = await client.schema(schema).from("orders").select("*").eq("assigned_driver_id", driverId).in("status", ["assigned", "collected", "in_transit"]).order("scheduled_pickup_at", { ascending: true });
+    if (error) throw error;
+    return data ?? [];
+  });
+}

package/dist/runtime/composables/useFleet.d.ts

@@ -0,0 +1 @@
+export declare function useFleet(): any;

package/dist/runtime/composables/useFleet.js

@@ -0,0 +1,16 @@
+export function useFleet() {
+  return useAsyncData("mbl-order:fleet", async () => {
+    const client = useSupabaseClient();
+    const config = useRuntimeConfig();
+    const schema = config.public.mblOrder.supabaseSchema;
+    const { data, error } = await client.schema(schema).from("drivers").select(`
+        *,
+        vehicles (*),
+        orders!assigned_driver_id (
+          id, order_number, status, pickup_address, delivery_address
+        )
+      `);
+    if (error) throw error;
+    return data ?? [];
+  });
+}

package/dist/runtime/composables/useInvoice.d.ts

@@ -0,0 +1 @@
+export declare function useInvoice(orderId: string): any;

package/dist/runtime/composables/useInvoice.js

@@ -0,0 +1,10 @@
+export function useInvoice(orderId) {
+  return useAsyncData(`mbl-order:invoice:${orderId}`, async () => {
+    const client = useSupabaseClient();
+    const config = useRuntimeConfig();
+    const schema = config.public.mblOrder.supabaseSchema;
+    const { data, error } = await client.schema(schema).from("invoices").select("*").eq("order_id", orderId).order("created_at", { ascending: false }).limit(1).maybeSingle();
+    if (error) throw error;
+    return data;
+  });
+}

package/dist/runtime/composables/useInvoiceActions.d.ts

@@ -0,0 +1,5 @@
+import type { Invoice, GenerateInvoicePayload, ActionResult } from '../../types.js';
+export declare function useInvoiceActions(): {
+    generateInvoice: (payload: GenerateInvoicePayload) => Promise<ActionResult<Invoice>>;
+    markPaid: (invoiceId: string, paidAt?: string) => Promise<ActionResult<Invoice>>;
+};

package/dist/runtime/composables/useInvoiceActions.js

@@ -0,0 +1,39 @@
+export function useInvoiceActions() {
+  const client = useSupabaseClient();
+  const config = useRuntimeConfig();
+  const schema = config.public.mblOrder.supabaseSchema;
+  async function generateInvoice(payload) {
+    try {
+      const { data, error } = await client.schema(schema).from("invoices").insert({
+        order_id: payload.orderId,
+        due_at: payload.dueAt ?? null,
+        status: "draft",
+        currency: config.public.mblOrder.currency,
+        accounting_provider: null,
+        external_id: null,
+        // TODO: compute from order lines
+        total_excl_vat: 0,
+        total_vat: 0,
+        total_incl_vat: 0
+      }).select().single();
+      if (error) throw error;
+      return { data, error: null };
+    } catch (err) {
+      return { data: null, error: err };
+    }
+  }
+  async function markPaid(invoiceId, paidAt) {
+    try {
+      const { data, error } = await client.schema(schema).from("invoices").update({
+        status: "paid",
+        paid_at: paidAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+        updated_at: (/* @__PURE__ */ new Date()).toISOString()
+      }).eq("id", invoiceId).select().single();
+      if (error) throw error;
+      return { data, error: null };
+    } catch (err) {
+      return { data: null, error: err };
+    }
+  }
+  return { generateInvoice, markPaid };
+}

package/dist/runtime/composables/useOrder.d.ts

@@ -0,0 +1 @@
+export declare function useOrder(id: string): any;

package/dist/runtime/composables/useOrder.js

@@ -0,0 +1,18 @@
+export function useOrder(id) {
+  return useAsyncData(`mbl-order:order:${id}`, async () => {
+    const client = useSupabaseClient();
+    const config = useRuntimeConfig();
+    const schema = config.public.mblOrder.supabaseSchema;
+    const { data, error } = await client.schema(schema).from("orders").select(`
+        *,
+        order_lines (*),
+        quotes (*),
+        invoices (*),
+        storage_periods (*),
+        drivers (*),
+        vehicles (*)
+      `).eq("id", id).single();
+    if (error) throw error;
+    return data;
+  });
+}

package/dist/runtime/composables/useOrderActions.d.ts

@@ -0,0 +1,7 @@
+import type { Order, OrderStatus, CreateOrderPayload, ActionResult } from '../../types.js';
+export declare function useOrderActions(): {
+    createOrder: (payload: CreateOrderPayload) => Promise<ActionResult<Order>>;
+    updateStatus: (orderId: string, status: OrderStatus) => Promise<ActionResult<Order>>;
+    assignDriver: (orderId: string, driverId: string, vehicleId?: string) => Promise<ActionResult<Order>>;
+    cancelOrder: (orderId: string, reason?: string) => Promise<ActionResult<Order>>;
+};

package/dist/runtime/composables/useOrderActions.js

@@ -0,0 +1,55 @@
+export function useOrderActions() {
+  const client = useSupabaseClient();
+  const config = useRuntimeConfig();
+  const schema = config.public.mblOrder.supabaseSchema;
+  async function createOrder(payload) {
+    try {
+      const { data, error } = await client.schema(schema).from("orders").insert({
+        /* TODO: map payload to snake_case */
+        ...payload
+      }).select().single();
+      if (error) throw error;
+      return { data, error: null };
+    } catch (err) {
+      return { data: null, error: err };
+    }
+  }
+  async function updateStatus(orderId, status) {
+    try {
+      const { data, error } = await client.schema(schema).from("orders").update({ status, updated_at: (/* @__PURE__ */ new Date()).toISOString() }).eq("id", orderId).select().single();
+      if (error) throw error;
+      return { data, error: null };
+    } catch (err) {
+      return { data: null, error: err };
+    }
+  }
+  async function assignDriver(orderId, driverId, vehicleId) {
+    try {
+      const { data, error } = await client.schema(schema).from("orders").update({
+        assigned_driver_id: driverId,
+        assigned_vehicle_id: vehicleId ?? null,
+        status: "assigned",
+        updated_at: (/* @__PURE__ */ new Date()).toISOString()
+      }).eq("id", orderId).select().single();
+      if (error) throw error;
+      return { data, error: null };
+    } catch (err) {
+      return { data: null, error: err };
+    }
+  }
+  async function cancelOrder(orderId, reason) {
+    try {
+      const { data, error } = await client.schema(schema).from("orders").update({
+        status: "draft",
+        // placeholder — actual cancel status TBD
+        notes: reason ?? null,
+        updated_at: (/* @__PURE__ */ new Date()).toISOString()
+      }).eq("id", orderId).select().single();
+      if (error) throw error;
+      return { data, error: null };
+    } catch (err) {
+      return { data: null, error: err };
+    }
+  }
+  return { createOrder, updateStatus, assignDriver, cancelOrder };
+}

package/dist/runtime/composables/useOrderConfig.d.ts

@@ -0,0 +1,2 @@
+import type { OrderConfig } from '../../types.js';
+export declare function useOrderConfig(): OrderConfig;

package/dist/runtime/composables/useOrderConfig.js

@@ -0,0 +1,4 @@
+export function useOrderConfig() {
+  const config = useRuntimeConfig();
+  return config.public.mblOrder;
+}

package/dist/runtime/composables/useOrderKpis.d.ts

@@ -0,0 +1,2 @@
+import type { KpiFilters } from '../../types.js';
+export declare function useOrderKpis(filters?: KpiFilters): any;

package/dist/runtime/composables/useOrderKpis.js

@@ -0,0 +1,30 @@
+export function useOrderKpis(filters) {
+  const key = `mbl-order:kpis:${JSON.stringify(filters ?? {})}`;
+  return useAsyncData(key, async () => {
+    const client = useSupabaseClient();
+    const config = useRuntimeConfig();
+    const schema = config.public.mblOrder.supabaseSchema;
+    const { data, error } = await client.schema(schema).from("orders").select("status, type, created_at");
+    if (error) throw error;
+    const rows = data ?? [];
+    const kpis = {
+      totalOrders: rows.length,
+      activeOrders: rows.filter((r) => !["invoiced", "ended", "delivered"].includes(r.status)).length,
+      deliveredOrders: rows.filter((r) => r.status === "delivered").length,
+      cancelledOrders: 0,
+      // TODO: add cancelled status
+      averageDeliveryTimeHours: null,
+      // TODO: compute from actual_pickup_at / actual_delivery_at
+      totalRevenue: 0,
+      // TODO: sum from invoices
+      pendingInvoices: 0,
+      // TODO: query invoices with status draft/sent
+      overdueInvoices: 0,
+      // TODO: query invoices with status overdue
+      activeStorageContracts: rows.filter((r) => r.type === "storage" && r.status === "active").length,
+      fleetUtilisationPercent: null
+      // TODO: compute from fleet + active orders
+    };
+    return kpis;
+  });
+}

package/dist/runtime/composables/useOrderLocale.d.ts

@@ -0,0 +1,7 @@
+import type { Locale } from '../../types.js';
+export declare function useOrderLocale(): {
+    t: (key: string) => string;
+    formatCurrency: (amount: number) => string;
+    formatDate: (dateStr: string) => string;
+    locale: Locale;
+};

package/dist/runtime/composables/useOrderLocale.js

@@ -0,0 +1,32 @@
+import en from "../locales/en.js";
+import sv from "../locales/sv.js";
+const LOCALES = { en, sv };
+function resolve(obj, path) {
+  const value = path.split(".").reduce((node, key) => {
+    if (node && typeof node === "object") return node[key];
+    return void 0;
+  }, obj);
+  return typeof value === "string" ? value : path;
+}
+export function useOrderLocale() {
+  const config = useRuntimeConfig();
+  const locale = config.public.mblOrder?.locale ?? "en";
+  const messages = LOCALES[locale] ?? LOCALES.en;
+  function t(key) {
+    return resolve(messages, key);
+  }
+  function formatCurrency(amount) {
+    const currency = config.public.mblOrder?.currency ?? "GBP";
+    const intlLocale = locale === "sv" ? "sv-SE" : "en-GB";
+    return new Intl.NumberFormat(intlLocale, { style: "currency", currency }).format(amount);
+  }
+  function formatDate(dateStr) {
+    const intlLocale = locale === "sv" ? "sv-SE" : "en-GB";
+    return new Intl.DateTimeFormat(intlLocale, {
+      day: "numeric",
+      month: "long",
+      year: "numeric"
+    }).format(new Date(dateStr));
+  }
+  return { t, formatCurrency, formatDate, locale };
+}

package/dist/runtime/composables/useOrders.d.ts

@@ -0,0 +1,2 @@
+import type { OrderFilters } from '../../types.js';
+export declare function useOrders(filters?: OrderFilters): any;

package/dist/runtime/composables/useOrders.js

@@ -0,0 +1,11 @@
+export function useOrders(filters) {
+  const key = `mbl-order:orders:${JSON.stringify(filters ?? {})}`;
+  return useAsyncData(key, async () => {
+    const client = useSupabaseClient();
+    const config = useRuntimeConfig();
+    const schema = config.public.mblOrder.supabaseSchema;
+    const { data, error } = await client.schema(schema).from("orders").select("*");
+    if (error) throw error;
+    return data ?? [];
+  });
+}

package/dist/runtime/composables/useQuote.d.ts

@@ -0,0 +1 @@
+export declare function useQuote(orderId: string): any;

package/dist/runtime/composables/useQuote.js

@@ -0,0 +1,10 @@
+export function useQuote(orderId) {
+  return useAsyncData(`mbl-order:quote:${orderId}`, async () => {
+    const client = useSupabaseClient();
+    const config = useRuntimeConfig();
+    const schema = config.public.mblOrder.supabaseSchema;
+    const { data, error } = await client.schema(schema).from("quotes").select("*").eq("order_id", orderId).order("created_at", { ascending: false }).limit(1).maybeSingle();
+    if (error) throw error;
+    return data;
+  });
+}