@webround/commerce 0.0.0-stage → 0.3.0

package/dist/errors.d.ts

@@ -0,0 +1,65 @@
+export type CommerceErrorKind = 
+/** The server answered with an error status. */
+'http'
+/** There was no answer: no connection, DNS, CORS, the server down. */
+ | 'network'
+/** There was no answer in time (`timeoutMs`). */
+ | 'timeout'
+/** The caller cancelled the request (its own `signal`). */
+ | 'aborted'
+/** The answer was not what a store sends (not JSON). */
+ | 'parse';
+export interface CommerceErrorInit {
+    kind: CommerceErrorKind;
+    message: string;
+    status?: number | null;
+    code?: string | null;
+    meta?: unknown;
+    issues?: readonly unknown[] | null;
+    retryAfterSeconds?: number | null;
+    method?: string;
+    path?: string;
+    cause?: unknown;
+}
+export declare class CommerceError extends Error {
+    readonly kind: CommerceErrorKind;
+    /** The HTTP status, when the server answered at all. */
+    readonly status: number | null;
+    /** The server's own code (`INVALID_CREDENTIALS`, `CART_CURRENCY_MISMATCH`…): null when it gave none. What the interface translates. */
+    readonly code: string | null;
+    /** What the server added to the code, as it sent it. */
+    readonly meta: unknown;
+    /** The fields a validation refused, as the server listed them. */
+    readonly issues: readonly unknown[] | null;
+    /** How long to wait before asking again, when the server said (a rate limit). */
+    readonly retryAfterSeconds: number | null;
+    readonly method: string | null;
+    readonly path: string | null;
+    readonly cause?: unknown;
+    constructor(init: CommerceErrorInit);
+}
+export declare const isCommerceError: (value: unknown) => value is CommerceError;
+/**
+ * The error of an answer with an error status. The stores send it in a few shapes, and this reads them all the same way:
+ *  - commerce-core: `{ message, code | null, meta | null, statusCode }`, whose `message` is a list of `{ path, message, … }` for a validation (the fields it refused)
+ *  - a validation: `{ message: 'Validation failed', issues: [...] }`
+ *  - the catalog's rate limit: `{ statusCode: 429, error, message, details: { retryAfterSeconds } }`
+ *  - what Nest itself says: `{ statusCode, message: string | string[], error }`
+ * `body` is the parsed JSON, or null when it was not JSON (a proxy's HTML page): the status then says what happened.
+ */
+export declare function commerceErrorFromResponse(input: {
+    status: number;
+    body: unknown;
+    retryAfterHeader?: string | null;
+    method: string;
+    path: string;
+}): CommerceError;
+/** What went wrong, as the one error of the package: a `CommerceError` is as it is; anything else (a failure that is not the store's answer) is "the store could not be reached", with the cause kept. */
+export declare const toCommerceError: (error: unknown) => CommerceError;
+/**
+ * The limit a store puts on how much a customer may keep (addresses, wishlist items: 5, 50…), when `error` is that store refusing to go over it, and null when it is anything else. Today the store answers it with a 429, like
+ * a rate limit, and with no code: what tells it apart is the message ("Too many store_customer_addresss. Limit is 5."), where a rate limit says per how long ("Limit is 5 in 86400 seconds") and may say when to ask
+ * again. A store that gives it a code of its own (`DATA_LIMIT_REACHED`, with `meta.limit`) is read by that, which is what an interface translates.
+ */
+export declare function dataLimitOf(error: unknown): number | null;
+//# sourceMappingURL=errors.d.ts.map

package/dist/errors.js

@@ -0,0 +1,96 @@
+// The one error of @webround/commerce. Whatever goes wrong talking to a store (it answered no, it did not answer, the answer made no sense, the caller gave up), the
+// caller gets this, with what a screen needs to say something useful: the server's own `code` (a stable word, for the interface to translate), its `message`
+// (a fallback to show when there is no translation), and what the kind of failure adds (the fields of a refused form, how long to wait).
+//
+// It holds the method and the path, never the headers, the body or the query: an error is logged and shown, and a token or a password must never be in one.
+export class CommerceError extends Error {
+    constructor(init) {
+        super(init.message);
+        this.name = 'CommerceError';
+        this.kind = init.kind;
+        this.status = init.status ?? null;
+        this.code = init.code ?? null;
+        this.meta = init.meta ?? null;
+        this.issues = init.issues ?? null;
+        this.retryAfterSeconds = init.retryAfterSeconds ?? null;
+        this.method = init.method ?? null;
+        this.path = init.path ?? null;
+        if (init.cause !== undefined)
+            this.cause = init.cause;
+    }
+}
+export const isCommerceError = (value) => value instanceof CommerceError;
+const isObject = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
+/** The text a body says its message is: a string, or a list (of strings, or of objects that have a `message`) joined; undefined when it says none. */
+function messageOf(body) {
+    const { message } = body;
+    if (typeof message === 'string' && message !== '')
+        return message;
+    if (Array.isArray(message)) {
+        const parts = message
+            .map((part) => (typeof part === 'string' ? part : isObject(part) && typeof part.message === 'string' ? part.message : ''))
+            .filter((part) => part !== '');
+        if (parts.length > 0)
+            return parts.join(', ');
+    }
+    return undefined;
+}
+/**
+ * The fields a validation refused: `issues` when the body has them (the catalog's), or the `message` when it is a list of objects that each say which field (`path`), as commerce-core's validation sends
+ * it. A message that is a list of texts says no field, so it is no issue.
+ */
+function issuesOf(body) {
+    if (Array.isArray(body.issues))
+        return body.issues;
+    const { message } = body;
+    return Array.isArray(message) && message.length > 0 && message.every((part) => isObject(part) && Array.isArray(part.path)) ? message : null;
+}
+/** Whole seconds, from a number or a header's text (`Retry-After: 30`); null for anything else (a date, a negative, nonsense). */
+function secondsOf(value) {
+    const seconds = typeof value === 'string' && /^\d+$/.test(value.trim()) ? Number(value) : value;
+    return typeof seconds === 'number' && Number.isFinite(seconds) && seconds >= 0 ? Math.ceil(seconds) : null;
+}
+/**
+ * The error of an answer with an error status. The stores send it in a few shapes, and this reads them all the same way:
+ *  - commerce-core: `{ message, code | null, meta | null, statusCode }`, whose `message` is a list of `{ path, message, … }` for a validation (the fields it refused)
+ *  - a validation: `{ message: 'Validation failed', issues: [...] }`
+ *  - the catalog's rate limit: `{ statusCode: 429, error, message, details: { retryAfterSeconds } }`
+ *  - what Nest itself says: `{ statusCode, message: string | string[], error }`
+ * `body` is the parsed JSON, or null when it was not JSON (a proxy's HTML page): the status then says what happened.
+ */
+export function commerceErrorFromResponse(input) {
+    const { status, body, method, path } = input;
+    const fields = isObject(body) ? body : {};
+    const details = isObject(fields.details) ? fields.details : {};
+    return new CommerceError({
+        kind: 'http',
+        status,
+        message: messageOf(fields) ?? `The store answered ${status}`,
+        code: typeof fields.code === 'string' && fields.code !== '' ? fields.code : null,
+        meta: fields.meta ?? null,
+        issues: issuesOf(fields),
+        retryAfterSeconds: secondsOf(details.retryAfterSeconds) ?? secondsOf(input.retryAfterHeader),
+        method,
+        path,
+    });
+}
+/** What went wrong, as the one error of the package: a `CommerceError` is as it is; anything else (a failure that is not the store's answer) is "the store could not be reached", with the cause kept. */
+export const toCommerceError = (error) => (isCommerceError(error) ? error : new CommerceError({ kind: 'network', message: 'The store could not be reached.', cause: error }));
+/**
+ * The limit a store puts on how much a customer may keep (addresses, wishlist items: 5, 50…), when `error` is that store refusing to go over it, and null when it is anything else. Today the store answers it with a 429, like
+ * a rate limit, and with no code: what tells it apart is the message ("Too many store_customer_addresss. Limit is 5."), where a rate limit says per how long ("Limit is 5 in 86400 seconds") and may say when to ask
+ * again. A store that gives it a code of its own (`DATA_LIMIT_REACHED`, with `meta.limit`) is read by that, which is what an interface translates.
+ */
+export function dataLimitOf(error) {
+    if (!isCommerceError(error) || error.kind !== 'http')
+        return null;
+    if (error.code === 'DATA_LIMIT_REACHED') {
+        const limit = error.meta?.limit;
+        return typeof limit === 'number' ? limit : null;
+    }
+    if (error.status !== 429 || error.retryAfterSeconds !== null)
+        return null;
+    const found = /^Too many [\w-]+\. Limit is (\d+)\.?$/.exec(error.message.trim());
+    return found ? Number(found[1]) : null;
+}
+//# sourceMappingURL=errors.js.map

package/dist/http.d.ts

@@ -0,0 +1,49 @@
+export type QueryValue = string | number | boolean | null | undefined | readonly (string | number | boolean)[];
+export type Query = Readonly<Record<string, QueryValue>>;
+export type HttpMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+export interface HttpClientConfig {
+    /** The backend's address, with or without a trailing `/`. */
+    baseUrl: string;
+    /** The store the requests are for: it goes in the `store-id` header, and no request can say another. */
+    storeId: string;
+    /** How long a request may take, answer included. Default 60 seconds. */
+    timeoutMs?: number;
+    /**
+     * Whether cookies travel. `omit` (the default): they do not, and nothing needs them, because everything a customer does is the JWT in `Authorization` (see `getHeaders`). The only
+     * cookie there is is commerce-core's refresh token, which is for getting in again (automatic login, a new JWT): a request that needs it says so (`RequestOptions.credentials`).
+     */
+    credentials?: 'omit' | 'same-origin' | 'include';
+    /** Headers added to EVERY request, asked for each time: the JWT (`Authorization: Bearer …`), and the CSRF token where an endpoint asks for it. */
+    getHeaders?: () => Record<string, string> | Promise<Record<string, string>>;
+    /** Another `fetch` (a test, a runtime without a global one). */
+    fetch?: typeof fetch;
+}
+export interface RequestOptions {
+    method?: HttpMethod;
+    /** The path on the backend, with or without the leading `/`. */
+    path: string;
+    query?: Query;
+    /** Sent as JSON. */
+    body?: unknown;
+    /** For this request only; they win over `getHeaders`, never over `store-id`. */
+    headers?: Record<string, string>;
+    /** For this request only: `include` for the few that need the refresh token's cookie (logging in again, renewing the JWT, logging out). Wins over the client's. */
+    credentials?: 'omit' | 'same-origin' | 'include';
+    signal?: AbortSignal;
+}
+export interface HttpClient {
+    /** The backend this client talks to, without a trailing `/`. What a cache key is made of, so that it is always the key of the client that asks. */
+    readonly baseUrl: string;
+    /** The store this client is for. */
+    readonly storeId: string;
+    /** The answer's JSON (undefined for an empty one), or a `CommerceError`. */
+    request<T = unknown>(options: RequestOptions): Promise<T>;
+}
+/**
+ * The query as ONE text for the same query: `a=1&b=2` and `b=2&a=1` are the same query, so both come out `a=1&b=2` (keys in order); `tag=x&tag=y` and `tag=y&tag=x` are the same
+ * too (the values of a list are in order). A number and its text are the same (`1`, `'1'`), what is not there (null, undefined, an empty list) is left out, and a list repeats its key.
+ * Order is by code point, so it is the same everywhere. An API for which the order of a list matters is the API's mistake, not something to carry here.
+ */
+export declare function queryString(query: Query | undefined): string;
+export declare function createHttpClient(config: HttpClientConfig): HttpClient;
+//# sourceMappingURL=http.d.ts.map

package/dist/http.js

@@ -0,0 +1,94 @@
+import { CommerceError, commerceErrorFromResponse } from './errors.js';
+const DEFAULT_TIMEOUT_MS = 60000;
+/**
+ * The query as ONE text for the same query: `a=1&b=2` and `b=2&a=1` are the same query, so both come out `a=1&b=2` (keys in order); `tag=x&tag=y` and `tag=y&tag=x` are the same
+ * too (the values of a list are in order). A number and its text are the same (`1`, `'1'`), what is not there (null, undefined, an empty list) is left out, and a list repeats its key.
+ * Order is by code point, so it is the same everywhere. An API for which the order of a list matters is the API's mistake, not something to carry here.
+ */
+export function queryString(query) {
+    const params = new URLSearchParams();
+    for (const key of Object.keys(query ?? {}).sort()) {
+        const value = query?.[key];
+        if (value === undefined || value === null)
+            continue;
+        const items = (Array.isArray(value) ? value : [value]).map(String);
+        for (const item of Array.isArray(value) ? items.sort() : items)
+            params.append(key, item);
+    }
+    return params.toString();
+}
+export function createHttpClient(config) {
+    const base = config.baseUrl.replace(/\/+$/, '');
+    const timeoutMs = config.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    async function request(options) {
+        const method = options.method ?? 'GET';
+        const path = `/${options.path.replace(/^\/+/, '')}`;
+        const query = queryString(options.query);
+        const url = `${base}${path}${query ? `?${query}` : ''}`;
+        const fail = (kind, message, cause) => new CommerceError({ kind, message, method, path, cause });
+        if (options.signal?.aborted)
+            throw fail('aborted', 'The request was cancelled.');
+        // What the caller adds (the JWT) is asked for before the clock starts: it is not the store's time
+        const headers = {
+            Accept: 'application/json',
+            ...(options.body !== undefined ? { 'Content-Type': 'application/json' } : {}),
+            ...(await config.getHeaders?.()),
+            ...options.headers,
+            'store-id': config.storeId,
+        };
+        const controller = new AbortController();
+        let timedOut = false;
+        const timer = setTimeout(() => { timedOut = true; controller.abort(); }, timeoutMs);
+        const onCallerAbort = () => controller.abort();
+        options.signal?.addEventListener('abort', onCallerAbort, { once: true });
+        try {
+            // The caller may have given up while its headers (the JWT) were being asked for: that is before the listener, so it is looked at again
+            if (options.signal?.aborted)
+                throw fail('aborted', 'The request was cancelled.');
+            const doFetch = config.fetch ?? ((input, init) => globalThis.fetch(input, init));
+            let response;
+            let text;
+            try {
+                response = await doFetch(url, {
+                    method,
+                    headers,
+                    body: options.body !== undefined ? JSON.stringify(options.body) : undefined,
+                    credentials: options.credentials ?? config.credentials ?? 'omit',
+                    signal: controller.signal,
+                });
+                // The clock runs until the answer has been read, not only until it started to come
+                text = await response.text();
+            }
+            catch (err) {
+                if (timedOut)
+                    throw fail('timeout', 'The store did not answer in time.', err);
+                if (options.signal?.aborted)
+                    throw fail('aborted', 'The request was cancelled.', err);
+                throw fail('network', 'The store could not be reached.', err);
+            }
+            let body = null;
+            let parsed = true;
+            if (text !== '') {
+                try {
+                    body = JSON.parse(text);
+                }
+                catch {
+                    parsed = false;
+                }
+            }
+            if (!response.ok) {
+                // An error that is not JSON (a proxy's page) says nothing but its status
+                throw commerceErrorFromResponse({ status: response.status, body: parsed ? body : null, retryAfterHeader: response.headers.get('retry-after'), method, path });
+            }
+            if (!parsed)
+                throw new CommerceError({ kind: 'parse', message: 'The store answered with something that is not JSON.', status: response.status, method, path });
+            return (text === '' ? undefined : body);
+        }
+        finally {
+            clearTimeout(timer);
+            options.signal?.removeEventListener('abort', onCallerAbort);
+        }
+    }
+    return { baseUrl: base, storeId: config.storeId, request };
+}
+//# sourceMappingURL=http.js.map

package/dist/index.d.ts

@@ -0,0 +1,32 @@
+export { cacheKey, cachePrefix, createCache } from './cache.js';
+export type { Cache, CacheKeyParts, CacheSnapshot, LoadOptions } from './cache.js';
+export { canonicalize, canonicalJson } from './canonical.js';
+export type { Canonical } from './canonical.js';
+export { CommerceError, commerceErrorFromResponse, dataLimitOf, isCommerceError, toCommerceError } from './errors.js';
+export type { CommerceErrorInit, CommerceErrorKind } from './errors.js';
+export { createHttpClient, queryString } from './http.js';
+export type { HttpClient, HttpClientConfig, HttpMethod, Query, QueryValue, RequestOptions } from './http.js';
+export { createCatalog } from './catalog/catalog.js';
+export type { Catalog } from './catalog/catalog.js';
+export { createCachedCatalog } from './catalog/cached.js';
+export type { CachedCatalog, CatalogCall, CatalogIdentity, CatalogForget, CatalogResources } from './catalog/cached.js';
+export { createResourceFactory } from './resource.js';
+export type { Resource, ResourceIdentity } from './resource.js';
+export { createCustomerResources } from './customer-resources.js';
+export type { CustomerResources } from './customer-resources.js';
+export { createCommerce } from './commerce.js';
+export type { Commerce, CommerceConfig } from './commerce.js';
+export * from './account/index.js';
+export * from './addresses/index.js';
+export * from './auth/index.js';
+export * from './cart/index.js';
+export * from './checkout/index.js';
+export * from './orders/index.js';
+export * from './returns/index.js';
+export * from './reviews/index.js';
+export * from './wishlist/index.js';
+export * from './shop/index.js';
+export type { ProductsApi } from './catalog/products.js';
+export type { StoreDataApi } from './catalog/store-data.js';
+export type { AssetDetail, AssetSummary, AssetType, AttributeDetail, AttributeSummary, Availability, CallOptions, Format, OptionDetail, OptionValueDetail, Pagination, PriceDetail, PriceRange, ProductByIdInput, ProductBySlugInput, ProductDetail, ProductDetailInput, ProductDetailResponse, ProductLoad, ProductPage, ProductRelatedInput, ProductReviewsInput, ProductSearch, ProductSortField, ProductSummary, QuantityTier, Review, ReviewPage, ReviewStats, SortDirection, StoreAttribute, StoreCollection, StoreData, StoreDataResponse, StoreFilter, StoreFilterCondition, StoreSettings, StoreTag, StoreTagValue, TagDetail, TagSummary, TagType, TagValueDetail, TagValueSummary, ValueFormat, VariantDetail, VariantSummary, } from './catalog/types.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,22 @@
+// @webround/commerce: the logic of a Webround Commerce store (its catalog, cart, customers, checkout), with no UI and no framework.
+// What a framework needs to use it comes as a package of its own (`@webround/commerce-react`, one day `@webround/commerce-next`…), never in here.
+export { cacheKey, cachePrefix, createCache } from './cache.js';
+export { canonicalize, canonicalJson } from './canonical.js';
+export { CommerceError, commerceErrorFromResponse, dataLimitOf, isCommerceError, toCommerceError } from './errors.js';
+export { createHttpClient, queryString } from './http.js';
+export { createCatalog } from './catalog/catalog.js';
+export { createCachedCatalog } from './catalog/cached.js';
+export { createResourceFactory } from './resource.js';
+export { createCustomerResources } from './customer-resources.js';
+export { createCommerce } from './commerce.js';
+export * from './account/index.js';
+export * from './addresses/index.js';
+export * from './auth/index.js';
+export * from './cart/index.js';
+export * from './checkout/index.js';
+export * from './orders/index.js';
+export * from './returns/index.js';
+export * from './reviews/index.js';
+export * from './wishlist/index.js';
+export * from './shop/index.js';
+//# sourceMappingURL=index.js.map

package/dist/orders/api.d.ts

@@ -0,0 +1,16 @@
+import type { HttpClient } from '../http.js';
+import type { CallOptions } from '../catalog/types.js';
+import type { AccessTokenOptions } from '../auth/api.js';
+import type { Order, OrderPage, PageQuery, Subscription, SubscriptionPage } from './types.js';
+export interface OrderApi {
+    /** `GET /store-customer-orders`: the customer's orders, a page at a time (the newest first). */
+    list(input?: PageQuery, options?: CallOptions & AccessTokenOptions): Promise<OrderPage>;
+    /** `GET /store-customer-orders/:id`: one order, with its items. 404 for one that is not the customer's. */
+    get(id: string, options?: CallOptions & AccessTokenOptions): Promise<Order>;
+    /** `GET /store-customer-orders/subscriptions`: the customer's subscriptions (what they pay for again and again), a page at a time. */
+    listSubscriptions(input?: PageQuery, options?: CallOptions & AccessTokenOptions): Promise<SubscriptionPage>;
+    /** `GET /store-customer-orders/subscriptions/:id`. */
+    getSubscription(id: string, options?: CallOptions & AccessTokenOptions): Promise<Subscription>;
+}
+export declare function createOrderApi(http: HttpClient): OrderApi;
+//# sourceMappingURL=api.d.ts.map

package/dist/orders/api.js

@@ -0,0 +1,13 @@
+// The calls of commerce-core that are about what a customer bought (`/store-customer-orders`), each asking one thing and giving back what the store answers, unchanged. All need the JWT of the customer, and all read.
+const bearer = (options) => (options?.accessToken ? { Authorization: `Bearer ${options.accessToken}` } : {});
+const part = (id) => encodeURIComponent(id);
+const query = (q) => ({ page: q?.page, limit: q?.limit, sortBy: q?.sortBy, sortDirection: q?.sortDirection, lang: q?.lang });
+export function createOrderApi(http) {
+    return {
+        list: (input, options) => http.request({ path: '/store-customer-orders', query: query(input), headers: bearer(options), signal: options?.signal }),
+        get: (id, options) => http.request({ path: `/store-customer-orders/${part(id)}`, headers: bearer(options), signal: options?.signal }),
+        listSubscriptions: (input, options) => http.request({ path: '/store-customer-orders/subscriptions', query: query(input), headers: bearer(options), signal: options?.signal }),
+        getSubscription: (id, options) => http.request({ path: `/store-customer-orders/subscriptions/${part(id)}`, headers: bearer(options), signal: options?.signal }),
+    };
+}
+//# sourceMappingURL=api.js.map

package/dist/orders/index.d.ts

@@ -0,0 +1,6 @@
+export { createOrderApi } from './api.js';
+export type { OrderApi } from './api.js';
+export { createOrders } from './orders.js';
+export type { Orders } from './orders.js';
+export type { Order, OrderAddress, OrderItem, OrderPage, Page, PageInfo, PageQuery, Subscription, SubscriptionPage } from './types.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/orders/index.js

@@ -0,0 +1,3 @@
+export { createOrderApi } from './api.js';
+export { createOrders } from './orders.js';
+//# sourceMappingURL=index.js.map

package/dist/orders/orders.d.ts

@@ -0,0 +1,19 @@
+import type { CustomerResources } from '../customer-resources.js';
+import type { Resource } from '../resource.js';
+import type { OrderApi } from './api.js';
+import type { Order, OrderPage, PageQuery, Subscription, SubscriptionPage } from './types.js';
+export interface Orders {
+    list(query?: PageQuery): Resource<OrderPage> | null;
+    get(id: string): Resource<Order> | null;
+    subscriptions: {
+        list(query?: PageQuery): Resource<SubscriptionPage> | null;
+        get(id: string): Resource<Subscription> | null;
+    };
+    /** Forgets what was kept of orders and subscriptions, so the next question is asked again. */
+    refresh(): void;
+}
+export declare function createOrders(options: {
+    api: OrderApi;
+    customer: CustomerResources;
+}): Orders;
+//# sourceMappingURL=orders.d.ts.map

package/dist/orders/orders.js

@@ -0,0 +1,18 @@
+export function createOrders(options) {
+    const { api, customer } = options;
+    // Nothing asked and an empty ask are the same question
+    const asked = (q) => q ?? {};
+    return {
+        list: (query) => customer.resource('orders.list', undefined, asked(query), (o) => api.list(query, o)),
+        get: (id) => customer.resource('orders.get', id, undefined, (o) => api.get(id, o)),
+        subscriptions: {
+            list: (query) => customer.resource('subscriptions.list', undefined, asked(query), (o) => api.listSubscriptions(query, o)),
+            get: (id) => customer.resource('subscriptions.get', id, undefined, (o) => api.getSubscription(id, o)),
+        },
+        refresh() {
+            for (const call of ['orders.list', 'orders.get', 'subscriptions.list', 'subscriptions.get'])
+                customer.forget(call);
+        },
+    };
+}
+//# sourceMappingURL=orders.js.map

package/dist/orders/types.d.ts

@@ -0,0 +1,88 @@
+export interface PageQuery {
+    page?: number;
+    /** 1 to 100; 25 by default. */
+    limit?: number;
+    sortBy?: string;
+    sortDirection?: 'asc' | 'desc';
+    /** The language of what is named (the products). */
+    lang?: string;
+}
+export interface PageInfo {
+    page: number;
+    limit: number;
+    total: number;
+    totalPages: number;
+}
+export interface Page<T> {
+    data: T[];
+    pagination: PageInfo;
+}
+/** An address as an order keeps it: what was given, without the defaults. */
+export interface OrderAddress {
+    fullName: string;
+    company?: string | null;
+    phone?: string | null;
+    addressLine1: string;
+    addressLine2?: string | null;
+    city: string;
+    province?: string | null;
+    postalCode: string;
+    countryCode: string;
+    vatCode?: string | null;
+    additionalInfo?: string | null;
+}
+export interface OrderItem {
+    /** What a return request names (`items[].orderItemId`). */
+    orderItemId: string | null;
+    productId: string | null;
+    variantId: string | null;
+    variantName: string | null;
+    coverUrl: string | null;
+    quantity: number | null;
+    deliveryMethod: string | null;
+    appliedTaxRate: number | null;
+    unitNet: string | null;
+    unitGross: string | null;
+    unitTax: string | null;
+    totalNet: string | null;
+    totalGross: string | null;
+    totalTax: string | null;
+}
+export interface Order {
+    id: string;
+    storeId: string;
+    customerId: string | null;
+    /** The number the customer is given for the order. */
+    reference: number | null;
+    amount: string | null;
+    currencyCode: string;
+    paymentStatus: string;
+    shippingStatus: string | null;
+    stripeInvoiceUrl: string | null;
+    shippingTrackingUrl: string | null;
+    shippingAddress: OrderAddress | null;
+    billingAddress: OrderAddress | null;
+    promotionSnapshot?: unknown;
+    createdAt: string | null;
+    updatedAt: string | null;
+    items: OrderItem[];
+}
+export interface Subscription {
+    id: string;
+    stripeId: string | null;
+    status: string | null;
+    activeSince: string | null;
+    currentPeriodEnd: string | null;
+    cancelAtPeriodEnd: boolean | null;
+    latestInvoiceId: string | null;
+    latestInvoiceUrl: string | null;
+    trialStart: string | null;
+    trialEnd: string | null;
+    createdAt: string | null;
+    updatedAt: string | null;
+    /** The order the subscription came from. */
+    order: Order | null;
+}
+export type OrderPage = Page<Order>;
+export type SubscriptionPage = Page<Subscription>;
+//# sourceMappingURL=types.d.ts.map

package/dist/orders/types.js

@@ -0,0 +1,4 @@
+// What the order calls of commerce-core give, as the store says it. A customer sees their own orders and their subscriptions; nothing here is written. Dates come as text, as JSON has them; amounts as text of digits.
+// (Checked against the store's code and the documented shapes: a store with orders of its own is where to hold them against real answers.)
+export {};
+//# sourceMappingURL=types.js.map

package/dist/resource.d.ts

@@ -0,0 +1,19 @@
+import { type Cache, type CacheSnapshot, type LoadOptions } from './cache.js';
+import type { CallOptions } from './catalog/types.js';
+/** The cache's view of ONE question: its key, how to ask it, how it stands now, and how to be told when that changes. What a framework's binding is made of. */
+export interface Resource<T> {
+    key: string;
+    /** The answer: from the cache if it has it, joining the request under way if there is one, else asking. */
+    load(options?: LoadOptions): Promise<T>;
+    /** How the question stands now. It never asks anything, and is the same object until it changes. */
+    snapshot(): CacheSnapshot<T>;
+    subscribe(listener: () => void): () => void;
+}
+/** What tells one store's questions from another's in the cache: where the backend is, and which store. */
+export type ResourceIdentity = {
+    baseUrl: string;
+    storeId: string;
+};
+/** Makes the resources of one backend and store, over one cache. */
+export declare function createResourceFactory(cache: Cache, identity: ResourceIdentity): <T>(call: string, subject: string | undefined, params: unknown, fetch: (options: CallOptions) => Promise<T>) => Resource<T>;
+//# sourceMappingURL=resource.d.ts.map

package/dist/resource.js

@@ -0,0 +1,15 @@
+import { cacheKey } from './cache.js';
+/** Makes the resources of one backend and store, over one cache. */
+export function createResourceFactory(cache, identity) {
+    return function resource(call, subject, params, fetch) {
+        const key = cacheKey({ base: identity.baseUrl, storeId: identity.storeId, call, subject, params });
+        return {
+            key,
+            // The signal the request gets is the cache's (aborted when nobody is waiting any more); the caller's own is only for that caller
+            load: (options) => cache.load(key, (signal) => fetch({ signal }), options),
+            snapshot: () => cache.snapshot(key),
+            subscribe: (listener) => cache.subscribe(key, listener),
+        };
+    };
+}
+//# sourceMappingURL=resource.js.map

package/dist/returns/api.d.ts

@@ -0,0 +1,27 @@
+import type { HttpClient } from '../http.js';
+import type { CallOptions } from '../catalog/types.js';
+import type { AccessTokenOptions } from '../auth/api.js';
+import type { CreateGuestReturnInput, CreateReturnInput, GuestReturnSession, GuestVerifyAnswer, GuestVerifyInput, PageQuery, ReturnRequest, ReturnRequestPage } from './types.js';
+export interface ReturnApi {
+    /** `GET /store-customer-return-requests` (JWT): the customer's requests, a page at a time. */
+    list(input?: PageQuery, options?: CallOptions & AccessTokenOptions): Promise<ReturnRequestPage>;
+    /** `GET /store-customer-return-requests/:id` (JWT). */
+    get(id: string, options?: CallOptions & AccessTokenOptions): Promise<ReturnRequest>;
+    /** `POST /store-customer-return-requests` (JWT): asks to return some of the items of an order (`201`). The store emails the customer (and the shop). */
+    create(input: CreateReturnInput, options?: CallOptions & AccessTokenOptions): Promise<ReturnRequest>;
+    /** `DELETE /store-customer-return-requests/:id` (JWT): cancels a request that is still `pending` (400 for any other); gives back the one it cancelled. */
+    cancel(id: string, options?: CallOptions & AccessTokenOptions): Promise<ReturnRequest>;
+    /**
+     * `POST …/guest/verify` (no JWT): asks the store to email a link to the address of the order, for a guest. It answers the same whether the order exists or not. An order that belongs to an account is refused
+     * (400): its customer has to log in.
+     */
+    verifyGuest(input: GuestVerifyInput, options?: CallOptions): Promise<GuestVerifyAnswer>;
+    /** `GET …/guest/session?token=` (no JWT): the order the link's token opens. 401 for a token that is not good or has ended. */
+    guestSession(token: string, options?: CallOptions): Promise<GuestReturnSession>;
+    /** `POST …/guest` (no JWT, the token in the body): a guest asks to return some of the items of their order (`201`). */
+    createGuest(input: CreateGuestReturnInput, options?: CallOptions): Promise<ReturnRequest>;
+    /** `DELETE …/guest/:id?token=` (no JWT): cancels a guest's request that is still `pending`. */
+    cancelGuest(id: string, token: string, options?: CallOptions): Promise<ReturnRequest>;
+}
+export declare function createReturnApi(http: HttpClient): ReturnApi;
+//# sourceMappingURL=api.d.ts.map

package/dist/returns/api.js

@@ -0,0 +1,19 @@
+// The calls of commerce-core that are about returns (`/store-customer-return-requests`), each asking one thing and giving back what the store answers, unchanged. A customer's need their JWT. A guest's need none: what proves
+// who they are is a TOKEN, in the link the store emailed to the address of the order (`guest/verify` asks for the email; the site's page `/returns?token=…` is where the link leads, and reads the token from the address).
+const PATH = '/store-customer-return-requests';
+const bearer = (options) => (options?.accessToken ? { Authorization: `Bearer ${options.accessToken}` } : {});
+const part = (id) => encodeURIComponent(id);
+const query = (q) => ({ page: q?.page, limit: q?.limit, sortBy: q?.sortBy, sortDirection: q?.sortDirection, lang: q?.lang });
+export function createReturnApi(http) {
+    return {
+        list: (input, options) => http.request({ path: PATH, query: query(input), headers: bearer(options), signal: options?.signal }),
+        get: (id, options) => http.request({ path: `${PATH}/${part(id)}`, headers: bearer(options), signal: options?.signal }),
+        create: (input, options) => http.request({ method: 'POST', path: PATH, body: input, headers: bearer(options), signal: options?.signal }),
+        cancel: (id, options) => http.request({ method: 'DELETE', path: `${PATH}/${part(id)}`, headers: bearer(options), signal: options?.signal }),
+        verifyGuest: (input, options) => http.request({ method: 'POST', path: `${PATH}/guest/verify`, body: input, signal: options?.signal }),
+        guestSession: (token, options) => http.request({ path: `${PATH}/guest/session`, query: { token }, signal: options?.signal }),
+        createGuest: (input, options) => http.request({ method: 'POST', path: `${PATH}/guest`, body: input, signal: options?.signal }),
+        cancelGuest: (id, token, options) => http.request({ method: 'DELETE', path: `${PATH}/guest/${part(id)}`, query: { token }, signal: options?.signal }),
+    };
+}
+//# sourceMappingURL=api.js.map

package/dist/returns/index.d.ts

@@ -0,0 +1,6 @@
+export { createReturnApi } from './api.js';
+export type { ReturnApi } from './api.js';
+export { createReturns } from './returns.js';
+export type { Returns } from './returns.js';
+export type { CreateGuestReturnInput, CreateReturnInput, GuestOrderItem, GuestReturnSession, GuestVerifyAnswer, GuestVerifyInput, ReturnItem, ReturnItemInput, ReturnRequest, ReturnRequestPage, ReturnStatus, } from './types.js';
+//# sourceMappingURL=index.d.ts.map