@sixtyninecommerce/admin 0.11.0 → 0.13.0

package/dist/shipping/rate-tables.js

@@ -9,30 +9,34 @@ const SUMMARY_FIELDS = /* GraphQL */ `
   createdAt
   updatedAt
 `;
+const MEMBER_FIELDS = /* GraphQL */ `
+  id
+  countryCode
+  postalCodeFrom
+  postalCodeTo
+`;
+const RATE_FIELDS = /* GraphQL */ `
+  id
+  minWeightGrams
+  maxWeightGrams
+  price
+  currencyCode
+`;
+/** One selection for a zone wherever it is read or answered, so every door answers the same zone. */
+const ZONE_FIELDS = /* GraphQL */ `
+  id
+  name
+  type
+  position
+  members { ${MEMBER_FIELDS} }
+  rates { ${RATE_FIELDS} }
+  createdAt
+  updatedAt
+`;
 /** One selection for the single read and both writes, so all three answer the same table. */
 const TABLE_FIELDS = /* GraphQL */ `
   ${SUMMARY_FIELDS}
-  zones {
-    id
-    name
-    type
-    position
-    members {
-      id
-      countryCode
-      postalCodeFrom
-      postalCodeTo
-    }
-    rates {
-      id
-      minWeightGrams
-      maxWeightGrams
-      price
-      currencyCode
-    }
-    createdAt
-    updatedAt
-  }
+  zones { ${ZONE_FIELDS} }
 `;
 export const RATE_TABLES_QUERY = /* GraphQL */ `
   query StoreRateTables {
@@ -62,6 +66,39 @@ export const DELETE_RATE_TABLE_MUTATION = /* GraphQL */ `
     }
   }
 `;
+export const CREATE_RATE_TABLE_ZONE_MUTATION = /* GraphQL */ `
+  mutation CreateStoreRateTableZone($configId: ID!, $input: CreateShippingZoneInput!) {
+    createShippingZone(configId: $configId, input: $input) { ${ZONE_FIELDS} }
+  }
+`;
+export const UPDATE_RATE_TABLE_ZONE_MUTATION = /* GraphQL */ `
+  mutation UpdateStoreRateTableZone($id: ID!, $input: UpdateShippingZoneInput!) {
+    updateShippingZone(id: $id, input: $input) { ${ZONE_FIELDS} }
+  }
+`;
+export const DELETE_RATE_TABLE_ZONE_MUTATION = /* GraphQL */ `
+  mutation DeleteStoreRateTableZone($id: ID!) {
+    deleteShippingZone(id: $id) {
+      result
+      message
+    }
+  }
+`;
+export const REORDER_RATE_TABLE_ZONES_MUTATION = /* GraphQL */ `
+  mutation ReorderStoreRateTableZones($configId: ID!, $zoneIds: [ID!]!) {
+    reorderShippingZones(configId: $configId, zoneIds: $zoneIds) { ${ZONE_FIELDS} }
+  }
+`;
+export const SET_RATE_TABLE_ZONE_MEMBERS_MUTATION = /* GraphQL */ `
+  mutation SetStoreRateTableZoneMembers($zoneId: ID!, $members: [ShippingZoneMemberInput!]!) {
+    setShippingZoneMembers(zoneId: $zoneId, members: $members) { ${MEMBER_FIELDS} }
+  }
+`;
+export const SET_RATE_TABLE_ZONE_RATES_MUTATION = /* GraphQL */ `
+  mutation SetStoreRateTableZoneRates($zoneId: ID!, $rates: [ShippingRateInput!]!) {
+    setShippingRates(zoneId: $zoneId, rates: $rates) { ${RATE_FIELDS} }
+  }
+`;
 /** GraphQL's `Int`: a 32-bit signed integer. A wider number cannot be sent at all. */
 const INT_MIN = -2_147_483_648;
 const INT_MAX = 2_147_483_647;
@@ -152,14 +189,182 @@ function tableInput(input, mode) {
     problems.throwIfAny();
     return out;
 }
-const requireId = (id) => {
+/** `field` is the operation's own argument (`/id`, `/configId`, `/zoneId`). */
+const requireId = (id, field = '/id', what = 'a rate table id') => {
     if (typeof id !== 'string' || id === '') {
         const problems = new Problems();
-        problems.add('/id', 'type', 'id must be a rate table id.');
+        problems.add(field, 'type', `${field.slice(1)} must be ${what}.`);
         problems.throwIfAny();
     }
     return id;
 };
+/**
+ * A zone's input as the engine takes it, with only the fields the caller named. A create's name
+ * and type are `String!`, so a missing one cannot be sent; every other `null` goes through as
+ * sent (a create reads a null position as "after the last zone", an update refuses it).
+ */
+function zoneInput(input, mode) {
+    const problems = new Problems();
+    if (!isObject(input)) {
+        problems.add('/input', 'type', mode === 'create'
+            ? 'A new zone must be an object.'
+            : 'The change to a zone must be an object.');
+        problems.throwIfAny();
+    }
+    const fields = input;
+    const out = {};
+    const texts = [
+        ['name', 'Give the zone a name.', 'The zone name must be text.'],
+        [
+            'type',
+            'Give the zone a type: "domestic" (it matches postal-code ranges) or "international" (it matches countries).',
+            'The zone type must be text.',
+        ],
+    ];
+    for (const [key, missing, notText] of texts) {
+        const value = fields[key];
+        if (value == null && mode === 'create') {
+            problems.add(`/input/${key}`, 'required', missing);
+        }
+        else if (value !== undefined) {
+            if (value !== null && typeof value !== 'string') {
+                problems.add(`/input/${key}`, 'type', notText);
+            }
+            out[key] = value;
+        }
+    }
+    if (fields.position !== undefined) {
+        if (fields.position !== null) {
+            intInput(problems, '/input/position', 'The position', fields.position);
+        }
+        out.position = fields.position;
+    }
+    problems.throwIfAny();
+    return out;
+}
+const MEMBER_TEXTS = [
+    ['countryCode', 'country'],
+    ['postalCodeFrom', 'postal-code start'],
+    ['postalCodeTo', 'postal-code end'],
+];
+/** Only the three member fields, each text or null; whether the zone matches it is the engine's. */
+function membersInput(members) {
+    const problems = new Problems();
+    if (!Array.isArray(members)) {
+        problems.add('/members', 'type', 'The members must be a list.');
+        problems.throwIfAny();
+    }
+    const out = members.map((member, index) => {
+        const at = `/members/${String(index)}`;
+        const row = {};
+        if (!isObject(member)) {
+            problems.add(at, 'type', `Member ${String(index + 1)} must be an object.`);
+            return row;
+        }
+        for (const [key, label] of MEMBER_TEXTS) {
+            const value = member[key];
+            if (value === undefined)
+                continue;
+            if (value !== null && typeof value !== 'string') {
+                problems.add(`${at}/${key}`, 'type', `Member ${String(index + 1)}'s ${label} must be text.`);
+            }
+            row[key] = value;
+        }
+        return row;
+    });
+    problems.throwIfAny();
+    return out;
+}
+const RATE_NUMBERS = [
+    ['minWeightGrams', 'a start weight'],
+    ['maxWeightGrams', 'an end weight'],
+    ['price', 'a price'],
+];
+/**
+ * Only the four tier fields. Each is non-null on the wire (`Int!`, `String!`), so a missing one
+ * cannot be sent; the tier's values (negative, ending before it starts, overlapping another, an
+ * unknown currency) are the engine's to judge.
+ */
+function ratesInput(rates) {
+    const problems = new Problems();
+    if (!Array.isArray(rates)) {
+        problems.add('/rates', 'type', 'The rates must be a list of weight tiers.');
+        problems.throwIfAny();
+    }
+    const out = rates.map((rate, index) => {
+        const at = `/rates/${String(index)}`;
+        const tier = `Tier ${String(index + 1)}`;
+        if (!isObject(rate)) {
+            problems.add(at, 'type', `${tier} must be an object.`);
+            return {};
+        }
+        for (const [key, label] of RATE_NUMBERS) {
+            const value = rate[key];
+            if (value == null)
+                problems.add(`${at}/${key}`, 'required', `${tier} needs ${label}.`);
+            else
+                intInput(problems, `${at}/${key}`, `${tier}'s ${label.replace(/^an? /, '')}`, value);
+        }
+        if (rate.currencyCode == null) {
+            problems.add(`${at}/currencyCode`, 'required', `${tier} needs a currency.`);
+        }
+        else if (typeof rate.currencyCode !== 'string') {
+            problems.add(`${at}/currencyCode`, 'type', `${tier}'s currency must be text (ISO 4217, e.g. EUR).`);
+        }
+        return {
+            minWeightGrams: rate.minWeightGrams,
+            maxWeightGrams: rate.maxWeightGrams,
+            price: rate.price,
+            currencyCode: rate.currencyCode,
+        };
+    });
+    problems.throwIfAny();
+    return out;
+}
+/** A list of zone ids; whether it names every zone of the table once is the engine's. */
+function zoneIdsInput(zoneIds) {
+    const problems = new Problems();
+    if (!Array.isArray(zoneIds)) {
+        problems.add('/zoneIds', 'type', 'The zone order must be a list of zone ids.');
+        problems.throwIfAny();
+    }
+    zoneIds.forEach((id, index) => {
+        if (typeof id !== 'string' || id === '') {
+            problems.add(`/zoneIds/${String(index)}`, 'type', `Place ${String(index + 1)} must be a zone id.`);
+        }
+    });
+    problems.throwIfAny();
+    return zoneIds;
+}
+function createZonesModule(transport) {
+    return {
+        async create(tableId, input, options) {
+            const configId = requireId(tableId, '/configId');
+            return fieldOf(transport, CREATE_RATE_TABLE_ZONE_MUTATION, 'createShippingZone', { configId, input: zoneInput(input, 'create') }, options);
+        },
+        async update(zoneId, patch, options) {
+            const id = requireId(zoneId, '/id', 'a zone id');
+            return fieldOf(transport, UPDATE_RATE_TABLE_ZONE_MUTATION, 'updateShippingZone', { id, input: zoneInput(patch, 'update') }, options);
+        },
+        async delete(zoneId, options) {
+            assertDeleted('SHIPPING_ZONE_NOT_DELETED', [
+                await fieldOf(transport, DELETE_RATE_TABLE_ZONE_MUTATION, 'deleteShippingZone', { id: requireId(zoneId, '/id', 'a zone id') }, options),
+            ]);
+        },
+        async reorder(tableId, zoneIds, options) {
+            const configId = requireId(tableId, '/configId');
+            return fieldOf(transport, REORDER_RATE_TABLE_ZONES_MUTATION, 'reorderShippingZones', { configId, zoneIds: zoneIdsInput(zoneIds) }, options);
+        },
+        async setMembers(zoneId, members, options) {
+            const id = requireId(zoneId, '/zoneId', 'a zone id');
+            return fieldOf(transport, SET_RATE_TABLE_ZONE_MEMBERS_MUTATION, 'setShippingZoneMembers', { zoneId: id, members: membersInput(members) }, options);
+        },
+        async setRates(zoneId, rates, options) {
+            const id = requireId(zoneId, '/zoneId', 'a zone id');
+            return fieldOf(transport, SET_RATE_TABLE_ZONE_RATES_MUTATION, 'setShippingRates', { zoneId: id, rates: ratesInput(rates) }, options);
+        },
+    };
+}
 export function createRateTablesModule(transport) {
     return {
         async list(options) {
@@ -180,5 +385,6 @@ export function createRateTablesModule(transport) {
                 await fieldOf(transport, DELETE_RATE_TABLE_MUTATION, 'deleteShippingZoneConfig', { id: requireId(id) }, options),
             ]);
         },
+        zones: createZonesModule(transport),
     };
 }

package/dist/shipping/ship-to-countries.d.ts

@@ -0,0 +1,75 @@
+import type { Transport } from '@sixtyninecommerce/core';
+import type { Call } from '../types.js';
+/**
+ * How a store's ship-to list reads: `ALL` (no list: every enabled country is offered), `SUBSET`
+ * (only the listed countries are offered, and an order to any other cannot be placed), or
+ * `MALFORMED` (the stored value cannot be read; checkout offers every enabled country and logs
+ * it, and saving a list replaces it).
+ */
+export type ShipToCountriesGate = 'ALL' | 'SUBSET' | 'MALFORMED';
+/** One row of a ship-to picker. */
+export interface ShipToCountryOption {
+    /** ISO-3166 alpha-2 code, upper-case. */
+    code: string;
+    /** The country's name; a selected code that is not an enabled country shows as its code. */
+    name: string;
+    /** False for a selected code that is not an enabled country: no shopper can choose it. */
+    enabled: boolean;
+}
+/** The countries a store ships to, as checkout applies them. */
+export interface ShipToCountries {
+    gate: ShipToCountriesGate;
+    /** Why the stored value cannot be read (`MALFORMED` only); else null. */
+    reason: string | null;
+    /** The selected codes, trimmed, upper-cased and de-duplicated (`SUBSET` only); else empty. */
+    selected: string[];
+    /** The codes the storefront offers at checkout (Shop `availableCountries`), in its order. */
+    served: string[];
+    /**
+     * Selected codes that are not enabled countries: selected, but no shopper can choose them.
+     * Only a platform administrator enables a country (`platform.countries`).
+     */
+    unservable: string[];
+    /** The enabled countries, then every selected code that is not one, so it can be removed. */
+    options: ShipToCountryOption[];
+}
+/**
+ * The ACTIVE store's ship-to countries (`admin.shipping.shipToCountries`): which countries its
+ * storefront offers at checkout, and to which an order may be addressed. Reading needs any
+ * administrator permission on the store; `set` needs `UpdateChannel`.
+ *
+ * The engine owns every rule (how codes are read, which are offered, which are unservable): ask
+ * {@link preview} for a list that is not saved.
+ */
+export interface ShipToCountriesModule {
+    /**
+     * The list as checkout applies it.
+     *
+     * @effect read
+     */
+    get(options?: Call): Promise<ShipToCountries>;
+    /**
+     * How a list WOULD read once stored, without saving anything. Refused as {@link set} refuses.
+     *
+     * @effect read
+     */
+    preview(countryCodes: readonly string[], options?: Call): Promise<ShipToCountries>;
+    /**
+     * Replace the list, and answer it as checkout now applies it. Codes are trimmed, upper-cased
+     * and de-duplicated. An empty list means every enabled country, never "ships nowhere".
+     *
+     * Refused `SHIP_TO_COUNTRIES_INVALID` (`ValidationError`, one `details[]` entry per offending
+     * entry, `field` = `countryCodes.<index>`) for an entry that is not a two-letter ISO-3166 code,
+     * or more than 300 entries; `FORBIDDEN` / `CHANNEL_ACCESS_DENIED` without `UpdateChannel`.
+     * A two-letter code that is not an enabled country is stored and reported in `unservable`.
+     *
+     * Narrowing the list changes which countries shoppers may order to.
+     *
+     * @effect write
+     */
+    set(countryCodes: readonly string[], options?: Call): Promise<ShipToCountries>;
+}
+export declare const SHIP_TO_COUNTRIES_QUERY = "\n  query ShipToCountries {\n    shipToCountries { \n  gate\n  reason\n  selected\n  served\n  unservable\n  options { code name enabled }\n }\n  }\n";
+export declare const PREVIEW_SHIP_TO_COUNTRIES_QUERY = "\n  query PreviewShipToCountries($countryCodes: [String!]!) {\n    previewShipToCountries(countryCodes: $countryCodes) { \n  gate\n  reason\n  selected\n  served\n  unservable\n  options { code name enabled }\n }\n  }\n";
+export declare const SET_SHIP_TO_COUNTRIES_MUTATION = "\n  mutation SetShipToCountries($countryCodes: [String!]!) {\n    setShipToCountries(countryCodes: $countryCodes) { \n  gate\n  reason\n  selected\n  served\n  unservable\n  options { code name enabled }\n }\n  }\n";
+export declare function createShipToCountriesModule(transport: Transport): ShipToCountriesModule;

package/dist/shipping/ship-to-countries.js

@@ -0,0 +1,47 @@
+const VIEW_FIELDS = /* GraphQL */ `
+  gate
+  reason
+  selected
+  served
+  unservable
+  options { code name enabled }
+`;
+export const SHIP_TO_COUNTRIES_QUERY = /* GraphQL */ `
+  query ShipToCountries {
+    shipToCountries { ${VIEW_FIELDS} }
+  }
+`;
+export const PREVIEW_SHIP_TO_COUNTRIES_QUERY = /* GraphQL */ `
+  query PreviewShipToCountries($countryCodes: [String!]!) {
+    previewShipToCountries(countryCodes: $countryCodes) { ${VIEW_FIELDS} }
+  }
+`;
+export const SET_SHIP_TO_COUNTRIES_MUTATION = /* GraphQL */ `
+  mutation SetShipToCountries($countryCodes: [String!]!) {
+    setShipToCountries(countryCodes: $countryCodes) { ${VIEW_FIELDS} }
+  }
+`;
+export function createShipToCountriesModule(transport) {
+    return {
+        async get(options) {
+            const data = await transport.graphql({ api: 'admin', query: SHIP_TO_COUNTRIES_QUERY }, options);
+            return data.shipToCountries;
+        },
+        async preview(countryCodes, options) {
+            const data = await transport.graphql({
+                api: 'admin',
+                query: PREVIEW_SHIP_TO_COUNTRIES_QUERY,
+                variables: { countryCodes: [...countryCodes] },
+            }, options);
+            return data.previewShipToCountries;
+        },
+        async set(countryCodes, options) {
+            const data = await transport.graphql({
+                api: 'admin',
+                query: SET_SHIP_TO_COUNTRIES_MUTATION,
+                variables: { countryCodes: [...countryCodes] },
+            }, options);
+            return data.setShipToCountries;
+        },
+    };
+}

package/dist/stock/by-location.d.ts

@@ -0,0 +1,86 @@
+import { type Page, type Transport } from '@sixtyninecommerce/core';
+import type { ListOptions } from '../types.js';
+import type { StockMovementType } from './index.js';
+/** One variant's stock level at one location. */
+export interface LocationStockLevel {
+    /** The stock level's own id. */
+    id: string;
+    variantId: string;
+    sku: string;
+    variantName: string;
+    /** The variant's product, for its name and picture. */
+    product: {
+        id: string;
+        name: string;
+        featuredAsset: {
+            id: string;
+            preview: string;
+        } | null;
+    };
+    /** Units the location holds. */
+    onHand: number;
+    /** Of those, the units reserved for orders. */
+    allocated: number;
+    /** When the level last changed. */
+    updatedAt: string;
+}
+export interface LocationStockLevelFilter extends ListOptions {
+    /** Matches the SKU or the variant's name, ignoring case. Blank searches nothing. */
+    search?: string;
+    /** By units on hand: `DESC` (most first, the default) or `ASC`. */
+    sort?: 'ASC' | 'DESC';
+}
+/** One line of a location's stock ledger. */
+export interface LocationStockMovement {
+    id: string;
+    createdAt: string;
+    type: StockMovementType;
+    /**
+     * The movement's own signed quantity as the engine stores it. A `SALE` is negative; a
+     * `RELEASE` is stored positive although it lowers `allocated`.
+     */
+    quantity: number;
+    variantId: string;
+    sku: string;
+    variantName: string;
+    /** The order the movement was made for (an allocation, a sale, a release, …), else null. */
+    order: {
+        id: string;
+        code: string;
+    } | null;
+}
+/**
+ * What one stock location holds and what moved there, a page at a time. The location must be
+ * the store's own: another store's, or an id that does not exist, is refused
+ * `LOCATION_NOT_IN_CHANNEL` (→ `ValidationError`), never read; a credential restricted with
+ * `locationIds` is refused `LOCATION_NOT_ALLOWED` (→ `PermissionDeniedError`) at a location it
+ * does not hold. A location several stores share lists only this store's variants.
+ */
+export interface StockByLocationReads {
+    /**
+     * The variants stocked at `locationId`, by units on hand (most first unless `sort` says
+     * `ASC`); `limit` defaults to 25 and the engine answers at most 200 per page. A variant whose
+     * level row was never written there is not listed.
+     *
+     * @effect read
+     * @permission ReadStockLocation
+     */
+    levelsAt(locationId: string, filter?: LocationStockLevelFilter): Promise<Page<LocationStockLevel>>;
+    /**
+     * The stock ledger at `locationId`, newest first; `limit` defaults to 25. It lists the
+     * movements the engine records (allocations, sales, releases, cancellations, returns and
+     * adjustments); a bulk stock import writes the levels directly and is not on it.
+     *
+     * Known limit: at a location several stores share, a variant that more than one of them sells
+     * also carries the other stores' order movements, whose order this store cannot read. The
+     * engine then fails the whole page (`GRAPHQL_ERROR`, "Cannot return null for non-nullable
+     * field") instead of leaving the row out; the levels read is not affected.
+     *
+     * @effect read
+     * @permission ReadStockLocation
+     */
+    movementsAt(locationId: string, filter?: ListOptions): Promise<Page<LocationStockMovement>>;
+}
+export declare const STOCK_LEVELS_AT_LOCATION_QUERY = "\n  query StockLevelsAtLocation($locationId: ID!, $options: StockLevelListOptions) {\n    stockLevelsByLocation(locationId: $locationId, options: $options) {\n      items {\n        id\n        stockOnHand\n        stockAllocated\n        updatedAt\n        productVariant {\n          id\n          name\n          sku\n          product { id name featuredAsset { id preview } }\n        }\n      }\n      totalItems\n    }\n  }\n";
+export declare const STOCK_MOVEMENTS_AT_LOCATION_QUERY = "\n  query StockMovementsAtLocation($locationId: ID!, $options: StockMovementListOptions) {\n    stockMovementsByLocation(locationId: $locationId, options: $options) {\n      items {\n        id\n        createdAt\n        type\n        quantity\n        productVariant { id name sku }\n        orderLine { order { id code } }\n      }\n      totalItems\n    }\n  }\n";
+export declare function createStockByLocationReads(transport: Transport): StockByLocationReads;

package/dist/stock/by-location.js

@@ -0,0 +1,94 @@
+import { pageFromVendureList, readOffsetCursor, } from '@sixtyninecommerce/core';
+export const STOCK_LEVELS_AT_LOCATION_QUERY = /* GraphQL */ `
+  query StockLevelsAtLocation($locationId: ID!, $options: StockLevelListOptions) {
+    stockLevelsByLocation(locationId: $locationId, options: $options) {
+      items {
+        id
+        stockOnHand
+        stockAllocated
+        updatedAt
+        productVariant {
+          id
+          name
+          sku
+          product { id name featuredAsset { id preview } }
+        }
+      }
+      totalItems
+    }
+  }
+`;
+export const STOCK_MOVEMENTS_AT_LOCATION_QUERY = /* GraphQL */ `
+  query StockMovementsAtLocation($locationId: ID!, $options: StockMovementListOptions) {
+    stockMovementsByLocation(locationId: $locationId, options: $options) {
+      items {
+        id
+        createdAt
+        type
+        quantity
+        productVariant { id name sku }
+        orderLine { order { id code } }
+      }
+      totalItems
+    }
+  }
+`;
+const toLevel = ({ productVariant, ...level }) => ({
+    id: level.id,
+    variantId: productVariant.id,
+    sku: productVariant.sku,
+    variantName: productVariant.name,
+    product: {
+        id: productVariant.product.id,
+        name: productVariant.product.name,
+        featuredAsset: productVariant.product.featuredAsset ?? null,
+    },
+    onHand: level.stockOnHand,
+    allocated: level.stockAllocated,
+    updatedAt: level.updatedAt,
+});
+const toMovement = ({ productVariant, orderLine, ...movement }) => ({
+    ...movement,
+    variantId: productVariant.id,
+    sku: productVariant.sku,
+    variantName: productVariant.name,
+    order: orderLine?.order ?? null,
+});
+const DEFAULT_PAGE_SIZE = 25;
+const firstSkip = (filter) => filter?.after === undefined ? 0 : readOffsetCursor(filter.after);
+export function createStockByLocationReads(transport) {
+    const levelsPage = async (locationId, skip, take, filter) => {
+        const search = filter?.search?.trim();
+        const data = await transport.graphql({
+            api: 'admin',
+            query: STOCK_LEVELS_AT_LOCATION_QUERY,
+            variables: {
+                locationId,
+                options: { skip, take, sort: filter?.sort ?? 'DESC', ...(search ? { search } : {}) },
+            },
+        }, filter);
+        return pageFromVendureList({
+            items: data.stockLevelsByLocation.items.map(toLevel),
+            totalItems: data.stockLevelsByLocation.totalItems,
+        }, skip, take, (cursor) => levelsPage(locationId, readOffsetCursor(cursor), take, filter));
+    };
+    const movementsPage = async (locationId, skip, take, filter) => {
+        const data = await transport.graphql({
+            api: 'admin',
+            query: STOCK_MOVEMENTS_AT_LOCATION_QUERY,
+            variables: { locationId, options: { skip, take } },
+        }, filter);
+        return pageFromVendureList({
+            items: data.stockMovementsByLocation.items.map(toMovement),
+            totalItems: data.stockMovementsByLocation.totalItems,
+        }, skip, take, (cursor) => movementsPage(locationId, readOffsetCursor(cursor), take, filter));
+    };
+    return {
+        levelsAt(locationId, filter) {
+            return levelsPage(locationId, firstSkip(filter), filter?.limit ?? DEFAULT_PAGE_SIZE, filter);
+        },
+        movementsAt(locationId, filter) {
+            return movementsPage(locationId, firstSkip(filter), filter?.limit ?? DEFAULT_PAGE_SIZE, filter);
+        },
+    };
+}

package/dist/stock/index.d.ts

@@ -1,6 +1,8 @@
 import { type Page, type Transport } from '@sixtyninecommerce/core';
 import type { Call, ListOptions } from '../types.js';
+import { type StockByLocationReads } from './by-location.js';
 import { type StockLocationsModule } from './locations.js';
+import { type StockSettingsModule } from './settings.js';
 import { type StockTransfersModule } from './transfers.js';
 /**
  * One variant's stock at one location, in integer units.
@@ -133,7 +135,7 @@ export interface StockAllocationsModule {
  * narrowed to that list instead); `STOCK_LOCATION_REQUIRED` and
  * `STOCK_WOULD_GO_NEGATIVE` (→ `BusinessRuleError`).
  */
-export interface StockModule {
+export interface StockModule extends StockByLocationReads {
     /** The variant's stock at every location of this store (or one). A location that never held it has no entry. */
     position(variantId: string, options?: StockPositionOptions): Promise<StockPosition[]>;
     /** The variant's ledger at this store's locations, with each movement's reason. */
@@ -165,6 +167,11 @@ export interface StockModule {
     allocations: StockAllocationsModule;
     /** The store's stock locations themselves: list, read, create, change, delete. */
     locations: StockLocationsModule;
+    /**
+     * The store's stock settings as the engine reads them, saved or previewed: tracking, the
+     * threshold, exposure to the storefront, the storefront warehouses and the backorder default.
+     */
+    settings: StockSettingsModule;
 }
 export declare const STOCK_POSITION_QUERY = "\n  query StockPosition($variantId: ID!, $locationId: ID) {\n    stockPosition(variantId: $variantId, locationId: $locationId) { \n  locationId\n  locationName\n  onHand\n  allocated\n  available\n  incoming\n  onOrder\n  reserved\n  trackInventory\n }\n  }\n";
 export declare const STOCK_MOVEMENTS_QUERY: string;

package/dist/stock/index.js

@@ -1,5 +1,7 @@
 import { errorFromErrorResult, isErrorResult, pageFromVendureList, readOffsetCursor, } from '@sixtyninecommerce/core';
+import { createStockByLocationReads } from './by-location.js';
 import { createStockLocationsModule } from './locations.js';
+import { createStockSettingsModule } from './settings.js';
 import { createStockTransfersModule } from './transfers.js';
 const POSITION_FIELDS = /* GraphQL */ `
   locationId
@@ -104,6 +106,8 @@ export function createStockModule(transport) {
         },
         transfers: createStockTransfersModule(transport),
         locations: createStockLocationsModule(transport),
+        settings: createStockSettingsModule(transport),
+        ...createStockByLocationReads(transport),
         allocations: {
             async release(orderId, options) {
                 const data = await transport.graphql({ api: 'admin', query: RELEASE_ORDER_ALLOCATION_MUTATION, variables: { orderId } }, options);