@sixtyninecommerce/admin 0.8.0 → 0.10.0

package/dist/catalog/variants.js

@@ -0,0 +1,288 @@
+import { NotFoundError, UpstreamError, ValidationError, } from '@sixtyninecommerce/core';
+import { ASSET_REF_FIELDS, assertDeleted, availabilityCustomFields, DELETION_FIELDS, FACET_VALUE_REF_FIELDS, fieldOf, vendureListPage, } from './types.js';
+const PARCEL_PACKING_MODES = ['shared', 'separate', 'none'];
+/** The engine's bounds for `parcelCapacity` (shipping-calculator's `MAX_PARCEL_CAPACITY`). */
+const PARCEL_CAPACITY_MIN = 1;
+const PARCEL_CAPACITY_MAX = 10_000;
+/** The engine's bound on one `revertPrice` call (`MAX_REVERT_VARIANTS`). */
+export const MAX_REVERT_PRICE_VARIANTS = 500;
+export const VARIANT_FIELDS = /* GraphQL */ `
+  id
+  productId
+  createdAt
+  updatedAt
+  languageCode
+  name
+  sku
+  enabled
+  price
+  priceWithTax
+  currencyCode
+  taxCategory {
+    id
+    name
+  }
+  trackInventory
+  outOfStockThreshold
+  useGlobalOutOfStockThreshold
+  stockLevels {
+    stockLocationId
+    stockOnHand
+    stockAllocated
+  }
+  options {
+    id
+    code
+    name
+    groupId
+  }
+  featuredAsset { ${ASSET_REF_FIELDS} }
+  assets { ${ASSET_REF_FIELDS} }
+  facetValues { ${FACET_VALUE_REF_FIELDS} }
+  translations {
+    id
+    languageCode
+    name
+  }
+  customFields {
+    taxClassKey
+    availabilityState
+    availableFrom
+    preorderLimit
+    parcelCapacity
+    parcelPacking
+  }
+`;
+export const VARIANTS_QUERY = /* GraphQL */ `
+  query CatalogVariants($productId: ID!, $options: ProductVariantListOptions) {
+    productVariants(productId: $productId, options: $options) {
+      items { ${VARIANT_FIELDS} }
+      totalItems
+    }
+  }
+`;
+export const VARIANT_QUERY = /* GraphQL */ `
+  query CatalogVariant($id: ID!) {
+    productVariant(id: $id) { ${VARIANT_FIELDS} }
+  }
+`;
+export const CREATE_VARIANTS_MUTATION = /* GraphQL */ `
+  mutation CatalogCreateVariants($input: [CreateProductVariantInput!]!) {
+    createProductVariants(input: $input) { ${VARIANT_FIELDS} }
+  }
+`;
+export const UPDATE_VARIANTS_MUTATION = /* GraphQL */ `
+  mutation CatalogUpdateVariants($input: [UpdateProductVariantInput!]!) {
+    updateProductVariants(input: $input) { ${VARIANT_FIELDS} }
+  }
+`;
+export const DELETE_VARIANTS_MUTATION = /* GraphQL */ `
+  mutation CatalogDeleteVariants($ids: [ID!]!) {
+    deleteProductVariants(ids: $ids) { ${DELETION_FIELDS} }
+  }
+`;
+/**
+ * A document of its own, never a field of `VARIANT_FIELDS`: every other variant read keeps
+ * working against an engine older than the field, and pays nothing for it.
+ */
+export const VARIANT_PRICE_SOURCES_QUERY = /* GraphQL */ `
+  query CatalogVariantPriceSources($id: ID!) {
+    productVariant(id: $id) {
+      id
+      priceSources {
+        currencyCode
+        price
+        source
+        organizationPrice
+        organizationName
+      }
+    }
+  }
+`;
+export const REVERT_TO_ORGANIZATION_PRICE_MUTATION = /* GraphQL */ `
+  mutation CatalogRevertToOrganizationPrice($variantIds: [ID!]!, $currencyCodes: [CurrencyCode!]) {
+    revertToOrganizationPrice(variantIds: $variantIds, currencyCodes: $currencyCodes) { ${VARIANT_FIELDS} }
+  }
+`;
+/** The price basis the store stores, read on the SAME tenant as the write. */
+export const PRICE_BASIS_QUERY = /* GraphQL */ `
+  query CatalogPriceBasis {
+    activeChannel {
+      pricesIncludeTax
+    }
+  }
+`;
+function isParcelPacking(value) {
+    return PARCEL_PACKING_MODES.includes(value);
+}
+export function toVariant(wire) {
+    const { customFields, ...rest } = wire;
+    return {
+        ...rest,
+        taxClassKey: customFields?.taxClassKey ?? null,
+        availabilityState: customFields?.availabilityState ?? 'inherit',
+        availableFrom: customFields?.availableFrom ?? null,
+        preorderLimit: customFields?.preorderLimit ?? null,
+        parcelCapacity: customFields?.parcelCapacity ?? null,
+        parcelPacking: isParcelPacking(customFields?.parcelPacking)
+            ? customFields.parcelPacking
+            : 'shared',
+    };
+}
+/** Refuse a parcel rule the engine would refuse, before anything is sent. */
+function assertParcelRule(input) {
+    const { parcelCapacity, parcelPacking } = input;
+    if (parcelCapacity !== undefined &&
+        parcelCapacity !== null &&
+        !(Number.isInteger(parcelCapacity) &&
+            parcelCapacity >= PARCEL_CAPACITY_MIN &&
+            parcelCapacity <= PARCEL_CAPACITY_MAX)) {
+        throw refuse('INVALID_PARCEL_CAPACITY', `parcelCapacity must be a whole number from ${String(PARCEL_CAPACITY_MIN)} to ${String(PARCEL_CAPACITY_MAX)}, or null for the default (the store's items per parcel, or 1 when parcelPacking is separate); got ${JSON.stringify(parcelCapacity)}.`);
+    }
+    if (parcelPacking !== undefined && parcelPacking !== null && !isParcelPacking(parcelPacking)) {
+        throw refuse('INVALID_PARCEL_PACKING', `parcelPacking must be "shared", "separate", "none" or null; got ${JSON.stringify(parcelPacking)}.`);
+    }
+}
+function toWireInput(input) {
+    const { availabilityState, availableFrom, preorderLimit, taxClassKey, parcelCapacity, parcelPacking, priceBasis, minOrderQuantity, salesUnit, cost, packageWeightGrams, packageLengthCm, packageWidthCm, packageHeightCm, backorderPolicy, backorderLimit, gtin, mpn, ...rest } = input;
+    void priceBasis;
+    const customFields = availabilityCustomFields({
+        availabilityState,
+        availableFrom,
+        preorderLimit,
+    });
+    const fields = {
+        minOrderQuantity,
+        salesUnit,
+        cost,
+        packageWeightGrams,
+        packageLengthCm,
+        packageWidthCm,
+        packageHeightCm,
+        backorderPolicy,
+        backorderLimit,
+        gtin,
+        mpn,
+    };
+    for (const [key, value] of Object.entries(fields)) {
+        if (value !== undefined)
+            customFields[key] = value;
+    }
+    if (taxClassKey !== undefined)
+        customFields.taxClassKey = taxClassKey;
+    if (parcelCapacity !== undefined)
+        customFields.parcelCapacity = parcelCapacity;
+    if (parcelPacking !== undefined) {
+        customFields.parcelPacking = parcelPacking === 'shared' ? null : parcelPacking;
+    }
+    return Object.keys(customFields).length > 0 ? { ...rest, customFields } : rest;
+}
+function refuse(code, message) {
+    return new ValidationError({ code, message, status: 400, service: 'vendure' });
+}
+/**
+ * Every priced input (`price`, or any `prices` entry) must be whole minor units and state its
+ * basis, and the basis must be the store's. Read per call, with the call's own options, so a
+ * per-call tenant is checked against ITS store rather than the client's default one.
+ */
+export async function assertPricesStateBasis(transport, inputs, options) {
+    const priced = inputs.filter((input) => input.price !== undefined || input.prices !== undefined);
+    if (priced.length === 0)
+        return;
+    for (const input of priced) {
+        const amounts = [
+            ...(input.price !== undefined ? [input.price] : []),
+            ...(input.prices ?? []).map((entry) => entry.price),
+        ];
+        const fractional = amounts.find((amount) => !Number.isInteger(amount));
+        if (fractional !== undefined) {
+            throw refuse('INVALID_PRICE', `price must be a whole number of minor units; got ${String(fractional)}.`);
+        }
+        if (input.priceBasis !== 'net' && input.priceBasis !== 'gross') {
+            throw refuse('PRICE_BASIS_REQUIRED', 'A variant price must state its basis: priceBasis "net" or "gross".');
+        }
+    }
+    const channel = await fieldOf(transport, PRICE_BASIS_QUERY, 'activeChannel', {}, options);
+    const storeBasis = channel.pricesIncludeTax ? 'gross' : 'net';
+    const wrong = priced.find((input) => input.priceBasis !== storeBasis);
+    if (wrong) {
+        throw refuse('PRICE_BASIS_MISMATCH', `This store states prices ${storeBasis === 'gross' ? 'including' : 'excluding'} tax, so a price must be sent with priceBasis "${storeBasis}"; got "${String(wrong.priceBasis)}". Convert it before sending — the SDK does not, because the rate depends on each order's zone.`);
+    }
+}
+export function createVariantsModule(transport) {
+    /**
+     * Every priced input must state its basis, and the basis must be the store's.
+     * Read per call, with the call's own options, so a per-call tenant is checked
+     * against ITS store rather than the client's default one.
+     */
+    const assertPriceBasis = async (inputs, options) => {
+        await assertPricesStateBasis(transport, inputs, options);
+    };
+    const mapAll = (rows, what) => rows.map((row) => {
+        if (row === null) {
+            // `[ProductVariant]!` allows a null item; a write that answers one has
+            // lost track of a row it just wrote, and pretending otherwise would
+            // hand the caller fewer variants than it sent.
+            throw new UpstreamError({
+                code: 'VARIANT_WRITE_UNCONFIRMED',
+                message: `The engine answered ${what} without one of the variants it wrote. Read them back with variants.list(productId) before retrying.`,
+                status: 502,
+                service: 'vendure',
+            });
+        }
+        return toVariant(row);
+    });
+    const update = async (inputs, options) => {
+        inputs.forEach(assertParcelRule);
+        await assertPriceBasis(inputs, options);
+        const rows = await fieldOf(transport, UPDATE_VARIANTS_MUTATION, 'updateProductVariants', { input: inputs.map((input) => toWireInput({ ...input })) }, options);
+        return mapAll(rows, 'updateProductVariants');
+    };
+    return {
+        list(productId, options) {
+            return vendureListPage(transport, VARIANTS_QUERY, 'productVariants', (skip, take) => ({ productId, options: { skip, take } }), options, toVariant);
+        },
+        async get(id, options) {
+            const variant = await fieldOf(transport, VARIANT_QUERY, 'productVariant', { id }, options);
+            return variant ? toVariant(variant) : null;
+        },
+        async create(inputs, options) {
+            inputs.forEach(assertParcelRule);
+            await assertPriceBasis(inputs, options);
+            const rows = await fieldOf(transport, CREATE_VARIANTS_MUTATION, 'createProductVariants', { input: inputs.map((input) => toWireInput({ ...input })) }, options);
+            return mapAll(rows, 'createProductVariants');
+        },
+        update,
+        async delete(ids, options) {
+            assertDeleted('VARIANT_NOT_DELETED', await fieldOf(transport, DELETE_VARIANTS_MUTATION, 'deleteProductVariants', { ids }, options));
+        },
+        async setStockLevels(variantId, levels, options) {
+            const [variant] = await update([{ id: variantId, stockLevels: levels }], options);
+            return variant;
+        },
+        async priceSources(variantId, options) {
+            const variant = await fieldOf(transport, VARIANT_PRICE_SOURCES_QUERY, 'productVariant', { id: variantId }, options);
+            if (!variant) {
+                throw new NotFoundError({
+                    code: 'VARIANT_NOT_FOUND',
+                    message: `This store has no variant ${variantId}.`,
+                    status: 404,
+                    service: 'vendure',
+                });
+            }
+            return variant.priceSources;
+        },
+        async revertPrice(variantIds, options) {
+            const { currencyCodes, ...call } = options ?? {};
+            // The engine counts distinct ids the way it stores them (lower case).
+            const distinct = new Set(variantIds.map((id) => id.toLowerCase())).size;
+            if (distinct > MAX_REVERT_PRICE_VARIANTS) {
+                throw refuse('ORGANIZATION_PRICE_REVERT_INVALID', `Revert at most ${String(MAX_REVERT_PRICE_VARIANTS)} variants per call; this one named ${String(distinct)}. Nothing was sent.`);
+            }
+            if (variantIds.length === 0)
+                return [];
+            const rows = await fieldOf(transport, REVERT_TO_ORGANIZATION_PRICE_MUTATION, 'revertToOrganizationPrice', { variantIds, currencyCodes: currencyCodes === undefined ? null : [...currencyCodes] }, call);
+            return mapAll(rows, 'revertToOrganizationPrice');
+        },
+    };
+}

package/dist/catalog/visibility.d.ts

@@ -0,0 +1,57 @@
+import { type Transport } from '@sixtyninecommerce/core';
+import type { Call } from '../types.js';
+export type ProductVisibilityMode = 'public' | 'private';
+/**
+ * Who a product is shown to on the storefront. A product with no row is
+ * public; `private` limits it to the listed customer groups (none listed: to
+ * nobody). Enforced on the Shop API's product, product list and search
+ * resolvers — the Admin API always sees every product.
+ */
+export interface ProductVisibility {
+    productId: string;
+    mode: ProductVisibilityMode;
+    /** `manual` for anything written here; `imported` for rows the import pipeline wrote. */
+    source: 'manual' | 'imported';
+    allowedCustomerGroupIds: string[];
+    createdAt: string;
+    updatedAt: string;
+}
+export interface SetProductVisibilityInput {
+    productId: string;
+    mode: ProductVisibilityMode;
+    /** Ignored under `public`. */
+    allowedCustomerGroupIds?: string[];
+}
+/**
+ * Per-product storefront visibility. Needs `ReadCatalog` / `UpdateCatalog`.
+ *
+ * `set` on a product of another store is refused with the engine's
+ * `USER_INPUT_ERROR` (`ValidationError`): "Product {id} not found in this
+ * channel". A write from here is always `source: manual`, which a later
+ * pipeline import leaves alone.
+ *
+ * The Admin API's `productsByVisibility` list is deliberately NOT exposed: it
+ * counts and pages visibility rows across every store before narrowing to this
+ * one, so its totals and pages are wrong (recorded as a finding).
+ */
+export interface VisibilityModule {
+    /** Null when the product has no override (it is public). `NotFoundError` for an unknown product. */
+    get(productId: string, options?: Call): Promise<ProductVisibility | null>;
+    set(input: SetProductVisibilityInput, options?: Call): Promise<ProductVisibility>;
+    /** Apply one setting to many products; answers how many rows changed. */
+    bulkSet(input: {
+        productIds: string[];
+        mode: ProductVisibilityMode;
+        allowedCustomerGroupIds?: string[];
+    }, options?: Call): Promise<number>;
+    /**
+     * Remove the override (the product becomes public). Resolves the same way
+     * whether or not there was one: the engine does not say.
+     */
+    clear(productId: string, options?: Call): Promise<void>;
+}
+export declare const PRODUCT_VISIBILITY_QUERY = "\n  query CatalogProductVisibility($id: ID!) {\n    product(id: $id) {\n      id\n      visibility { \n  productId\n  mode\n  source\n  allowedCustomerGroupIds\n  createdAt\n  updatedAt\n }\n    }\n  }\n";
+export declare const SET_VISIBILITY_MUTATION = "\n  mutation CatalogSetVisibility($input: SetProductVisibilityInput!) {\n    setProductVisibility(input: $input) { \n  productId\n  mode\n  source\n  allowedCustomerGroupIds\n  createdAt\n  updatedAt\n }\n  }\n";
+export declare const BULK_SET_VISIBILITY_MUTATION = "\n  mutation CatalogBulkSetVisibility($input: BulkSetProductVisibilityInput!) {\n    bulkSetProductVisibility(input: $input) {\n      updated\n    }\n  }\n";
+export declare const CLEAR_VISIBILITY_MUTATION = "\n  mutation CatalogClearVisibility($productId: ID!) {\n    clearProductVisibility(productId: $productId)\n  }\n";
+export declare function createVisibilityModule(transport: Transport): VisibilityModule;

package/dist/catalog/visibility.js

@@ -0,0 +1,59 @@
+import { NotFoundError } from '@sixtyninecommerce/core';
+import { fieldOf } from './types.js';
+const VISIBILITY_FIELDS = /* GraphQL */ `
+  productId
+  mode
+  source
+  allowedCustomerGroupIds
+  createdAt
+  updatedAt
+`;
+export const PRODUCT_VISIBILITY_QUERY = /* GraphQL */ `
+  query CatalogProductVisibility($id: ID!) {
+    product(id: $id) {
+      id
+      visibility { ${VISIBILITY_FIELDS} }
+    }
+  }
+`;
+export const SET_VISIBILITY_MUTATION = /* GraphQL */ `
+  mutation CatalogSetVisibility($input: SetProductVisibilityInput!) {
+    setProductVisibility(input: $input) { ${VISIBILITY_FIELDS} }
+  }
+`;
+export const BULK_SET_VISIBILITY_MUTATION = /* GraphQL */ `
+  mutation CatalogBulkSetVisibility($input: BulkSetProductVisibilityInput!) {
+    bulkSetProductVisibility(input: $input) {
+      updated
+    }
+  }
+`;
+export const CLEAR_VISIBILITY_MUTATION = /* GraphQL */ `
+  mutation CatalogClearVisibility($productId: ID!) {
+    clearProductVisibility(productId: $productId)
+  }
+`;
+export function createVisibilityModule(transport) {
+    return {
+        async get(productId, options) {
+            const product = await fieldOf(transport, PRODUCT_VISIBILITY_QUERY, 'product', { id: productId }, options);
+            if (!product) {
+                throw new NotFoundError({
+                    code: 'PRODUCT_NOT_FOUND',
+                    message: `This store has no product ${productId}.`,
+                    status: 404,
+                    service: 'vendure',
+                });
+            }
+            return product.visibility;
+        },
+        set: (input, options) => fieldOf(transport, SET_VISIBILITY_MUTATION, 'setProductVisibility', { input }, options),
+        async bulkSet(input, options) {
+            const result = await fieldOf(transport, BULK_SET_VISIBILITY_MUTATION, 'bulkSetProductVisibility', { input }, options);
+            return result.updated;
+        },
+        async clear(productId, options) {
+            await fieldOf(transport, CLEAR_VISIBILITY_MUTATION, 'clearProductVisibility', { productId }, options);
+        },
+    };
+}