@sixtyninecommerce/admin 0.8.0 → 0.9.0

package/dist/reports/index.d.ts

@@ -0,0 +1,199 @@
+import { type OrderScope, type Page, type Transport } from '@sixtyninecommerce/core';
+import type { BulkModule, BulkOperation } from '../bulk/index.js';
+import type { JobHandle, JobsModule } from '../jobs/index.js';
+import type { Call, ListOptions } from '../types.js';
+/**
+ * A report period (spec §9.3).
+ *
+ * Each bound is EITHER a date, `YYYY-MM-DD`, read as a whole day in the
+ * STORE's time zone (`Channel.customFields.timezone`, else Europe/Amsterdam) —
+ * never yours, never the server's — OR an ISO-8601 instant WITH an explicit
+ * offset (`2026-09-01T00:00:00+02:00`, `…Z`); a time without an offset is
+ * refused (`INVALID_REPORT_PERIOD`, a `ValidationError`).
+ *
+ * `from` is inclusive. `to` is inclusive as a DATE (`{ from: '2026-09-01',
+ * to: '2026-09-30' }` is all of September) and exclusive as an instant. At most
+ * 366 days.
+ */
+export interface ReportPeriod {
+    from: string;
+    to: string;
+}
+export interface ReportOverviewInput {
+    period: ReportPeriod;
+    /**
+     * One stock location of this store (`stockLocationId`). Keeps the orders whose
+     * stock was allocated or sold there, or that stated it at entry; an order
+     * touching two locations counts at both. A location of another store is
+     * refused with `LOCATION_NOT_IN_CHANNEL` (`ValidationError`). Omitted, the
+     * client's `tenant.location` (`x-location`) applies, as on every
+     * location-taking read. A credential restricted to some locations
+     * (`locationIds`) is refused elsewhere with `LOCATION_NOT_ALLOWED`
+     * (`PermissionDeniedError`) and, naming none, reads only its own locations'
+     * orders.
+     */
+    locationId?: string;
+    /** One storefront's orders: `CONSUMER` (retail) or `TRADE` (B2B). */
+    orderScope?: OrderScope;
+}
+/** The money of one period. Every `…Minor` is an integer in minor units of `currencyCode`. */
+export interface ReportTotals {
+    /** Placed, uncancelled orders — every currency. Carts never count. */
+    orderCount: number;
+    cancelledCount: number;
+    /**
+     * What those orders BILLED: the sum of each order's total with its goodwill
+     * rounding folded in — the same figure its invoice and its payment position
+     * read — for the orders in `currencyCode`.
+     */
+    revenueMinor: number;
+    /** The same orders' billable net totals, the rounding split at each order's own VAT rate. */
+    revenueNetMinor: number;
+    /** `revenueMinor` ÷ the orders in `currencyCode`, rounded half up. */
+    averageOrderValueMinor: number;
+    averageOrderValueNetMinor: number;
+    /** Orders placed in another currency: in `orderCount`, in no `…Minor` figure. */
+    ordersInOtherCurrencies: number;
+}
+/** One day of the store's calendar. */
+export interface ReportDay {
+    /** The instant the day begins in the store's zone, ISO-8601 UTC. A DST day is 23 or 25 hours long. */
+    startsAt: string;
+    orderCount: number;
+    revenueMinor: number;
+    revenueNetMinor: number;
+}
+export interface ReportOverview {
+    /** ISO 4217. The store's default currency; every `…Minor` value is in it. */
+    currencyCode: string;
+    /** IANA zone the days are cut in — the store's. */
+    timeZone: string;
+    /** The resolved period, ISO-8601 UTC: `from` inclusive, `to` exclusive. */
+    from: string;
+    to: string;
+    /** The comparison window immediately before, same length. */
+    previousFrom: string;
+    previousTo: string;
+    current: ReportTotals;
+    previous: ReportTotals;
+    days: ReportDay[];
+    newCustomers: number;
+    previousNewCustomers: number;
+    /** Live, not period-scoped: placed orders whose goods have not all been handed off. */
+    awaitingFulfillment: number;
+    /** Placed orders of the period by lifecycle (`open`, `completed`, `cancelled`). */
+    statusBreakdown: Array<{
+        status: string;
+        count: number;
+    }>;
+    topProducts: Array<{
+        productVariantId: string;
+        productId: string;
+        name: string;
+        sku: string;
+        unitsSold: number;
+    }>;
+}
+export interface PopularVariantsInput {
+    /** 1–50, default 8. */
+    take?: number;
+    /** 1–3650, default 90. */
+    sinceDays?: number;
+}
+export interface PopularVariant {
+    id: string;
+    productId: string;
+    name: string;
+    sku: string;
+}
+export interface LowStockInput extends ListOptions {
+    /** Rows whose `available` is at or below this; a whole number, 0–1,000,000. */
+    threshold: number;
+    /**
+     * One stock location of this store. Omitted: the client's `tenant.location`
+     * (`x-location`), else every location this credential may act at.
+     */
+    locationId?: string;
+}
+/** One variant at one stock location. */
+export interface LowStockVariant {
+    productVariantId: string;
+    productId: string;
+    sku: string;
+    name: string;
+    stockLocationId: string;
+    stockLocationName: string;
+    stockOnHand: number;
+    stockAllocated: number;
+    /** Units the out-of-stock threshold holds back from sale: `max(0, threshold)`. */
+    reserved: number;
+    /**
+     * `stockOnHand − stockAllocated − threshold` — the same figure `admin.stock`
+     * reports; negative when more is allocated than can be sold.
+     */
+    available: number;
+}
+/** The reports `export` can produce. */
+export type ReportExportKind = 'overview';
+export interface ReportExportFilter {
+    period: ReportPeriod;
+    /**
+     * Omitted, the client's (or the call's) `tenant.location` is used — the same
+     * fallback `overview` gets from `x-location` — so a file and the screen it
+     * mirrors cover the same place.
+     */
+    locationId?: string;
+    orderScope?: OrderScope;
+}
+/**
+ * A finished export: a bulk operation whose `resultUrl` is a short-lived
+ * signed link to the JSONL — one line per store day:
+ * `{ date, startsAt, timeZone, currencyCode, orderCount, revenueMinor, revenueNetMinor }`.
+ * Read `status` before the file: a failed run carries `error.code`.
+ */
+export type ReportExport = Omit<BulkOperation, 'entity'> & {
+    /** Export-only report entities are not among the importable `BulkEntity` values. */
+    entity: 'report_overview';
+};
+/**
+ * Tenant reporting (spec §9.2 `reports`): the order-analytics surface the
+ * dashboard reads, with money in integer minor units + `currencyCode` and time
+ * as ISO-8601 UTC (§9.3).
+ *
+ * Everything is scoped to the client's store; nothing here reads another.
+ * `overview` needs `ReadOrder`, `lowStock` `ReadCatalog` or `ReadProduct`,
+ * `popularVariants` `ReadOrder`, `export` `ReadOrder`. The cross-store fleet is
+ * `admin.platform.reports.fleet` (SuperAdmin session only).
+ */
+export interface ReportsModule {
+    /** Orders, revenue and customers of a period, by the store's own days. */
+    overview(input: ReportOverviewInput, options?: Call): Promise<ReportOverview>;
+    /**
+     * Variants ranked by units sold in placed orders of the last `sinceDays`
+     * days, most first. A `Page` because every list is one; it is always a
+     * single, final page.
+     */
+    popularVariants(input?: PopularVariantsInput, options?: Call): Promise<Page<PopularVariant>>;
+    /**
+     * Variants at or below `threshold` available units, per stock location,
+     * lowest first. Untracked variants are never low.
+     */
+    lowStock(input: LowStockInput): Promise<Page<LowStockVariant>>;
+    /**
+     * Write a report to a file, as a job (`kind: report.export`). `wait()`
+     * resolves with the operation and a freshly signed `resultUrl`. The filter's
+     * shape is checked when you call; its meaning (a real period, a location of
+     * this store) when the job runs, so a bad location fails the JOB. A
+     * location-restricted credential must name one of its own locations
+     * (`LOCATION_NOT_ALLOWED` otherwise) — a store-wide file is what its
+     * restriction withholds.
+     */
+    export(kind: ReportExportKind, filter: ReportExportFilter, options?: Call): Promise<JobHandle<ReportExport>>;
+}
+/** Only the §9.3 generation is selected — never the deprecated Float/String fields. */
+export declare const REPORT_OVERVIEW_QUERY = "\n  query ReportOverview($range: ReportPeriodInput!, $locationId: ID, $orderScope: OrderScope) {\n    commerceOverviewMetrics(range: $range, locationId: $locationId, orderScope: $orderScope) {\n      currencyCode\n      timeZone\n      from\n      to\n      previousFrom\n      previousTo\n      current { \n  orderCount\n  cancelledCount\n  revenueMinor\n  revenueNetMinor\n  averageOrderValueMinor\n  averageOrderValueNetMinor\n  ordersInOtherCurrencies\n }\n      previous { \n  orderCount\n  cancelledCount\n  revenueMinor\n  revenueNetMinor\n  averageOrderValueMinor\n  averageOrderValueNetMinor\n  ordersInOtherCurrencies\n }\n      revenueSeries { startsAt valueMinor valueNetMinor }\n      orderSeries { startsAt value }\n      newCustomers\n      previousNewCustomers\n      awaitingFulfillment\n      statusBreakdown { state count }\n      topProducts { productVariantId productId name sku unitsSold }\n    }\n  }\n";
+export declare const POPULAR_VARIANTS_QUERY = "\n  query ReportPopularVariants($take: Int, $sinceDays: Int) {\n    popularProductVariantsInChannel(take: $take, sinceDays: $sinceDays) {\n      id\n      productId\n      name\n      sku\n    }\n  }\n";
+export declare const LOW_STOCK_QUERY = "\n  query ReportLowStock($threshold: Int!, $locationId: ID, $options: LowStockVariantListOptions) {\n    lowStockVariants(threshold: $threshold, locationId: $locationId, options: $options) {\n      items {\n        productVariantId\n        productId\n        sku\n        name\n        stockLocationId\n        stockLocationName\n        stockOnHand\n        stockAllocated\n        reserved\n        available\n      }\n      totalItems\n    }\n  }\n";
+export declare function createReportsModule(transport: Transport, bulk: BulkModule, jobs: JobsModule, 
+/** The client's `tenant.location`, read per call (a derived client has its own). */
+clientLocation?: () => string | undefined): ReportsModule;

package/dist/reports/index.js

@@ -0,0 +1,154 @@
+import { createPage, pageFromVendureList, readOffsetCursor, } from '@sixtyninecommerce/core';
+const TOTALS_FIELDS = /* GraphQL */ `
+  orderCount
+  cancelledCount
+  revenueMinor
+  revenueNetMinor
+  averageOrderValueMinor
+  averageOrderValueNetMinor
+  ordersInOtherCurrencies
+`;
+/** Only the §9.3 generation is selected — never the deprecated Float/String fields. */
+export const REPORT_OVERVIEW_QUERY = /* GraphQL */ `
+  query ReportOverview($range: ReportPeriodInput!, $locationId: ID, $orderScope: OrderScope) {
+    commerceOverviewMetrics(range: $range, locationId: $locationId, orderScope: $orderScope) {
+      currencyCode
+      timeZone
+      from
+      to
+      previousFrom
+      previousTo
+      current { ${TOTALS_FIELDS} }
+      previous { ${TOTALS_FIELDS} }
+      revenueSeries { startsAt valueMinor valueNetMinor }
+      orderSeries { startsAt value }
+      newCustomers
+      previousNewCustomers
+      awaitingFulfillment
+      statusBreakdown { state count }
+      topProducts { productVariantId productId name sku unitsSold }
+    }
+  }
+`;
+export const POPULAR_VARIANTS_QUERY = /* GraphQL */ `
+  query ReportPopularVariants($take: Int, $sinceDays: Int) {
+    popularProductVariantsInChannel(take: $take, sinceDays: $sinceDays) {
+      id
+      productId
+      name
+      sku
+    }
+  }
+`;
+export const LOW_STOCK_QUERY = /* GraphQL */ `
+  query ReportLowStock($threshold: Int!, $locationId: ID, $options: LowStockVariantListOptions) {
+    lowStockVariants(threshold: $threshold, locationId: $locationId, options: $options) {
+      items {
+        productVariantId
+        productId
+        sku
+        name
+        stockLocationId
+        stockLocationName
+        stockOnHand
+        stockAllocated
+        reserved
+        available
+      }
+      totalItems
+    }
+  }
+`;
+const DEFAULT_LOW_STOCK_PAGE = 50;
+/** The bulk entity a report kind is exported as. */
+const EXPORT_ENTITY = { overview: 'report_overview' };
+/** Filter keys travel as the service spells them — see `bulk/index.ts`'s `FILTER_PASSTHROUGH`. */
+const FILTER_PASSTHROUGH = new Set(['filter']);
+export function createReportsModule(transport, bulk, jobs, 
+/** The client's `tenant.location`, read per call (a derived client has its own). */
+clientLocation = () => undefined) {
+    const lowStockPage = async (input, skip, take) => {
+        const data = await transport.graphql({
+            api: 'admin',
+            query: LOW_STOCK_QUERY,
+            variables: {
+                threshold: input.threshold,
+                locationId: input.locationId ?? null,
+                options: { skip, take },
+            },
+        }, input);
+        return pageFromVendureList(data.lowStockVariants, skip, take, (cursor) => lowStockPage(input, readOffsetCursor(cursor), take));
+    };
+    return {
+        async overview(input, options) {
+            const data = await transport.graphql({
+                api: 'admin',
+                query: REPORT_OVERVIEW_QUERY,
+                variables: {
+                    range: { from: input.period.from, to: input.period.to },
+                    locationId: input.locationId ?? null,
+                    orderScope: input.orderScope ?? null,
+                },
+            }, options);
+            const { revenueSeries, orderSeries, statusBreakdown, ...rest } = data.commerceOverviewMetrics;
+            // The two series are the same buckets; joined on the instant rather than
+            // the index so a reordering on the server could never pair two days.
+            const orders = new Map(orderSeries.map((point) => [point.startsAt, point.value]));
+            return {
+                ...rest,
+                days: revenueSeries.map((point) => ({
+                    startsAt: point.startsAt,
+                    orderCount: orders.get(point.startsAt) ?? 0,
+                    revenueMinor: point.valueMinor ?? 0,
+                    revenueNetMinor: point.valueNetMinor ?? 0,
+                })),
+                statusBreakdown: statusBreakdown.map((row) => ({ status: row.state, count: row.count })),
+            };
+        },
+        async popularVariants(input, options) {
+            const data = await transport.graphql({
+                api: 'admin',
+                query: POPULAR_VARIANTS_QUERY,
+                variables: { take: input?.take ?? null, sinceDays: input?.sinceDays ?? null },
+            }, options);
+            const items = data.popularProductVariantsInChannel;
+            return createPage(items, { nextCursor: null, hasNext: false, total: items.length }, () => {
+                // Unreachable while `hasNext` is false — `Page.next()` short-circuits.
+                throw new Error('popularVariants returns one ranked list; there is no next page');
+            });
+        },
+        lowStock(input) {
+            const take = input.limit ?? DEFAULT_LOW_STOCK_PAGE;
+            const skip = input.after === undefined ? 0 : readOffsetCursor(input.after);
+            return lowStockPage(input, skip, take);
+        },
+        async export(kind, filter, options) {
+            // The worker runs without the caller's `x-location`, so the fallback
+            // `overview` gets from that header is applied here, explicitly.
+            const locationId = filter.locationId ?? options?.tenant?.location ?? clientLocation();
+            const { jobId } = await transport.rest('plugins', {
+                method: 'POST',
+                path: '/bulk/exports',
+                body: {
+                    entity: EXPORT_ENTITY[kind],
+                    filter: {
+                        from: filter.period.from,
+                        to: filter.period.to,
+                        ...(locationId === undefined ? {} : { location_id: locationId }),
+                        ...(filter.orderScope === undefined ? {} : { order_scope: filter.orderScope }),
+                    },
+                },
+            }, { ...options, preserveKeys: FILTER_PASSTHROUGH });
+            return {
+                runId: jobId,
+                async wait(waitOptions) {
+                    // Wait on the JOB, then read the operation once: its signed link is
+                    // minted per read, so one minted while the run was going would have
+                    // expired by the time the file existed.
+                    await jobs.wait(jobId, { ...options, ...waitOptions });
+                    return (await bulk.get(jobId, options));
+                },
+            };
+        },
+    };
+}

package/dist/shipping/parcel-count-suggestion.d.ts

@@ -0,0 +1,52 @@
+import { type Transport } from '@sixtyninecommerce/core';
+import type { Call } from '../types.js';
+export declare const PARCEL_SUGGESTION_MAX_ITEMS = 500;
+export declare const PARCEL_SUGGESTION_MAX_QUANTITY = 100000;
+export interface ParcelCountSuggestionItem {
+    productVariantId: string;
+    /** Whole units, 1..100,000. Items of one variant are summed by the engine. */
+    quantity: number;
+}
+export interface ParcelCountSuggestionInput {
+    /** 1..500 items, from any number of the active channel's orders. */
+    items: ParcelCountSuggestionItem[];
+    /** ISO 3166-1 alpha-2. Only sets `destinationRequiresCustoms`; the count ignores it. */
+    destinationCountryCode?: string | null;
+}
+/** The active channel's parcel-count rule applied to the items. */
+export interface ParcelCountSuggestion {
+    /** 1..50. */
+    count: number;
+    /** The unclamped count; 0 when nothing was counted. */
+    raw: number;
+    /** False only when no rule applied (then `count` is 1 and `reason` is `NO_PARCEL_RULE`). */
+    resolvable: boolean;
+    /** Every counted item had all the data the rule asks for. */
+    exact: boolean;
+    /** `raw` exceeded 50. */
+    capped: boolean;
+    /** The channel's items per parcel, when set. */
+    capacity: number | null;
+    /** The channel's maximum parcel weight in grams, when set. */
+    maxWeightGrams: number | null;
+    /** Variants counted without a capacity: `count` is a lower bound. */
+    unratedLines: number;
+    /** Variants counted without a package weight under a maximum: `count` is a lower bound. */
+    unweighedLines: number;
+    /** `NO_PARCEL_RULE`, or null. A code: the caller owns the wording, and may meet new codes. */
+    reason: string | null;
+    /** `UNIT_OVER_MAX_WEIGHT` and/or `CAPPED`; may gain codes. */
+    warnings: string[];
+    /** Whether a parcel there needs a customs declaration; null without a destination. */
+    destinationRequiresCustoms: boolean | null;
+}
+/**
+ * `admin.shipping.parcelCountSuggestion`: how many parcels the active
+ * channel's rule gives a set of variant + quantity items. Needs `ReadCatalog`
+ * or `ReadFulfillment`. A malformed input is refused before any request with
+ * `PARCEL_COUNT_INPUT_INVALID` ({@link ValidationError}); an unknown variant,
+ * or another store's, is `PARCEL_COUNT_VARIANT_NOT_FOUND` (`NotFoundError`).
+ */
+export type ParcelCountSuggestionMethod = (input: ParcelCountSuggestionInput, options?: Call) => Promise<ParcelCountSuggestion>;
+export declare const PARCEL_COUNT_SUGGESTION_QUERY = "\n  query ParcelCountSuggestion($input: ParcelCountSuggestionInput!) {\n    parcelCountSuggestion(input: $input) {\n      count\n      raw\n      resolvable\n      exact\n      capped\n      capacity\n      maxWeightGrams\n      unratedLines\n      unweighedLines\n      reason\n      warnings\n      destinationRequiresCustoms\n    }\n  }\n";
+export declare function createParcelCountSuggestion(transport: Transport): ParcelCountSuggestionMethod;

package/dist/shipping/parcel-count-suggestion.js

@@ -0,0 +1,73 @@
+import { ValidationError } from '@sixtyninecommerce/core';
+// Mirror the engine's bounds (`services/vendure/src/parcel-count/`), which are
+// the authority; these only refuse a bad input before it leaves the process.
+export const PARCEL_SUGGESTION_MAX_ITEMS = 500;
+export const PARCEL_SUGGESTION_MAX_QUANTITY = 100_000;
+export const PARCEL_COUNT_SUGGESTION_QUERY = /* GraphQL */ `
+  query ParcelCountSuggestion($input: ParcelCountSuggestionInput!) {
+    parcelCountSuggestion(input: $input) {
+      count
+      raw
+      resolvable
+      exact
+      capped
+      capacity
+      maxWeightGrams
+      unratedLines
+      unweighedLines
+      reason
+      warnings
+      destinationRequiresCustoms
+    }
+  }
+`;
+function invalid(field, message) {
+    return new ValidationError({
+        code: 'PARCEL_COUNT_INPUT_INVALID',
+        message,
+        status: 400,
+        service: 'vendure',
+        details: [{ field, code: 'PARCEL_COUNT_INPUT_INVALID', message }],
+    });
+}
+function assertInput(input) {
+    const items = input?.items;
+    if (!Array.isArray(items) || items.length < 1 || items.length > PARCEL_SUGGESTION_MAX_ITEMS) {
+        throw invalid('items', `Pass between 1 and ${PARCEL_SUGGESTION_MAX_ITEMS} items.`);
+    }
+    items.forEach((item, index) => {
+        if (typeof item?.productVariantId !== 'string' || item.productVariantId === '') {
+            throw invalid(`items[${index}].productVariantId`, 'productVariantId is required.');
+        }
+        const quantity = item.quantity;
+        if (typeof quantity !== 'number' ||
+            !Number.isInteger(quantity) ||
+            quantity < 1 ||
+            quantity > PARCEL_SUGGESTION_MAX_QUANTITY) {
+            throw invalid(`items[${index}].quantity`, `quantity must be a whole number from 1 to ${PARCEL_SUGGESTION_MAX_QUANTITY.toLocaleString('en')}; got ${JSON.stringify(quantity)}.`);
+        }
+    });
+    const country = input.destinationCountryCode;
+    if (country !== undefined && country !== null && !/^[A-Za-z]{2}$/.test(country.trim())) {
+        throw invalid('destinationCountryCode', 'destinationCountryCode must be an ISO 3166-1 alpha-2 code, such as NL.');
+    }
+}
+export function createParcelCountSuggestion(transport) {
+    return async (input, options) => {
+        assertInput(input);
+        const data = await transport.graphql({
+            api: 'admin',
+            query: PARCEL_COUNT_SUGGESTION_QUERY,
+            variables: {
+                input: {
+                    items: input.items.map(({ productVariantId, quantity }) => ({
+                        productVariantId,
+                        quantity,
+                    })),
+                    destinationCountryCode: input.destinationCountryCode ?? null,
+                },
+            },
+        }, options);
+        return data.parcelCountSuggestion;
+    };
+}

package/dist/shipping/parcel-rule.d.ts

@@ -0,0 +1,48 @@
+import { type Transport } from '@sixtyninecommerce/core';
+import type { Call } from '../types.js';
+export declare const PARCEL_CAPACITY_MAX = 10000;
+export declare const PARCEL_WEIGHT_GRAMS_MAX = 70000;
+/** How the active channel counts parcels. `null` means "not set". */
+export interface ParcelRule {
+    channelId: string;
+    /**
+     * Units that fill one parcel unless a variant sets its own. `null` is no
+     * rule: every order counts as one parcel.
+     */
+    defaultParcelCapacity: number | null;
+    /** Extra lower bound from known package weights, in grams. `null` is no limit. */
+    maxParcelWeightGrams: number | null;
+}
+/**
+ * A PATCH: a key left out is unchanged, `null` clears it. At least one key is
+ * required.
+ */
+export interface SetParcelRuleInput {
+    /** Integer 1..10,000, or `null` to remove the rule. */
+    defaultParcelCapacity?: number | null;
+    /** Integer grams 1..70,000, or `null` to remove the limit. */
+    maxParcelWeightGrams?: number | null;
+}
+/**
+ * The ACTIVE channel's parcel-count rule (`admin.shipping.parcelRule`),
+ * stored as Channel custom fields and written through core `updateChannel`.
+ *
+ * Reading needs an authenticated administrator on the channel; writing needs
+ * `UpdateChannel`. A value out of range is refused here with
+ * `PARCEL_RULE_INVALID` ({@link ValidationError}) before any request, and by
+ * the engine's own custom-field validation for any other writer.
+ *
+ * The engine's storefront pricing reads the rule from its channel cache, so a
+ * change reaches another process after that cache refreshes.
+ */
+export interface ParcelRuleModule {
+    get(options?: Call): Promise<ParcelRule>;
+    set(input: SetParcelRuleInput, options?: Call): Promise<ParcelRule>;
+}
+/** `admin.shipping` (spec §9.2 `shipping`). */
+export interface ShippingModule {
+    parcelRule: ParcelRuleModule;
+}
+export declare const PARCEL_RULE_QUERY = "\n  query ParcelRule {\n    activeChannel { \n  id\n  customFields {\n    defaultParcelCapacity\n    maxParcelWeightGrams\n  }\n }\n  }\n";
+export declare const SET_PARCEL_RULE_MUTATION = "\n  mutation SetParcelRule($input: UpdateChannelInput!) {\n    updateChannel(input: $input) {\n      ... on Channel { \n  id\n  customFields {\n    defaultParcelCapacity\n    maxParcelWeightGrams\n  }\n }\n      ... on ErrorResult { errorCode message }\n    }\n  }\n";
+export declare function createShippingModule(transport: Transport): ShippingModule;

package/dist/shipping/parcel-rule.js

@@ -0,0 +1,91 @@
+import { errorFromErrorResult, isErrorResult, ValidationError, } from '@sixtyninecommerce/core';
+// Mirrors `MAX_PARCEL_CAPACITY` / `MAX_PARCEL_WEIGHT_GRAMS` in
+// `vendure-plugin-shipping-calculator/src/parcels/parcel-rule-fields.ts`. The
+// engine's custom-field `min`/`max` is the authority; these only refuse a bad
+// value before it leaves the process. Change both together.
+export const PARCEL_CAPACITY_MAX = 10_000;
+export const PARCEL_WEIGHT_GRAMS_MAX = 70_000;
+const RULE_FIELDS = /* GraphQL */ `
+  id
+  customFields {
+    defaultParcelCapacity
+    maxParcelWeightGrams
+  }
+`;
+export const PARCEL_RULE_QUERY = /* GraphQL */ `
+  query ParcelRule {
+    activeChannel { ${RULE_FIELDS} }
+  }
+`;
+export const SET_PARCEL_RULE_MUTATION = /* GraphQL */ `
+  mutation SetParcelRule($input: UpdateChannelInput!) {
+    updateChannel(input: $input) {
+      ... on Channel { ${RULE_FIELDS} }
+      ... on ErrorResult { errorCode message }
+    }
+  }
+`;
+function toRule(channel) {
+    return {
+        channelId: channel.id,
+        defaultParcelCapacity: channel.customFields?.defaultParcelCapacity ?? null,
+        maxParcelWeightGrams: channel.customFields?.maxParcelWeightGrams ?? null,
+    };
+}
+function invalid(field, message) {
+    return new ValidationError({
+        code: 'PARCEL_RULE_INVALID',
+        message,
+        status: 400,
+        service: 'vendure',
+        details: [{ field, code: 'PARCEL_RULE_INVALID', message }],
+    });
+}
+function assertBound(field, value, max, unit) {
+    if (value === undefined || value === null)
+        return;
+    if (typeof value === 'number' && Number.isInteger(value) && value >= 1 && value <= max)
+        return;
+    throw invalid(field, `${field} must be a whole number of ${unit} from 1 to ${max.toLocaleString('en')}, or null to clear it; got ${JSON.stringify(value)}.`);
+}
+function customFieldsOf(input) {
+    const fields = {};
+    if (input.defaultParcelCapacity !== undefined) {
+        fields.defaultParcelCapacity = input.defaultParcelCapacity;
+    }
+    if (input.maxParcelWeightGrams !== undefined) {
+        fields.maxParcelWeightGrams = input.maxParcelWeightGrams;
+    }
+    return fields;
+}
+export function createShippingModule(transport) {
+    const get = async (options) => {
+        const data = await transport.graphql({ api: 'admin', query: PARCEL_RULE_QUERY }, options);
+        return toRule(data.activeChannel);
+    };
+    return {
+        parcelRule: {
+            get,
+            async set(input, options) {
+                assertBound('defaultParcelCapacity', input?.defaultParcelCapacity, PARCEL_CAPACITY_MAX, 'items');
+                assertBound('maxParcelWeightGrams', input?.maxParcelWeightGrams, PARCEL_WEIGHT_GRAMS_MAX, 'grams');
+                const customFields = customFieldsOf(input ?? {});
+                if (Object.keys(customFields).length === 0) {
+                    throw invalid('input', 'Pass defaultParcelCapacity and/or maxParcelWeightGrams; an empty input changes nothing.');
+                }
+                // `updateChannel` needs the id, and the active channel is the one the
+                // client is scoped to — read it with the SAME call options, so a
+                // per-call tenant writes its own channel rather than the client's.
+                const { channelId } = await get(options);
+                const data = await transport.graphql({
+                    api: 'admin',
+                    query: SET_PARCEL_RULE_MUTATION,
+                    variables: { input: { id: channelId, customFields } },
+                }, options);
+                if (isErrorResult(data.updateChannel))
+                    throw errorFromErrorResult(data.updateChannel);
+                return toRule(data.updateChannel);
+            },
+        },
+    };
+}