@takeshape/schema 11.40.0 → 11.41.0

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

@@ -0,0 +1,345 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isOAuth2BearerAuthentication = exports.isOAuth2Authentication = exports.isSearchParamsAuthentication = exports.isBasicAuthentication = exports.isBearerAuthentication = exports.isServiceAuthentication = exports.isServiceConfigWithCustomAuthentication = exports.isServiceConfigWithOAuth2Authentication = exports.isEncryptedServiceConfig = exports.isShopifyServiceConfig = exports.isOpenAPIServiceConfig = exports.isRESTServiceConfig = exports.isGraphQLServiceConfig = exports.isAnyServiceConfig = exports.isObjectSchema = exports.isReturnShapeArraySchema = exports.isArraySchema = exports.isEnumSchema = exports.isOneOfSchema = exports.isExtendsSchema = exports.isAllOfSchema = exports.isRefSchemaLegacy = exports.isRefSchema = exports.isParameterSerializeStyleOptions = exports.isParameterSerializeStyleForPathParams = exports.isParameterSerializeStyleForSearchParams = exports.isParameterOpOp = exports.isParameterOpValue = exports.isParameterOpMapping = exports.isParameterOpNested = exports.isParameterOp = exports.isParameterSerializeContentOptions = exports.isDirectiveConfig = exports.isDirectiveMappingArray = exports.isDirectiveMappingMap = exports.containsResolver = exports.isProjectSchemaWithServices = exports.isAIAgentStateExecution = exports.isAIResolver = exports.isAIResolverName = exports.aiResolverNames = exports.isUtilResolver = exports.isAwsLambdaResolver = exports.isRestResolver = exports.isGraphqlResolver = exports.isShapedbResolver = exports.isTakeshapeResolver = exports.isComposeResolver = exports.isServiceResolver = exports.isBasicResolver = void 0;
+exports.isMeshShape = exports.getCachedShapeMap = exports.listCachedShapes = exports.isCachedShape = exports.isModelShape = exports.isPropertySchemaWithRelationship = exports.getRefType = exports.getArgsType = exports.isCustomAuthentication = exports.isGoogleAuthentication = 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 has_js_1 = __importDefault(require("lodash/has.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);
+}
+exports.isBasicResolver = isBasicResolver;
+function isServiceResolver(resolver) {
+    return (0, util_1.isRecord)(resolver) && (0, isString_js_1.default)(resolver.name) && (0, isString_js_1.default)(resolver.service);
+}
+exports.isServiceResolver = isServiceResolver;
+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, shapedbResolver, utilResolver, graphqlResolver, restResolver, awsLambdaResolver } } = schemas_1.latestSchemaJson;
+function isTakeshapeResolver(resolver) {
+    return isBasicResolver(resolver) && takeshapeResolver.properties.name.enum.includes(resolver.name);
+}
+exports.isTakeshapeResolver = isTakeshapeResolver;
+function isShapedbResolver(resolver) {
+    return isBasicResolver(resolver) && shapedbResolver.properties.name.enum.includes(resolver.name);
+}
+exports.isShapedbResolver = isShapedbResolver;
+function isGraphqlResolver(resolver) {
+    return isBasicResolver(resolver) && graphqlResolver.properties.name.enum.includes(resolver.name);
+}
+exports.isGraphqlResolver = isGraphqlResolver;
+function isRestResolver(resolver) {
+    return isBasicResolver(resolver) && restResolver.properties.name.enum.includes(resolver.name);
+}
+exports.isRestResolver = isRestResolver;
+function isAwsLambdaResolver(resolver) {
+    return isBasicResolver(resolver) && awsLambdaResolver.properties.name.enum.includes(resolver.name);
+}
+exports.isAwsLambdaResolver = isAwsLambdaResolver;
+function isUtilResolver(resolver) {
+    return isBasicResolver(resolver) && utilResolver.properties.name.enum.includes(resolver.name);
+}
+exports.isUtilResolver = isUtilResolver;
+exports.aiResolverNames = ['ai:generateText', 'ai:chat'];
+function isAIResolverName(name) {
+    return name ? exports.aiResolverNames.includes(name) : false;
+}
+exports.isAIResolverName = isAIResolverName;
+function isAIResolver(resolver) {
+    return isBasicResolver(resolver) && isAIResolverName(resolver.name);
+}
+exports.isAIResolver = isAIResolver;
+function isAIAgentStateExecution(agentExecution) {
+    return agentExecution.type === 'generate' || agentExecution.type === 'chat';
+}
+exports.isAIAgentStateExecution = isAIAgentStateExecution;
+function isProjectSchemaWithServices(schema) {
+    return !(0, isUndefined_js_1.default)(schema.services);
+}
+exports.isProjectSchemaWithServices = isProjectSchemaWithServices;
+function containsResolver(resolver, predicate) {
+    if (isBasicResolver(resolver)) {
+        return predicate(resolver);
+    }
+    return Boolean(resolver.compose.find(resolver => containsResolver(resolver, predicate)));
+}
+exports.containsResolver = containsResolver;
+/** 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(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(maybeOp.ops);
+}
+exports.isParameterOpNested = isParameterOpNested;
+/**
+ * Determine whether a `ParameterOp` is a `ParameterOpMapping`
+ */
+function isParameterOpMapping(maybeOp) {
+    return Boolean(maybeOp.mapping);
+}
+exports.isParameterOpMapping = isParameterOpMapping;
+/**
+ * Determine whether a `ParameterOp` is a `ParameterOpValue`
+ */
+function isParameterOpValue(maybeOp) {
+    return Boolean(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;
+const { definitions: { parameterSerializeStyleOptionsForSearchParams, parameterSerializeStyleOptionsForPathParams } } = schemas_1.latestSchemaJson;
+function isParameterSerializeStyleForSearchParams(maybeParam) {
+    return Boolean(maybeParam && parameterSerializeStyleOptionsForSearchParams.properties.style.enum.includes(maybeParam));
+}
+exports.isParameterSerializeStyleForSearchParams = isParameterSerializeStyleForSearchParams;
+function isParameterSerializeStyleForPathParams(maybeParam) {
+    return Boolean(maybeParam && parameterSerializeStyleOptionsForPathParams.properties.style.enum.includes(maybeParam));
+}
+exports.isParameterSerializeStyleForPathParams = isParameterSerializeStyleForPathParams;
+/**
+ * Determine whether a ParameterSerializeOption is a style serializer
+ */
+function isParameterSerializeStyleOptions(maybeStyle) {
+    return Boolean(maybeStyle.style);
+}
+exports.isParameterSerializeStyleOptions = isParameterSerializeStyleOptions;
+/** 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);
+}
+exports.isRefSchema = isRefSchema;
+function isRefSchemaLegacy(propertySchema) {
+    return (0, isString_js_1.default)(propertySchema.$ref);
+}
+exports.isRefSchemaLegacy = isRefSchemaLegacy;
+function isAllOfSchema(propertySchema) {
+    return (0, isArray_js_1.default)(propertySchema.allOf);
+}
+exports.isAllOfSchema = isAllOfSchema;
+function isExtendsSchema(propertySchema) {
+    return (0, util_1.isRecord)(propertySchema) && (0, isArray_js_1.default)(propertySchema.extends);
+}
+exports.isExtendsSchema = isExtendsSchema;
+function isOneOfSchema(propertySchema) {
+    return (0, isArray_js_1.default)(propertySchema.oneOf);
+}
+exports.isOneOfSchema = isOneOfSchema;
+function isEnumSchema(obj) {
+    return (0, isArray_js_1.default)(obj.enum);
+}
+exports.isEnumSchema = isEnumSchema;
+function isArraySchema(propertySchema) {
+    return propertySchema.type === 'array' && (0, util_1.isRecord)(propertySchema.items);
+}
+exports.isArraySchema = isArraySchema;
+function isReturnShapeArraySchema(returnShape) {
+    return typeof returnShape === 'object' && returnShape.type === 'array';
+}
+exports.isReturnShapeArraySchema = isReturnShapeArraySchema;
+function isObjectSchema(propertySchema) {
+    return (0, util_1.isRecord)(propertySchema) && propertySchema.type === 'object' && (0, util_1.isRecord)(propertySchema.properties);
+}
+exports.isObjectSchema = isObjectSchema;
+/** 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));
+}
+exports.isAnyServiceConfig = isAnyServiceConfig;
+function isGraphQLServiceConfig(maybeConfig) {
+    return (isAnyServiceConfig(maybeConfig) && maybeConfig.serviceType === 'graphql' && (0, isString_js_1.default)(maybeConfig.options?.endpoint));
+}
+exports.isGraphQLServiceConfig = isGraphQLServiceConfig;
+function isRESTServiceConfig(maybeConfig) {
+    return isAnyServiceConfig(maybeConfig) && maybeConfig.serviceType === 'rest';
+}
+exports.isRESTServiceConfig = isRESTServiceConfig;
+function isOpenAPIServiceConfig(maybeConfig) {
+    return isAnyServiceConfig(maybeConfig) && maybeConfig.serviceType === 'openapi';
+}
+exports.isOpenAPIServiceConfig = isOpenAPIServiceConfig;
+function isShopifyServiceConfig(maybeShopify) {
+    return maybeShopify.provider === 'shopify';
+}
+exports.isShopifyServiceConfig = isShopifyServiceConfig;
+function isEncryptedServiceConfig(maybeConfig) {
+    return isAnyServiceConfig(maybeConfig) && (0, isString_js_1.default)(maybeConfig.authentication);
+}
+exports.isEncryptedServiceConfig = isEncryptedServiceConfig;
+function isServiceConfigWithOAuth2Authentication(maybeServiceConfig) {
+    return (isAnyServiceConfig(maybeServiceConfig) &&
+        isServiceAuthentication(maybeServiceConfig.authentication) &&
+        isOAuth2Authentication(maybeServiceConfig.authentication));
+}
+exports.isServiceConfigWithOAuth2Authentication = isServiceConfigWithOAuth2Authentication;
+function isServiceConfigWithCustomAuthentication(maybeServiceConfig) {
+    return (isAnyServiceConfig(maybeServiceConfig) &&
+        isServiceAuthentication(maybeServiceConfig.authentication) &&
+        isCustomAuthentication(maybeServiceConfig.authentication));
+}
+exports.isServiceConfigWithCustomAuthentication = isServiceConfigWithCustomAuthentication;
+/** Authentication Utils **/
+function isServiceAuthentication(maybeAuthentication) {
+    return maybeAuthentication?.type;
+}
+exports.isServiceAuthentication = isServiceAuthentication;
+function isBearerAuthentication(authentication) {
+    return authentication?.type === 'bearer';
+}
+exports.isBearerAuthentication = isBearerAuthentication;
+function isBasicAuthentication(authentication) {
+    return authentication?.type === 'basic';
+}
+exports.isBasicAuthentication = isBasicAuthentication;
+function isSearchParamsAuthentication(authentication) {
+    return authentication?.type === 'searchParams';
+}
+exports.isSearchParamsAuthentication = isSearchParamsAuthentication;
+function isOAuth2Authentication(authentication) {
+    return authentication?.type === 'oauth2';
+}
+exports.isOAuth2Authentication = isOAuth2Authentication;
+function isOAuth2BearerAuthentication(authentication) {
+    return authentication?.type === 'oauth2Bearer';
+}
+exports.isOAuth2BearerAuthentication = isOAuth2BearerAuthentication;
+function isGoogleAuthentication(authentication) {
+    return authentication?.type === 'google';
+}
+exports.isGoogleAuthentication = isGoogleAuthentication;
+function isCustomAuthentication(authentication) {
+    return authentication?.type === 'custom';
+}
+exports.isCustomAuthentication = isCustomAuthentication;
+/** 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';
+}
+exports.isPropertySchemaWithRelationship = isPropertySchemaWithRelationship;
+function isModelShape(shape) {
+    return Boolean(shape.model);
+}
+exports.isModelShape = isModelShape;
+function isCachedShape(shape) {
+    return shape.cache?.enabled === true && shape.loaders !== undefined;
+}
+exports.isCachedShape = isCachedShape;
+function listCachedShapes(shapes) {
+    return Object.values(shapes).filter(isCachedShape);
+}
+exports.listCachedShapes = listCachedShapes;
+function getCachedShapeMap(shapes) {
+    const results = {};
+    for (const shape of Object.values(shapes)) {
+        if (isCachedShape(shape)) {
+            results[shape.name] = shape;
+        }
+    }
+    return results;
+}
+exports.getCachedShapeMap = getCachedShapeMap;
+function isMeshShape(shape) {
+    return Boolean(shape.joins);
+}
+exports.isMeshShape = isMeshShape;

package/dist/cjs/src/unions.js

@@ -0,0 +1,90 @@
+"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 = exports.oneOfToObject = exports.isUnionSchema = exports.enumerateOneOfKeys = void 0;
+const util_1 = require("@takeshape/util");
+const omit_js_1 = __importDefault(require("lodash/omit.js"));
+const errors_1 = require("@takeshape/errors");
+const refs_1 = require("./refs");
+const utils_1 = require("./types/utils");
+const shapes_1 = require("./util/shapes");
+const names_1 = require("./template-shapes/names");
+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;
+}
+exports.enumerateOneOfKeys = enumerateOneOfKeys;
+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));
+}
+exports.isUnionSchema = isUnionSchema;
+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 };
+}
+exports.oneOfToObject = oneOfToObject;
+function formatKeys(keys) {
+    return keys.map(k => `"${k}"`).join(', ');
+}
+// eslint-disable-next-line max-params
+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;
+// eslint-disable-next-line max-params
+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

@@ -0,0 +1,8 @@
+"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

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

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

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getGetQueryIndexConfig = exports.getListQueryIndexConfigs = exports.getIndexedServices = exports.serviceHasIndexedShapes = void 0;
+const util_1 = require("@takeshape/util");
+const types_1 = require("../types");
+const util_2 = require("../services/util");
+const schema_util_1 = require("../schema-util");
+const refs_1 = require("../refs");
+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;
+}
+exports.serviceHasIndexedShapes = serviceHasIndexedShapes;
+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;
+    }, []);
+}
+exports.getIndexedServices = getIndexedServices;
+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

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasCycle = void 0;
+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);
+}
+exports.hasCycle = hasCycle;

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

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findShapeAtPath = exports.findSchemaAtPath = void 0;
+const types_1 = require("../types");
+const refs_1 = require("../refs");
+/**
+ *
+ * @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;
+}
+exports.findSchemaAtPath = findSchemaAtPath;
+/**
+ *
+ * @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);
+    }
+}
+exports.findShapeAtPath = findShapeAtPath;