@takeshape/schema 11.40.0 → 11.40.3

package/dist/cjs/src/layers/layers.js

@@ -0,0 +1,308 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.flattenSchema = exports.collectReferencedShapeNames = exports.getAllRefs = exports.getAllRefsInQueries = exports.getAllRefsInQuery = exports.getAllRefsInShapes = exports.isObjectSchemaV4_0_0 = void 0;
+const minimatch_1 = __importDefault(require("minimatch"));
+const util_1 = require("@takeshape/util");
+const uniq_js_1 = __importDefault(require("lodash/uniq.js"));
+const set_js_1 = __importDefault(require("lodash/set.js"));
+const refs_1 = require("../refs");
+const refs_2 = require("./refs");
+const type_utils_1 = require("./type-utils");
+const visitor_1 = require("./visitor");
+const layerDefaults = {
+    namespace: '',
+    visibility: []
+};
+function filterMap(prefix, fields, filters) {
+    const result = {};
+    for (const [name, value] of Object.entries(fields)) {
+        for (const filter of filters) {
+            if ((0, minimatch_1.default)(`${prefix}.${name}`, filter)) {
+                result[name] = value;
+            }
+        }
+    }
+    return result;
+}
+function filterLayer(layerSchema, filters) {
+    return {
+        ...layerSchema,
+        queries: filterMap('queries', layerSchema.queries ?? {}, filters),
+        mutations: filterMap('mutations', layerSchema.mutations ?? {}, filters),
+        shapes: filterMap('shapes', layerSchema.shapes ?? {}, filters),
+        workflows: filterMap('workflows', layerSchema.workflows ?? {}, filters)
+    };
+}
+// TODO use non-versioned util eventually
+function isObjectSchemaV4_0_0(maybeObjectSchema) {
+    return maybeObjectSchema.type === 'object' && (0, util_1.isRecord)(maybeObjectSchema.properties);
+}
+exports.isObjectSchemaV4_0_0 = isObjectSchemaV4_0_0;
+function mergeShape(a, b) {
+    if (b.override === 'extend') {
+        if (isObjectSchemaV4_0_0(a.schema) && isObjectSchemaV4_0_0(b.schema)) {
+            const combinedRequired = (0, uniq_js_1.default)((a.schema.required ?? []).concat(b.schema.required ?? []));
+            const combinedSchema = {
+                type: 'object',
+                properties: {
+                    ...a.schema.properties,
+                    ...b.schema.properties
+                }
+            };
+            if (combinedRequired.length) {
+                combinedSchema.required = combinedRequired;
+            }
+            return { ...a, ...b, schema: combinedSchema };
+        }
+    }
+    return b;
+}
+function assignShapes(flattenedShapes, layerShapes) {
+    for (const [shapeName, shape] of Object.entries(layerShapes)) {
+        flattenedShapes[shapeName] = flattenedShapes[shapeName] ? mergeShape(flattenedShapes[shapeName], shape) : shape;
+    }
+}
+function addRef(refs, ref, predicate) {
+    if (ref && (!predicate || predicate(ref))) {
+        refs.push(ref);
+    }
+}
+/**
+ * Walk through a `ProjectSchema` and collect all the `ref`s.
+ */
+function getAllRefsInShapes(shapes, predicate) {
+    const items = [];
+    const shapeVisitor = (schema, schemaPath) => {
+        if (schema['@args'] && typeof schema['@args'] === 'object') {
+            (0, visitor_1.visitSchemaProperties)(schema['@args'], schemaPath.concat(['@args']), (argSchema, argPath) => {
+                addRef(items, (0, refs_2.getRefOrItemsRef)(argSchema, argPath), predicate);
+            });
+        }
+        addRef(items, (0, refs_2.getArgsReferenceWithPath)(schema, schemaPath), predicate);
+        const newPath = schema.items ? schemaPath.concat('items') : schemaPath;
+        const newSchema = schema.items ?? schema;
+        if ((0, type_utils_1.isRefSchema)(newSchema)) {
+            addRef(items, (0, refs_2.getRefOrItemsRef)(newSchema, newPath), predicate);
+        }
+        else if ((0, type_utils_1.isObjectSchema)(newSchema) || (0, type_utils_1.isAllOfSchema)(newSchema) || (0, type_utils_1.isOneOfSchema)(newSchema)) {
+            (0, visitor_1.visitSchemaProperties)(newSchema, newPath, shapeVisitor);
+        }
+    };
+    for (const [shapeName, shape] of Object.entries(shapes)) {
+        (0, visitor_1.visitSchemaProperties)(shape.schema, ['shapes', shapeName, 'schema'], shapeVisitor);
+    }
+    return items;
+}
+exports.getAllRefsInShapes = getAllRefsInShapes;
+/**
+ * Get all refs
+ */
+function getAllRefsInQuery(shapes, queryPath, query, predicate) {
+    const refItems = [];
+    const propertyVisitor = (propSchema, propSchemaPath) => {
+        addRef(refItems, (0, refs_2.getRefOrItemsRef)(propSchema, propSchemaPath), predicate);
+    };
+    if (query.args && typeof query.args === 'string') {
+        addRef(refItems, (0, refs_2.getArgsReferenceWithPath)(query, queryPath), predicate);
+    }
+    if (query.args && typeof query.args === 'object') {
+        (0, visitor_1.visitSchemaProperties)((0, refs_2.dereferenceSchema)(shapes, query.args), queryPath, propertyVisitor);
+    }
+    if (query.shape) {
+        const refItem = (0, refs_2.parseReturnShape)(query.shape).ref;
+        if (refItem) {
+            addRef(refItems, {
+                ...refItem,
+                path: queryPath.concat(['shape'])
+            }, predicate);
+        }
+    }
+    return refItems;
+}
+exports.getAllRefsInQuery = getAllRefsInQuery;
+/**
+ * Collect refs from `queries` or `mutations`.
+ */
+function getAllRefsInQueries(context, rootPropertyName, predicate) {
+    const refItems = [];
+    const rootPath = [rootPropertyName];
+    for (const [queryName, query] of Object.entries(context[rootPropertyName])) {
+        const queryPath = rootPath.concat([queryName]);
+        const queryRefs = getAllRefsInQuery(context.shapes, queryPath, query, predicate);
+        if (queryRefs.length) {
+            refItems.push(...queryRefs);
+        }
+    }
+    return refItems;
+}
+exports.getAllRefsInQueries = getAllRefsInQueries;
+/**
+ * Get all refs in a ProjectSchema
+ * @param predicate return true to include the ref in
+ */
+function getAllRefs(projectSchema, predicate) {
+    return [
+        ...getAllRefsInShapes(projectSchema.shapes, predicate),
+        ...getAllRefsInQueries(projectSchema, 'queries', predicate),
+        ...getAllRefsInQueries(projectSchema, 'mutations', predicate)
+    ];
+}
+exports.getAllRefs = getAllRefs;
+function collectReferencedShapeNames(layerId, refSet) {
+    const addLayerId = (ref) => ({ ...ref, layerId });
+    const collect = (schema) => {
+        const args = schema['@args'];
+        if (args && typeof args === 'object') {
+            Object.values(args.properties).forEach(collect);
+        }
+        const argsRefItem = (0, refs_2.getArgsReferenceWithPath)(schema);
+        if (argsRefItem) {
+            refSet.add((0, refs_2.refItemToString)(addLayerId(argsRefItem)));
+        }
+        const refItem = (0, refs_2.getRefOrItemsRef)(schema);
+        if (refItem) {
+            refSet.add((0, refs_2.refItemToString)(addLayerId(refItem)));
+        }
+    };
+    return collect;
+}
+exports.collectReferencedShapeNames = collectReferencedShapeNames;
+function collectServiceRefs(flattenedSchema, getLayer) {
+    const refs = new Set(getAllRefs(flattenedSchema, refItem => refItem.layerId !== 'local').map(refs_2.refItemToString));
+    if (refs.size) {
+        for (const ref of refs) {
+            const [layerId, shapeName] = (0, refs_2.splitAtRef)(ref);
+            if (layerId !== 'local') {
+                const layer = getLayer(layerId);
+                const shape = layer?.shapes?.[shapeName];
+                if (shape) {
+                    (0, visitor_1.visitSchemaProperties)(shape.schema, ['schema'], collectReferencedShapeNames(layerId, refs));
+                }
+            }
+        }
+    }
+    return refs;
+}
+function ensureServiceLayer(flattenedSchema, layerId) {
+    flattenedSchema.serviceLayers ||= {};
+    let serviceLayer = flattenedSchema.serviceLayers[layerId];
+    if (!serviceLayer) {
+        serviceLayer = { layerId, schemaVersion: '4.0.0', shapes: {}, queries: {}, mutations: {} };
+        flattenedSchema.serviceLayers[layerId] = serviceLayer;
+    }
+    return serviceLayer;
+}
+function rewriteLayerId(localShapes, layerId, query) {
+    const newQuery = (0, util_1.deepClone)(query);
+    const propertyVisitor = (propSchema, propSchemaPath) => {
+        const ref = (propSchema.items ?? propSchema)['@ref'];
+        if (ref) {
+            const [argsLayerId, shapeName] = (0, refs_2.splitAtRef)(ref);
+            if (argsLayerId === 'local' && !localShapes[shapeName]) {
+                const path = propSchemaPath.concat(propSchema.items ? ['items', '@ref'] : ['@ref']);
+                (0, set_js_1.default)(newQuery, path, `${layerId}:${shapeName}`);
+            }
+        }
+    };
+    if (query.args) {
+        if (typeof query.args === 'string') {
+            const [argsLayerId, shapeName] = (0, refs_2.splitAtRef)((0, refs_1.parseTemplateShape)(query.args).shapeName);
+            if (argsLayerId === 'local' && !localShapes[shapeName]) {
+                newQuery.args = `${layerId}:${shapeName}`;
+            }
+        }
+        else {
+            (0, visitor_1.visitSchemaProperties)(query.args, ['args'], propertyVisitor);
+        }
+    }
+    if (typeof query.shape === 'string') {
+        const [argsLayerId, shapeName] = (0, refs_2.splitAtRef)((0, refs_1.parseTemplateShape)(query.shape).shapeName);
+        if (argsLayerId === 'local' && !localShapes[shapeName]) {
+            newQuery.shape = `${layerId}:${shapeName}`;
+        }
+    }
+    else {
+        const ref = query.shape.items['@ref'];
+        if (ref) {
+            const [argsLayerId, shapeName] = (0, refs_2.splitAtRef)(ref);
+            if (argsLayerId === 'local' && !localShapes[shapeName]) {
+                (0, set_js_1.default)(newQuery, ['shape', 'items', '@ref'], `${layerId}:${shapeName}`);
+            }
+        }
+    }
+    return newQuery;
+}
+function assignQueries(localShapes, queries, layerId, layerQueries) {
+    for (const [queryName, query] of Object.entries(layerQueries)) {
+        queries[queryName] = rewriteLayerId(localShapes, layerId, query);
+    }
+}
+function flattenSchema(projectSchema, getLayer) {
+    const { layers, ...rest } = projectSchema;
+    const flattenedSchema = {
+        ...rest,
+        shapes: {},
+        queries: {},
+        mutations: {},
+        workflows: {},
+        forms: {}
+    };
+    const filteredLayers = layers
+        .reverse()
+        .map(layer => {
+        const config = typeof layer === 'string' ? { ...layerDefaults, id: layer } : layer;
+        const layerSchema = getLayer(config.id);
+        if (!layerSchema) {
+            throw new Error(`Unable to flatten schema for project ${projectSchema.projectId}. Cannot get layer ${config.id}`);
+        }
+        return config.visibility?.length ? filterLayer(layerSchema, config.visibility) : undefined;
+    })
+        .filter(util_1.isDefined);
+    for (const filteredLayer of filteredLayers) {
+        const { layerId } = filteredLayer;
+        // Preserve original queries
+        if (projectSchema.services?.[layerId]) {
+            const serviceLayer = ensureServiceLayer(flattenedSchema, layerId);
+            if (serviceLayer.queries && filteredLayer.queries) {
+                Object.assign(serviceLayer.queries, filteredLayer.queries);
+            }
+            if (serviceLayer.mutations && filteredLayer.mutations) {
+                Object.assign(serviceLayer.mutations, filteredLayer.mutations);
+            }
+        }
+        if (filteredLayer.workflows) {
+            Object.assign(flattenedSchema.workflows, filteredLayer.workflows);
+        }
+        if (flattenedSchema.forms && filteredLayer.forms) {
+            Object.assign(flattenedSchema.forms, filteredLayer.forms);
+        }
+        if (filteredLayer.shapes) {
+            assignShapes(flattenedSchema.shapes, filteredLayer.shapes);
+        }
+    }
+    for (const filteredLayer of filteredLayers) {
+        if (filteredLayer.queries) {
+            assignQueries(flattenedSchema.shapes, flattenedSchema.queries, filteredLayer.layerId, filteredLayer.queries);
+        }
+        if (filteredLayer.mutations) {
+            assignQueries(flattenedSchema.shapes, flattenedSchema.mutations, filteredLayer.layerId, filteredLayer.mutations);
+        }
+    }
+    // Preserve original service schema shapes
+    for (const refStr of collectServiceRefs(flattenedSchema, getLayer)) {
+        const [layerId, shapeName] = (0, refs_2.splitAtRef)(refStr);
+        if (layerId !== 'local') {
+            const shape = getLayer(layerId)?.shapes?.[shapeName];
+            if (shape) {
+                const serviceLayer = ensureServiceLayer(flattenedSchema, layerId);
+                serviceLayer.shapes ||= {};
+                serviceLayer.shapes[shapeName] = shape;
+            }
+        }
+    }
+    return flattenedSchema;
+}
+exports.flattenSchema = flattenSchema;

package/dist/cjs/src/layers/refs.js

@@ -0,0 +1,243 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseReturnShape = exports.dereferenceSchema = exports.getArgsReferenceWithPath = exports.hasResolvableRef = exports.hasRef = exports.followRef = exports.omitRefAndExtend = exports.refItemToShape = exports.refItemToString = exports.getRefOrItemsRef = exports.hasRefProperty = exports.getRefWithPath = exports.getRef = exports.atRefToRefItem = exports.splitAtRef = exports.refExpressionToShape = exports.refExpressionToRefItem = void 0;
+const assign_js_1 = __importDefault(require("lodash/fp/assign.js"));
+const omit_js_1 = __importDefault(require("lodash/fp/omit.js"));
+const util_1 = require("@takeshape/util");
+const isEmpty_js_1 = __importDefault(require("lodash/isEmpty.js"));
+const refs_1 = require("../refs");
+const type_utils_1 = require("./type-utils");
+/**
+ * Safely turn a "template" shape reference (`@args`, `args`, `shape`) into a `RefItem`
+ *
+ * @param context A partial project schema
+ * @param refExpression
+ * A ref expression might include "template" name and refer to a local or remote
+ * shape, `Foo` or `CreateArgs<Foo>` or `CreateArgs<remote:Foo>`.*
+ */
+function refExpressionToRefItem(refExpression) {
+    const { shapeName, template } = (0, refs_1.parseTemplateShape)(refExpression);
+    return atRefToRefItem(shapeName, template);
+}
+exports.refExpressionToRefItem = refExpressionToRefItem;
+/**
+ * Sugar for converting a `refExpression` directly into a shape, without the
+ * intermediate `refItem`.
+ *
+ * @param context A partial project schema
+ * @param refExpression
+ * A ref expression might include "template" name and refer to a local or remote
+ * shape, `Foo` or `CreateArgs<Foo>` or `CreateArgs<remote:Foo>`.
+ */
+function refExpressionToShape(shapes, refExpression) {
+    return refItemToShape(shapes, refExpressionToRefItem(refExpression));
+}
+exports.refExpressionToShape = refExpressionToShape;
+/**
+ * Provided a service name and a referenced type. Supports 2 or 3 part
+ * references, e.g., `shopify:my-store:ProductInput` or `my-store:ProductInput`.
+ *
+ * @returns
+ * A 2 member array, where 0 is the service name, 1 is the referenced type.
+ */
+function splitAtRef(atRef) {
+    const refParts = atRef.split(':');
+    if (refParts.length === 1) {
+        return ['local', atRef];
+    }
+    if (refParts.length === 2) {
+        return [refParts[0], refParts[1]];
+    }
+    throw new Error(`Invalid ref string ${atRef}`);
+}
+exports.splitAtRef = splitAtRef;
+/**
+ * Parses and returns a typeName, serviceKey, and potentially a namespace for
+ * the type.
+ */
+function atRefToRefItem(atRef, template) {
+    const [serviceKey, typeName] = splitAtRef(atRef);
+    return {
+        typeName,
+        layerId: serviceKey,
+        template
+    };
+}
+exports.atRefToRefItem = atRefToRefItem;
+/**
+ * Given a content schema and project schema, finds a `@ref` or `$ref` and
+ * returns a `RefItem` suitable for loading a referenced schema...
+ */
+function getRef(refSchema) {
+    if (refSchema['@ref']) {
+        // @ref: my-service:ShapeName
+        return atRefToRefItem(refSchema['@ref']);
+    }
+}
+exports.getRef = getRef;
+function getRefWithPath(refSchema, schemaPath = []) {
+    const refItem = getRef(refSchema);
+    if (refItem) {
+        return {
+            ...refItem,
+            path: schemaPath.concat(['@ref'])
+        };
+    }
+}
+exports.getRefWithPath = getRefWithPath;
+/**
+ * Tests for a `@ref` or `$ref` property directly on the passed schema.
+ *
+ * @param schema Any schema that might could have a ref property.
+ */
+function hasRefProperty(schema) {
+    return Boolean(schema['@ref'] ?? schema.$ref);
+}
+exports.hasRefProperty = hasRefProperty;
+/**
+ * From a schema with a ref, will return the top-level ref, and potentially
+ * a ref item from a nested `items` property.
+ */
+function getRefOrItemsRef(refSchema, schemaPath = []) {
+    const refItem = getRefWithPath(refSchema, schemaPath);
+    if (refItem) {
+        return refItem;
+    }
+    if (refSchema.items) {
+        return getRefOrItemsRef(refSchema.items, schemaPath.concat(['items']));
+    }
+}
+exports.getRefOrItemsRef = getRefOrItemsRef;
+/**
+ * Turns a `RefItem` into an `@ref`.
+ */
+function refItemToString(refItem) {
+    return `${refItem.layerId}:${refItem.typeName}`;
+}
+exports.refItemToString = refItemToString;
+/**
+ * Get a Shape referenced by a `RefItem`.
+ */
+function refItemToShape(shapes, refItem) {
+    return shapes[refItemToString(refItem)];
+}
+exports.refItemToShape = refItemToShape;
+/**
+ * Helper fn to omit `ref` props from the target schema, and then extend it with the source schema.
+ */
+const omitRefAndExtend = (targetSchema, sourceSchema) => (0, assign_js_1.default)((0, omit_js_1.default)(['@ref', '$ref'], targetSchema), sourceSchema);
+exports.omitRefAndExtend = omitRefAndExtend;
+/**
+ * If there is a $ref, this will insert a content schema from the top level
+ * in place of the reference.
+ */
+function followRef(shapes, contentSchema) {
+    const refItem = getRef(contentSchema);
+    if (refItem) {
+        const referencedSchema = refItemToShape(shapes, refItem)?.schema;
+        if (referencedSchema) {
+            return (0, exports.omitRefAndExtend)(contentSchema, referencedSchema);
+        }
+    }
+    return contentSchema;
+}
+exports.followRef = followRef;
+/**
+ * Returns whether a schema has refs.
+ */
+function hasRef(contentSchema) {
+    if ((0, type_utils_1.isRefSchema)(contentSchema)) {
+        return true;
+    }
+    if ((0, type_utils_1.isAllOfSchema)(contentSchema)) {
+        return Boolean(contentSchema.allOf.find(hasRef));
+    }
+    if ((0, type_utils_1.isOneOfSchema)(contentSchema)) {
+        return Boolean(contentSchema.oneOf.find(hasRef));
+    }
+    return false;
+}
+exports.hasRef = hasRef;
+/**
+ * Returns whether a schema has refs which can be followed.
+ */
+function hasResolvableRef(shapes, contentSchema) {
+    if ((0, type_utils_1.isRefSchema)(contentSchema)) {
+        return Boolean(refItemToShape(shapes, getRef(contentSchema)));
+    }
+    if ((0, type_utils_1.isAllOfSchema)(contentSchema)) {
+        return Boolean(contentSchema.allOf.find(s => hasResolvableRef(shapes, s)));
+    }
+    if ((0, type_utils_1.isOneOfSchema)(contentSchema)) {
+        return Boolean(contentSchema.oneOf.find(s => hasResolvableRef(shapes, s)));
+    }
+    return false;
+}
+exports.hasResolvableRef = hasResolvableRef;
+function getArgsReferenceWithPath(argsSchema, schemaPath = []) {
+    const isQuery = 'args' in argsSchema;
+    const args = isQuery ? argsSchema.args : argsSchema['@args'];
+    const refItem = typeof args === 'string' ? refExpressionToRefItem(args) : undefined;
+    if (refItem) {
+        return {
+            ...refItem,
+            path: schemaPath.concat([isQuery ? 'args' : '@args'])
+        };
+    }
+}
+exports.getArgsReferenceWithPath = getArgsReferenceWithPath;
+/*
+ * Helper fn to omit `allOf` props from the target schema, and then extend it with the source schema.
+ */
+const omitAllOfAndExtend = (targetSchema, sourceSchema) => (0, assign_js_1.default)((0, omit_js_1.default)(['allOf'], targetSchema), sourceSchema);
+function dereferenceSchema(shapes, shapeOrFieldSchema, schemaPath = []) {
+    const resolveAll = (resolveSchema, resolvePath) => {
+        try {
+            if ((0, type_utils_1.isAllOfSchema)(resolveSchema)) {
+                const allOfSchema = resolveSchema.allOf
+                    .map((stub, index) => resolveAll(stub, [...resolvePath, 'allOf', index]))
+                    .reduce((prev, curr) => (0, util_1.mergeWithArrayConcat)(prev, curr), {});
+                return (0, isEmpty_js_1.default)(allOfSchema) ? undefined : omitAllOfAndExtend(resolveSchema, allOfSchema);
+            }
+            if ((0, type_utils_1.isRefSchema)(resolveSchema)) {
+                const refItem = getRefWithPath(resolveSchema);
+                if (!refItem) {
+                    throw new Error('ref could not be parsed');
+                }
+                const refSchema = refItemToShape(shapes, refItem);
+                if (refSchema) {
+                    return resolveAll((0, exports.omitRefAndExtend)(resolveSchema, refSchema), refItem.path);
+                }
+                return;
+            }
+            return resolveSchema;
+        }
+        catch (err) {
+            throw new Error(`error at '${resolvePath.join('.')}', ${err.message}`);
+        }
+    };
+    return resolveAll(shapeOrFieldSchema, schemaPath) ?? shapeOrFieldSchema;
+}
+exports.dereferenceSchema = dereferenceSchema;
+function parseReturnShape(shape) {
+    if (typeof shape === 'object') {
+        if ((0, type_utils_1.isRefSchema)(shape.items)) {
+            const ref = getRef(shape.items);
+            if (!ref) {
+                throw new Error(`Could not parse ${JSON.stringify(shape.items)}: invalid ref`);
+            }
+            return { isArray: true, ref, shapeName: refItemToString(ref) };
+        }
+        if (typeof shape.items.type !== 'string') {
+            throw new Error(`Could not parse ${JSON.stringify(shape.items)}: invalid type`);
+        }
+        return { isArray: true, shapeName: shape.items.type };
+    }
+    const ref = refExpressionToRefItem(shape);
+    const shapeName = refItemToString(ref);
+    return { isArray: false, shapeName, ref, template: ref.template };
+}
+exports.parseReturnShape = parseReturnShape;

package/dist/cjs/src/layers/type-utils.js

@@ -0,0 +1,146 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isObjectSchema = exports.isArraySchema = exports.isOneOfSchema = exports.isAllOfSchema = exports.isRefSchema = exports.isParameterSerializeStyleOptions = exports.isParameterOpOp = exports.isParameterOpValue = exports.isParameterOpMapping = exports.isParameterOpNested = exports.isParameterOp = exports.isParameterSerializeContentOptions = exports.isDirectiveConfig = exports.isDirectiveMappingArray = exports.isDirectiveMappingMap = exports.isUtilResolver = exports.isAwsLambdaResolver = exports.isRestResolver = exports.isGraphqlResolver = exports.isTakeshapeResolver = exports.isComposeResolver = exports.isBasicResolver = void 0;
+const util_1 = require("@takeshape/util");
+const isPlainObject_js_1 = __importDefault(require("lodash/isPlainObject.js"));
+const isString_js_1 = __importDefault(require("lodash/isString.js"));
+const isArray_js_1 = __importDefault(require("lodash/isArray.js"));
+const schemas_1 = require("../schemas");
+/** Resolver Type Utils **/
+/**
+ * Only tests that the shape is right, not that the name is correct. That's a job for the validator.
+ */
+function isBasicResolver(resolver) {
+    return (0, isString_js_1.default)(resolver?.name) && (0, isString_js_1.default)(resolver.service);
+}
+exports.isBasicResolver = isBasicResolver;
+function isComposeResolver(resolver) {
+    return Boolean((0, isArray_js_1.default)(resolver?.compose) &&
+        resolver.compose.length &&
+        resolver.compose.every(isBasicResolver));
+}
+exports.isComposeResolver = isComposeResolver;
+const { definitions: { takeshapeResolver, utilResolver, graphqlResolver, restResolver, awsLambdaResolver } } = schemas_1.latestSchemaJson;
+function isTakeshapeResolver(resolver) {
+    return takeshapeResolver.properties.name.enum.includes(resolver.name);
+}
+exports.isTakeshapeResolver = isTakeshapeResolver;
+function isGraphqlResolver(resolver) {
+    return graphqlResolver.properties.name.enum.includes(resolver.name);
+}
+exports.isGraphqlResolver = isGraphqlResolver;
+function isRestResolver(resolver) {
+    return restResolver.properties.name.enum.includes(resolver.name);
+}
+exports.isRestResolver = isRestResolver;
+function isAwsLambdaResolver(resolver) {
+    return awsLambdaResolver.properties.name.enum.includes(resolver.name);
+}
+exports.isAwsLambdaResolver = isAwsLambdaResolver;
+function isUtilResolver(resolver) {
+    return utilResolver.properties.name.enum.includes(resolver.name);
+}
+exports.isUtilResolver = isUtilResolver;
+/** Directive Mapping Utils **/
+/**
+ * Determine whether the ambiguous Directive structure is a DirectiveMappingMap
+ */
+function isDirectiveMappingMap(maybeMap) {
+    return (0, isPlainObject_js_1.default)(maybeMap) && Object.keys(maybeMap).length > 0;
+}
+exports.isDirectiveMappingMap = isDirectiveMappingMap;
+/**
+ * Determine whether the ambiguous Directive structure is a DirectiveMappingArray
+ */
+function isDirectiveMappingArray(maybeArray) {
+    return (0, isArray_js_1.default)(maybeArray) && (0, isArray_js_1.default)(maybeArray[0]) && (0, isString_js_1.default)(maybeArray[0][0]) && (0, isArray_js_1.default)(maybeArray[0][1]);
+}
+exports.isDirectiveMappingArray = isDirectiveMappingArray;
+/**
+ * Determine whether the ambiguous Directive structure is a DirectiveConfig array
+ */
+function isDirectiveConfig(maybeConfig) {
+    return (0, isArray_js_1.default)(maybeConfig) && (0, isArray_js_1.default)(maybeConfig[0]) && (0, isString_js_1.default)(maybeConfig[0][0]) && (0, util_1.isRecord)(maybeConfig[0][1]);
+}
+exports.isDirectiveConfig = isDirectiveConfig;
+/**
+ * Determine whether a ParameterSerializeOption is a content type serializer
+ */
+function isParameterSerializeContentOptions(maybeContent) {
+    return Boolean('contentType' in maybeContent && maybeContent.contentType);
+}
+exports.isParameterSerializeContentOptions = isParameterSerializeContentOptions;
+/**
+ * Determine whether an unknown variable is a `ParameterOp`
+ */
+function isParameterOp(maybeOp) {
+    const op = maybeOp;
+    if (!op.path) {
+        return false;
+    }
+    return isParameterOpNested(op) || isParameterOpMapping(op) || isParameterOpValue(op) || isParameterOpOp(op);
+}
+exports.isParameterOp = isParameterOp;
+/**
+ * Determine whether a `ParameterOp` is a `ParameterOpNested`
+ */
+function isParameterOpNested(maybeOp) {
+    return Boolean('ops' in maybeOp && maybeOp.ops);
+}
+exports.isParameterOpNested = isParameterOpNested;
+/**
+ * Determine whether a `ParameterOp` is a `ParameterOpMapping`
+ */
+function isParameterOpMapping(maybeOp) {
+    return Boolean('mapping' in maybeOp && maybeOp.mapping);
+}
+exports.isParameterOpMapping = isParameterOpMapping;
+/**
+ * Determine whether a `ParameterOp` is a `ParameterOpMapping`
+ */
+function isParameterOpValue(maybeOp) {
+    return Boolean('value' in maybeOp && maybeOp.value);
+}
+exports.isParameterOpValue = isParameterOpValue;
+/**
+ * Determine whether a `ParameterOp` is a `ParameterOpOp`
+ */
+function isParameterOpOp(maybeOp) {
+    const op = maybeOp;
+    if (!op.op) {
+        return false;
+    }
+    return !(isParameterOpNested(op) || isParameterOpMapping(op) || isParameterOpValue(op));
+}
+exports.isParameterOpOp = isParameterOpOp;
+/**
+ * Determine whether a ParameterSerializeOption is a style serializer
+ */
+function isParameterSerializeStyleOptions(maybeStyle) {
+    return Boolean('style' in maybeStyle && maybeStyle.style);
+}
+exports.isParameterSerializeStyleOptions = isParameterSerializeStyleOptions;
+/** Typeguards for different types of shape schemas **/
+function isRefSchema(maybeRefSchema) {
+    return (0, isString_js_1.default)(maybeRefSchema['@ref']) || (0, isString_js_1.default)(maybeRefSchema.$ref);
+}
+exports.isRefSchema = isRefSchema;
+function isAllOfSchema(schema) {
+    return (0, isArray_js_1.default)(schema.allOf);
+}
+exports.isAllOfSchema = isAllOfSchema;
+function isOneOfSchema(schema) {
+    return (0, isArray_js_1.default)(schema.oneOf);
+}
+exports.isOneOfSchema = isOneOfSchema;
+function isArraySchema(schema) {
+    return schema.type === 'array' && (0, util_1.isRecord)(schema.items);
+}
+exports.isArraySchema = isArraySchema;
+function isObjectSchema(schema) {
+    return schema.type === 'object' && (0, util_1.isRecord)(schema.properties);
+}
+exports.isObjectSchema = isObjectSchema;