@mercurjs/core 2.2.0-canary.1 → 2.2.0-canary.12

package/.medusa/server/src/workflows/product/steps/resolve-attribute-refs.d.ts

@@ -0,0 +1,90 @@
+import { AttributeType, ProductAttributeInputDTO } from "@mercurjs/types";
+/**
+ * UI-facing attribute reference, as accepted by the create + update
+ * product wrappers. Two shapes:
+ *
+ *   1. **Existing reference** — `{ attribute_id, value_ids?, values? }`.
+ *      Points at a pre-created `ProductAttribute`. `value_ids` are
+ *      `ProductAttributeValue` ids; `values` are value names looked up
+ *      against the attribute (only meaningful for text/unit/toggle).
+ *
+ *   2. **Inline custom** — `{ name, type, values, is_variant_axis? }`.
+ *      Materialised by the wrapper as a product-scoped
+ *      `ProductAttribute` (`product_id` FK pinned to the product being
+ *      mutated).
+ */
+export type AttributeRef = ProductAttributeInputDTO;
+export declare const isExistingRef: (r: AttributeRef) => r is Extract<AttributeRef, {
+    attribute_id: string;
+}>;
+export declare const isInlineRef: (r: AttributeRef) => r is Extract<AttributeRef, {
+    name: string;
+}>;
+export type ResolvedExistingRef = {
+    attribute_id: string;
+    attribute_name: string;
+    attribute_type: AttributeType;
+    is_variant_axis: boolean;
+    value_ids: string[];
+    value_names: string[];
+};
+export type ResolvedInlineRef = {
+    name: string;
+    type: AttributeType;
+    is_variant_axis: boolean;
+    values: string[];
+    is_filterable?: boolean;
+    is_required?: boolean;
+    description?: string | null;
+    metadata?: Record<string, unknown> | null;
+};
+export type ResolvedRefs = {
+    existing_variant: ResolvedExistingRef[];
+    inline_variant: ResolvedInlineRef[];
+    existing_product: ResolvedExistingRef[];
+    inline_product: ResolvedInlineRef[];
+};
+/**
+ * Input is a list of *groups* (one per product on the create wrapper,
+ * one in total on the update wrapper). Each group carries the raw
+ * `variant_attributes` / `product_attributes` arrays from the wrapper
+ * payload. The step:
+ *
+ *   - looks up every existing `attribute_id` once (single batched
+ *     `listProductAttributes` call) so the workflow transforms can
+ *     synthesise stock `options[]` from real attribute + value names;
+ *   - resolves `values` (names) → `value_ids` for refs that didn't
+ *     pre-resolve ids (text/unit/toggle attributes);
+ *   - splits inline refs from existing refs and normalises their shape.
+ *
+ * Read-only — no compensation.
+ */
+export type ResolveAttributeRefsInput = {
+    groups: {
+        variant_attributes?: AttributeRef[];
+        product_attributes?: AttributeRef[];
+    }[];
+};
+export declare const resolveAttributeRefsStepId = "mercur-resolve-attribute-refs";
+export declare const resolveAttributeRefsStep: import("@medusajs/framework/workflows-sdk").StepFunction<ResolveAttributeRefsInput, ResolvedRefs[]>;
+/**
+ * Flat plan entry describing one inline-custom attribute to materialise.
+ * Carries enough context to (a) feed
+ * `createProductAttributesStep` and (b) slice the returned values back
+ * into per-product link rows.
+ */
+export type InlinePlanEntry = {
+    name: string;
+    type: AttributeType;
+    is_variant_axis: boolean;
+    is_filterable: boolean;
+    is_required: boolean;
+    description: string | null;
+    metadata: Record<string, unknown> | null;
+    product_id: string;
+    /** Internal: index into the surrounding groups array. */
+    _group_idx: number;
+    /** Internal: value names to materialise once the attribute exists. */
+    _value_names: string[];
+};
+export declare function buildInlinePlan(groups: ResolvedRefs[], productIdAt: (groupIdx: number) => string | undefined): InlinePlanEntry[];

package/.medusa/server/src/workflows/product/steps/resolve-attribute-refs.js

@@ -0,0 +1,185 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveAttributeRefsStep = exports.resolveAttributeRefsStepId = exports.isInlineRef = exports.isExistingRef = void 0;
+exports.buildInlinePlan = buildInlinePlan;
+const utils_1 = require("@medusajs/framework/utils");
+const workflows_sdk_1 = require("@medusajs/framework/workflows-sdk");
+const types_1 = require("@mercurjs/types");
+const isExistingRef = (r) => r.attribute_id !== undefined;
+exports.isExistingRef = isExistingRef;
+const isInlineRef = (r) => r.name !== undefined;
+exports.isInlineRef = isInlineRef;
+exports.resolveAttributeRefsStepId = "mercur-resolve-attribute-refs";
+exports.resolveAttributeRefsStep = (0, workflows_sdk_1.createStep)(exports.resolveAttributeRefsStepId, async (input, { container }) => {
+    const attributeIds = new Set();
+    for (const g of input.groups) {
+        for (const r of [
+            ...(g.variant_attributes ?? []),
+            ...(g.product_attributes ?? []),
+        ]) {
+            if ((0, exports.isExistingRef)(r))
+                attributeIds.add(r.attribute_id);
+        }
+    }
+    let attrsById = new Map();
+    if (attributeIds.size) {
+        const service = container.resolve(types_1.MercurModules.PRODUCT_ATTRIBUTE);
+        const attrs = await service.listProductAttributes({ id: Array.from(attributeIds) }, {
+            relations: ["values"],
+            select: ["id", "name", "type", "is_variant_axis"],
+        });
+        attrsById = new Map(attrs.map((a) => [
+            a.id,
+            {
+                id: a.id,
+                name: a.name,
+                type: a.type,
+                is_variant_axis: !!a.is_variant_axis,
+                values: (a.values ?? []).map((v) => ({ id: v.id, name: v.name })),
+            },
+        ]));
+    }
+    const resolveExisting = (ref) => {
+        const attr = attrsById.get(ref.attribute_id);
+        if (!attr) {
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.NOT_FOUND, `Product attribute ${ref.attribute_id} not found`);
+        }
+        const idToName = new Map(attr.values.map((v) => [v.id, v.name]));
+        const nameToId = new Map(attr.values.map((v) => [v.name, v.id]));
+        const value_ids = [];
+        const value_names = [];
+        for (const id of ref.value_ids ?? []) {
+            const name = idToName.get(id);
+            if (!name) {
+                throw new utils_1.MedusaError(utils_1.MedusaError.Types.NOT_FOUND, `Product attribute value ${id} not found on attribute ${ref.attribute_id}`);
+            }
+            value_ids.push(id);
+            value_names.push(name);
+        }
+        for (const name of ref.values ?? []) {
+            const id = nameToId.get(name);
+            // Select-type values must already exist; text/unit values are
+            // free-form and resolved elsewhere — skip silently here.
+            if (!id)
+                continue;
+            if (!value_ids.includes(id)) {
+                value_ids.push(id);
+                value_names.push(name);
+            }
+        }
+        return {
+            attribute_id: ref.attribute_id,
+            attribute_name: attr.name,
+            attribute_type: attr.type,
+            is_variant_axis: attr.is_variant_axis,
+            value_ids,
+            value_names,
+        };
+    };
+    const perGroup = input.groups.map((g) => {
+        const out = {
+            existing_variant: [],
+            inline_variant: [],
+            existing_product: [],
+            inline_product: [],
+        };
+        for (const r of g.variant_attributes ?? []) {
+            if ((0, exports.isExistingRef)(r))
+                out.existing_variant.push(resolveExisting(r));
+            else if ((0, exports.isInlineRef)(r))
+                out.inline_variant.push({
+                    name: r.name,
+                    type: r.type,
+                    is_variant_axis: true,
+                    values: r.values ?? [],
+                    is_filterable: r.is_filterable,
+                    is_required: r.is_required,
+                    description: r.description,
+                    metadata: r.metadata,
+                });
+        }
+        for (const r of g.product_attributes ?? []) {
+            if ((0, exports.isExistingRef)(r))
+                out.existing_product.push(resolveExisting(r));
+            else if ((0, exports.isInlineRef)(r))
+                out.inline_product.push({
+                    name: r.name,
+                    type: r.type,
+                    is_variant_axis: r.is_variant_axis ?? false,
+                    values: r.values ?? [],
+                    is_filterable: r.is_filterable,
+                    is_required: r.is_required,
+                    description: r.description,
+                    metadata: r.metadata,
+                });
+        }
+        return out;
+    });
+    return new workflows_sdk_1.StepResponse(perGroup);
+});
+/**
+ * Flattens inline refs across resolved groups into the deterministic
+ * `InlinePlanEntry[]` shape consumed by the create / update wrappers.
+ * Order: per group → inline variant refs → inline product refs. Both
+ * wrappers recompute the plan the same way, so the resulting indices
+ * align with the flat outputs of `createProductAttributesStep` /
+ * `createProductAttributeValuesStep`.
+ */
+/**
+ * Drops empty entries and de-duplicates value names per ref. The
+ * underlying `ProductAttributeValue` uniqueness index is on
+ * `(attribute_id, handle)`, but two values with the same `name` are
+ * legal at the DB level — the UI form, however, treats names as the
+ * user-facing identity. Deduping here keeps the materialised set in
+ * line with what the form expects to round-trip.
+ */
+const dedupeValueNames = (values) => {
+    const seen = new Set();
+    const out = [];
+    for (const v of values) {
+        const trimmed = v?.trim();
+        if (!trimmed || seen.has(trimmed))
+            continue;
+        seen.add(trimmed);
+        out.push(trimmed);
+    }
+    return out;
+};
+function buildInlinePlan(groups, productIdAt) {
+    const plan = [];
+    groups.forEach((r, idx) => {
+        const product_id = productIdAt(idx);
+        if (!product_id)
+            return;
+        for (const ref of r.inline_variant) {
+            plan.push({
+                name: ref.name,
+                type: ref.type,
+                is_variant_axis: true,
+                is_filterable: ref.is_filterable ?? false,
+                is_required: ref.is_required ?? false,
+                description: ref.description ?? null,
+                metadata: ref.metadata ?? null,
+                product_id,
+                _group_idx: idx,
+                _value_names: dedupeValueNames(ref.values),
+            });
+        }
+        for (const ref of r.inline_product) {
+            plan.push({
+                name: ref.name,
+                type: ref.type,
+                is_variant_axis: ref.is_variant_axis,
+                is_filterable: ref.is_filterable ?? false,
+                is_required: ref.is_required ?? false,
+                description: ref.description ?? null,
+                metadata: ref.metadata ?? null,
+                product_id,
+                _group_idx: idx,
+                _value_names: dedupeValueNames(ref.values),
+            });
+        }
+    });
+    return plan;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"resolve-attribute-refs.js","sourceRoot":"","sources":["../../../../../../src/workflows/product/steps/resolve-attribute-refs.ts"],"names":[],"mappings":"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"}

package/.medusa/server/src/workflows/product/steps/validate-products-status.d.ts

@@ -0,0 +1,19 @@
+import { ProductStatus } from "@medusajs/framework/utils";
+type ValidateProductsStatusStepInput = {
+    products: Array<{
+        id: string;
+        status: string;
+    }>;
+    expected_status: ProductStatus | ProductStatus[];
+};
+export declare const validateProductsStatusStepId = "validate-products-status";
+/**
+ * Guard that all input products are in one of the expected statuses.
+ * Used by the publish-approval workflows (`confirmProductsWorkflow`,
+ * `rejectProductWorkflow`, `requestProductChangeWorkflow`) which all
+ * require `proposed` as the only eligible state. Existence is
+ * presumed validated upstream by `useQueryGraphStep` with
+ * `throwIfKeyNotFound: true`.
+ */
+export declare const validateProductsStatusStep: import("@medusajs/framework/workflows-sdk").StepFunction<ValidateProductsStatusStepInput, undefined>;
+export {};

package/.medusa/server/src/workflows/product/steps/validate-products-status.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateProductsStatusStep = exports.validateProductsStatusStepId = void 0;
+const utils_1 = require("@medusajs/framework/utils");
+const workflows_sdk_1 = require("@medusajs/framework/workflows-sdk");
+exports.validateProductsStatusStepId = "validate-products-status";
+/**
+ * Guard that all input products are in one of the expected statuses.
+ * Used by the publish-approval workflows (`confirmProductsWorkflow`,
+ * `rejectProductWorkflow`, `requestProductChangeWorkflow`) which all
+ * require `proposed` as the only eligible state. Existence is
+ * presumed validated upstream by `useQueryGraphStep` with
+ * `throwIfKeyNotFound: true`.
+ */
+exports.validateProductsStatusStep = (0, workflows_sdk_1.createStep)(exports.validateProductsStatusStepId, async ({ products, expected_status }) => {
+    const allowed = Array.isArray(expected_status)
+        ? new Set(expected_status)
+        : new Set([expected_status]);
+    const invalid = products.filter((p) => !allowed.has(p.status));
+    if (invalid.length) {
+        const expected = [...allowed].join(", ");
+        throw new utils_1.MedusaError(utils_1.MedusaError.Types.NOT_ALLOWED, `Product(s) [${invalid
+            .map((p) => `${p.id} (status: ${p.status})`)
+            .join(", ")}] are not in an eligible status. Expected one of: ${expected}.`);
+    }
+    return new workflows_sdk_1.StepResponse(void 0);
+});
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmFsaWRhdGUtcHJvZHVjdHMtc3RhdHVzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vc3JjL3dvcmtmbG93cy9wcm9kdWN0L3N0ZXBzL3ZhbGlkYXRlLXByb2R1Y3RzLXN0YXR1cy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFBQSxxREFBc0U7QUFDdEUscUVBQTRFO0FBTy9ELFFBQUEsNEJBQTRCLEdBQUcsMEJBQTBCLENBQUE7QUFFdEU7Ozs7Ozs7R0FPRztBQUNVLFFBQUEsMEJBQTBCLEdBQUcsSUFBQSwwQkFBVSxFQUNsRCxvQ0FBNEIsRUFDNUIsS0FBSyxFQUFFLEVBQUUsUUFBUSxFQUFFLGVBQWUsRUFBbUMsRUFBRSxFQUFFO0lBQ3ZFLE1BQU0sT0FBTyxHQUFHLEtBQUssQ0FBQyxPQUFPLENBQUMsZUFBZSxDQUFDO1FBQzVDLENBQUMsQ0FBQyxJQUFJLEdBQUcsQ0FBUyxlQUFlLENBQUM7UUFDbEMsQ0FBQyxDQUFDLElBQUksR0FBRyxDQUFTLENBQUMsZUFBZSxDQUFDLENBQUMsQ0FBQTtJQUV0QyxNQUFNLE9BQU8sR0FBRyxRQUFRLENBQUMsTUFBTSxDQUFDLENBQUMsQ0FBQyxFQUFFLEVBQUUsQ0FBQyxDQUFDLE9BQU8sQ0FBQyxHQUFHLENBQUMsQ0FBQyxDQUFDLE1BQU0sQ0FBQyxDQUFDLENBQUE7SUFFOUQsSUFBSSxPQUFPLENBQUMsTUFBTSxFQUFFLENBQUM7UUFDbkIsTUFBTSxRQUFRLEdBQUcsQ0FBQyxHQUFHLE9BQU8sQ0FBQyxDQUFDLElBQUksQ0FBQyxJQUFJLENBQUMsQ0FBQTtRQUN4QyxNQUFNLElBQUksbUJBQVcsQ0FDbkIsbUJBQVcsQ0FBQyxLQUFLLENBQUMsV0FBVyxFQUM3QixlQUFlLE9BQU87YUFDbkIsR0FBRyxDQUFDLENBQUMsQ0FBQyxFQUFFLEVBQUUsQ0FBQyxHQUFHLENBQUMsQ0FBQyxFQUFFLGFBQWEsQ0FBQyxDQUFDLE1BQU0sR0FBRyxDQUFDO2FBQzNDLElBQUksQ0FBQyxJQUFJLENBQUMscURBQXFELFFBQVEsR0FBRyxDQUM5RSxDQUFBO0lBQ0gsQ0FBQztJQUVELE9BQU8sSUFBSSw0QkFBWSxDQUFDLEtBQUssQ0FBQyxDQUFDLENBQUE7QUFDakMsQ0FBQyxDQUNGLENBQUEifQ==

package/.medusa/server/src/workflows/product/steps/validate-seller-product-permissions.d.ts

@@ -1,7 +1,6 @@
 type ValidateSellerProductPermissionsInput = {
     seller_id: string;
     category_ids?: string[];
-    brand_ids?: string[];
 };
 export declare const validateSellerProductPermissionsStep: import("@medusajs/framework/workflows-sdk").StepFunction<ValidateSellerProductPermissionsInput, undefined>;
 export {};

package/.medusa/server/src/workflows/product/steps/validate-seller-product-permissions.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.validateSellerProductPermissionsStep = void 0;
 const utils_1 = require("@medusajs/framework/utils");
 const workflows_sdk_1 = require("@medusajs/framework/workflows-sdk");
-exports.validateSellerProductPermissionsStep = (0, workflows_sdk_1.createStep)("validate-seller-product-permissions", async ({ seller_id, category_ids, brand_ids, }, { container }) => {
+exports.validateSellerProductPermissionsStep = (0, workflows_sdk_1.createStep)("validate-seller-product-permissions", async ({ seller_id, category_ids, }, { container }) => {
     const query = container.resolve(utils_1.ContainerRegistrationKeys.QUERY);
     // Category restriction (blacklist): if a category-seller link exists for
     // (category_id, seller_id), the seller is BLOCKED from that category.
@@ -21,25 +21,6 @@ exports.validateSellerProductPermissionsStep = (0, workflows_sdk_1.createStep)("
             throw new utils_1.MedusaError(utils_1.MedusaError.Types.NOT_ALLOWED, `Seller is restricted from categories: ${blockedIds.join(", ")}`);
         }
     }
-    // Brand restriction (whitelist): only enforced when `brand.is_restricted`
-    // is true; in that case the seller must appear in the brand's sellers.
-    if (brand_ids && brand_ids.length > 0) {
-        const uniqueBrandIds = [...new Set(brand_ids)];
-        const { data: brands } = await query.graph({
-            entity: "product_brand",
-            fields: ["id", "is_restricted", "sellers.id"],
-            filters: { id: uniqueBrandIds },
-        });
-        for (const brand of brands) {
-            if (!brand.is_restricted) {
-                continue;
-            }
-            const isAuthorized = (brand.sellers ?? []).some((s) => s.id === seller_id);
-            if (!isAuthorized) {
-                throw new utils_1.MedusaError(utils_1.MedusaError.Types.NOT_ALLOWED, `Seller is not authorized to use restricted brand '${brand.id}'`);
-            }
-        }
-    }
     return new workflows_sdk_1.StepResponse(void 0);
 });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmFsaWRhdGUtc2VsbGVyLXByb2R1Y3QtcGVybWlzc2lvbnMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9zcmMvd29ya2Zsb3dzL3Byb2R1Y3Qvc3RlcHMvdmFsaWRhdGUtc2VsbGVyLXByb2R1Y3QtcGVybWlzc2lvbnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBQ0EscURBR2tDO0FBQ2xDLHFFQUE0RTtBQU8vRCxRQUFBLG9DQUFvQyxHQUFHLElBQUEsMEJBQVUsRUFDNUQscUNBQXFDLEVBQ3JDLEtBQUssRUFDSCxFQUNFLFNBQVMsRUFDVCxZQUFZLEdBQzBCLEVBQ3hDLEVBQUUsU0FBUyxFQUFFLEVBQ2IsRUFBRTtJQUNGLE1BQU0sS0FBSyxHQUFHLFNBQVMsQ0FBQyxPQUFPLENBQVEsaUNBQXlCLENBQUMsS0FBSyxDQUFDLENBQUE7SUFFdkUseUVBQXlFO0lBQ3pFLHNFQUFzRTtJQUN0RSxJQUFJLFlBQVksSUFBSSxZQUFZLENBQUMsTUFBTSxHQUFHLENBQUMsRUFBRSxDQUFDO1FBQzVDLE1BQU0saUJBQWlCLEdBQUcsQ0FBQyxHQUFHLElBQUksR0FBRyxDQUFDLFlBQVksQ0FBQyxDQUFDLENBQUE7UUFFcEQsTUFBTSxFQUFFLElBQUksRUFBRSxVQUFVLEVBQUUsR0FBRyxNQUFNLEtBQUssQ0FBQyxLQUFLLENBQUM7WUFDN0MsTUFBTSxFQUFFLGtCQUFrQjtZQUMxQixNQUFNLEVBQUUsQ0FBQyxJQUFJLEVBQUUsWUFBWSxDQUFDO1lBQzVCLE9BQU8sRUFBRSxFQUFFLEVBQUUsRUFBRSxpQkFBaUIsRUFBRTtTQUNuQyxDQUFDLENBQUE7UUFFRixNQUFNLFVBQVUsR0FBRyxVQUFVO2FBQzFCLE1BQU0sQ0FBQyxDQUFDLENBQUMsRUFBRSxFQUFFLENBQ1osQ0FBQyxDQUFDLENBQUMsT0FBTyxJQUFJLEVBQUUsQ0FBQyxDQUFDLElBQUksQ0FBQyxDQUFDLENBQUMsRUFBRSxFQUFFLENBQUMsQ0FBQyxDQUFDLEVBQUUsS0FBSyxTQUFTLENBQUMsQ0FDbEQ7YUFDQSxHQUFHLENBQUMsQ0FBQyxDQUFDLEVBQUUsRUFBRSxDQUFDLENBQUMsQ0FBQyxFQUFFLENBQUMsQ0FBQTtRQUVuQixJQUFJLFVBQVUsQ0FBQyxNQUFNLEdBQUcsQ0FBQyxFQUFFLENBQUM7WUFDMUIsTUFBTSxJQUFJLG1CQUFXLENBQ25CLG1CQUFXLENBQUMsS0FBSyxDQUFDLFdBQVcsRUFDN0IseUNBQXlDLFVBQVUsQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLEVBQUUsQ0FDakUsQ0FBQTtRQUNILENBQUM7SUFDSCxDQUFDO0lBRUQsT0FBTyxJQUFJLDRCQUFZLENBQUMsS0FBSyxDQUFDLENBQUMsQ0FBQTtBQUNqQyxDQUFDLENBQ0YsQ0FBQSJ9

package/.medusa/server/src/workflows/product/workflows/confirm-products.d.ts

@@ -1,4 +1,4 @@
-export declare const confirmProductsWorkflowId = "confirm-products";
+export declare const confirmProductsWorkflowId = "mercur-confirm-products";
 type ConfirmProductsWorkflowInput = {
     product_ids: string[];
     actor_id?: string;
@@ -8,6 +8,18 @@ type ConfirmProductsWorkflowInput = {
      */
     internal_note?: string;
 };
+/**
+ * Admin-side "publish a vendor submission". Mirrors the audit-trail
+ * pattern used by `createProductsWorkflow`:
+ *
+ *   1. Load + validate the products are `proposed`.
+ *   2. Record one CONFIRMED `ProductChange` per product with a
+ *      pre-applied `STATUS_CHANGE` action (delegated to
+ *      `recordProductAuditChangeWorkflow`). The change is the audit
+ *      row — no admin queue.
+ *   3. Apply the actual product status update.
+ *   4. Emit `product.published` so notifications / search reindex.
+ */
 export declare const confirmProductsWorkflow: import("@medusajs/framework/workflows-sdk").ReturnWorkflow<ConfirmProductsWorkflowInput, undefined, [import("@medusajs/framework/workflows-sdk").Hook<"productsConfirmed", {
     product_ids: string[];
     internal_note: string | undefined;

package/.medusa/server/src/workflows/product/workflows/confirm-products.js

@@ -2,45 +2,56 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.confirmProductsWorkflow = exports.confirmProductsWorkflowId = void 0;
 const workflows_sdk_1 = require("@medusajs/framework/workflows-sdk");
+const utils_1 = require("@medusajs/framework/utils");
 const core_flows_1 = require("@medusajs/medusa/core-flows");
 const types_1 = require("@mercurjs/types");
 const events_1 = require("../events");
-const steps_1 = require("../steps");
-const steps_2 = require("../../product-edit/steps");
-const override_workflow_1 = require("../../utils/override-workflow");
-exports.confirmProductsWorkflowId = "confirm-products";
-exports.confirmProductsWorkflow = (0, override_workflow_1.overrideWorkflow)(exports.confirmProductsWorkflowId, function (input) {
+const validate_products_status_1 = require("../steps/validate-products-status");
+const record_product_audit_change_1 = require("../../product-edit/workflows/record-product-audit-change");
+exports.confirmProductsWorkflowId = "mercur-confirm-products";
+/**
+ * Admin-side "publish a vendor submission". Mirrors the audit-trail
+ * pattern used by `createProductsWorkflow`:
+ *
+ *   1. Load + validate the products are `proposed`.
+ *   2. Record one CONFIRMED `ProductChange` per product with a
+ *      pre-applied `STATUS_CHANGE` action (delegated to
+ *      `recordProductAuditChangeWorkflow`). The change is the audit
+ *      row — no admin queue.
+ *   3. Apply the actual product status update.
+ *   4. Emit `product.published` so notifications / search reindex.
+ */
+exports.confirmProductsWorkflow = (0, workflows_sdk_1.createWorkflow)(exports.confirmProductsWorkflowId, function (input) {
     const { data: products } = (0, core_flows_1.useQueryGraphStep)({
         entity: "product",
         fields: ["id", "status"],
         filters: { id: input.product_ids },
         options: { throwIfKeyNotFound: true },
     }).config({ name: "get-products" });
-    (0, steps_1.validateConfirmProductsStep)({ products });
-    const changeData = (0, workflows_sdk_1.transform)({ products, input }, ({ products, input }) => products.map((product) => ({
-        product_id: product.id,
-        created_by: input.actor_id,
-        status: types_1.ProductChangeStatus.CONFIRMED,
-        confirmed_by: input.actor_id,
-        confirmed_at: new Date(),
-        internal_note: input.internal_note,
-    })));
-    const changes = (0, steps_2.createProductChangesStep)(changeData);
-    const actionDataList = (0, workflows_sdk_1.transform)({ products, changes }, ({ products, changes }) => products.map((product, index) => ({
-        product_change_id: changes[index].id,
-        product_id: product.id,
-        action: types_1.ProductChangeActionType.STATUS_CHANGE,
-        details: { status: types_1.ProductStatus.PUBLISHED },
-        applied: true,
-    })));
-    (0, steps_2.createProductChangeActionsStep)(actionDataList);
-    const updateInput = (0, workflows_sdk_1.transform)({ input }, ({ input }) => ({
+    (0, validate_products_status_1.validateProductsStatusStep)({
+        products,
+        expected_status: utils_1.ProductStatus.PROPOSED,
+    });
+    record_product_audit_change_1.recordProductAuditChangeWorkflow.runAsStep({
+        input: (0, workflows_sdk_1.transform)({ products, input }, ({ products, input }) => ({
+            actor_id: input.actor_id,
+            changes: products.map((product) => ({
+                product_id: product.id,
+                internal_note: input.internal_note,
+                actions: [
+                    {
+                        product_id: product.id,
+                        action: types_1.ProductChangeActionType.STATUS_CHANGE,
+                        details: { status: utils_1.ProductStatus.PUBLISHED },
+                    },
+                ],
+            })),
+        })),
+    });
+    (0, core_flows_1.updateProductsStep)((0, workflows_sdk_1.transform)({ input }, ({ input }) => ({
         selector: { id: input.product_ids },
-        data: {
-            status: types_1.ProductStatus.PUBLISHED,
-        },
-    }));
-    (0, steps_1.updateProductsStep)(updateInput);
+        update: { status: utils_1.ProductStatus.PUBLISHED },
+    })));
     (0, core_flows_1.emitEventStep)({
         eventName: events_1.ProductWorkflowEvents.PUBLISHED,
         data: (0, workflows_sdk_1.transform)({ input }, ({ input }) => input.product_ids.map((id) => ({
@@ -54,4 +65,4 @@ exports.confirmProductsWorkflow = (0, override_workflow_1.overrideWorkflow)(expo
     });
     return new workflows_sdk_1.WorkflowResponse(void 0, { hooks: [productsConfirmed] });
 });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/.medusa/server/src/workflows/product/workflows/create-products.d.ts

@@ -1,3 +1,59 @@
-import { overrideWorkflow } from "../../utils/override-workflow";
-export declare const createProductsWorkflowId = "create-products";
-export declare const createProductsWorkflow: ReturnType<typeof overrideWorkflow>;
+import { type ReturnWorkflow } from "@medusajs/framework/workflows-sdk";
+import { AdditionalData, ProductTypes } from "@medusajs/framework/types";
+import { CreateProductDTO } from "@mercurjs/types";
+import { type AttributeRef } from "../steps";
+type ProductOptionInput = {
+    title: string;
+    values: string[];
+};
+/** Per-product input on the create wrapper. */
+export type CreateProductWorkflowInput = Omit<CreateProductDTO, "variant_attributes" | "product_attributes" | "variants"> & {
+    variant_attributes?: AttributeRef[];
+    product_attributes?: AttributeRef[];
+    seller_ids?: string[];
+    options?: ProductOptionInput[];
+    variants?: Array<Record<string, unknown> & {
+        options?: Record<string, string>;
+        attribute_values?: Record<string, string | string[]> | string[];
+    }>;
+};
+export type CreateProductsWorkflowInput = {
+    products: CreateProductWorkflowInput[];
+    /**
+     * Marketplace add-on: seller ids to authorize for **every** created
+     * product. For per-product seller authorization, set `seller_ids` on
+     * the individual product entry instead.
+     */
+    seller_ids?: string[];
+} & AdditionalData;
+export declare const createProductsWorkflowId = "mercur-create-products";
+/**
+ * Marketplace wrapper over stock `createProductsWorkflow`.
+ *
+ * On top of stock it:
+ *   1. Resolves `variant_attributes` / `product_attributes` (existing
+ *      attribute lookups, value name ↔ id resolution) via
+ *      `resolveAttributeRefsStep`.
+ *   2. Synthesizes stock `options[]` from variant-axis attributes (both
+ *      existing and inline) — UI doesn't have to emit a parallel
+ *      `options` field.
+ *   3. Renames `variants[].attribute_values` (the Mercur extension —
+ *      `{Size: "S"}` name map) to `variants[].options` so stock variant
+ *      generation works unchanged.
+ *   4. Strips marketplace-only fields before delegating to stock.
+ *   5. Pins every variant's `manage_inventory` to `false` (marketplace
+ *      invariant — vendor variants never participate in inventory
+ *      bookkeeping).
+ *   6. Synthesizes a default option + variant for simple products so
+ *      stock's variant validator does not throw.
+ *   7. After stock returns, materialises inline-custom attributes via
+ *      `createProductAttributesStep` + their values via
+ *      `createProductAttributeValuesStep` (both scoped to the created
+ *      product through the `product_id` FK).
+ *   8. Writes `product_attribute_value_link` rows for every chosen
+ *      value (existing + inline) using stock `createRemoteLinkStep`,
+ *      so the edit form can pre-select them.
+ *   9. Writes `product_seller` link rows for the requested seller_ids.
+ */
+export declare const createProductsWorkflow: ReturnWorkflow<CreateProductsWorkflowInput, ProductTypes.ProductDTO[], unknown[]>;
+export {};