@stacksjs/commerce 0.72.102 → 0.73.0

package/dist/orders/index.d.ts

@@ -29,6 +29,7 @@ export {
   fetchAll,
   fetchById,
   fetchDailyOrderTrends,
+  fetchRecent,
   fetchStats,
 } from './fetch';
 export {

package/dist/shippings/couriers/destroy.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Delete a courier by ID
+ *
+ * @param id The ID of the courier to delete
+ * @returns True if the courier was deleted, false otherwise
+ */
+export declare function destroy(id: number): Promise<boolean>;
+/**
+ * Delete multiple couriers at once
+ *
+ * @param ids Array of courier IDs to delete
+ * @returns Number of couriers deleted
+ */
+export declare function bulkDestroy(ids: number[]): Promise<number>;

package/dist/shippings/couriers/fetch.d.ts

@@ -0,0 +1,10 @@
+import type { Courier, ModelRow } from '@stacksjs/orm';
+/**
+ * Fetch a courier by ID
+ */
+export declare function fetchById(id: number): Promise<CourierJsonResponse | undefined>;
+/**
+ * Fetch all couriers
+ */
+export declare function fetchAll(): Promise<CourierJsonResponse[]>;
+declare type CourierJsonResponse = ModelRow<typeof Courier>;

package/dist/shippings/couriers/store.d.ts

@@ -0,0 +1,17 @@
+import type { Courier, ModelRow, NewModelData } from '@stacksjs/orm';
+/**
+ * Create a new courier
+ *
+ * @param data The courier data to store
+ * @returns The newly created courier record
+ */
+export declare function store(data: NewCourier): Promise<CourierJsonResponse>;
+/**
+ * Create multiple couriers at once
+ *
+ * @param data Array of courier data to store
+ * @returns Number of couriers created
+ */
+export declare function bulkStore(data: NewCourier[]): Promise<number>;
+declare type CourierJsonResponse = ModelRow<typeof Courier>;
+declare type NewCourier = NewModelData<typeof Courier>;

package/dist/shippings/couriers/update.d.ts

@@ -0,0 +1,27 @@
+import type { Courier, ModelRow, UpdateModelData } from '@stacksjs/orm';
+/**
+ * Update a courier
+ *
+ * @param id The id of the courier to update
+ * @param data The courier data to update
+ * @returns The updated courier record
+ */
+export declare function update(id: number, data: CourierUpdate): Promise<CourierJsonResponse | undefined>;
+/**
+ * Update a courier's status
+ *
+ * @param id The ID of the courier
+ * @param status The new status (active, on_delivery, on_break)
+ * @returns The updated courier with the new status
+ */
+export declare function updateStatus(id: number, status: 'active' | 'on_delivery' | 'on_break'): Promise<CourierJsonResponse>;
+/**
+ * Update courier's contact information
+ *
+ * @param id The ID of the courier
+ * @param phone The updated phone number
+ * @returns The updated courier
+ */
+export declare function updateContact(id: number, phone?: string): Promise<CourierJsonResponse>;
+declare type CourierJsonResponse = ModelRow<typeof Courier>;
+declare type CourierUpdate = UpdateModelData<typeof Courier>;

package/dist/shippings/delivery-routes/fetch.d.ts

@@ -12,7 +12,7 @@ export declare function fetchAll(): Promise<DeliveryRouteJsonResponse[]>;
  */
 export declare function fetchActive(): Promise<DeliveryRouteJsonResponse[]>;
 /**
- * Fetch delivery routes by driver
+ * Fetch delivery routes by courier
  */
-export declare function fetchByDriver(driver: string): Promise<DeliveryRouteJsonResponse[]>;
+export declare function fetchByCourier(courier: string): Promise<DeliveryRouteJsonResponse[]>;
 declare type DeliveryRouteJsonResponse = RowOf<'delivery_routes'>;

package/dist/shippings/delivery-routes/index.d.ts

@@ -7,7 +7,7 @@ export {
 export {
   fetchActive,
   fetchAll,
-  fetchByDriver,
+  fetchByCourier,
   fetchById,
 } from './fetch';
 // Functions from store.ts

package/dist/shippings/index.d.ts

@@ -1,5 +1,5 @@
+import * as couriers from './couriers/index';
 import * as digital from './digital-deliveries/index';
-import * as drivers from './drivers/index';
 import * as geocoding from './geocoding/index';
 import * as licenses from './license-keys/index';
 import * as methods from './shipping-methods/index';
@@ -10,7 +10,7 @@ import * as zones from './shipping-zones/index';
 declare const shippings: ShippingsNamespace;
 declare interface ShippingsNamespace {
   digital: typeof digital
-  drivers: typeof drivers
+  couriers: typeof couriers
   geocoding: typeof geocoding
   licenses: typeof licenses
   methods: typeof methods
@@ -21,7 +21,7 @@ declare interface ShippingsNamespace {
 }
 export {
   digital,
-  drivers,
+  couriers,
   geocoding,
   licenses,
   methods,

package/dist/shippings/tracking/events.d.ts

@@ -7,37 +7,37 @@ export declare function routeTrackingChannel(routeId: number | string): string;
  * Best-effort broadcast to a realtime channel.
  *
  * Private rather than public: the payload is a named customer's address and a
- * driver's live position. Authorisation happens in the app's websocket
+ * courier's live position. Authorisation happens in the app's websocket
  * authenticator (`setWsAuthenticator`), which is where the tracking token is
  * checked.
  */
 export declare function broadcastToChannel(channelName: string, event: string, payload: Record<string, unknown>): Promise<void>;
 /**
- * A driver moved.
+ * A courier moved.
  *
  * Broadcast only — this fires several times a minute per active delivery and
  * has no business waking every event listener in the application.
  */
 export declare function emitDeliveryPosition(orderIds: readonly (number | string)[], routeId: number | null | undefined, payload: DeliveryPositionPayload): Promise<void>;
-/** A stop was assigned to a route and a driver. Both paths. */
+/** A stop was assigned to a route and a courier. Both paths. */
 export declare function emitDeliveryAssigned(stop: Record<string, unknown>): Promise<void>;
 /** The vehicle left with this order on it. Both paths. */
 export declare function emitDeliveryStarted(stop: Record<string, unknown>): Promise<void>;
 /**
- * The driver came within the "nearly there" radius.
+ * The courier came within the "nearly there" radius.
  *
  * The event worth sending an SMS for, and the reason the whole ingest path
  * computes distance per ping rather than leaving it to the client.
  */
 export declare function emitDeliveryNearby(stop: Record<string, unknown>, distanceMeters: number, etaSeconds: number | null): Promise<void>;
-/** The driver reached the address. Both paths. */
+/** The courier reached the address. Both paths. */
 export declare function emitDeliveryArrived(stop: Record<string, unknown>): Promise<void>;
 /** Handover done. Both paths. */
 export declare function emitDeliveryCompleted(stop: Record<string, unknown>): Promise<void>;
 /** The stop could not be completed. Event bus only; there is no live view to update. */
 export declare function emitDeliveryFailed(stop: Record<string, unknown>, reason?: string): Promise<void>;
 export declare interface DeliveryPositionPayload extends Coordinates, Record<string, unknown> {
-  driverId: number
+  courierId: number
   routeId?: number | null
   heading?: number | null
   speed?: number | null

package/dist/shippings/tracking/geo.d.ts

@@ -23,7 +23,7 @@ export declare function bearingInDegrees(from: Coordinates, to: Coordinates): nu
  * great circles, and clamped below by `minimumSeconds` so an ETA never reads
  * "arriving now" from two blocks away.
  *
- * Returns null when the driver is stopped, because dividing by zero speed
+ * Returns null when the courier is stopped, because dividing by zero speed
  * produces Infinity and showing "arriving in ∞ minutes" is worse than showing
  * nothing.
  */

package/dist/shippings/tracking/index.d.ts

@@ -1,11 +1,11 @@
 export type { DeliveryPositionPayload } from './events';
 export type { Coordinates } from './geo';
-export type { DriverPingInput, DriverPingResult } from './ping';
+export type { CourierPingInput, CourierPingResult } from './ping';
 export type { AssignStopInput } from './stops';
 /**
  * Live delivery tracking.
  *
- * `drivers` and `delivery-routes` are CRUD over the records. This is the part
+ * `couriers` and `delivery-routes` are CRUD over the records. This is the part
  * that moves: position ingest, the stop lifecycle, the geodesy the ETA is
  * derived from, and the two fan-outs (event bus for the application, realtime
  * channel for the browser).
@@ -32,7 +32,7 @@ export {
 export {
   ARRIVAL_RADIUS_METERS,
   NEARBY_RADIUS_METERS,
-  recordDriverPing,
+  recordCourierPing,
 } from './ping';
 export {
   assignStop,

package/dist/shippings/tracking/ping.d.ts

@@ -1,15 +1,15 @@
 import type { Coordinates } from './geo';
-export declare function recordDriverPing(input: DriverPingInput): Promise<DriverPingResult>;
+export declare function recordCourierPing(input: CourierPingInput): Promise<CourierPingResult>;
 /**
- * Driver position ingest.
+ * Courier position ingest.
  *
- * One entry point for "the driver's device says it is here". Everything that
+ * One entry point for "the courier's device says it is here". Everything that
  * has to happen on a fix happens here, in one place, because splitting it
  * across the route handler and a listener is how a tracking page ends up
  * showing a position that the ETA disagrees with:
  *
- *   1. Append to the `driver_pings` series.
- *   2. Update the driver's denormalised present position.
+ *   1. Append to the `courier_pings` series.
+ *   2. Update the courier's denormalised present position.
  *   3. Recompute distance and ETA for the stop being served.
  *   4. Push position to everyone watching (broadcast only).
  *   5. Raise `delivery:nearby` and `delivery:arrived` on threshold crossings,
@@ -17,16 +17,16 @@ export declare function recordDriverPing(input: DriverPingInput): Promise<Driver
  */
 /** Within this many metres of the destination, the customer is told to expect the door. */
 export declare const NEARBY_RADIUS_METERS: 400;
-/** Within this, the driver is treated as arrived. */
+/** Within this, the courier is treated as arrived. */
 export declare const ARRIVAL_RADIUS_METERS: 60;
-export declare interface DriverPingInput extends Coordinates {
-  driverId: number
+export declare interface CourierPingInput extends Coordinates {
+  courierId: number
   heading?: number | null
   speed?: number | null
   accuracy?: number | null
   recordedAt?: string
 }
-export declare interface DriverPingResult {
+export declare interface CourierPingResult {
   pingId: number | null
   routeId: number | null
   stopId: number | null

package/dist/shippings/tracking/stops.d.ts

@@ -1,7 +1,7 @@
 /** Put an order on a route. */
 export declare function assignStop(input: AssignStopInput): Promise<Record<string, unknown>>;
 /**
- * The driver is now driving to this stop.
+ * The courier is now driving to this stop.
  *
  * Also moves the order to OUT_FOR_DELIVERY, which is the state the customer's
  * tracking page and notifications key on.
@@ -17,20 +17,8 @@ export declare function completeStop(stopId: number, notes?: string): Promise<Re
  * told a vehicle is still coming.
  */
 export declare function failStop(stopId: number, reason: string): Promise<Record<string, unknown> | null>;
-/** Start a route. Until this runs, pings from its driver find no active route. */
+/** Start a route. Until this runs, pings from its courier find no active route. */
 export declare function startRoute(routeId: number): Promise<void>;
-/**
- * Stop lifecycle.
- *
- * Every state change a driver makes goes through one of these, so the order's
- * status, the stop's timestamps and the outgoing events stay in step. Writing
- * `delivery_stops.status` directly works and is how a tracking page ends up
- * saying "out for delivery" about an order that was delivered ten minutes ago.
- *
- * The order status is kept in lockstep on purpose: `OUT_FOR_DELIVERY` and
- * `DELIVERED` are the two states a customer actually sees, and they mean the
- * same thing as the stop being `en_route` and `completed`.
- */
 export declare interface AssignStopInput {
   deliveryRouteId: number
   orderId?: number | null
@@ -41,4 +29,18 @@ export declare interface AssignStopInput {
   recipientName?: string | null
   recipientPhone?: string | null
   etaAt?: string | null
+  type?: StopType
 }
+/**
+ * Stop lifecycle.
+ *
+ * Every state change a courier makes goes through one of these, so the order's
+ * status, the stop's timestamps and the outgoing events stay in step. Writing
+ * `delivery_stops.status` directly works and is how a tracking page ends up
+ * saying "out for delivery" about an order that was delivered ten minutes ago.
+ *
+ * The order status is kept in lockstep on purpose: `OUT_FOR_DELIVERY` and
+ * `DELIVERED` are the two states a customer actually sees, and they mean the
+ * same thing as the stop being `en_route` and `completed`.
+ */
+export type StopType = 'pickup' | 'dropoff';

package/dist/shippings/write-data.d.ts

@@ -3,7 +3,7 @@ export declare function shippingRateWriteData(input: ShippingWriteInput): Record
 export declare function shippingZoneWriteData(input: ShippingWriteInput): Record<string, unknown>;
 export declare function digitalDeliveryWriteData(input: ShippingWriteInput): Record<string, unknown>;
 export declare function licenseKeyWriteData(input: ShippingWriteInput): Record<string, unknown>;
-export declare function driverWriteData(input: ShippingWriteInput): Record<string, unknown>;
+export declare function courierWriteData(input: ShippingWriteInput): Record<string, unknown>;
 export declare function deliveryRouteWriteData(input: ShippingWriteInput): Record<string, unknown>;
 declare type ShippingWriteInput = Record<string, unknown>;
 declare type ShippingColumnAliases = Readonly<Record<string, readonly string[]>>;

package/dist/tax/breakdown.d.ts

@@ -1,19 +1,6 @@
 /** Every active rate, in the order they should be listed. */
 export declare function activeTaxRates(options?: BreakdownOptions): Promise<any[]>;
-/**
- * Tax on `taxable` cents, itemised.
- *
- * Each component is rounded on its own rather than the total being rounded
- * once. That is what a receipt has to show — the parts have to add up to the
- * figure charged, and a single rounding at the end leaves a line that is a
- * cent out from the sum above it.
- *
- * Every component is applied to `taxable` directly. Jurisdictions that compound
- * — where one tax forms part of the base for another — need an explicit order,
- * and that is a bigger claim than this should make quietly; an app that needs
- * it should compose two calls.
- */
-export declare function breakdownFor(taxable: number, rates: any[], options?: BreakdownOptions): TaxBreakdown;
+export declare function breakdownFor(taxable: number, rates: readonly TaxRateRow[], options?: BreakdownOptions): TaxBreakdown;
 /**
  * Read the active rates and apply them.
  *
@@ -42,3 +29,24 @@ export declare interface BreakdownOptions {
   codes?: string[]
   country?: string
 }
+/**
+ * Tax on `taxable` cents, itemised.
+ *
+ * Each component is rounded on its own rather than the total being rounded
+ * once. That is what a receipt has to show — the parts have to add up to the
+ * figure charged, and a single rounding at the end leaves a line that is a
+ * cent out from the sum above it.
+ *
+ * Every component is applied to `taxable` directly. Jurisdictions that compound
+ * — where one tax forms part of the base for another — need an explicit order,
+ * and that is a bigger claim than this should make quietly; an app that needs
+ * it should compose two calls.
+ */
+/** One tax rate row, in the terms the breakdown reads it. */
+export declare interface TaxRateRow {
+  id?: number | string
+  name?: string
+  code?: string
+  rate?: number | string
+  exemptible?: boolean
+}

package/dist/types.d.ts

@@ -203,6 +203,8 @@ export declare interface FetchManufacturersOptions {
   country?: string
   featured?: boolean
   search?: string
+  page?: number
+  limit?: number
 }
 export declare interface FetchCouponsOptions {
   page?: number

package/dist/utils/inserted-id.d.ts

@@ -0,0 +1,20 @@
+/**
+ * The id of the row an INSERT just created, or `undefined` when the driver did
+ * not report one.
+ *
+ * Every driver spells it differently, and one of them does not answer at all:
+ * SQLite reports `lastInsertRowid`, MySQL reports `insertId`, and Postgres
+ * reports neither without a `RETURNING` clause. A caller that only reads one
+ * spelling silently loses the row it just wrote on every other dialect.
+ *
+ * **Row counts are deliberately not consulted.** `numInsertedOrUpdatedRows` and
+ * its siblings say how MANY rows changed, not WHICH one. Reading a count as an
+ * id is worse than reading nothing: a successful single-row insert reports `1`,
+ * so the caller fetches id 1 and returns the FIRST row of the table as though
+ * it were the new one. Use {@link mutationCount} when the count is what you
+ * want.
+ *
+ * @param result Whatever `executeTakeFirst()` resolved to.
+ * @returns A positive integer id, or `undefined` when the driver reported none.
+ */
+export declare function insertedId(result: unknown): number | undefined;

package/package.json

@@ -2,7 +2,7 @@
   "name": "@stacksjs/commerce",
   "type": "module",
   "sideEffects": false,
-  "version": "0.72.102",
+  "version": "0.73.0",
   "description": "Stacks commerce utilities.",
   "author": "Chris Breuer",
   "contributors": [

package/dist/shippings/drivers/destroy.d.ts

@@ -1,14 +0,0 @@
-/**
- * Delete a driver by ID
- *
- * @param id The ID of the driver to delete
- * @returns True if the driver was deleted, false otherwise
- */
-export declare function destroy(id: number): Promise<boolean>;
-/**
- * Delete multiple drivers at once
- *
- * @param ids Array of driver IDs to delete
- * @returns Number of drivers deleted
- */
-export declare function bulkDestroy(ids: number[]): Promise<number>;

package/dist/shippings/drivers/fetch.d.ts

@@ -1,10 +0,0 @@
-import type { Driver, ModelRow } from '@stacksjs/orm';
-/**
- * Fetch a driver by ID
- */
-export declare function fetchById(id: number): Promise<DriverJsonResponse | undefined>;
-/**
- * Fetch all drivers
- */
-export declare function fetchAll(): Promise<DriverJsonResponse[]>;
-declare type DriverJsonResponse = ModelRow<typeof Driver>;

package/dist/shippings/drivers/store.d.ts

@@ -1,17 +0,0 @@
-import type { Driver, ModelRow, NewModelData } from '@stacksjs/orm';
-/**
- * Create a new driver
- *
- * @param data The driver data to store
- * @returns The newly created driver record
- */
-export declare function store(data: NewDriver): Promise<DriverJsonResponse>;
-/**
- * Create multiple drivers at once
- *
- * @param data Array of driver data to store
- * @returns Number of drivers created
- */
-export declare function bulkStore(data: NewDriver[]): Promise<number>;
-declare type DriverJsonResponse = ModelRow<typeof Driver>;
-declare type NewDriver = NewModelData<typeof Driver>;

package/dist/shippings/drivers/update.d.ts

@@ -1,27 +0,0 @@
-import type { Driver, ModelRow, UpdateModelData } from '@stacksjs/orm';
-/**
- * Update a driver
- *
- * @param id The id of the driver to update
- * @param data The driver data to update
- * @returns The updated driver record
- */
-export declare function update(id: number, data: DriverUpdate): Promise<DriverJsonResponse | undefined>;
-/**
- * Update a driver's status
- *
- * @param id The ID of the driver
- * @param status The new status (active, on_delivery, on_break)
- * @returns The updated driver with the new status
- */
-export declare function updateStatus(id: number, status: 'active' | 'on_delivery' | 'on_break'): Promise<DriverJsonResponse>;
-/**
- * Update driver's contact information
- *
- * @param id The ID of the driver
- * @param phone The updated phone number
- * @returns The updated driver
- */
-export declare function updateContact(id: number, phone?: string): Promise<DriverJsonResponse>;
-declare type DriverJsonResponse = ModelRow<typeof Driver>;
-declare type DriverUpdate = UpdateModelData<typeof Driver>;