@mercurjs/core 2.1.6 → 2.2.0-canary.11

package/.medusa/server/src/workflows/product-attribute/steps/upsert-product-attribute-values.d.ts

@@ -0,0 +1,43 @@
+import { UpsertProductAttributeValueDTO } from "@mercurjs/types";
+export declare const upsertProductAttributeValuesStepId = "pa-upsert-product-attribute-values";
+export type UpsertProductAttributeValuesStepInput = (UpsertProductAttributeValueDTO & {
+    attribute_id?: string;
+})[];
+/**
+ * Hand-rolled upsert: MedusaService autogenerates create/update/delete but not
+ * upsert for the new `product-attribute` module. Split the input into
+ * create rows (no `id`) and update rows (with `id`), call create / update
+ * separately, and return the union. Compensation undoes both: delete the
+ * created rows and restore the updated rows from captured `prevValues`.
+ */
+export declare const upsertProductAttributeValuesStep: import("@medusajs/framework/workflows-sdk").StepFunction<UpsertProductAttributeValuesStepInput, {
+    id: string;
+    handle: string | null;
+    name: string;
+    rank: number;
+    is_active: boolean;
+    metadata: Record<string, unknown> | null;
+    attribute: {
+        id: string;
+        handle: string | null;
+        name: string;
+        description: string | null;
+        type: import("@mercurjs/types").AttributeType;
+        is_required: boolean;
+        is_filterable: boolean;
+        is_variant_axis: boolean;
+        rank: number;
+        is_active: boolean;
+        created_by: string | null;
+        product_id: string | null;
+        metadata: Record<string, unknown> | null;
+        values: /*elided*/ any[];
+        created_at: Date;
+        updated_at: Date;
+        deleted_at: Date | null;
+    };
+    created_at: Date;
+    updated_at: Date;
+    deleted_at: Date | null;
+    attribute_id: string;
+}[]>;

package/.medusa/server/src/workflows/product-attribute/steps/upsert-product-attribute-values.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.upsertProductAttributeValuesStep = exports.upsertProductAttributeValuesStepId = void 0;
+const workflows_sdk_1 = require("@medusajs/framework/workflows-sdk");
+const types_1 = require("@mercurjs/types");
+exports.upsertProductAttributeValuesStepId = "pa-upsert-product-attribute-values";
+/**
+ * Hand-rolled upsert: MedusaService autogenerates create/update/delete but not
+ * upsert for the new `product-attribute` module. Split the input into
+ * create rows (no `id`) and update rows (with `id`), call create / update
+ * separately, and return the union. Compensation undoes both: delete the
+ * created rows and restore the updated rows from captured `prevValues`.
+ */
+exports.upsertProductAttributeValuesStep = (0, workflows_sdk_1.createStep)(exports.upsertProductAttributeValuesStepId, async (data, { container }) => {
+    const service = container.resolve(types_1.MercurModules.PRODUCT_ATTRIBUTE);
+    const updateRows = data.filter((v) => typeof v.id === "string" && v.id.length > 0);
+    const createRows = data
+        .filter((v) => !v.id)
+        .map((v) => {
+        const { id: _id, ...rest } = v;
+        return rest;
+    });
+    const prevValues = updateRows.length
+        ? await service.listProductAttributeValues({
+            id: updateRows.map((u) => u.id),
+        })
+        : [];
+    const created = createRows.length
+        ? await service.createProductAttributeValues(createRows)
+        : [];
+    const updated = updateRows.length
+        ? await service.updateProductAttributeValues(updateRows)
+        : [];
+    const compensation = {
+        createdIds: created.map((v) => v.id),
+        prevValues,
+    };
+    return new workflows_sdk_1.StepResponse([...created, ...updated], compensation);
+}, async (compensation, { container }) => {
+    if (!compensation) {
+        return;
+    }
+    const service = container.resolve(types_1.MercurModules.PRODUCT_ATTRIBUTE);
+    if (compensation.createdIds.length) {
+        await service.deleteProductAttributeValues(compensation.createdIds);
+    }
+    if (compensation.prevValues.length) {
+        await service.updateProductAttributeValues(compensation.prevValues.map((v) => ({ ...v })));
+    }
+});
+//# sourceMappingURL=data:application/json;base64,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

package/.medusa/server/src/workflows/product-attribute/steps/upsert-product-options-for-axis.d.ts

@@ -0,0 +1,7 @@
+export type UpsertProductOptionsForAxisInput = Array<{
+    product_id: string;
+    title: string;
+    values: string[];
+}>;
+export declare const upsertProductOptionsForAxisStepId = "pa-upsert-product-options-for-axis";
+export declare const upsertProductOptionsForAxisStep: import("@medusajs/framework/workflows-sdk").StepFunction<UpsertProductOptionsForAxisInput, undefined>;

package/.medusa/server/src/workflows/product-attribute/steps/upsert-product-options-for-axis.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.upsertProductOptionsForAxisStep = exports.upsertProductOptionsForAxisStepId = void 0;
+const utils_1 = require("@medusajs/framework/utils");
+const workflows_sdk_1 = require("@medusajs/framework/workflows-sdk");
+exports.upsertProductOptionsForAxisStepId = "pa-upsert-product-options-for-axis";
+exports.upsertProductOptionsForAxisStep = (0, workflows_sdk_1.createStep)(exports.upsertProductOptionsForAxisStepId, async (input, { container }) => {
+    const valid = input.filter((e) => e.title && e.values.length);
+    if (!valid.length) {
+        return new workflows_sdk_1.StepResponse(undefined, { created_ids: [] });
+    }
+    const service = container.resolve(utils_1.Modules.PRODUCT);
+    const productIds = Array.from(new Set(valid.map((e) => e.product_id)));
+    const titles = Array.from(new Set(valid.map((e) => e.title)));
+    const existing = await service.listProductOptions({ product_id: productIds, title: titles }, { relations: ["values"] });
+    const existingByKey = new Map();
+    for (const o of existing) {
+        existingByKey.set(`${o.product_id}::${o.title}`, o);
+    }
+    const toCreate = [];
+    const toUpdate = [];
+    for (const entry of valid) {
+        const current = existingByKey.get(`${entry.product_id}::${entry.title}`);
+        if (!current) {
+            toCreate.push({
+                title: entry.title,
+                values: entry.values,
+                product_id: entry.product_id,
+            });
+            continue;
+        }
+        const currentValues = (current.values ?? []).map((v) => v.value);
+        const currentSet = new Set(currentValues);
+        const missing = entry.values.filter((v) => !currentSet.has(v));
+        if (!missing.length)
+            continue;
+        toUpdate.push({
+            id: current.id,
+            title: current.title,
+            values: [...currentValues, ...missing],
+            product_id: entry.product_id,
+        });
+    }
+    const created = toCreate.length
+        ? await service.createProductOptions(toCreate)
+        : [];
+    if (toUpdate.length) {
+        await service.upsertProductOptions(toUpdate);
+    }
+    return new workflows_sdk_1.StepResponse(undefined, {
+        created_ids: created.map((o) => o.id),
+    });
+}, async (compensation, { container }) => {
+    if (!compensation || !compensation.created_ids.length)
+        return;
+    const service = container.resolve(utils_1.Modules.PRODUCT);
+    await service.deleteProductOptions(compensation.created_ids);
+});
+//# sourceMappingURL=data:application/json;base64,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

package/.medusa/server/src/workflows/product-attribute/steps/validate-attribute-accepts-values.d.ts

@@ -0,0 +1,6 @@
+export declare const validateAttributeAcceptsValuesStepId = "pa-validate-attribute-accepts-values";
+type ValidateAttributeAcceptsValuesStepInput = {
+    attribute_id: string;
+};
+export declare const validateAttributeAcceptsValuesStep: import("@medusajs/framework/workflows-sdk").StepFunction<ValidateAttributeAcceptsValuesStepInput, undefined>;
+export {};

package/.medusa/server/src/workflows/product-attribute/steps/validate-attribute-accepts-values.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateAttributeAcceptsValuesStep = exports.validateAttributeAcceptsValuesStepId = void 0;
+const utils_1 = require("@medusajs/framework/utils");
+const workflows_sdk_1 = require("@medusajs/framework/workflows-sdk");
+const types_1 = require("@mercurjs/types");
+exports.validateAttributeAcceptsValuesStepId = "pa-validate-attribute-accepts-values";
+const VALUE_ACCEPTING_TYPES = new Set([
+    types_1.AttributeType.SINGLE_SELECT,
+    types_1.AttributeType.MULTI_SELECT,
+]);
+exports.validateAttributeAcceptsValuesStep = (0, workflows_sdk_1.createStep)(exports.validateAttributeAcceptsValuesStepId, async ({ attribute_id }, { container }) => {
+    const service = container.resolve(types_1.MercurModules.PRODUCT_ATTRIBUTE);
+    const attribute = (await service.retrieveProductAttribute(attribute_id));
+    if (!VALUE_ACCEPTING_TYPES.has(attribute.type)) {
+        throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, `Attribute '${attribute.name}' (type=${attribute.type}) does not accept enumerated values. Only single_select and multi_select attributes may define values.`);
+    }
+    return new workflows_sdk_1.StepResponse(void 0);
+});
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmFsaWRhdGUtYXR0cmlidXRlLWFjY2VwdHMtdmFsdWVzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vc3JjL3dvcmtmbG93cy9wcm9kdWN0LWF0dHJpYnV0ZS9zdGVwcy92YWxpZGF0ZS1hdHRyaWJ1dGUtYWNjZXB0cy12YWx1ZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBQUEscURBQXVEO0FBQ3ZELHFFQUE0RTtBQUM1RSwyQ0FJd0I7QUFJWCxRQUFBLG9DQUFvQyxHQUMvQyxzQ0FBc0MsQ0FBQTtBQUV4QyxNQUFNLHFCQUFxQixHQUFHLElBQUksR0FBRyxDQUFnQjtJQUNuRCxxQkFBYSxDQUFDLGFBQWE7SUFDM0IscUJBQWEsQ0FBQyxZQUFZO0NBQzNCLENBQUMsQ0FBQTtBQU1XLFFBQUEsa0NBQWtDLEdBQUcsSUFBQSwwQkFBVSxFQUMxRCw0Q0FBb0MsRUFDcEMsS0FBSyxFQUNILEVBQUUsWUFBWSxFQUEyQyxFQUN6RCxFQUFFLFNBQVMsRUFBRSxFQUNiLEVBQUU7SUFDRixNQUFNLE9BQU8sR0FBRyxTQUFTLENBQUMsT0FBTyxDQUMvQixxQkFBYSxDQUFDLGlCQUFpQixDQUNoQyxDQUFBO0lBQ0QsTUFBTSxTQUFTLEdBQUcsQ0FBQyxNQUFNLE9BQU8sQ0FBQyx3QkFBd0IsQ0FDdkQsWUFBWSxDQUNiLENBQXdCLENBQUE7SUFFekIsSUFBSSxDQUFDLHFCQUFxQixDQUFDLEdBQUcsQ0FBQyxTQUFTLENBQUMsSUFBcUIsQ0FBQyxFQUFFLENBQUM7UUFDaEUsTUFBTSxJQUFJLG1CQUFXLENBQ25CLG1CQUFXLENBQUMsS0FBSyxDQUFDLFlBQVksRUFDOUIsY0FBYyxTQUFTLENBQUMsSUFBSSxXQUFXLFNBQVMsQ0FBQyxJQUFJLHdHQUF3RyxDQUM5SixDQUFBO0lBQ0gsQ0FBQztJQUVELE9BQU8sSUFBSSw0QkFBWSxDQUFDLEtBQUssQ0FBQyxDQUFDLENBQUE7QUFDakMsQ0FBQyxDQUNGLENBQUEifQ==

package/.medusa/server/src/workflows/product-attribute/steps/validate-product-attribute-input.d.ts

@@ -0,0 +1,7 @@
+import { CreateProductAttributeDTO } from "@mercurjs/types";
+export declare const validateProductAttributeInputStepId = "pa-validate-product-attribute-input";
+type ValidateProductAttributeInputStepInput = {
+    attributes: CreateProductAttributeDTO[];
+};
+export declare const validateProductAttributeInputStep: import("@medusajs/framework/workflows-sdk").StepFunction<ValidateProductAttributeInputStepInput, undefined>;
+export {};

package/.medusa/server/src/workflows/product-attribute/steps/validate-product-attribute-input.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateProductAttributeInputStep = exports.validateProductAttributeInputStepId = void 0;
+const utils_1 = require("@medusajs/framework/utils");
+const workflows_sdk_1 = require("@medusajs/framework/workflows-sdk");
+const types_1 = require("@mercurjs/types");
+exports.validateProductAttributeInputStepId = "pa-validate-product-attribute-input";
+const ALLOWED_TYPES = new Set(Object.values(types_1.AttributeType));
+exports.validateProductAttributeInputStep = (0, workflows_sdk_1.createStep)(exports.validateProductAttributeInputStepId, async ({ attributes }) => {
+    for (const attr of attributes) {
+        if (!attr.name || !attr.name.trim()) {
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, "Product attribute requires a non-empty 'name'");
+        }
+        if (!ALLOWED_TYPES.has(attr.type)) {
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, `Unsupported product attribute type '${attr.type}'`);
+        }
+    }
+    return new workflows_sdk_1.StepResponse(void 0);
+});
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmFsaWRhdGUtcHJvZHVjdC1hdHRyaWJ1dGUtaW5wdXQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9zcmMvd29ya2Zsb3dzL3Byb2R1Y3QtYXR0cmlidXRlL3N0ZXBzL3ZhbGlkYXRlLXByb2R1Y3QtYXR0cmlidXRlLWlucHV0LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztBQUFBLHFEQUF1RDtBQUN2RCxxRUFBNEU7QUFDNUUsMkNBQTBFO0FBRTdELFFBQUEsbUNBQW1DLEdBQzlDLHFDQUFxQyxDQUFBO0FBTXZDLE1BQU0sYUFBYSxHQUFHLElBQUksR0FBRyxDQUFnQixNQUFNLENBQUMsTUFBTSxDQUFDLHFCQUFhLENBQUMsQ0FBQyxDQUFBO0FBRTdELFFBQUEsaUNBQWlDLEdBQUcsSUFBQSwwQkFBVSxFQUN6RCwyQ0FBbUMsRUFDbkMsS0FBSyxFQUFFLEVBQUUsVUFBVSxFQUEwQyxFQUFFLEVBQUU7SUFDL0QsS0FBSyxNQUFNLElBQUksSUFBSSxVQUFVLEVBQUUsQ0FBQztRQUM5QixJQUFJLENBQUMsSUFBSSxDQUFDLElBQUksSUFBSSxDQUFDLElBQUksQ0FBQyxJQUFJLENBQUMsSUFBSSxFQUFFLEVBQUUsQ0FBQztZQUNwQyxNQUFNLElBQUksbUJBQVcsQ0FDbkIsbUJBQVcsQ0FBQyxLQUFLLENBQUMsWUFBWSxFQUM5QiwrQ0FBK0MsQ0FDaEQsQ0FBQTtRQUNILENBQUM7UUFDRCxJQUFJLENBQUMsYUFBYSxDQUFDLEdBQUcsQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLEVBQUUsQ0FBQztZQUNsQyxNQUFNLElBQUksbUJBQVcsQ0FDbkIsbUJBQVcsQ0FBQyxLQUFLLENBQUMsWUFBWSxFQUM5Qix1Q0FBdUMsSUFBSSxDQUFDLElBQUksR0FBRyxDQUNwRCxDQUFBO1FBQ0gsQ0FBQztJQUNILENBQUM7SUFDRCxPQUFPLElBQUksNEJBQVksQ0FBQyxLQUFLLENBQUMsQ0FBQyxDQUFBO0FBQ2pDLENBQUMsQ0FDRixDQUFBIn0=

package/.medusa/server/src/workflows/product-attribute/workflows/add-product-attribute.d.ts

@@ -0,0 +1,52 @@
+import { AdditionalData } from "@medusajs/framework/types";
+import { AttributeType } from "@mercurjs/types";
+/**
+ * Input accepted by {@link addProductAttributeWorkflow}. Mirrors the
+ * `POST /vendor/products/:id/attributes` (and admin equivalent) body —
+ * the union of the **attach-existing** and **inline-create** branches.
+ */
+export type AddProductAttributeWorkflowInput = {
+    product_id: string;
+    attribute_id?: string;
+    value_ids?: string[];
+    name?: string;
+    type?: AttributeType;
+    values?: string[];
+    is_variant_axis?: boolean;
+    is_filterable?: boolean;
+    is_required?: boolean;
+    description?: string | null;
+    metadata?: Record<string, unknown> | null;
+} & AdditionalData;
+export declare const addProductAttributeWorkflowId = "add-product-attribute";
+/**
+ * Adds a product attribute to a product in one shot. Composes the
+ * marketplace building blocks:
+ *
+ *   1. `resolveAttributeRefsStep` — existing attribute lookups (by
+ *      `attribute_id`) and value-name → id resolution.
+ *   2. `materializeProductAttributesWorkflow` — when the caller passed
+ *      inline `{ name, type, … }`, creates the product-scoped
+ *      attribute + its values.
+ *   3. `createRemoteLinkStep` — writes `product_attribute_value_link`
+ *      rows so the product picks up the attached values on next read.
+ *   4. `syncProductAttributeOptionsWorkflow` — upserts a stock product
+ *      option for variant-axis attributes so the product's option set
+ *      stays in sync with its variant axes.
+ */
+export declare const addProductAttributeWorkflow: import("@medusajs/framework/workflows-sdk").ReturnWorkflow<{
+    product_id: string;
+    attribute_id?: string;
+    value_ids?: string[];
+    name?: string;
+    type?: AttributeType;
+    values?: string[];
+    is_variant_axis?: boolean;
+    is_filterable?: boolean;
+    is_required?: boolean;
+    description?: string | null;
+    metadata?: Record<string, unknown> | null;
+} & AdditionalData, undefined, [import("@medusajs/framework/workflows-sdk").Hook<"productAttributeAdded", {
+    product_id: string;
+    additional_data: Record<string, unknown> | undefined;
+}, unknown>]>;

package/.medusa/server/src/workflows/product-attribute/workflows/add-product-attribute.js

@@ -0,0 +1,120 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addProductAttributeWorkflow = exports.addProductAttributeWorkflowId = void 0;
+const utils_1 = require("@medusajs/framework/utils");
+const workflows_sdk_1 = require("@medusajs/framework/workflows-sdk");
+const core_flows_1 = require("@medusajs/medusa/core-flows");
+const types_1 = require("@mercurjs/types");
+const materialize_product_attributes_1 = require("./materialize-product-attributes");
+const sync_product_attribute_options_1 = require("./sync-product-attribute-options");
+const steps_1 = require("../../product/steps");
+exports.addProductAttributeWorkflowId = "add-product-attribute";
+/**
+ * Adds a product attribute to a product in one shot. Composes the
+ * marketplace building blocks:
+ *
+ *   1. `resolveAttributeRefsStep` — existing attribute lookups (by
+ *      `attribute_id`) and value-name → id resolution.
+ *   2. `materializeProductAttributesWorkflow` — when the caller passed
+ *      inline `{ name, type, … }`, creates the product-scoped
+ *      attribute + its values.
+ *   3. `createRemoteLinkStep` — writes `product_attribute_value_link`
+ *      rows so the product picks up the attached values on next read.
+ *   4. `syncProductAttributeOptionsWorkflow` — upserts a stock product
+ *      option for variant-axis attributes so the product's option set
+ *      stays in sync with its variant axes.
+ */
+exports.addProductAttributeWorkflow = (0, workflows_sdk_1.createWorkflow)(exports.addProductAttributeWorkflowId, function (input) {
+    const groups = (0, workflows_sdk_1.transform)({ input }, ({ input }) => {
+        const ref = input.attribute_id !== undefined
+            ? {
+                attribute_id: input.attribute_id,
+                value_ids: input.value_ids,
+                values: input.values,
+            }
+            : {
+                name: input.name,
+                type: input.type,
+                values: input.values,
+                is_variant_axis: input.is_variant_axis,
+                is_filterable: input.is_filterable,
+                is_required: input.is_required,
+                description: input.description,
+                metadata: input.metadata,
+            };
+        const isVariantAxis = input.is_variant_axis === true ||
+            (input.attribute_id !== undefined && input.is_variant_axis !== false);
+        return [
+            {
+                variant_attributes: isVariantAxis ? [ref] : undefined,
+                product_attributes: isVariantAxis ? undefined : [ref],
+            },
+        ];
+    });
+    const resolved = (0, steps_1.resolveAttributeRefsStep)({ groups });
+    const inlinePlan = (0, workflows_sdk_1.transform)({ resolved, input }, ({ resolved, input }) => (0, steps_1.buildInlinePlan)(resolved, () => input.product_id));
+    const materialized = materialize_product_attributes_1.materializeProductAttributesWorkflow.runAsStep({
+        input: (0, workflows_sdk_1.transform)({ inlinePlan }, ({ inlinePlan }) => ({
+            plan: inlinePlan,
+        })),
+    });
+    const optionPlan = (0, workflows_sdk_1.transform)({ resolved, materialized }, ({ resolved, materialized }) => {
+        const r = resolved[0];
+        const existing = r.existing_variant[0] ?? r.existing_product[0];
+        const inline = r.inline_variant[0] ?? r.inline_product[0];
+        if (existing) {
+            return {
+                value_ids: existing.value_ids,
+                title: existing.attribute_name,
+                value_names: existing.value_names,
+                is_variant_axis: existing.is_variant_axis,
+            };
+        }
+        if (inline) {
+            return {
+                value_ids: materialized.inline_values.map((v) => v.id),
+                title: inline.name,
+                value_names: inline.values,
+                is_variant_axis: inline.is_variant_axis,
+            };
+        }
+        return {
+            value_ids: [],
+            title: "",
+            value_names: [],
+            is_variant_axis: false,
+        };
+    });
+    const valueLinks = (0, workflows_sdk_1.transform)({ input, optionPlan }, ({ input, optionPlan }) => optionPlan.value_ids.map((value_id) => ({
+        [utils_1.Modules.PRODUCT]: { product_id: input.product_id },
+        [types_1.MercurModules.PRODUCT_ATTRIBUTE]: {
+            product_attribute_value_id: value_id,
+        },
+    })));
+    (0, core_flows_1.createRemoteLinkStep)(valueLinks).config({
+        name: "add-product-attribute-link-values",
+    });
+    sync_product_attribute_options_1.syncProductAttributeOptionsWorkflow.runAsStep({
+        input: (0, workflows_sdk_1.transform)({ input, optionPlan }, ({ input, optionPlan }) => ({
+            upsert: optionPlan.is_variant_axis &&
+                optionPlan.title &&
+                optionPlan.value_names.length
+                ? [
+                    {
+                        product_id: input.product_id,
+                        title: optionPlan.title,
+                        values: optionPlan.value_names,
+                    },
+                ]
+                : [],
+        })),
+    });
+    const productAttributeAdded = (0, workflows_sdk_1.createHook)("productAttributeAdded", {
+        product_id: input.product_id,
+        additional_data: input.additional_data,
+    });
+    return new workflows_sdk_1.WorkflowResponse(void 0, {
+        hooks: [productAttributeAdded],
+    });
+});
+//# sourceMappingURL=data:application/json;base64,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

package/.medusa/server/src/workflows/product-attribute/workflows/batch-product-attribute-values.d.ts

@@ -0,0 +1,23 @@
+import { type Hook, type ReturnWorkflow } from "@medusajs/framework/workflows-sdk";
+export type BatchProductAttributeValuesCreateInput = {
+    attribute_id: string;
+    attribute_value_ids?: string[];
+    values?: string[];
+};
+export type BatchProductAttributeValuesWorkflowInput = {
+    product_id: string;
+    create?: BatchProductAttributeValuesCreateInput[];
+    delete?: string[];
+};
+export type BatchProductAttributeValuesWorkflowHooks = [
+    Hook<"validate", {
+        input: BatchProductAttributeValuesWorkflowInput;
+    }, unknown>,
+    Hook<"productAttributeValuesBatched", {
+        product_id: string;
+        attached_value_ids: string[];
+        detached_value_ids: string[];
+    }, unknown>
+];
+export declare const batchProductAttributeValuesWorkflowId = "batch-product-attribute-values";
+export declare const batchProductAttributeValuesWorkflow: ReturnWorkflow<BatchProductAttributeValuesWorkflowInput, void, BatchProductAttributeValuesWorkflowHooks>;