n8n-nodes-shopify-custom 2.0.0

package/dist/nodes/ShopifyCustom/shared/graphql/registry.js

@@ -0,0 +1,962 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRegistryOperation = getRegistryOperation;
+const collection_1 = require("./templates/collection");
+const customer_1 = require("./templates/customer");
+const draftOrder_1 = require("./templates/draftOrder");
+const metafields_1 = require("./templates/metafields");
+const metaobject_1 = require("./templates/metaobject");
+const order_1 = require("./templates/order");
+const product_1 = require("./templates/product");
+const productVariant_1 = require("./templates/productVariant");
+const ruleConditions_1 = require("../collections/ruleConditions");
+const definitions_1 = require("../metafields/definitions");
+function isObject(value) {
+    return !!value && typeof value === 'object' && !Array.isArray(value);
+}
+function asString(value) {
+    if (value === undefined || value === null) {
+        return undefined;
+    }
+    const normalized = String(value).trim();
+    return normalized.length > 0 ? normalized : undefined;
+}
+function asBoolean(value) {
+    if (value === undefined || value === null) {
+        return undefined;
+    }
+    return Boolean(value);
+}
+function asNumber(value) {
+    if (value === undefined || value === null || value === '') {
+        return undefined;
+    }
+    const parsed = Number(value);
+    return Number.isNaN(parsed) ? undefined : parsed;
+}
+function parseTags(value) {
+    const raw = asString(value);
+    if (!raw) {
+        return undefined;
+    }
+    const tags = raw
+        .split(',')
+        .map((tag) => tag.trim())
+        .filter((tag) => tag.length > 0);
+    return tags.length > 0 ? tags : undefined;
+}
+function parseSeoInput(parameters) {
+    const title = asString(parameters.seoTitle);
+    const description = asString(parameters.seoDescription);
+    if (!title && !description) {
+        return undefined;
+    }
+    return {
+        title,
+        description,
+    };
+}
+function getPaginationOptions(parameters) {
+    if (isObject(parameters.paginationOptions)) {
+        return parameters.paginationOptions;
+    }
+    if (isObject(parameters.options)) {
+        return parameters.options;
+    }
+    return {};
+}
+function getConnectionVariables(parameters) {
+    var _a, _b, _c, _d, _e, _f;
+    const options = getPaginationOptions(parameters);
+    const sorting = isObject(options.sorting) ? options.sorting : {};
+    const limit = (_a = asNumber(parameters.limit)) !== null && _a !== void 0 ? _a : 50;
+    return {
+        first: Math.max(1, Math.trunc(limit)),
+        after: asString(options.afterCursor),
+        query: asString((_b = options.query) !== null && _b !== void 0 ? _b : parameters.query),
+        sortKey: asString((_d = (_c = sorting.sortKey) !== null && _c !== void 0 ? _c : options.sortKey) !== null && _d !== void 0 ? _d : parameters.sortKey),
+        reverse: asBoolean((_f = (_e = sorting.reverse) !== null && _e !== void 0 ? _e : options.reverse) !== null && _f !== void 0 ? _f : parameters.reverse),
+    };
+}
+function parseSelectedMetafieldKeys(value) {
+    if (!Array.isArray(value)) {
+        return undefined;
+    }
+    const keys = value
+        .map((item) => asString(item))
+        .filter((item) => !!item)
+        .map((item) => {
+        try {
+            const definition = (0, definitions_1.decodeDefinitionOptionValue)(item);
+            const namespace = asString(definition.namespace);
+            const key = asString(definition.key);
+            if (!namespace || !key) {
+                return undefined;
+            }
+            return `${namespace}.${key}`;
+        }
+        catch {
+            const fallback = asString(item);
+            if (!fallback || !fallback.includes('.')) {
+                return undefined;
+            }
+            return fallback;
+        }
+    })
+        .filter((item) => !!item);
+    if (keys.length === 0) {
+        return undefined;
+    }
+    return Array.from(new Set(keys));
+}
+function getMetafieldReadVariables(parameters) {
+    var _a, _b, _c, _d, _e, _f;
+    const options = getPaginationOptions(parameters);
+    const metafields = isObject(options.metafields) ? options.metafields : {};
+    const selectedMetafieldKeys = parseSelectedMetafieldKeys((_b = (_a = metafields.selectedMetafields) !== null && _a !== void 0 ? _a : options.selectedMetafields) !== null && _b !== void 0 ? _b : parameters.selectedMetafields);
+    return {
+        includeMetafields: Boolean((_d = (_c = metafields.includeMetafields) !== null && _c !== void 0 ? _c : options.includeMetafields) !== null && _d !== void 0 ? _d : parameters.includeMetafields),
+        metafieldsFirst: 250,
+        metafieldKeys: selectedMetafieldKeys,
+        resolveMetafieldReferences: Boolean((_f = (_e = metafields.resolveMetafieldReferences) !== null && _e !== void 0 ? _e : options.resolveMetafieldReferences) !== null && _f !== void 0 ? _f : parameters.resolveMetafieldReferences),
+        metafieldReferencesFirst: 50,
+    };
+}
+function getPathValue(source, path) {
+    let current = source;
+    for (const chunk of path) {
+        if (Array.isArray(current)) {
+            const index = Number(chunk);
+            if (Number.isNaN(index)) {
+                return undefined;
+            }
+            current = current[index];
+            continue;
+        }
+        if (!isObject(current)) {
+            return undefined;
+        }
+        current = current[chunk];
+    }
+    return current;
+}
+const JSON_METAFIELD_TYPES = new Set([
+    'json',
+    'rich_text_field',
+    'money',
+    'rating',
+    'dimension',
+    'volume',
+    'weight',
+]);
+function shouldParseMetafieldValue(typeName) {
+    if (!typeName) {
+        return false;
+    }
+    return typeName.startsWith('list.') || JSON_METAFIELD_TYPES.has(typeName);
+}
+function parseMetafieldValue(typeName, value) {
+    if (!shouldParseMetafieldValue(typeName) || typeof value !== 'string') {
+        return value;
+    }
+    const trimmed = value.trim();
+    if (!trimmed) {
+        return value;
+    }
+    try {
+        return JSON.parse(trimmed);
+    }
+    catch {
+        return value;
+    }
+}
+function normalizeMetafieldNode(metafield) {
+    const typeName = asString(metafield.type);
+    const parsedValue = parseMetafieldValue(typeName, metafield.value);
+    let changed = false;
+    const normalized = { ...metafield };
+    if (parsedValue !== metafield.value) {
+        normalized.value = parsedValue;
+        changed = true;
+    }
+    if (isObject(metafield.references) && Array.isArray(metafield.references.nodes)) {
+        normalized.references = metafield.references.nodes.filter(isObject);
+        changed = true;
+    }
+    if (Array.isArray(metafield.references)) {
+        normalized.references = metafield.references.filter(isObject);
+        changed = true;
+    }
+    if (isObject(metafield.reference)) {
+        normalized.reference = metafield.reference;
+        changed = true;
+    }
+    return changed ? normalized : metafield;
+}
+function normalizeMetafieldArray(value) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    return value.filter(isObject).map(normalizeMetafieldNode);
+}
+function normalizeNode(node) {
+    const normalized = { ...node };
+    let changed = false;
+    if (isObject(node.metafield)) {
+        normalized.metafield = normalizeMetafieldNode(node.metafield);
+        changed = true;
+    }
+    if (isObject(node.metafields) && Array.isArray(node.metafields.nodes)) {
+        normalized.metafields = normalizeMetafieldArray(node.metafields.nodes);
+        changed = true;
+    }
+    if (Array.isArray(node.metafields)) {
+        normalized.metafields = normalizeMetafieldArray(node.metafields);
+        changed = true;
+    }
+    return changed ? normalized : node;
+}
+function mapNodesFromConnection(data, connectionPath) {
+    const connection = getPathValue(data, connectionPath);
+    if (!isObject(connection) || !Array.isArray(connection.nodes)) {
+        return [];
+    }
+    return connection.nodes.filter(isObject).map(normalizeNode);
+}
+function mapSingleNode(data, path) {
+    const node = getPathValue(data, path);
+    return isObject(node) ? normalizeNode(node) : undefined;
+}
+function mapMutationPayload(data, path) {
+    const payload = getPathValue(data, path);
+    return isObject(payload) ? payload : undefined;
+}
+function parseLineItems(value) {
+    if (!isObject(value) || !Array.isArray(value.items)) {
+        return [];
+    }
+    return value.items
+        .filter(isObject)
+        .map((item) => {
+        const variantId = asString(item.variantId);
+        const quantity = asNumber(item.quantity);
+        if (!variantId || !quantity) {
+            return undefined;
+        }
+        return {
+            variantId,
+            quantity: Math.max(1, Math.trunc(quantity)),
+        };
+    })
+        .filter((item) => item !== undefined);
+}
+function parseCollectionProductIds(value) {
+    if (!isObject(value) || !Array.isArray(value.items)) {
+        return undefined;
+    }
+    const productIds = value.items
+        .filter(isObject)
+        .map((item) => asString(item.productId))
+        .filter((item) => !!item);
+    return productIds.length > 0 ? Array.from(new Set(productIds)) : undefined;
+}
+function parseCollectionRules(value) {
+    if (!isObject(value) || !Array.isArray(value.items)) {
+        return undefined;
+    }
+    function resolveMetafieldConditionValue(item) {
+        const encodedRule = asString(item.metafieldRule);
+        if (!encodedRule) {
+            return undefined;
+        }
+        const decodedRule = (0, ruleConditions_1.decodeMetafieldRuleOptionValue)(encodedRule);
+        if (!decodedRule) {
+            return undefined;
+        }
+        switch (decodedRule.valueType) {
+            case 'boolean': {
+                const booleanValue = asBoolean(item.metafieldValueBoolean);
+                return booleanValue === undefined ? undefined : booleanValue ? 'true' : 'false';
+            }
+            case 'number': {
+                const numberValue = asNumber(item.metafieldValueNumber);
+                return numberValue === undefined ? undefined : String(numberValue);
+            }
+            case 'metaobject_reference':
+                return asString(item.metafieldValueMetaobjectId);
+            case 'text':
+            default:
+                return asString(item.metafieldValueText);
+        }
+    }
+    const rules = value.items
+        .filter(isObject)
+        .map((item) => {
+        var _a;
+        const source = (_a = asString(item.ruleSource)) !== null && _a !== void 0 ? _a : 'native';
+        const nativeRelation = asString(item.nativeRelation);
+        if (source === 'metafield') {
+            const encodedRule = asString(item.metafieldRule);
+            const decodedRule = encodedRule ? (0, ruleConditions_1.decodeMetafieldRuleOptionValue)(encodedRule) : undefined;
+            const condition = resolveMetafieldConditionValue(item);
+            const effectiveRelation = asString(decodedRule === null || decodedRule === void 0 ? void 0 : decodedRule.defaultRelation);
+            if (!decodedRule || !effectiveRelation || condition === undefined) {
+                return undefined;
+            }
+            return {
+                column: decodedRule.ruleType,
+                relation: effectiveRelation,
+                condition,
+                conditionObjectId: decodedRule.definitionId,
+            };
+        }
+        const column = asString(item.nativeRuleType);
+        const condition = asString(item.nativeValue);
+        if (!column || !nativeRelation || condition === undefined) {
+            return undefined;
+        }
+        const parsedRule = {
+            column,
+            relation: nativeRelation,
+            condition,
+        };
+        return parsedRule;
+    })
+        .filter((item) => item !== undefined);
+    return rules.length > 0 ? rules : undefined;
+}
+function parseValidations(value) {
+    if (!isObject(value) || !Array.isArray(value.items)) {
+        return undefined;
+    }
+    const validations = value.items
+        .filter(isObject)
+        .map((item) => {
+        const name = asString(item.name);
+        const validationValue = asString(item.value);
+        if (!name || validationValue === undefined) {
+            return undefined;
+        }
+        return {
+            name,
+            value: validationValue,
+        };
+    })
+        .filter((validation) => validation !== undefined);
+    return validations.length > 0 ? validations : undefined;
+}
+function parseMetaobjectFieldInputs(value) {
+    if (!isObject(value) || !Array.isArray(value.items)) {
+        return undefined;
+    }
+    const fields = value.items
+        .filter(isObject)
+        .map((item) => {
+        const key = asString(item.key);
+        const fieldValue = asString(item.value);
+        if (!key || fieldValue === undefined) {
+            return undefined;
+        }
+        return {
+            key,
+            value: fieldValue,
+        };
+    })
+        .filter((field) => field !== undefined);
+    return fields.length > 0 ? fields : undefined;
+}
+function parseUserErrors(data, path) {
+    const payload = getPathValue(data, path);
+    if (!isObject(payload) || !Array.isArray(payload.userErrors)) {
+        return [];
+    }
+    return payload.userErrors
+        .filter(isObject)
+        .map((item) => {
+        var _a, _b;
+        return ({
+            field: Array.isArray(item.field)
+                ? item.field.filter((fieldPart) => typeof fieldPart === 'string')
+                : null,
+            message: String((_a = item.message) !== null && _a !== void 0 ? _a : 'Unknown Shopify user error'),
+            code: (_b = asString(item.code)) !== null && _b !== void 0 ? _b : null,
+        });
+    });
+}
+function withId(idFieldName, input, parameters) {
+    const id = asString(parameters[idFieldName]);
+    if (!id) {
+        return input;
+    }
+    return {
+        ...input,
+        id,
+    };
+}
+const operationRegistry = {
+    'product.create': {
+        document: product_1.PRODUCT_CREATE_MUTATION,
+        buildVariables: (parameters) => ({
+            product: {
+                title: asString(parameters.title),
+                handle: asString(parameters.handle),
+                descriptionHtml: asString(parameters.descriptionHtml),
+                seo: parseSeoInput(parameters),
+                templateSuffix: asString(parameters.templateSuffix),
+                vendor: asString(parameters.vendor),
+                productType: asString(parameters.productType),
+                status: asString(parameters.status),
+                tags: parseTags(parameters.tags),
+            },
+        }),
+        mapSimplified: (data) => mapSingleNode(data, ['productCreate', 'product']),
+        getUserErrors: (data) => parseUserErrors(data, ['productCreate']),
+    },
+    'product.get': {
+        document: product_1.PRODUCT_GET_QUERY,
+        buildVariables: (parameters) => ({
+            id: asString(parameters.productId),
+            ...getMetafieldReadVariables(parameters),
+        }),
+        mapSimplified: (data) => mapSingleNode(data, ['product']),
+    },
+    'product.getMany': {
+        document: product_1.PRODUCT_GET_MANY_QUERY,
+        buildVariables: (parameters) => ({
+            ...getConnectionVariables(parameters),
+            ...getMetafieldReadVariables(parameters),
+        }),
+        mapSimplified: (data) => mapNodesFromConnection(data, ['products']),
+        pagination: {
+            connectionPath: ['products'],
+        },
+    },
+    'product.update': {
+        document: product_1.PRODUCT_UPDATE_MUTATION,
+        buildVariables: (parameters) => ({
+            product: withId('productId', {
+                title: asString(parameters.title),
+                handle: asString(parameters.handle),
+                descriptionHtml: asString(parameters.descriptionHtml),
+                seo: parseSeoInput(parameters),
+                templateSuffix: asString(parameters.templateSuffix),
+                vendor: asString(parameters.vendor),
+                productType: asString(parameters.productType),
+                status: asString(parameters.status),
+                tags: parseTags(parameters.tags),
+            }, parameters),
+        }),
+        mapSimplified: (data) => mapSingleNode(data, ['productUpdate', 'product']),
+        getUserErrors: (data) => parseUserErrors(data, ['productUpdate']),
+    },
+    'product.delete': {
+        document: product_1.PRODUCT_DELETE_MUTATION,
+        buildVariables: (parameters) => ({
+            input: {
+                id: asString(parameters.productId),
+            },
+        }),
+        mapSimplified: (data) => mapMutationPayload(data, ['productDelete']),
+        getUserErrors: (data) => parseUserErrors(data, ['productDelete']),
+    },
+    'productVariant.create': {
+        document: productVariant_1.PRODUCT_VARIANT_CREATE_MUTATION,
+        buildVariables: (parameters) => {
+            var _a, _b;
+            return ({
+                productId: asString(parameters.productId),
+                variants: [
+                    {
+                        title: asString(parameters.title),
+                        sku: asString(parameters.sku),
+                        barcode: asString(parameters.barcode),
+                        price: (_a = asNumber(parameters.price)) === null || _a === void 0 ? void 0 : _a.toString(),
+                        compareAtPrice: (_b = asNumber(parameters.compareAtPrice)) === null || _b === void 0 ? void 0 : _b.toString(),
+                        taxable: asBoolean(parameters.taxable),
+                    },
+                ],
+            });
+        },
+        mapSimplified: (data) => { var _a; return (_a = getPathValue(data, ['productVariantsBulkCreate', 'productVariants'])) !== null && _a !== void 0 ? _a : []; },
+        getUserErrors: (data) => parseUserErrors(data, ['productVariantsBulkCreate']),
+    },
+    'productVariant.get': {
+        document: productVariant_1.PRODUCT_VARIANT_GET_QUERY,
+        buildVariables: (parameters) => ({
+            id: asString(parameters.variantId),
+            ...getMetafieldReadVariables(parameters),
+        }),
+        mapSimplified: (data) => mapSingleNode(data, ['productVariant']),
+    },
+    'productVariant.getMany': {
+        document: productVariant_1.PRODUCT_VARIANT_GET_MANY_QUERY,
+        buildVariables: (parameters) => ({
+            ...getConnectionVariables(parameters),
+            ...getMetafieldReadVariables(parameters),
+        }),
+        mapSimplified: (data) => mapNodesFromConnection(data, ['productVariants']),
+        pagination: {
+            connectionPath: ['productVariants'],
+        },
+    },
+    'productVariant.update': {
+        document: productVariant_1.PRODUCT_VARIANT_UPDATE_MUTATION,
+        buildVariables: (parameters) => {
+            var _a, _b;
+            return ({
+                productId: asString(parameters.productId),
+                variants: [
+                    {
+                        id: asString(parameters.variantId),
+                        title: asString(parameters.title),
+                        sku: asString(parameters.sku),
+                        barcode: asString(parameters.barcode),
+                        price: (_a = asNumber(parameters.price)) === null || _a === void 0 ? void 0 : _a.toString(),
+                        compareAtPrice: (_b = asNumber(parameters.compareAtPrice)) === null || _b === void 0 ? void 0 : _b.toString(),
+                        taxable: asBoolean(parameters.taxable),
+                    },
+                ],
+            });
+        },
+        mapSimplified: (data) => { var _a; return (_a = getPathValue(data, ['productVariantsBulkUpdate', 'productVariants'])) !== null && _a !== void 0 ? _a : []; },
+        getUserErrors: (data) => parseUserErrors(data, ['productVariantsBulkUpdate']),
+    },
+    'productVariant.delete': {
+        document: productVariant_1.PRODUCT_VARIANT_DELETE_MUTATION,
+        buildVariables: (parameters) => ({
+            productId: asString(parameters.productId),
+            variantsIds: [asString(parameters.variantId)].filter((item) => typeof item === 'string'),
+        }),
+        mapSimplified: (data) => mapMutationPayload(data, ['productVariantsBulkDelete']),
+        getUserErrors: (data) => parseUserErrors(data, ['productVariantsBulkDelete']),
+    },
+    'collection.create': {
+        document: collection_1.COLLECTION_CREATE_MUTATION,
+        buildVariables: (parameters) => {
+            var _a, _b;
+            const collectionType = (_a = asString(parameters.collectionType)) !== null && _a !== void 0 ? _a : 'manual';
+            const products = parseCollectionProductIds(parameters.manualProducts);
+            const rules = parseCollectionRules(parameters.collectionRules);
+            const ruleSet = collectionType === 'smart' && rules
+                ? {
+                    appliedDisjunctively: ((_b = asString(parameters.smartRuleMatchMode)) !== null && _b !== void 0 ? _b : 'all') === 'any',
+                    rules,
+                }
+                : undefined;
+            return {
+                input: {
+                    title: asString(parameters.title),
+                    handle: asString(parameters.handle),
+                    descriptionHtml: asString(parameters.descriptionHtml),
+                    seo: parseSeoInput(parameters),
+                    templateSuffix: asString(parameters.templateSuffix),
+                    products: collectionType === 'manual' ? products : undefined,
+                    ruleSet,
+                },
+            };
+        },
+        mapSimplified: (data) => mapSingleNode(data, ['collectionCreate', 'collection']),
+        getUserErrors: (data) => parseUserErrors(data, ['collectionCreate']),
+    },
+    'collection.get': {
+        document: collection_1.COLLECTION_GET_QUERY,
+        buildVariables: (parameters) => ({
+            id: asString(parameters.collectionId),
+            ...getMetafieldReadVariables(parameters),
+        }),
+        mapSimplified: (data) => mapSingleNode(data, ['collection']),
+    },
+    'collection.getMany': {
+        document: collection_1.COLLECTION_GET_MANY_QUERY,
+        buildVariables: (parameters) => ({
+            ...getConnectionVariables(parameters),
+            ...getMetafieldReadVariables(parameters),
+        }),
+        mapSimplified: (data) => mapNodesFromConnection(data, ['collections']),
+        pagination: {
+            connectionPath: ['collections'],
+        },
+    },
+    'collection.update': {
+        document: collection_1.COLLECTION_UPDATE_MUTATION,
+        buildVariables: (parameters) => ({
+            input: withId('collectionId', {
+                title: asString(parameters.title),
+                handle: asString(parameters.handle),
+                descriptionHtml: asString(parameters.descriptionHtml),
+                seo: parseSeoInput(parameters),
+                templateSuffix: asString(parameters.templateSuffix),
+            }, parameters),
+        }),
+        mapSimplified: (data) => mapSingleNode(data, ['collectionUpdate', 'collection']),
+        getUserErrors: (data) => parseUserErrors(data, ['collectionUpdate']),
+    },
+    'collection.delete': {
+        document: collection_1.COLLECTION_DELETE_MUTATION,
+        buildVariables: (parameters) => ({
+            input: {
+                id: asString(parameters.collectionId),
+            },
+        }),
+        mapSimplified: (data) => mapMutationPayload(data, ['collectionDelete']),
+        getUserErrors: (data) => parseUserErrors(data, ['collectionDelete']),
+    },
+    'customer.create': {
+        document: customer_1.CUSTOMER_CREATE_MUTATION,
+        buildVariables: (parameters) => ({
+            input: {
+                email: asString(parameters.email),
+                phone: asString(parameters.phone),
+                firstName: asString(parameters.firstName),
+                lastName: asString(parameters.lastName),
+                note: asString(parameters.note),
+                taxExempt: asBoolean(parameters.taxExempt),
+                tags: parseTags(parameters.tags),
+            },
+        }),
+        mapSimplified: (data) => mapSingleNode(data, ['customerCreate', 'customer']),
+        getUserErrors: (data) => parseUserErrors(data, ['customerCreate']),
+    },
+    'customer.get': {
+        document: customer_1.CUSTOMER_GET_QUERY,
+        buildVariables: (parameters) => ({
+            id: asString(parameters.customerId),
+            ...getMetafieldReadVariables(parameters),
+        }),
+        mapSimplified: (data) => mapSingleNode(data, ['customer']),
+    },
+    'customer.getMany': {
+        document: customer_1.CUSTOMER_GET_MANY_QUERY,
+        buildVariables: (parameters) => ({
+            ...getConnectionVariables(parameters),
+            ...getMetafieldReadVariables(parameters),
+        }),
+        mapSimplified: (data) => mapNodesFromConnection(data, ['customers']),
+        pagination: {
+            connectionPath: ['customers'],
+        },
+    },
+    'customer.update': {
+        document: customer_1.CUSTOMER_UPDATE_MUTATION,
+        buildVariables: (parameters) => ({
+            input: withId('customerId', {
+                email: asString(parameters.email),
+                phone: asString(parameters.phone),
+                firstName: asString(parameters.firstName),
+                lastName: asString(parameters.lastName),
+                note: asString(parameters.note),
+                taxExempt: asBoolean(parameters.taxExempt),
+                tags: parseTags(parameters.tags),
+            }, parameters),
+        }),
+        mapSimplified: (data) => mapSingleNode(data, ['customerUpdate', 'customer']),
+        getUserErrors: (data) => parseUserErrors(data, ['customerUpdate']),
+    },
+    'customer.delete': {
+        document: customer_1.CUSTOMER_DELETE_MUTATION,
+        buildVariables: (parameters) => ({
+            input: {
+                id: asString(parameters.customerId),
+            },
+        }),
+        mapSimplified: (data) => mapMutationPayload(data, ['customerDelete']),
+        getUserErrors: (data) => parseUserErrors(data, ['customerDelete']),
+    },
+    'order.create': {
+        document: order_1.ORDER_CREATE_MUTATION,
+        buildVariables: (parameters) => ({
+            order: {
+                email: asString(parameters.email),
+                note: asString(parameters.note),
+                tags: parseTags(parameters.tags),
+                lineItems: parseLineItems(parameters.lineItems),
+            },
+        }),
+        mapSimplified: (data) => mapSingleNode(data, ['orderCreate', 'order']),
+        getUserErrors: (data) => parseUserErrors(data, ['orderCreate']),
+    },
+    'order.get': {
+        document: order_1.ORDER_GET_QUERY,
+        buildVariables: (parameters) => ({
+            id: asString(parameters.orderId),
+            ...getMetafieldReadVariables(parameters),
+        }),
+        mapSimplified: (data) => mapSingleNode(data, ['order']),
+    },
+    'order.getMany': {
+        document: order_1.ORDER_GET_MANY_QUERY,
+        buildVariables: (parameters) => ({
+            ...getConnectionVariables(parameters),
+            ...getMetafieldReadVariables(parameters),
+        }),
+        mapSimplified: (data) => mapNodesFromConnection(data, ['orders']),
+        pagination: {
+            connectionPath: ['orders'],
+        },
+    },
+    'order.update': {
+        document: order_1.ORDER_UPDATE_MUTATION,
+        buildVariables: (parameters) => ({
+            input: {
+                id: asString(parameters.orderId),
+                email: asString(parameters.email),
+                note: asString(parameters.note),
+                tags: parseTags(parameters.tags),
+            },
+        }),
+        mapSimplified: (data) => mapSingleNode(data, ['orderUpdate', 'order']),
+        getUserErrors: (data) => parseUserErrors(data, ['orderUpdate']),
+    },
+    'order.delete': {
+        document: order_1.ORDER_DELETE_MUTATION,
+        buildVariables: (parameters) => ({
+            orderId: asString(parameters.orderId),
+        }),
+        mapSimplified: (data) => mapMutationPayload(data, ['orderDelete']),
+        getUserErrors: (data) => parseUserErrors(data, ['orderDelete']),
+    },
+    'draftOrder.create': {
+        document: draftOrder_1.DRAFT_ORDER_CREATE_MUTATION,
+        buildVariables: (parameters) => ({
+            input: {
+                email: asString(parameters.email),
+                note: asString(parameters.note),
+                tags: parseTags(parameters.tags),
+                lineItems: parseLineItems(parameters.lineItems),
+            },
+        }),
+        mapSimplified: (data) => mapSingleNode(data, ['draftOrderCreate', 'draftOrder']),
+        getUserErrors: (data) => parseUserErrors(data, ['draftOrderCreate']),
+    },
+    'draftOrder.get': {
+        document: draftOrder_1.DRAFT_ORDER_GET_QUERY,
+        buildVariables: (parameters) => ({
+            id: asString(parameters.draftOrderId),
+            ...getMetafieldReadVariables(parameters),
+        }),
+        mapSimplified: (data) => mapSingleNode(data, ['draftOrder']),
+    },
+    'draftOrder.getMany': {
+        document: draftOrder_1.DRAFT_ORDER_GET_MANY_QUERY,
+        buildVariables: (parameters) => ({
+            ...getConnectionVariables(parameters),
+            ...getMetafieldReadVariables(parameters),
+        }),
+        mapSimplified: (data) => mapNodesFromConnection(data, ['draftOrders']),
+        pagination: {
+            connectionPath: ['draftOrders'],
+        },
+    },
+    'draftOrder.update': {
+        document: draftOrder_1.DRAFT_ORDER_UPDATE_MUTATION,
+        buildVariables: (parameters) => ({
+            id: asString(parameters.draftOrderId),
+            input: {
+                email: asString(parameters.email),
+                note: asString(parameters.note),
+                tags: parseTags(parameters.tags),
+                lineItems: parseLineItems(parameters.lineItems),
+            },
+        }),
+        mapSimplified: (data) => mapSingleNode(data, ['draftOrderUpdate', 'draftOrder']),
+        getUserErrors: (data) => parseUserErrors(data, ['draftOrderUpdate']),
+    },
+    'draftOrder.delete': {
+        document: draftOrder_1.DRAFT_ORDER_DELETE_MUTATION,
+        buildVariables: (parameters) => ({
+            input: {
+                id: asString(parameters.draftOrderId),
+            },
+        }),
+        mapSimplified: (data) => mapMutationPayload(data, ['draftOrderDelete']),
+        getUserErrors: (data) => parseUserErrors(data, ['draftOrderDelete']),
+    },
+    'metaobject.create': {
+        document: metaobject_1.METAOBJECT_CREATE_MUTATION,
+        buildVariables: (parameters) => ({
+            metaobject: {
+                type: asString(parameters.metaobjectType),
+                handle: asString(parameters.handle),
+                fields: parseMetaobjectFieldInputs(parameters.metaobjectFields),
+            },
+        }),
+        mapSimplified: (data) => mapSingleNode(data, ['metaobjectCreate', 'metaobject']),
+        getUserErrors: (data) => parseUserErrors(data, ['metaobjectCreate']),
+    },
+    'metaobject.get': {
+        document: metaobject_1.METAOBJECT_GET_QUERY,
+        buildVariables: (parameters) => ({
+            id: asString(parameters.metaobjectId),
+        }),
+        mapSimplified: (data) => mapSingleNode(data, ['metaobject']),
+    },
+    'metaobject.getMany': {
+        document: metaobject_1.METAOBJECT_GET_MANY_QUERY,
+        buildVariables: (parameters) => ({
+            type: asString(parameters.metaobjectType),
+            ...getConnectionVariables(parameters),
+        }),
+        mapSimplified: (data) => mapNodesFromConnection(data, ['metaobjects']),
+        pagination: {
+            connectionPath: ['metaobjects'],
+        },
+    },
+    'metaobject.update': {
+        document: metaobject_1.METAOBJECT_UPDATE_MUTATION,
+        buildVariables: (parameters) => ({
+            id: asString(parameters.metaobjectId),
+            metaobject: {
+                handle: asString(parameters.handle),
+                fields: parseMetaobjectFieldInputs(parameters.metaobjectFields),
+                redirectNewHandle: isObject(parameters.metaobjectOptions)
+                    ? asBoolean(parameters.metaobjectOptions.redirectNewHandle)
+                    : undefined,
+            },
+        }),
+        mapSimplified: (data) => mapSingleNode(data, ['metaobjectUpdate', 'metaobject']),
+        getUserErrors: (data) => parseUserErrors(data, ['metaobjectUpdate']),
+    },
+    'metaobject.delete': {
+        document: metaobject_1.METAOBJECT_DELETE_MUTATION,
+        buildVariables: (parameters) => ({
+            id: asString(parameters.metaobjectId),
+        }),
+        mapSimplified: (data) => mapMutationPayload(data, ['metaobjectDelete']),
+        getUserErrors: (data) => parseUserErrors(data, ['metaobjectDelete']),
+    },
+    'metafieldValue.set': {
+        document: metafields_1.METAFIELD_SET_MUTATION,
+        buildVariables: (parameters) => ({
+            metafields: Array.isArray(parameters.metafieldsPayload)
+                ? parameters.metafieldsPayload
+                : [],
+        }),
+        mapSimplified: (data) => normalizeMetafieldArray(getPathValue(data, ['metafieldsSet', 'metafields'])),
+        getUserErrors: (data) => parseUserErrors(data, ['metafieldsSet']),
+    },
+    'metafieldValue.get': {
+        document: metafields_1.METAFIELD_GET_QUERY,
+        buildVariables: (parameters) => ({
+            ownerId: asString(parameters.ownerId),
+            namespace: asString(parameters.namespace),
+            key: asString(parameters.key),
+        }),
+        mapSimplified: (data) => {
+            var _a;
+            const nodes = getPathValue(data, ['nodes']);
+            if (!Array.isArray(nodes) || nodes.length === 0 || !isObject(nodes[0])) {
+                return undefined;
+            }
+            const node = nodes[0];
+            const metafield = (_a = node.metafield) !== null && _a !== void 0 ? _a : undefined;
+            return metafield ? normalizeMetafieldNode(metafield) : undefined;
+        },
+    },
+    'metafieldValue.getMany': {
+        document: metafields_1.METAFIELD_GET_MANY_QUERY,
+        buildVariables: (parameters) => {
+            var _a;
+            return ({
+                ownerId: asString(parameters.ownerId),
+                namespace: asString(parameters.namespace),
+                first: Math.max(1, Math.trunc((_a = asNumber(parameters.limit)) !== null && _a !== void 0 ? _a : 50)),
+                after: asString(parameters.afterCursor),
+            });
+        },
+        mapSimplified: (data) => {
+            const nodes = getPathValue(data, ['nodes']);
+            if (!Array.isArray(nodes) || nodes.length === 0 || !isObject(nodes[0])) {
+                return [];
+            }
+            const ownerNode = nodes[0];
+            const metafieldsConnection = ownerNode.metafields;
+            if (!isObject(metafieldsConnection) || !Array.isArray(metafieldsConnection.nodes)) {
+                return [];
+            }
+            return normalizeMetafieldArray(metafieldsConnection.nodes);
+        },
+        pagination: {
+            connectionPath: ['nodes', '0', 'metafields'],
+        },
+    },
+    'metafieldValue.delete': {
+        document: metafields_1.METAFIELD_DELETE_MUTATION,
+        buildVariables: (parameters) => ({
+            metafields: Array.isArray(parameters.metafieldsPayload)
+                ? parameters.metafieldsPayload
+                : [],
+        }),
+        mapSimplified: (data) => { var _a; return (_a = getPathValue(data, ['metafieldsDelete', 'deletedMetafields'])) !== null && _a !== void 0 ? _a : []; },
+        getUserErrors: (data) => parseUserErrors(data, ['metafieldsDelete']),
+    },
+    'metafieldDefinition.list': {
+        document: metafields_1.METAFIELD_DEFINITION_LIST_QUERY,
+        buildVariables: (parameters) => {
+            var _a;
+            return ({
+                ownerType: asString(parameters.ownerType),
+                query: asString(parameters.query),
+                first: Math.max(1, Math.trunc((_a = asNumber(parameters.limit)) !== null && _a !== void 0 ? _a : 50)),
+                after: asString(parameters.afterCursor),
+            });
+        },
+        mapSimplified: (data) => mapNodesFromConnection(data, ['metafieldDefinitions']),
+        pagination: {
+            connectionPath: ['metafieldDefinitions'],
+        },
+    },
+    'metafieldDefinition.get': {
+        document: metafields_1.METAFIELD_DEFINITION_GET_QUERY,
+        buildVariables: (parameters) => ({
+            id: asString(parameters.definitionId),
+        }),
+        mapSimplified: (data) => mapSingleNode(data, ['node']),
+    },
+    'metafieldDefinition.create': {
+        document: metafields_1.METAFIELD_DEFINITION_CREATE_MUTATION,
+        buildVariables: (parameters) => ({
+            definition: {
+                ownerType: asString(parameters.ownerType),
+                name: asString(parameters.name),
+                namespace: asString(parameters.namespace),
+                key: asString(parameters.key),
+                type: asString(parameters.definitionType),
+                description: asString(parameters.description),
+                validations: parseValidations(parameters.validations),
+            },
+        }),
+        mapSimplified: (data) => mapSingleNode(data, ['metafieldDefinitionCreate', 'createdDefinition']),
+        getUserErrors: (data) => parseUserErrors(data, ['metafieldDefinitionCreate']),
+    },
+    'metafieldDefinition.update': {
+        document: metafields_1.METAFIELD_DEFINITION_UPDATE_MUTATION,
+        buildVariables: (parameters) => ({
+            definition: {
+                id: asString(parameters.definitionId),
+                name: asString(parameters.name),
+                description: asString(parameters.description),
+                validations: parseValidations(parameters.validations),
+            },
+        }),
+        mapSimplified: (data) => mapSingleNode(data, ['metafieldDefinitionUpdate', 'updatedDefinition']),
+        getUserErrors: (data) => parseUserErrors(data, ['metafieldDefinitionUpdate']),
+    },
+    'metafieldDefinition.delete': {
+        document: metafields_1.METAFIELD_DEFINITION_DELETE_MUTATION,
+        buildVariables: (parameters) => ({
+            id: asString(parameters.definitionId),
+            deleteAllAssociatedMetafields: asBoolean(parameters.deleteAllAssociatedMetafields),
+        }),
+        mapSimplified: (data) => mapMutationPayload(data, ['metafieldDefinitionDelete']),
+        getUserErrors: (data) => parseUserErrors(data, ['metafieldDefinitionDelete']),
+    },
+    'service.listDefinitionTypes': {
+        document: metafields_1.METAFIELD_DEFINITION_TYPES_QUERY,
+        buildVariables: () => ({}),
+        mapSimplified: (data) => { var _a; return (_a = getPathValue(data, ['metafieldDefinitionTypes'])) !== null && _a !== void 0 ? _a : []; },
+    },
+};
+function getRegistryOperation(operationKey) {
+    return operationRegistry[operationKey];
+}
+//# sourceMappingURL=registry.js.map