@takeshape/schema 11.52.0 → 11.56.1

package/dist/cjs/src/types/utils.js

@@ -1,344 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getRefType = exports.getArgsType = exports.aiResolverNames = void 0;
-exports.isBasicResolver = isBasicResolver;
-exports.isServiceResolver = isServiceResolver;
-exports.isComposeResolver = isComposeResolver;
-exports.isTakeshapeResolver = isTakeshapeResolver;
-exports.isShapedbResolver = isShapedbResolver;
-exports.isGraphqlResolver = isGraphqlResolver;
-exports.isRestResolver = isRestResolver;
-exports.isAwsLambdaResolver = isAwsLambdaResolver;
-exports.isUtilResolver = isUtilResolver;
-exports.isAIResolverName = isAIResolverName;
-exports.isAIResolver = isAIResolver;
-exports.isAIAgentStateExecution = isAIAgentStateExecution;
-exports.isProjectSchemaWithServices = isProjectSchemaWithServices;
-exports.containsResolver = containsResolver;
-exports.isDirectiveMappingMap = isDirectiveMappingMap;
-exports.isDirectiveMappingArray = isDirectiveMappingArray;
-exports.isDirectiveConfig = isDirectiveConfig;
-exports.isParameterSerializeContentOptions = isParameterSerializeContentOptions;
-exports.isParameterOp = isParameterOp;
-exports.isParameterOpNested = isParameterOpNested;
-exports.isParameterOpMapping = isParameterOpMapping;
-exports.isParameterOpValue = isParameterOpValue;
-exports.isParameterOpOp = isParameterOpOp;
-exports.isParameterSerializeStyleForSearchParams = isParameterSerializeStyleForSearchParams;
-exports.isParameterSerializeStyleForPathParams = isParameterSerializeStyleForPathParams;
-exports.isParameterSerializeStyleOptions = isParameterSerializeStyleOptions;
-exports.isRefSchema = isRefSchema;
-exports.isRefSchemaLegacy = isRefSchemaLegacy;
-exports.isAllOfSchema = isAllOfSchema;
-exports.isExtendsSchema = isExtendsSchema;
-exports.isOneOfSchema = isOneOfSchema;
-exports.isEnumSchema = isEnumSchema;
-exports.isArraySchema = isArraySchema;
-exports.isReturnShapeArraySchema = isReturnShapeArraySchema;
-exports.isObjectSchema = isObjectSchema;
-exports.isAnyServiceConfig = isAnyServiceConfig;
-exports.isGraphQLServiceConfig = isGraphQLServiceConfig;
-exports.isRESTServiceConfig = isRESTServiceConfig;
-exports.isOpenAPIServiceConfig = isOpenAPIServiceConfig;
-exports.isShopifyServiceConfig = isShopifyServiceConfig;
-exports.isEncryptedServiceConfig = isEncryptedServiceConfig;
-exports.isServiceConfigWithOAuth2Authentication = isServiceConfigWithOAuth2Authentication;
-exports.isServiceConfigWithCustomAuthentication = isServiceConfigWithCustomAuthentication;
-exports.isServiceAuthentication = isServiceAuthentication;
-exports.isBearerAuthentication = isBearerAuthentication;
-exports.isBasicAuthentication = isBasicAuthentication;
-exports.isSearchParamsAuthentication = isSearchParamsAuthentication;
-exports.isOAuth2Authentication = isOAuth2Authentication;
-exports.isOAuth2BearerAuthentication = isOAuth2BearerAuthentication;
-exports.isGoogleAuthentication = isGoogleAuthentication;
-exports.isCustomAuthentication = isCustomAuthentication;
-exports.isPropertySchemaWithRelationship = isPropertySchemaWithRelationship;
-exports.isModelShape = isModelShape;
-exports.isCachedShape = isCachedShape;
-exports.listCachedShapes = listCachedShapes;
-exports.getCachedShapeMap = getCachedShapeMap;
-exports.isMeshShape = isMeshShape;
-const util_1 = require("@takeshape/util");
-const has_js_1 = __importDefault(require("lodash/has.js"));
-const isArray_js_1 = __importDefault(require("lodash/isArray.js"));
-const isPlainObject_js_1 = __importDefault(require("lodash/isPlainObject.js"));
-const isString_js_1 = __importDefault(require("lodash/isString.js"));
-const isUndefined_js_1 = __importDefault(require("lodash/isUndefined.js"));
-const schemas_1 = require("../schemas");
-const types_1 = require("./types");
-/** 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, util_1.isRecord)(resolver) && (0, isString_js_1.default)(resolver.name);
-}
-function isServiceResolver(resolver) {
-    return (0, util_1.isRecord)(resolver) && (0, isString_js_1.default)(resolver.name) && (0, isString_js_1.default)(resolver.service);
-}
-function isComposeResolver(resolver) {
-    return Boolean((0, isArray_js_1.default)(resolver?.compose) &&
-        resolver.compose.length &&
-        resolver.compose.every(isBasicResolver));
-}
-const { definitions: { takeshapeResolver, shapedbResolver, utilResolver, graphqlResolver, restResolver, awsLambdaResolver } } = schemas_1.latestSchemaJson;
-function isTakeshapeResolver(resolver) {
-    return isBasicResolver(resolver) && takeshapeResolver.properties.name.enum.includes(resolver.name);
-}
-function isShapedbResolver(resolver) {
-    return isBasicResolver(resolver) && shapedbResolver.properties.name.enum.includes(resolver.name);
-}
-function isGraphqlResolver(resolver) {
-    return isBasicResolver(resolver) && graphqlResolver.properties.name.enum.includes(resolver.name);
-}
-function isRestResolver(resolver) {
-    return isBasicResolver(resolver) && restResolver.properties.name.enum.includes(resolver.name);
-}
-function isAwsLambdaResolver(resolver) {
-    return isBasicResolver(resolver) && awsLambdaResolver.properties.name.enum.includes(resolver.name);
-}
-function isUtilResolver(resolver) {
-    return isBasicResolver(resolver) && utilResolver.properties.name.enum.includes(resolver.name);
-}
-exports.aiResolverNames = ['ai:generateText', 'ai:chat'];
-function isAIResolverName(name) {
-    return name ? exports.aiResolverNames.includes(name) : false;
-}
-function isAIResolver(resolver) {
-    return isBasicResolver(resolver) && isAIResolverName(resolver.name);
-}
-function isAIAgentStateExecution(agentExecution) {
-    return agentExecution.type === 'generate' || agentExecution.type === 'chat';
-}
-function isProjectSchemaWithServices(schema) {
-    return !(0, isUndefined_js_1.default)(schema.services);
-}
-function containsResolver(resolver, predicate) {
-    if (isBasicResolver(resolver)) {
-        return predicate(resolver);
-    }
-    return Boolean(resolver.compose.find((resolver) => containsResolver(resolver, predicate)));
-}
-/** 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;
-}
-/**
- * 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]);
-}
-/**
- * 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]);
-}
-/**
- * Determine whether a ParameterSerializeOption is a content type serializer
- */
-function isParameterSerializeContentOptions(maybeContent) {
-    return Boolean(maybeContent.contentType);
-}
-/**
- * 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);
-}
-/**
- * Determine whether a `ParameterOp` is a `ParameterOpNested`
- */
-function isParameterOpNested(maybeOp) {
-    return Boolean(maybeOp.ops);
-}
-/**
- * Determine whether a `ParameterOp` is a `ParameterOpMapping`
- */
-function isParameterOpMapping(maybeOp) {
-    return Boolean(maybeOp.mapping);
-}
-/**
- * Determine whether a `ParameterOp` is a `ParameterOpValue`
- */
-function isParameterOpValue(maybeOp) {
-    return Boolean(maybeOp.value);
-}
-/**
- * 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));
-}
-const { definitions: { parameterSerializeStyleOptionsForSearchParams, parameterSerializeStyleOptionsForPathParams } } = schemas_1.latestSchemaJson;
-function isParameterSerializeStyleForSearchParams(maybeParam) {
-    return Boolean(maybeParam && parameterSerializeStyleOptionsForSearchParams.properties.style.enum.includes(maybeParam));
-}
-function isParameterSerializeStyleForPathParams(maybeParam) {
-    return Boolean(maybeParam && parameterSerializeStyleOptionsForPathParams.properties.style.enum.includes(maybeParam));
-}
-/**
- * Determine whether a ParameterSerializeOption is a style serializer
- */
-function isParameterSerializeStyleOptions(maybeStyle) {
-    return Boolean(maybeStyle.style);
-}
-/** Typeguards for different types of shape schemas **/
-function isRefSchema(propertySchema) {
-    return (0, isString_js_1.default)(propertySchema['@ref']) || (0, isString_js_1.default)(propertySchema.$ref);
-}
-function isRefSchemaLegacy(propertySchema) {
-    return (0, isString_js_1.default)(propertySchema.$ref);
-}
-function isAllOfSchema(propertySchema) {
-    return (0, isArray_js_1.default)(propertySchema.allOf);
-}
-function isExtendsSchema(propertySchema) {
-    return (0, util_1.isRecord)(propertySchema) && (0, isArray_js_1.default)(propertySchema.extends);
-}
-function isOneOfSchema(propertySchema) {
-    return (0, isArray_js_1.default)(propertySchema.oneOf);
-}
-function isEnumSchema(obj) {
-    return (0, isArray_js_1.default)(obj.enum);
-}
-function isArraySchema(propertySchema) {
-    return propertySchema.type === 'array' && (0, util_1.isRecord)(propertySchema.items);
-}
-function isReturnShapeArraySchema(returnShape) {
-    return typeof returnShape === 'object' && returnShape.type === 'array';
-}
-function isObjectSchema(propertySchema) {
-    return (0, util_1.isRecord)(propertySchema) && propertySchema.type === 'object' && (0, util_1.isRecord)(propertySchema.properties);
-}
-/** Service Config Utils **/
-/**
- * Test all required props, currently:
- * "name", "slug", "provider", "serviceType", "authenticationType"
- */
-function isAnyServiceConfig(maybeConfig) {
-    return (maybeConfig &&
-        (0, isString_js_1.default)(maybeConfig.title) &&
-        (0, isString_js_1.default)(maybeConfig.id) &&
-        (0, isString_js_1.default)(maybeConfig.provider) &&
-        (0, isString_js_1.default)(maybeConfig.serviceType) &&
-        (0, isString_js_1.default)(maybeConfig.authenticationType));
-}
-function isGraphQLServiceConfig(maybeConfig) {
-    return (isAnyServiceConfig(maybeConfig) && maybeConfig.serviceType === 'graphql' && (0, isString_js_1.default)(maybeConfig.options?.endpoint));
-}
-function isRESTServiceConfig(maybeConfig) {
-    return isAnyServiceConfig(maybeConfig) && maybeConfig.serviceType === 'rest';
-}
-function isOpenAPIServiceConfig(maybeConfig) {
-    return isAnyServiceConfig(maybeConfig) && maybeConfig.serviceType === 'openapi';
-}
-function isShopifyServiceConfig(maybeShopify) {
-    return maybeShopify.provider === 'shopify';
-}
-function isEncryptedServiceConfig(maybeConfig) {
-    return isAnyServiceConfig(maybeConfig) && (0, isString_js_1.default)(maybeConfig.authentication);
-}
-function isServiceConfigWithOAuth2Authentication(maybeServiceConfig) {
-    return (isAnyServiceConfig(maybeServiceConfig) &&
-        isServiceAuthentication(maybeServiceConfig.authentication) &&
-        isOAuth2Authentication(maybeServiceConfig.authentication));
-}
-function isServiceConfigWithCustomAuthentication(maybeServiceConfig) {
-    return (isAnyServiceConfig(maybeServiceConfig) &&
-        isServiceAuthentication(maybeServiceConfig.authentication) &&
-        isCustomAuthentication(maybeServiceConfig.authentication));
-}
-/** Authentication Utils **/
-function isServiceAuthentication(maybeAuthentication) {
-    return maybeAuthentication?.type;
-}
-function isBearerAuthentication(authentication) {
-    return authentication?.type === 'bearer';
-}
-function isBasicAuthentication(authentication) {
-    return authentication?.type === 'basic';
-}
-function isSearchParamsAuthentication(authentication) {
-    return authentication?.type === 'searchParams';
-}
-function isOAuth2Authentication(authentication) {
-    return authentication?.type === 'oauth2';
-}
-function isOAuth2BearerAuthentication(authentication) {
-    return authentication?.type === 'oauth2Bearer';
-}
-function isGoogleAuthentication(authentication) {
-    return authentication?.type === 'google';
-}
-function isCustomAuthentication(authentication) {
-    return authentication?.type === 'custom';
-}
-/** Miscellaneous Utils **/
-/**
- * A utility to return the type of args present on a schema.
- *
- * @param argsSchema Any schema that may have an `args` property.
- */
-const getArgsType = (argsSchema) => {
-    if ((0, has_js_1.default)(argsSchema, '@args')) {
-        return types_1.ArgsType['@args'];
-    }
-    if ((0, has_js_1.default)(argsSchema, 'args')) {
-        return types_1.ArgsType.args;
-    }
-};
-exports.getArgsType = getArgsType;
-/**
- * A utility to return the type of ref present on a schema.
- *
- * @param refSchema Any schema that may have a `ref` property.
- */
-const getRefType = (refSchema) => {
-    if ((0, has_js_1.default)(refSchema, '@ref')) {
-        return types_1.RefType['@ref'];
-    }
-    if ((0, has_js_1.default)(refSchema, '$ref')) {
-        return types_1.RefType.$ref;
-    }
-};
-exports.getRefType = getRefType;
-function isPropertySchemaWithRelationship(schema) {
-    return schema['@resolver']?.name === 'shapedb:getRelated';
-}
-function isModelShape(shape) {
-    return Boolean(shape.model);
-}
-function isCachedShape(shape) {
-    return shape.cache?.enabled === true && shape.loaders !== undefined;
-}
-function listCachedShapes(shapes) {
-    return Object.values(shapes).filter(isCachedShape);
-}
-function getCachedShapeMap(shapes) {
-    const results = {};
-    for (const shape of Object.values(shapes)) {
-        if (isCachedShape(shape)) {
-            results[shape.name] = shape;
-        }
-    }
-    return results;
-}
-function isMeshShape(shape) {
-    return Boolean(shape.joins);
-}

package/dist/cjs/src/unions.js

@@ -1,88 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createWrapTransform = exports.createUnwrapTransform = void 0;
-exports.enumerateOneOfKeys = enumerateOneOfKeys;
-exports.isUnionSchema = isUnionSchema;
-exports.oneOfToObject = oneOfToObject;
-const errors_1 = require("@takeshape/errors");
-const util_1 = require("@takeshape/util");
-const omit_js_1 = __importDefault(require("lodash/omit.js"));
-const refs_1 = require("./refs");
-const names_1 = require("./template-shapes/names");
-const utils_1 = require("./types/utils");
-const shapes_1 = require("./util/shapes");
-function enumerateOneOfKeys(projectSchema, oneOf) {
-    const result = [];
-    for (const child of oneOf) {
-        const refItem = (0, refs_1.getRef)(projectSchema, child);
-        if (refItem) {
-            const shapeName = (0, refs_1.refItemToNamespacedShapeName)(refItem);
-            if (projectSchema.shapes[shapeName]) {
-                const shapeId = projectSchema.shapes[shapeName].id;
-                result.push({
-                    propName: (0, names_1.getOutputShapeName)((0, util_1.camelCase)(refItem.typeName)),
-                    propSchema: child,
-                    shapeName,
-                    shapeId
-                });
-            }
-        }
-    }
-    return result;
-}
-function getOneOf(schema) {
-    if (!schema.oneOf) {
-        throw new Error(`Expected ${JSON.stringify(schema)} to be a oneOf schema`);
-    }
-    return schema.oneOf;
-}
-function isUnionSchema(schema) {
-    return Boolean(schema.oneOf?.every(utils_1.isRefSchema));
-}
-function oneOfToObject(projectSchema, schema) {
-    const properties = {};
-    for (const { propName, propSchema: child } of enumerateOneOfKeys(projectSchema, getOneOf(schema))) {
-        properties[propName] = child;
-    }
-    return { ...(0, omit_js_1.default)(schema, 'oneOf'), type: 'object', properties };
-}
-function formatKeys(keys) {
-    return keys.map((k) => `"${k}"`).join(', ');
-}
-const createUnwrapTransform = (projectSchema) => (obj, schema, name, shape, next) => {
-    if ((0, util_1.isRecord)(obj)) {
-        const oneOfKeys = enumerateOneOfKeys(projectSchema, getOneOf(schema));
-        const objectKeys = Object.keys(obj);
-        if (objectKeys.length !== 1) {
-            const propNames = oneOfKeys.map((k) => k.propName);
-            throw new errors_1.BadDataError(`Object should only specify one of the following keys: ${formatKeys(propNames)}, but found keys: ${formatKeys(objectKeys)}`);
-        }
-        for (const { propName, shapeId, propSchema } of oneOfKeys) {
-            const propValue = obj[propName];
-            if ((0, util_1.isRecord)(propValue)) {
-                const transformedPropValue = next(propValue, propSchema, name);
-                if ((0, util_1.isRecord)(transformedPropValue)) {
-                    return {
-                        ...transformedPropValue,
-                        _shapeId: shapeId
-                    };
-                }
-            }
-        }
-    }
-};
-exports.createUnwrapTransform = createUnwrapTransform;
-const createWrapTransform = (projectSchema) => (obj, schema, name, shape, next) => {
-    if ((0, util_1.isRecord)(obj) && typeof obj._shapeId === 'string') {
-        const shape = (0, shapes_1.getShapeById)(projectSchema, obj._shapeId);
-        if (shape) {
-            return {
-                [(0, util_1.camelCase)(shape.name)]: next((0, omit_js_1.default)(obj, '_shapeId'), shape.schema, name)
-            };
-        }
-    }
-};
-exports.createWrapTransform = createWrapTransform;

package/dist/cjs/src/user-schema.js

@@ -1,8 +0,0 @@
-"use strict";
-/* tslint:disable */
-/**
- * This file was automatically generated by json-schema-to-typescript.
- * DO NOT MODIFY IT BY HAND. Instead, modify the source JSONSchema file,
- * and run json-schema-to-typescript to regenerate this file.
- */
-Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/src/util/ai-tools.js

@@ -1,10 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getToolRef = getToolRef;
-exports.normalizeToolConfig = normalizeToolConfig;
-function getToolRef(tool) {
-    return typeof tool === 'string' ? tool : tool.ref;
-}
-function normalizeToolConfig(tool) {
-    return typeof tool === 'string' ? { ref: tool } : tool;
-}

package/dist/cjs/src/util/api-indexing.js

@@ -1,62 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getGetQueryIndexConfig = exports.getListQueryIndexConfigs = void 0;
-exports.serviceHasIndexedShapes = serviceHasIndexedShapes;
-exports.getIndexedServices = getIndexedServices;
-const util_1 = require("@takeshape/util");
-const refs_1 = require("../refs");
-const schema_util_1 = require("../schema-util");
-const util_2 = require("../services/util");
-const types_1 = require("../types");
-function serviceHasIndexedShapes(schema, serviceId) {
-    for (const shape of Object.values(schema.shapes ?? {})) {
-        const indexingEnabled = (0, types_1.isCachedShape)(shape);
-        const listConfigs = shape.loaders?.list;
-        if (indexingEnabled && listConfigs) {
-            for (const { query: queryRef } of (0, util_1.ensureArray)(listConfigs)) {
-                const resolved = (0, refs_1.getQuery)(schema, queryRef);
-                if (resolved && (0, types_1.isServiceResolver)(resolved.query.resolver) && resolved.query.resolver.service === serviceId) {
-                    return true;
-                }
-            }
-        }
-    }
-    return false;
-}
-function getIndexedServices(projectSchema, configs) {
-    return (0, util_1.ensureArray)(configs).reduce((services, queryConfig) => {
-        const resolved = queryConfig?.query ? (0, refs_1.getQuery)(projectSchema, queryConfig.query) : undefined;
-        return resolved?.query ? [...services, ...(0, util_2.getResolverServices)(resolved.query.resolver)] : services;
-    }, []);
-}
-function flattenListQueryConfigs(base, queryConfig, maybeConfigArray) {
-    return (maybeConfigArray &&
-        (0, util_1.ensureArray)(maybeConfigArray).flatMap((config) => (0, util_1.ensureArray)(config.args).map((args) => ({
-            ...base,
-            ...queryConfig,
-            ...config,
-            args
-        }))));
-}
-function getQueryIndexConfigHelper(op) {
-    return ({ shapes }, shapeName) => {
-        const { cache, loaders } = shapes[shapeName] ?? {};
-        if (cache && loaders) {
-            const idField = (0, schema_util_1.getIdField)(cache);
-            if (op === 'list') {
-                return flattenListQueryConfigs({ shapeName, idField }, cache.fragment, loaders.list);
-            }
-            const queryConfig = loaders.get;
-            if (queryConfig) {
-                return {
-                    idField,
-                    shapeName,
-                    ...cache.fragment,
-                    ...queryConfig
-                };
-            }
-        }
-    };
-}
-exports.getListQueryIndexConfigs = getQueryIndexConfigHelper('list');
-exports.getGetQueryIndexConfig = getQueryIndexConfigHelper('get');

package/dist/cjs/src/util/detect-cycles.js

@@ -1,48 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.hasCycle = hasCycle;
-const util_1 = require("@takeshape/util");
-const refs_1 = require("../refs");
-function immutableSetAdd(set, str) {
-    const result = new Set(set);
-    result.add(str);
-    return result;
-}
-/**
- * Use a basic depth-first search to determine whether a schema contains a cycle
- */
-function hasCycle(projectSchema, schema, predicate = (0, util_1.value)(true)) {
-    const hasCycleHelper = (schema, shapesSeen = new Set(), shapeName, propName) => {
-        if (!predicate(projectSchema, schema, shapeName, propName)) {
-            return false;
-        }
-        const refItem = (0, refs_1.getRef)(projectSchema, schema);
-        if (refItem) {
-            const refShape = (0, refs_1.refItemToShape)(projectSchema, refItem);
-            // If we have a refItem, but no shape, this is a dangling ref and has no cycles
-            if (!refShape) {
-                return false;
-            }
-            if (shapesSeen.has(refShape.name)) {
-                return true;
-            }
-            return hasCycleHelper(refShape.schema, immutableSetAdd(shapesSeen, refShape.name), refShape.name);
-        }
-        const combo = schema.oneOf ?? schema.allOf ?? schema.extends;
-        if (combo) {
-            return combo.some((childSchema) => hasCycleHelper(childSchema, shapesSeen, shapeName, propName));
-        }
-        if (schema.items) {
-            return hasCycleHelper(schema.items, shapesSeen, shapeName, propName);
-        }
-        const { properties } = schema;
-        if (properties) {
-            return Object.keys(properties).some((name) => {
-                const propSchema = properties[name];
-                return hasCycleHelper(propSchema, shapesSeen, shapeName, name);
-            });
-        }
-        return false;
-    };
-    return hasCycleHelper(schema);
-}

package/dist/cjs/src/util/find-shape-at-path.js

@@ -1,57 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.findSchemaAtPath = findSchemaAtPath;
-exports.findShapeAtPath = findShapeAtPath;
-const refs_1 = require("../refs");
-const types_1 = require("../types");
-/**
- *
- * @param projectSchema
- * @param schema
- * @param queryPath
- *
- * @example
- * findShapeAtPath(projectSchema, projectSchema.shapes.Shopify_ProductConnection.shape, ['edges', 'node']) // finds {'@ref': Shopify_Product}
- */
-function findSchemaAtPath(projectSchema, schema, queryPath) {
-    if (queryPath.length === 0) {
-        return schema;
-    }
-    const [prop, ...rest] = queryPath;
-    if ((0, types_1.isRefSchema)(schema)) {
-        const ref = (0, refs_1.getRef)(projectSchema, schema);
-        if (ref) {
-            const shapeSchema = (0, refs_1.refItemToShapeSchema)(projectSchema, ref);
-            if (shapeSchema) {
-                return findSchemaAtPath(projectSchema, shapeSchema, queryPath);
-            }
-        }
-        return undefined;
-    }
-    if ((0, types_1.isArraySchema)(schema)) {
-        return findSchemaAtPath(projectSchema, schema.items, queryPath);
-    }
-    if ((0, types_1.isObjectSchema)(schema)) {
-        const propSchema = schema.properties[prop];
-        if (propSchema) {
-            return findSchemaAtPath(projectSchema, propSchema, rest);
-        }
-    }
-    return undefined;
-}
-/**
- *
- * @param projectSchema
- * @param propSchema
- * @param queryPath
- *
- * @example
- * findShapeAtPath(projectSchema, projectSchema.shapes.Shopify_ProductConnection.shape, ['edges', 'node']) // finds Shopify_Product
- */
-function findShapeAtPath(projectSchema, propSchema, queryPath) {
-    const result = findSchemaAtPath(projectSchema, propSchema, queryPath);
-    if (result) {
-        const refItem = (0, refs_1.getRef)(projectSchema, result.items ?? result);
-        return refItem && (0, refs_1.refItemToShape)(projectSchema, refItem);
-    }
-}

package/dist/cjs/src/util/form-config.js

@@ -1,66 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.normalizeForms = normalizeForms;
-exports.findShapeFormConfig = findShapeFormConfig;
-const util_1 = require("@takeshape/util");
-const refs_1 = require("../refs");
-const schema_util_1 = require("../schema-util");
-/**
- * If there any non-normal (nested) forms in the schema, create forms for referenced shapes.
- * The original forms are left intact.
- */
-function normalizeForms(projectSchema) {
-    const normalizedForms = {};
-    const { forms = {} } = projectSchema;
-    const storeSourceForm = (shapeName, formConfig, propName) => {
-        // Leave original forms intact for backwards compatibility
-        if (!forms[shapeName]) {
-            normalizedForms[shapeName] ||= { default: (0, util_1.deepClone)(formConfig) };
-            // Remove prop now that it has been normalized
-            delete normalizedForms[shapeName].default.properties[propName];
-        }
-    };
-    const normalizeNested = (shapeName, formConfig) => {
-        const shape = projectSchema.shapes[shapeName];
-        if (!shape || !formConfig.properties) {
-            return;
-        }
-        const propertyAccessor = (0, schema_util_1.createSchemaPropertyAccessor)(projectSchema, shape);
-        for (const propName of Object.keys(formConfig.properties)) {
-            const propConfig = formConfig.properties[propName];
-            const propSchema = propertyAccessor.getValue(propName);
-            if (propSchema) {
-                const ref = (0, refs_1.getRefOrItemsRef)(projectSchema, propSchema);
-                if (ref && propConfig.properties) {
-                    const nestedShapeName = (0, refs_1.refItemToNamespacedShapeName)(ref);
-                    normalizedForms[nestedShapeName] = { default: (0, util_1.deepClone)(propConfig) };
-                    storeSourceForm(shapeName, formConfig, propName);
-                    normalizeNested(nestedShapeName, propConfig);
-                }
-            }
-        }
-    };
-    if (forms) {
-        for (const shapeName of Object.keys(forms)) {
-            normalizeNested(shapeName, forms[shapeName].default);
-            // copy forms with no changes
-            normalizedForms[shapeName] ||= forms[shapeName];
-        }
-    }
-    return normalizedForms;
-}
-const cache = new WeakMap();
-/**
- * Find the form config for a given shape name and the form key.
- */
-function findShapeFormConfig(projectSchema, shapeName, formName) {
-    if (!projectSchema.forms) {
-        return;
-    }
-    let normalizedForms = cache.get(projectSchema);
-    if (!normalizedForms) {
-        normalizedForms = normalizeForms(projectSchema);
-        cache.set(projectSchema, normalizedForms);
-    }
-    return normalizedForms[shapeName]?.[formName];
-}