@aglyn/plugins-commerce 1.0.0-beta.220 → 1.0.0-beta.222

package/src/lib/transfer/product-import-step.component.js

@@ -0,0 +1,99 @@
+/**
+ * @license
+ * Copyright 2026 Aglyn LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */ 'use client';
+import { _ as _extends } from "@swc/helpers/_/_extends";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useConsoleWidgetSlot } from "@aglyn/aglyn/app-utils/console-widget-slot-context";
+import { useFirestore } from "@aglyn/tenant-feature-instance";
+import { Stack, Typography } from "@mui/material";
+import { doc, getDoc } from "firebase/firestore";
+import { useCallback, useEffect, useState } from "react";
+import { PRODUCT_IMPORT_ZONE } from "../components/console/product-zones.js";
+import { rememberProductImport } from "./product-import-results.js";
+/**
+ * The product import wizard's After import step (AGL-3531): the
+ * `productImport` zone, where another plugin offers what happens to the
+ * products once they land — the AI plugin's "write descriptions as they
+ * land". The options are filed with the job for the products hub, which
+ * hands them to `productsHub` with the ids the import created. Nothing here
+ * blocks the import: with no widget the step says so and lets it go on.
+ */ export function ProductImportOptionsStep(props) {
+    const { orgId, hostId, jobId, value, setValue, setComplete } = props;
+    const firestore = useFirestore();
+    const WidgetSlot = useConsoleWidgetSlot();
+    const options = value && typeof value === 'object' ? value : {};
+    const [count, setCount] = useState(0);
+    useEffect(()=>setComplete(true), [
+        setComplete
+    ]);
+    // How many products the dry run creates, from the job the wizard listens to.
+    useEffect(()=>{
+        if (!jobId || !orgId) return;
+        let live = true;
+        getDoc(doc(firestore, 'orgs', orgId, 'transferJobs', jobId)).then((snapshot)=>{
+            var _snapshot_get;
+            const creates = Number((_snapshot_get = snapshot.get('summary.create')) != null ? _snapshot_get : 0);
+            if (live) setCount(Number.isFinite(creates) ? creates : 0);
+        }).catch(()=>undefined);
+        return ()=>{
+            live = false;
+        };
+    }, [
+        firestore,
+        orgId,
+        jobId
+    ]);
+    useEffect(()=>{
+        if (hostId && jobId && orgId) rememberProductImport(hostId, {
+            orgId,
+            jobId,
+            options
+        });
+    }, [
+        hostId,
+        jobId,
+        orgId,
+        options
+    ]);
+    const setOption = useCallback((key, on)=>setValue(_extends({}, options, {
+            [key]: on
+        })), [
+        options,
+        setValue
+    ]);
+    return /*#__PURE__*/ _jsxs(Stack, {
+        spacing: 1,
+        children: [
+            /*#__PURE__*/ _jsx(Typography, {
+                variant: "body2",
+                color: "text.secondary",
+                children: 'What happens to the new products once they land.'
+            }),
+            WidgetSlot && hostId ? /*#__PURE__*/ _jsx(WidgetSlot, {
+                slot: PRODUCT_IMPORT_ZONE.id,
+                hostId: hostId,
+                orgId: orgId,
+                count: count,
+                options: options,
+                setOption: setOption
+            }) : null
+        ]
+    });
+}
+ProductImportOptionsStep.displayName = 'ProductImportOptionsStep';
+export default ProductImportOptionsStep;
+
+//# sourceMappingURL=product-import-step.component.js.map

package/src/lib/transfer/product-import-step.component.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../libs/plugins/commerce/src/lib/transfer/product-import-step.component.tsx"],"sourcesContent":["/**\n * @license\n * Copyright 2026 Aglyn LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n'use client'\n\nimport { useConsoleWidgetSlot } from '@aglyn/aglyn/app-utils/console-widget-slot-context'\nimport type { TransferWizardStepProps } from '@aglyn/aglyn/plugin-manager/plugin-transfer-resources'\nimport { useFirestore } from '@aglyn/tenant-feature-instance'\nimport { Stack, Typography } from '@mui/material'\nimport { doc, getDoc } from 'firebase/firestore'\nimport { useCallback, useEffect, useState } from 'react'\nimport { PRODUCT_IMPORT_ZONE } from '../components/console/product-zones'\nimport { rememberProductImport } from './product-import-results'\n\n/**\n * The product import wizard's After import step (AGL-3531): the\n * `productImport` zone, where another plugin offers what happens to the\n * products once they land — the AI plugin's \"write descriptions as they\n * land\". The options are filed with the job for the products hub, which\n * hands them to `productsHub` with the ids the import created. Nothing here\n * blocks the import: with no widget the step says so and lets it go on.\n */\nexport function ProductImportOptionsStep(props: TransferWizardStepProps) {\n  const { orgId, hostId, jobId, value, setValue, setComplete } = props\n  const firestore = useFirestore()\n  const WidgetSlot = useConsoleWidgetSlot()\n  const options = (value && typeof value === 'object' ? value : {}) as Record<string, boolean>\n  const [count, setCount] = useState(0)\n\n  useEffect(() => setComplete(true), [setComplete])\n\n  // How many products the dry run creates, from the job the wizard listens to.\n  useEffect(() => {\n    if (!jobId || !orgId) return\n    let live = true\n    getDoc(doc(firestore, 'orgs', orgId, 'transferJobs', jobId))\n      .then((snapshot) => {\n        const creates = Number(snapshot.get('summary.create') ?? 0)\n        if (live) setCount(Number.isFinite(creates) ? creates : 0)\n      })\n      .catch(() => undefined)\n    return () => {\n      live = false\n    }\n  }, [firestore, orgId, jobId])\n\n  useEffect(() => {\n    if (hostId && jobId && orgId) rememberProductImport(hostId, { orgId, jobId, options })\n  }, [hostId, jobId, orgId, options])\n\n  const setOption = useCallback(\n    (key: string, on: boolean) => setValue({ ...options, [key]: on }),\n    [options, setValue],\n  )\n\n  return (\n    <Stack spacing={1}>\n      <Typography variant=\"body2\" color=\"text.secondary\">\n        {'What happens to the new products once they land.'}\n      </Typography>\n      {WidgetSlot && hostId ? (\n        <WidgetSlot\n          slot={PRODUCT_IMPORT_ZONE.id}\n          hostId={hostId}\n          orgId={orgId}\n          count={count}\n          options={options}\n          setOption={setOption}\n        />\n      ) : null}\n    </Stack>\n  )\n}\nProductImportOptionsStep.displayName = 'ProductImportOptionsStep'\n\nexport default ProductImportOptionsStep\n"],"names":["useConsoleWidgetSlot","useFirestore","Stack","Typography","doc","getDoc","useCallback","useEffect","useState","PRODUCT_IMPORT_ZONE","rememberProductImport","ProductImportOptionsStep","props","orgId","hostId","jobId","value","setValue","setComplete","firestore","WidgetSlot","options","count","setCount","live","then","snapshot","creates","Number","get","isFinite","catch","undefined","setOption","key","on","spacing","variant","color","slot","id","displayName"],"mappings":"AAAA;;;;;;;;;;;;;;;CAeC,GAED;;;AAEA,SAASA,oBAAoB,QAAQ,qDAAoD;AAEzF,SAASC,YAAY,QAAQ,iCAAgC;AAC7D,SAASC,KAAK,EAAEC,UAAU,QAAQ,gBAAe;AACjD,SAASC,GAAG,EAAEC,MAAM,QAAQ,qBAAoB;AAChD,SAASC,WAAW,EAAEC,SAAS,EAAEC,QAAQ,QAAQ,QAAO;AACxD,SAASC,mBAAmB,QAAQ,yCAAqC;AACzE,SAASC,qBAAqB,QAAQ,8BAA0B;AAEhE;;;;;;;CAOC,GACD,OAAO,SAASC,yBAAyBC,KAA8B;IACrE,MAAM,EAAEC,KAAK,EAAEC,MAAM,EAAEC,KAAK,EAAEC,KAAK,EAAEC,QAAQ,EAAEC,WAAW,EAAE,GAAGN;IAC/D,MAAMO,YAAYlB;IAClB,MAAMmB,aAAapB;IACnB,MAAMqB,UAAWL,SAAS,OAAOA,UAAU,WAAWA,QAAQ,CAAC;IAC/D,MAAM,CAACM,OAAOC,SAAS,GAAGf,SAAS;IAEnCD,UAAU,IAAMW,YAAY,OAAO;QAACA;KAAY;IAEhD,6EAA6E;IAC7EX,UAAU;QACR,IAAI,CAACQ,SAAS,CAACF,OAAO;QACtB,IAAIW,OAAO;QACXnB,OAAOD,IAAIe,WAAW,QAAQN,OAAO,gBAAgBE,QAClDU,IAAI,CAAC,CAACC;gBACkBA;YAAvB,MAAMC,UAAUC,QAAOF,gBAAAA,SAASG,GAAG,CAAC,6BAAbH,gBAAkC;YACzD,IAAIF,MAAMD,SAASK,OAAOE,QAAQ,CAACH,WAAWA,UAAU;QAC1D,GACCI,KAAK,CAAC,IAAMC;QACf,OAAO;YACLR,OAAO;QACT;IACF,GAAG;QAACL;QAAWN;QAAOE;KAAM;IAE5BR,UAAU;QACR,IAAIO,UAAUC,SAASF,OAAOH,sBAAsBI,QAAQ;YAAED;YAAOE;YAAOM;QAAQ;IACtF,GAAG;QAACP;QAAQC;QAAOF;QAAOQ;KAAQ;IAElC,MAAMY,YAAY3B,YAChB,CAAC4B,KAAaC,KAAgBlB,SAAS,aAAKI;YAAS,CAACa,IAAI,EAAEC;aAC5D;QAACd;QAASJ;KAAS;IAGrB,qBACE,MAACf;QAAMkC,SAAS;;0BACd,KAACjC;gBAAWkC,SAAQ;gBAAQC,OAAM;0BAC/B;;YAEFlB,cAAcN,uBACb,KAACM;gBACCmB,MAAM9B,oBAAoB+B,EAAE;gBAC5B1B,QAAQA;gBACRD,OAAOA;gBACPS,OAAOA;gBACPD,SAASA;gBACTY,WAAWA;iBAEX;;;AAGV;AACAtB,yBAAyB8B,WAAW,GAAG;AAEvC,eAAe9B,yBAAwB"}

package/src/lib/transfer/product-transfer.d.ts

@@ -0,0 +1,211 @@
+/**
+ * @license
+ * Copyright 2026 Aglyn LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { type BuildTransferPlanInput, type MatchKeySpec, type PlannedTransferRow, type TransferAliasDictionary, type TransferField, type TransferFieldGroup, type TransferLockedRule, type TransferPlan, type TransferPlanRow, type TransferResourcePreset } from '@aglyn/aglyn/data-transfer';
+import type { PicklistSpec } from '@aglyn/aglyn/app-utils/picklists';
+import { type HostProduct, type ProductOption, type ProductVariant } from '../model/commerce';
+/** The field ids, as the catalog and every file name them. */
+export declare const PRODUCT_FIELD: {
+    readonly handle: "handle";
+    readonly title: "title";
+    readonly description: "description";
+    readonly kind: "type";
+    readonly status: "status";
+    readonly published: "published";
+    readonly tags: "tags";
+    readonly categories: "categories";
+    readonly option1Name: "option1Name";
+    readonly option2Name: "option2Name";
+    readonly option3Name: "option3Name";
+    readonly image: "image";
+    readonly seoTitle: "seoTitle";
+    readonly seoDescription: "seoDescription";
+    readonly taxExempt: "taxExempt";
+    readonly oversellPolicy: "oversellPolicy";
+    readonly lowStockThreshold: "lowStockThreshold";
+    readonly option1Value: "option1Value";
+    readonly option2Value: "option2Value";
+    readonly option3Value: "option3Value";
+    readonly sku: "sku";
+    readonly barcode: "barcode";
+    readonly price: "price";
+    readonly compareAtPrice: "compareAtPrice";
+    readonly inventory: "inventory";
+    readonly weightGrams: "weightGrams";
+    readonly variantImage: "variantImage";
+    readonly priceFrom: "priceFrom";
+    readonly totalInventory: "totalInventory";
+    readonly soldOut: "soldOut";
+    readonly variantCount: "variantCount";
+    readonly createdAt: "createdAt";
+    readonly updatedAt: "updatedAt";
+};
+/** The picklists the product fields name. */
+export declare const PRODUCT_KIND_PICKLIST = "commerce.productKind";
+export declare const PRODUCT_STATUS_PICKLIST = "commerce.productStatus";
+export declare const PRODUCT_OVERSELL_PICKLIST = "commerce.oversellPolicy";
+export declare const PRODUCT_CATEGORY_PICKLIST = "commerce.categories";
+/** The fixed lists products name, by picklist id. */
+export declare const PRODUCT_FIXED_PICKLISTS: Readonly<Record<string, PicklistSpec>>;
+/** The id a label of a fixed list names, by label or id in any case; `null` for none. */
+export declare function fixedListId(picklistId: string, value: unknown): string | null;
+export declare const PRODUCT_TRANSFER_GROUPS: readonly TransferFieldGroup[];
+/** The fields a product's first row carries: the product's own. */
+export declare const PRODUCT_LEVEL_FIELDS: readonly string[];
+/** The fields every row carries for its own variant. */
+export declare const VARIANT_LEVEL_FIELDS: readonly string[];
+/** Every writable product field, in picker order. */
+export declare const PRODUCT_STANDARD_FIELDS: readonly TransferField[];
+export declare const PRODUCT_DERIVED_FIELDS: readonly TransferField[];
+export declare const PRODUCT_SYSTEM_FIELDS: readonly TransferField[];
+/** Handle, then SKU, then the Aglyn ID. */
+export declare const PRODUCT_MATCH_KEYS: readonly MatchKeySpec[];
+/**
+ * A product's handle and its option names are changed in the product editor,
+ * never by a file: the handle is the product's address, and renaming an
+ * option moves every variant. A file gives a new product both, and names an
+ * option a product does not have yet.
+ */
+export declare const PRODUCT_LOCKED_RULES: readonly TransferLockedRule[];
+/** Shopify's product CSV columns, by the field each one means. */
+export declare const SHOPIFY_PRODUCT_COLUMNS: Readonly<Record<string, string>>;
+/** Shopify's export headers, so its file maps column for column. */
+export declare const PRODUCT_ALIAS_DICTIONARIES: readonly TransferAliasDictionary[];
+/**
+ * The Shopify preset: Shopify's product CSV columns, in Shopify's order and
+ * under Shopify's names. Status is left out — Shopify reads it in lowercase
+ * and Published says the same thing — and so is the kind, which Shopify's
+ * "Type" does not mean.
+ */
+export declare const SHOPIFY_PRODUCT_PRESET: TransferResourcePreset;
+/** Where a product's record keeps its variants, apart from its fields. */
+export declare const PRODUCT_VARIANT_ORDER = "$variants";
+/** The record key one variant's values live under. */
+export declare function productVariantKey(variantId: string): string;
+/** A variant's values, as a file names them. */
+export type VariantRecord = Record<string, unknown> & {
+    /** Its stock is kept per location. */
+    $byLocation?: boolean;
+};
+/** A product as a stored document, the way every reader lifts one. */
+type StoredProduct = Partial<HostProduct> & {
+    createdAt?: unknown;
+    updatedAt?: unknown;
+    createdAtMs?: number;
+    updatedAtMs?: number;
+};
+/** One variant as a file names it. */
+export declare function variantRecord(variant: ProductVariant, options: readonly ProductOption[]): VariantRecord;
+/**
+ * A product as one record: its fields by field id, and its variants under
+ * {@link productVariantKey} in the order {@link PRODUCT_VARIANT_ORDER} lists
+ * them. The lookup answers this shape, so the dry run's before → after and
+ * undo's "edited since" both read a product the way a file names it.
+ */
+export declare function productRecord(stored: StoredProduct, categoryNames?: ReadonlyMap<string, string>): Record<string, unknown>;
+/**
+ * A product's rows in a file, holding only `fieldIds`: one per variant (and
+ * per image past the variants), the product's own fields on the first, the
+ * handle and the ID on every one.
+ */
+export declare function productExportRows(id: string, stored: StoredProduct, fieldIds: readonly string[], categoryNames?: ReadonlyMap<string, string>): Array<Record<string, unknown>>;
+/** How many rows {@link productExportRows} writes for a product. */
+export declare function productExportRowCount(stored: Pick<StoredProduct, 'variants' | 'mediaUrls' | 'imageUrl'>): number;
+/** What a planned product row carries for the apply. */
+export interface ProductRowPlan {
+    /** The product the row writes: its id, or the id a new one is created under. */
+    productId: string;
+    /** The file row carrying the product's own fields. */
+    leader: number;
+    /**
+     * `create` makes the product (its leader); `part` is a row folded into a
+     * product the leader creates; `update` writes this row's changes into an
+     * existing product.
+     */
+    role: 'create' | 'part' | 'update';
+    /** The variant this row writes, when it writes one. */
+    variant?: {
+        id: string;
+        isNew: boolean;
+    };
+    /** On a new product's leader: the whole document's parts. */
+    create?: {
+        slug: string;
+        values: Record<string, unknown>;
+        variants: Array<{
+            id: string;
+            values: Record<string, unknown>;
+        }>;
+    };
+    /** Why the product this row belongs to cannot be stored, when it cannot. */
+    problem?: string;
+}
+/** A planned row with what the apply needs. */
+export type ProductPlannedRow = PlannedTransferRow & {
+    commerce?: ProductRowPlan;
+};
+export interface ProductPlanContext {
+    /** A new product's id. */
+    newProductId(): string;
+    /** A new variant's id, unique within its product. */
+    newVariantId(): string;
+    /** Whether a slug is held by a product already (deleted ones included). */
+    slugTaken?(slug: string): boolean;
+    /** How many products the site may still create; unbounded when absent. */
+    maxCreates?: number;
+}
+/** The tags a cell names, in their own case. */
+export declare function productTagList(value: unknown): string[];
+/**
+ * A product's document from its record values (see {@link productRecord}),
+ * for checking what a plan would store with the model's own rules.
+ */
+export declare function productFromRecord(values: Readonly<Record<string, unknown>>, variants: ReadonlyArray<{
+    id: string;
+    values: Readonly<Record<string, unknown>>;
+}>): HostProduct;
+/** One variant of a document from its record values. */
+export declare function variantFromRecord(id: string, values: Readonly<Record<string, unknown>>, optionNames: readonly (string | null | undefined)[]): ProductVariant;
+/**
+ * The products resource's plan: the core's plan per product and per variant,
+ * folded back into one verdict per file row (see the block header).
+ */
+export declare function planProductTransfer(input: BuildTransferPlanInput, context: ProductPlanContext): TransferPlan;
+/** The handles a plan may create products under, for the server to ask which are taken. */
+export declare function productPlanHandles(rows: readonly TransferPlanRow[]): string[];
+/** Category names → ids, for the categories a row names. */
+export type CategoryIdsOf = (names: readonly string[]) => string[];
+/** A product with one planned row's changes written into it — the product's own on its first row, and the row's variant. */
+export declare function applyProductRow(current: HostProduct, changes: {
+    product?: Readonly<Record<string, unknown>>;
+    variant?: {
+        id: string;
+        isNew: boolean;
+        values: Readonly<Record<string, unknown>>;
+    };
+}, categoryIdsOf: CategoryIdsOf): HostProduct;
+/** A new product's document from its leader's plan, before the platform's stamps. */
+export declare function createProductDocument(create: NonNullable<ProductRowPlan['create']>, categoryIdsOf: CategoryIdsOf): HostProduct;
+/** The values one planned row changes, split into the product's and its variant's. */
+export declare function productRowChanges(row: ProductPlannedRow): {
+    product: Record<string, unknown>;
+    variant?: {
+        id: string;
+        isNew: boolean;
+        values: Record<string, unknown>;
+    };
+};
+export {};