@takeshape/schema 11.52.0 → 11.55.0

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

@@ -1,1140 +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.getQueryMapName = exports.shapeHasArrayPropOfShape = exports.getDefaultMutationName = exports.ensureMutationByShape = exports.ensureQueryByShape = exports.findMutationByShape = exports.findQueryByShape = exports.createSchemaPropertyAccessor = exports.createSchemaPropertyList = exports.isBuiltInPropertyName = exports.BuiltInPropertiesProfile = exports.DEFAULT_ID_FIELD = exports.nonStructuralSchemaKeys = exports.multipleRelationshipSchemaKeys = exports.arraySchemaKeys = exports.objectSchemaKeys = exports.scalarSchemaKeys = exports.commonSchemaKeys = exports.schemaMetadataKeys = void 0;
-exports.isBuiltinShape = isBuiltinShape;
-exports.isBuiltinQuery = isBuiltinQuery;
-exports.isBuiltinMutation = isBuiltinMutation;
-exports.isBuiltinType = isBuiltinType;
-exports.getServiceIdFieldName = getServiceIdFieldName;
-exports.getGeneratorVersion = getGeneratorVersion;
-exports.pathBetween = pathBetween;
-exports.getShapeQueriesAndMutations = getShapeQueriesAndMutations;
-exports.getCommonBuiltInProperties = getCommonBuiltInProperties;
-exports.getIdField = getIdField;
-exports.getModelBuiltInProperties = getModelBuiltInProperties;
-exports.getBuiltInPropertyNames = getBuiltInPropertyNames;
-exports.applyBuiltinPropertiesToShape = applyBuiltinPropertiesToShape;
-exports.getBuiltinsUsed = getBuiltinsUsed;
-exports.applyDefaultsToSchema = applyDefaultsToSchema;
-exports.getShapeByRef = getShapeByRef;
-exports.getArgsReference = getArgsReference;
-exports.getArgsReferenceWithPath = getArgsReferenceWithPath;
-exports.getArgsShapeSchema = getArgsShapeSchema;
-exports.shapeToPropertySchema = shapeToPropertySchema;
-exports.projectSchemaToJSONSchema = projectSchemaToJSONSchema;
-exports.getShapeDependencies = getShapeDependencies;
-exports.getRelevantShapes = getRelevantShapes;
-exports.visitSchemaProperties = visitSchemaProperties;
-exports.visitShapeProperties = visitShapeProperties;
-exports.getAllRefsInShapes = getAllRefsInShapes;
-exports.getAllRefsInQuery = getAllRefsInQuery;
-exports.getAllRefsInQueries = getAllRefsInQueries;
-exports.getAllRefs = getAllRefs;
-exports.isValidRefItem = isValidRefItem;
-exports.getAllValidRefs = getAllValidRefs;
-exports.parseMapping = parseMapping;
-exports.splitMapping = splitMapping;
-exports.findMapping = findMapping;
-exports.getFirstMapping = getFirstMapping;
-exports.getFullyQualifiedShapeName = getFullyQualifiedShapeName;
-exports.getStorageKey = getStorageKey;
-exports.getPropertyService = getPropertyService;
-exports.emptySchema = emptySchema;
-exports.createLayerSchema = createLayerSchema;
-exports.getShapesById = getShapesById;
-exports.getAllNamespaceShapes = getAllNamespaceShapes;
-exports.getNamespacedShapeNameList = getNamespacedShapeNameList;
-exports.filterGraphQLServiceMap = filterGraphQLServiceMap;
-exports.createShape = createShape;
-exports.queryToPropertySchema = queryToPropertySchema;
-exports.getQueriesShape = getQueriesShape;
-exports.fieldMappingContainsKey = fieldMappingContainsKey;
-exports.schemaMatchesShapeName = schemaMatchesShapeName;
-const util_1 = require("@takeshape/util");
-const curry_js_1 = __importDefault(require("lodash/fp/curry.js"));
-const orderBy_js_1 = __importDefault(require("lodash/fp/orderBy.js"));
-const isArray_js_1 = __importDefault(require("lodash/isArray.js"));
-const isString_js_1 = __importDefault(require("lodash/isString.js"));
-const keyBy_js_1 = __importDefault(require("lodash/keyBy.js"));
-const mapValues_js_1 = __importDefault(require("lodash/mapValues.js"));
-const some_js_1 = __importDefault(require("lodash/some.js"));
-const uniq_js_1 = __importDefault(require("lodash/uniq.js"));
-const api_version_1 = require("./api-version");
-const builtin_schema_1 = require("./builtin-schema");
-const constants_1 = require("./constants");
-const refs_1 = require("./refs");
-const types_1 = require("./types");
-const unions_1 = require("./unions");
-const has_arg_1 = require("./util/has-arg");
-const merge_1 = require("./util/merge");
-const versions_1 = require("./versions");
-const workflows_1 = require("./workflows");
-function isBuiltinShape(shapeName) {
-    return Boolean(builtin_schema_1.builtInShapes[shapeName]);
-}
-const builtInQueriesAndMutations = getShapeQueriesAndMutations(Object.values(builtin_schema_1.builtInShapes));
-function isBuiltinQuery(name) {
-    return builtInQueriesAndMutations.queries[name] !== undefined;
-}
-function isBuiltinMutation(name) {
-    return builtInQueriesAndMutations.mutations[name] !== undefined;
-}
-function isBuiltinType(projectSchema, refSchema) {
-    const shapeName = (0, refs_1.getRefShapeName)(projectSchema, refSchema);
-    return shapeName !== undefined && isBuiltinShape(shapeName);
-}
-exports.schemaMetadataKeys = [
-    '$comment',
-    'title',
-    'description',
-    '@l10n',
-    '@deprecationReason',
-    '@tag',
-    '@tags',
-    '@syncLocaleStructure',
-    '@sensitive'
-];
-exports.commonSchemaKeys = ['type', 'default', 'readOnly', ...exports.schemaMetadataKeys];
-exports.scalarSchemaKeys = [
-    ...exports.commonSchemaKeys,
-    'format',
-    'oneOf',
-    'multipleOf',
-    'maximum',
-    'exclusiveMaximum',
-    'minimum',
-    'exclusiveMinimum',
-    'maxLength',
-    'minLength',
-    'pattern'
-];
-exports.objectSchemaKeys = [...exports.commonSchemaKeys, 'properties', 'required'];
-exports.arraySchemaKeys = [
-    ...exports.commonSchemaKeys,
-    'items',
-    'additionalItems',
-    'maxItems',
-    'minItems',
-    'uniqueItems'
-];
-exports.multipleRelationshipSchemaKeys = [...exports.schemaMetadataKeys, 'maxItems', 'minItems'];
-// All properties except properties, items, additionalItems
-exports.nonStructuralSchemaKeys = [
-    ...exports.scalarSchemaKeys,
-    '@resolver',
-    '@input',
-    '@output',
-    '@backreference',
-    '@args',
-    'required',
-    'maxItems',
-    'minItems',
-    'uniqueItems'
-];
-function getServiceIdFieldName(serviceFieldName) {
-    return `${serviceFieldName}Id`;
-}
-const generatorVersions = {
-    [constants_1.SERVICE_OBJECT_PATTERN_NAME]: '1'
-};
-function getGeneratorVersion(generator) {
-    return generatorVersions[generator];
-}
-// Follow refs to find the path between two shapes in a schema
-function pathBetween(fromShape, toShape, projectSchema, depthLimit = 4) {
-    if (fromShape.name === toShape.name) {
-        return [];
-    }
-    const toShapeName = toShape.name;
-    let shortestPath;
-    let shortestPathLength = Number.MAX_SAFE_INTEGER;
-    const pathBetweenHelper = (schema, pathSoFar, seen, depth) => {
-        if (depth > depthLimit) {
-            return;
-        }
-        if (schema.items) {
-            pathBetweenHelper(schema.items, pathSoFar, seen, depth);
-            return;
-        }
-        const refItem = (0, refs_1.getRef)(projectSchema, schema);
-        if (refItem) {
-            const referenced = (0, refs_1.refItemToShape)(projectSchema, refItem);
-            if (referenced) {
-                if (referenced.name === toShapeName && pathSoFar.length < shortestPathLength) {
-                    shortestPath = pathSoFar;
-                    shortestPathLength = pathSoFar.length;
-                }
-                else if (!seen.has(referenced.name)) {
-                    pathBetweenHelper(referenced.schema, pathSoFar, new Set([...seen, referenced.name]), depth);
-                }
-            }
-        }
-        else if (pathSoFar.length + 1 < shortestPathLength && (schema.oneOf ?? schema.allOf ?? schema.properties)) {
-            if (schema.oneOf) {
-                for (const itemSchema of schema.oneOf) {
-                    pathBetweenHelper(itemSchema, pathSoFar, seen, depth);
-                }
-            }
-            else {
-                for (const [propName, propSchema] of (0, exports.createSchemaPropertyList)(projectSchema, schema).getNodes()) {
-                    pathBetweenHelper(propSchema, pathSoFar.concat(String(propName)), seen, depth + 1);
-                }
-            }
-        }
-    };
-    pathBetweenHelper(fromShape.schema, [], new Set([fromShape.name]), 0);
-    if (!shortestPath) {
-        throw new Error(`No path between ${fromShape.name} and ${toShape.name}`);
-    }
-    return shortestPath;
-}
-function getShapeQueriesAndMutations(shapes) {
-    const queries = {};
-    const mutations = {};
-    for (const shape of (0, util_1.ensureArray)(shapes)) {
-        const { name, model } = shape;
-        const service = 'shapedb';
-        if (model) {
-            const isSingleton = model.type === 'single';
-            queries[`get${name}`] = {
-                shape: name,
-                resolver: {
-                    name: 'shapedb:get',
-                    service,
-                    shapeName: name
-                },
-                description: `Get a ${name} by ID`,
-                args: isSingleton
-                    ? (0, refs_1.createTemplateShapeName)('TSGetSingletonArgs', name)
-                    : (0, refs_1.createTemplateShapeName)('TSGetArgs', name)
-            };
-            mutations[`update${name}`] = {
-                shape: (0, refs_1.createTemplateShapeName)('UpdateResult', name),
-                resolver: {
-                    name: 'shapedb:update',
-                    service,
-                    shapeName: name
-                },
-                description: `Update ${name}`,
-                args: (0, refs_1.createTemplateShapeName)('UpdateArgs', name)
-            };
-            if (!isSingleton) {
-                queries[`get${name}List`] = {
-                    shape: (0, refs_1.createTemplateShapeName)('PaginatedList', name),
-                    resolver: {
-                        name: 'shapedb:list',
-                        service,
-                        shapeName: name
-                    },
-                    description: `Returns a list ${name} in natural order.`,
-                    args: (0, refs_1.createTemplateShapeName)('TSListArgs', name)
-                };
-                mutations[`create${name}`] = {
-                    shape: (0, refs_1.createTemplateShapeName)('CreateResult', name),
-                    resolver: {
-                        name: 'shapedb:create',
-                        service,
-                        shapeName: name
-                    },
-                    description: `Create ${name}`,
-                    args: (0, refs_1.createTemplateShapeName)('CreateArgs', name)
-                };
-                mutations[`duplicate${name}`] = {
-                    shape: (0, refs_1.createTemplateShapeName)('DuplicateResult', name),
-                    resolver: {
-                        name: 'shapedb:duplicate',
-                        service,
-                        shapeName: name
-                    },
-                    description: `Duplicate ${name}`,
-                    args: (0, refs_1.createTemplateShapeName)('DuplicateArgs', name)
-                };
-                mutations[`delete${name}`] = {
-                    shape: (0, refs_1.createTemplateShapeName)('DeleteResult', name),
-                    resolver: {
-                        name: 'shapedb:delete',
-                        service,
-                        shapeName: name
-                    },
-                    description: `Delete ${name}`,
-                    args: (0, refs_1.createTemplateShapeName)('DeleteArgs', name)
-                };
-            }
-        }
-    }
-    return { queries, mutations };
-}
-function getCommonBuiltInProperties(shape) {
-    return {
-        _id: {
-            title: 'Id',
-            type: 'string'
-        },
-        _shapeId: {
-            type: 'string',
-            title: 'Shape Id',
-            enum: [shape.id]
-        }
-    };
-}
-exports.DEFAULT_ID_FIELD = 'id';
-function getIdField(obj) {
-    return obj?.idField ?? exports.DEFAULT_ID_FIELD;
-}
-/**
- * Get properties necessary for cached / remote data to work with the TSSearchable interface.
- */
-function getCachedBuiltInProperties(projectSchema, shape, properties) {
-    const idField = getIdField(shape.cache);
-    // TODO Implement `searchSummary` and `_shapeId` here, and remove `getRemoteShapeTSSearchableFields`
-    return {
-        _id: {
-            title: 'Id',
-            type: 'string',
-            ...properties._id,
-            ...(properties[idField]?.['@mapping'] ? { '@mapping': properties[idField]['@mapping'] } : {})
-        }
-    };
-}
-function getModelBuiltInProperties(projectSchema, shape) {
-    const apiVersion = projectSchema.apiVersion ?? versions_1.CURRENT_API_VERSION;
-    const showDeprecationReason = apiVersion !== '1';
-    const properties = {
-        _version: {
-            title: 'Version',
-            type: 'integer'
-        },
-        _shapeName: {
-            title: 'Shape Name',
-            type: 'string'
-        },
-        _createdAt: {
-            title: 'Created',
-            type: 'string',
-            format: 'date-time'
-        },
-        _createdBy: {
-            title: 'Created By',
-            '@ref': 'local:TSUser',
-            '@input': {
-                type: 'string'
-            },
-            '@resolver': {
-                name: 'takeshape:getUser',
-                service: 'takeshape'
-            }
-        },
-        _updatedAt: {
-            title: 'Updated',
-            type: 'string',
-            format: 'date-time'
-        },
-        _updatedBy: {
-            title: 'Updated By',
-            '@ref': 'local:TSUser',
-            '@input': {
-                type: 'string'
-            },
-            '@resolver': {
-                name: 'takeshape:getUser',
-                service: 'takeshape'
-            }
-        },
-        _schemaVersion: {
-            title: 'Schema Version',
-            type: 'number'
-        },
-        _enabled: {
-            title: 'Enabled',
-            type: 'boolean',
-            ...(showDeprecationReason ? { '@deprecationReason': 'Use _status instead' } : {})
-        },
-        _enabledAt: {
-            title: 'Enabled Date',
-            type: 'string',
-            format: 'date-time',
-            ...(showDeprecationReason ? { '@deprecationReason': 'Use a custom date field instead' } : {})
-        }
-    };
-    if ((0, api_version_1.workflowsEnabled)(apiVersion)) {
-        return {
-            ...properties,
-            _status: {
-                ...(projectSchema.workflows && (0, workflows_1.getStatusField)(projectSchema.workflows, shape))
-            }
-        };
-    }
-    return properties;
-}
-/**
- * Return all the built in property names,
- */
-function getBuiltInPropertyNames(profile = BuiltInPropertiesProfile.Model) {
-    const fakeShape = {
-        id: 'shape-id'
-    };
-    let keys = [...Object.keys(getCommonBuiltInProperties(fakeShape))];
-    if (profile === BuiltInPropertiesProfile.Model) {
-        keys = [...keys, ...Object.keys(getModelBuiltInProperties({}, fakeShape))];
-    }
-    return new Set(keys);
-}
-var BuiltInPropertiesProfile;
-(function (BuiltInPropertiesProfile) {
-    BuiltInPropertiesProfile[BuiltInPropertiesProfile["Model"] = 0] = "Model";
-    BuiltInPropertiesProfile[BuiltInPropertiesProfile["Cached"] = 1] = "Cached";
-    BuiltInPropertiesProfile[BuiltInPropertiesProfile["None"] = 2] = "None";
-})(BuiltInPropertiesProfile || (exports.BuiltInPropertiesProfile = BuiltInPropertiesProfile = {}));
-const BUILT_IN_PROPERTY_NAMES = {
-    [BuiltInPropertiesProfile.Model]: getBuiltInPropertyNames(BuiltInPropertiesProfile.Model),
-    [BuiltInPropertiesProfile.Cached]: getBuiltInPropertyNames(BuiltInPropertiesProfile.Cached),
-    [BuiltInPropertiesProfile.None]: getBuiltInPropertyNames(BuiltInPropertiesProfile.None)
-};
-const isBuiltInPropertyName = (name, profile = BuiltInPropertiesProfile.Model) => {
-    return BUILT_IN_PROPERTY_NAMES[profile].has(name);
-};
-exports.isBuiltInPropertyName = isBuiltInPropertyName;
-/**
- * Get the profile to use for loading built-in properties
- */
-function getBuiltInPropertiesProfile(shape) {
-    if ((0, types_1.isModelShape)(shape)) {
-        return BuiltInPropertiesProfile.Model;
-    }
-    if ((0, types_1.isCachedShape)(shape)) {
-        return BuiltInPropertiesProfile.Cached;
-    }
-    return BuiltInPropertiesProfile.None;
-}
-function applyBuiltinPropertiesToShape(projectSchema, shape) {
-    const profile = getBuiltInPropertiesProfile(shape);
-    if (profile === BuiltInPropertiesProfile.None) {
-        return shape;
-    }
-    const shapeObjectSchema = (0, refs_1.dereferenceObjectSchema)(projectSchema, shape.schema, ['shapes', shape.name]);
-    const { properties } = shapeObjectSchema;
-    const commonProperties = getCommonBuiltInProperties(shape);
-    const modelProperties = profile === BuiltInPropertiesProfile.Model ? getModelBuiltInProperties(projectSchema, shape) : undefined;
-    const cachedProperties = profile === BuiltInPropertiesProfile.Cached
-        ? getCachedBuiltInProperties(projectSchema, shape, properties)
-        : undefined;
-    return {
-        ...shape,
-        schema: {
-            ...shapeObjectSchema,
-            properties: {
-                ...properties,
-                ...commonProperties,
-                ...modelProperties,
-                ...cachedProperties
-            }
-        }
-    };
-}
-// Dependencies of these built-in shapes are automatically added by getBuiltinsUsed
-const requiredBuiltinShapes = ['Asset', 'TSRelationship', 'TSStaticSite', 'TSUser'];
-/**
- * Get all built-in shapes that are depended on by the given project schema.
- * Required built-in shapes are always included.
- */
-function getBuiltinsUsed(projectSchema) {
-    const builtinsUsed = {};
-    const shapeNames = (0, uniq_js_1.default)(requiredBuiltinShapes.concat(getAllRefs(projectSchema, (refItem) => refItem.serviceKey === 'local' && isBuiltinShape(refItem.typeName)).map(refs_1.refItemToNamespacedShapeName)));
-    const schemaWithAllBuiltins = {
-        ...emptySchema('project-id'),
-        shapes: builtin_schema_1.builtInShapes
-    };
-    for (const builtinShapeName of shapeNames) {
-        builtinsUsed[builtinShapeName] = builtin_schema_1.builtInShapes[builtinShapeName];
-        for (const depShapeName of getShapeDependencies(schemaWithAllBuiltins, builtin_schema_1.builtInShapes[builtinShapeName])) {
-            builtinsUsed[depShapeName] = builtin_schema_1.builtInShapes[depShapeName];
-        }
-    }
-    return builtinsUsed;
-}
-function applyDefaultsToSchema(projectSchema) {
-    const builtinsUsed = getBuiltinsUsed(projectSchema);
-    return {
-        ...projectSchema,
-        workflows: {
-            ...projectSchema.workflows,
-            ...((0, api_version_1.workflowsEnabled)(projectSchema.apiVersion) && {
-                default: workflows_1.defaultWorkflow
-            })
-        },
-        queries: {
-            ...builtInQueriesAndMutations.queries,
-            ...projectSchema.queries
-        },
-        mutations: {
-            ...builtInQueriesAndMutations.mutations,
-            ...projectSchema.mutations
-        },
-        shapes: (0, mapValues_js_1.default)({ ...builtinsUsed, ...projectSchema.shapes }, (shape) => {
-            const builtInShape = builtinsUsed[shape.name];
-            if (builtInShape && builtInShape !== shape) {
-                shape = {
-                    ...shape,
-                    schema: (0, merge_1.mergeSchemaProperties)((0, refs_1.dereferenceObjectSchema)(projectSchema, shape.schema), (0, refs_1.dereferenceObjectSchema)(projectSchema, builtInShape.schema))
-                };
-            }
-            return applyBuiltinPropertiesToShape(projectSchema, shape);
-        }),
-        forms: (0, mapValues_js_1.default)({ ...builtin_schema_1.builtInForms, ...projectSchema.forms }, (formsConfig, shapeName) => {
-            const builtInFormsConfig = builtin_schema_1.builtInForms[shapeName];
-            if (builtInFormsConfig && builtInFormsConfig !== formsConfig) {
-                formsConfig = {
-                    ...formsConfig,
-                    default: (0, merge_1.mergeFormProperties)(formsConfig.default, builtInFormsConfig.default)
-                };
-            }
-            return formsConfig;
-        })
-    };
-}
-function getShapeByRef(projectSchema, shapeRef) {
-    return (0, refs_1.refItemToShape)(projectSchema, (0, refs_1.atRefToRefItem)(projectSchema, shapeRef));
-}
-function getArgsReference(projectSchema, argsSchema) {
-    const args = (0, has_arg_1.getArgs)(argsSchema);
-    if (args && typeof args === 'string') {
-        // @args: ShapeName OR Namespace_TypeName
-        return (0, refs_1.refExpressionToRefItem)(projectSchema, args);
-    }
-}
-function getArgsReferenceWithPath(context, argsSchema, schemaPath = []) {
-    const refItem = getArgsReference(context, argsSchema);
-    if (refItem) {
-        const argsType = (0, types_1.getArgsType)(argsSchema);
-        return {
-            ...refItem,
-            path: schemaPath.concat([argsType])
-        };
-    }
-}
-function getArgsShapeSchema(context, argsSchema) {
-    const args = (0, has_arg_1.getArgs)(argsSchema);
-    if (args) {
-        if (typeof args === 'string') {
-            const refItem = getArgsReference(context, argsSchema);
-            if (refItem) {
-                return (0, refs_1.refItemToShapeSchema)(context, refItem);
-            }
-        }
-        else {
-            return args;
-        }
-    }
-}
-const createShapeToPropertySchema = (projectSchema, definitions, definitionNames, { useShapeIdDiscriminator }) => {
-    const rewriteRefs = (shape) => {
-        const handleSchema = (propSchema) => {
-            // Unwrap array schema
-            propSchema = propSchema.items ?? propSchema;
-            if ((0, types_1.isOneOfSchema)(propSchema)) {
-                const isUnion = (0, unions_1.isUnionSchema)(propSchema);
-                if (useShapeIdDiscriminator && isUnion) {
-                    propSchema.discriminator = {
-                        propertyName: '_shapeId'
-                    };
-                    propSchema.required = ['_shapeId'];
-                }
-                for (const schema of propSchema.oneOf) {
-                    handleSchema(schema);
-                }
-                return;
-            }
-            // Add workflow validation
-            if (propSchema['@workflow']) {
-                const workflowName = propSchema['@workflow'];
-                const workflow = projectSchema.workflows[workflowName] || workflows_1.defaultWorkflow;
-                propSchema.oneOf = workflow.steps.map((step) => ({
-                    enum: [step.key, step.name],
-                    title: step.title
-                }));
-            }
-            const refItem = (0, refs_1.getRef)(projectSchema, propSchema);
-            if (refItem) {
-                const shapeName = (0, refs_1.refItemToNamespacedShapeName)(refItem);
-                const shape = (0, refs_1.refItemToShape)(projectSchema, refItem);
-                if (shape) {
-                    delete propSchema['@ref'];
-                    propSchema.$ref = `#/definitions/${shapeName}`;
-                    if (!definitionNames.has(shapeName)) {
-                        definitionNames.add(shapeName);
-                        const rewritten = rewriteRefs(shape);
-                        if (useShapeIdDiscriminator && (0, types_1.isObjectSchema)(rewritten)) {
-                            rewritten.properties._shapeId = {
-                                type: 'string',
-                                enum: [shape.id]
-                            };
-                        }
-                        definitions[shapeName] = rewritten;
-                    }
-                }
-            }
-        };
-        const shapeSchema = (0, util_1.deepClone)(shape.schema);
-        if ((0, types_1.isOneOfSchema)(shapeSchema)) {
-            handleSchema(shapeSchema);
-            return shapeSchema;
-        }
-        if (shapeSchema.enum) {
-            return shapeSchema;
-        }
-        const shapeSchemaCopy = (0, refs_1.dereferenceObjectSchema)(projectSchema, shapeSchema);
-        if (shape.title) {
-            shapeSchemaCopy.title = shape.title;
-        }
-        for (const schema of Object.values(shapeSchemaCopy.properties)) {
-            handleSchema(schema);
-        }
-        return shapeSchemaCopy;
-    };
-    return rewriteRefs;
-};
-function shapeToPropertySchema(projectSchema, shape) {
-    const definitions = {};
-    const definitionNames = new Set();
-    const convert = createShapeToPropertySchema(projectSchema, definitions, definitionNames, {
-        useShapeIdDiscriminator: true
-    });
-    return {
-        ...convert(shape),
-        definitions
-    };
-}
-function projectSchemaToJSONSchema(projectSchema) {
-    const definitions = {};
-    const definitionNames = new Set();
-    const convert = createShapeToPropertySchema(projectSchema, definitions, definitionNames, {
-        useShapeIdDiscriminator: false
-    });
-    for (const shape of Object.values(projectSchema.shapes)) {
-        definitions[shape.name] = convert(shape);
-        definitionNames.add(shape.name);
-    }
-    return {
-        definitions
-    };
-}
-function getShapeDependencies(projectSchema, shape, predicate) {
-    const shapeNames = new Set();
-    const findDependencies = (schema) => {
-        const shouldFollow = Boolean(!predicate || predicate(schema));
-        if (shouldFollow) {
-            schema = schema.items ?? schema;
-            const refItem = (0, refs_1.getRef)(projectSchema, schema);
-            if (refItem) {
-                const refShape = (0, refs_1.refItemToShape)(projectSchema, refItem);
-                if (refShape && !shapeNames.has(refShape.name)) {
-                    shapeNames.add(refShape.name);
-                    findDependencies((0, refs_1.dereferenceSchema)(projectSchema, refShape.schema, ['shapes', refShape.name]));
-                }
-            }
-            else if ((0, types_1.isObjectSchema)(schema) || (0, types_1.isAllOfSchema)(schema) || (0, types_1.isOneOfSchema)(schema)) {
-                visitSchemaProperties(schema, [], findDependencies);
-            }
-        }
-        return shouldFollow;
-    };
-    findDependencies(shape.schema);
-    return [...shapeNames];
-}
-function getRelevantShapes(projectSchema, params) {
-    const { shapeIds, shapeNames, byId = false, includeDependencies = true } = params;
-    if (Boolean(shapeNames?.length) || Boolean(shapeIds?.length)) {
-        const ids = new Set(shapeIds);
-        const names = new Set(shapeNames);
-        const shapes = {};
-        for (const shape of Object.values(projectSchema.shapes)) {
-            if (ids.has(shape.id) || names.has(shape.name)) {
-                const shapeNames = includeDependencies
-                    ? [shape.name].concat(getShapeDependencies(projectSchema, shape))
-                    : [shape.name];
-                for (const shapeName of shapeNames) {
-                    const dependentShape = projectSchema.shapes[shapeName];
-                    shapes[byId ? dependentShape.id : dependentShape.name] = dependentShape;
-                }
-            }
-        }
-        return shapes;
-    }
-    return {};
-}
-function visitSchemaProperties(root, path, callback) {
-    const visitEach = (entries, path) => {
-        for (const [name, propSchema] of entries) {
-            const newPath = [...path, name];
-            visit(propSchema, newPath);
-        }
-    };
-    const visit = (schema, path) => {
-        if (schema !== root && callback(schema, path) === false) {
-            return;
-        }
-        if ((0, types_1.isArraySchema)(schema)) {
-            visit(schema.items, [...path, 'items']);
-        }
-        else if ((0, types_1.isObjectSchema)(schema)) {
-            visitEach(Object.entries(schema.properties), [...path, 'properties']);
-        }
-        else if ((0, types_1.isExtendsSchema)(schema)) {
-            visitEach(Object.entries(schema.extends), [...path, 'extends']);
-        }
-        else if ((0, types_1.isAllOfSchema)(schema)) {
-            visitEach(Object.entries(schema.allOf), [...path, 'allOf']);
-        }
-        else if ((0, types_1.isOneOfSchema)(schema)) {
-            visitEach(Object.entries(schema.oneOf), [...path, 'oneOf']);
-        }
-    };
-    visit(root, path);
-}
-function visitShapeProperties(shapes, callback) {
-    for (const [shapeName, shape] of Object.entries(shapes)) {
-        visitSchemaProperties(shape.schema, ['shapes', shapeName, 'schema'], callback);
-    }
-}
-function addRef(refs, ref, predicate) {
-    if (ref && (!predicate || predicate(ref))) {
-        refs.push(ref);
-    }
-}
-/**
- * Walk through a `ProjectSchemaJSON` and collect all the `ref`s.
- */
-function getAllRefsInShapes(projectSchema, predicate) {
-    const items = [];
-    const refPropNames = ['$ref', '@ref', '@args', 'args', 'interfaces'];
-    (0, util_1.visit)(projectSchema.shapes, refPropNames, (interfaces, refPath) => {
-        const propName = refPath[refPath.length - 1];
-        const path = ['shapes', ...refPath];
-        if (propName === 'interfaces' && (0, isArray_js_1.default)(interfaces)) {
-            interfaces.forEach((interfaceRefExpression, index) => {
-                addRef(items, {
-                    ...(0, refs_1.refExpressionToRefItem)(projectSchema, interfaceRefExpression),
-                    path: [...path, index]
-                }, predicate);
-            });
-        }
-        // The client sometimes generates invalid schemas, like refs that are
-        // undefined. Treat ref as unknown and toss those out.
-        // See the `useShapeEditor > can deal with renames test`
-        if (!(0, isString_js_1.default)(interfaces)) {
-            return;
-        }
-        if (propName === '@ref') {
-            const { shapeName, template } = (0, refs_1.parseTemplateShape)(interfaces);
-            addRef(items, { ...(0, refs_1.atRefToRefItem)(projectSchema, shapeName, template), path }, predicate);
-        }
-        else if (propName === '$ref') {
-            addRef(items, { ...(0, refs_1.refToRefItem)(projectSchema, interfaces), path }, predicate);
-        }
-        else if (propName === '@args' || propName === 'args') {
-            addRef(items, { ...(0, refs_1.refExpressionToRefItem)(projectSchema, interfaces), path }, predicate);
-        }
-    });
-    return items;
-}
-/**
- * Get all refs
- */
-function getAllRefsInQuery(projectSchema, queryPath, query, predicate) {
-    const refItems = [];
-    const propertyVisitor = (propSchema, propSchemaPath) => {
-        addRef(refItems, (0, refs_1.getRefOrItemsRef)(projectSchema, propSchema, propSchemaPath), predicate);
-    };
-    if (query.args && typeof query.args === 'string') {
-        addRef(refItems, getArgsReferenceWithPath(projectSchema, query, queryPath), predicate);
-    }
-    if (query.args && typeof query.args === 'object') {
-        visitSchemaProperties((0, refs_1.dereferenceObjectSchema)(projectSchema, query.args), [...queryPath, 'args'], propertyVisitor);
-    }
-    if (query.shape) {
-        const { isArray, ref } = (0, refs_1.parseReturnShape)(projectSchema, query.shape);
-        if (ref) {
-            addRef(refItems, {
-                ...ref,
-                path: queryPath.concat(isArray ? ['shape', 'items', '@ref'] : ['shape'])
-            }, predicate);
-        }
-    }
-    return refItems;
-}
-/**
- * Collect refs from `queries` or `mutations`.
- */
-function getAllRefsInQueries(projectSchema, rootPropertyName, predicate) {
-    const refItems = [];
-    const rootPath = [rootPropertyName];
-    for (const [queryName, query] of Object.entries(projectSchema[rootPropertyName])) {
-        const queryPath = rootPath.concat([queryName]);
-        const queryRefs = getAllRefsInQuery(projectSchema, queryPath, query, predicate);
-        if (queryRefs.length) {
-            refItems.push(...queryRefs);
-        }
-    }
-    return refItems;
-}
-/**
- * Get all refs in a ProjectSchemaJSON
- * @param predicate return true to include the ref in
- */
-function getAllRefs(projectSchema, predicate) {
-    return [
-        ...getAllRefsInShapes(projectSchema, predicate),
-        ...getAllRefsInQueries(projectSchema, 'queries', predicate),
-        ...getAllRefsInQueries(projectSchema, 'mutations', predicate)
-    ];
-}
-function isValidRefItem(refItem) {
-    return refItem.isValidService;
-}
-/**
- * Get all valid refs in a ProjectSchemaJSON
- * @param predicate return true to include the ref in
- */
-function getAllValidRefs(projectSchema, predicate) {
-    return getAllRefs(projectSchema, predicate).filter(isValidRefItem);
-}
-function parseMapping(mapping) {
-    const [providerId, serviceId, coordinate] = mapping.split(':');
-    const [shapeName, key] = coordinate.split('.');
-    return {
-        providerId,
-        serviceId,
-        shapeName,
-        key
-    };
-}
-function splitMapping(mapping) {
-    const parts = mapping.split('.');
-    return [parts[0], parts.slice(1).join('.')];
-}
-function findMapping(schema, predicate) {
-    const mapping = schema['@mapping'];
-    if (Array.isArray(mapping)) {
-        return mapping.find(predicate);
-    }
-    return mapping && predicate(mapping) ? mapping : undefined;
-}
-function getFirstMapping(schema) {
-    return Array.isArray(schema['@mapping']) ? schema['@mapping'][0] : schema['@mapping'];
-}
-function getFullyQualifiedShapeName(schema) {
-    const first = getFirstMapping(schema);
-    return first ? splitMapping(first)[0] : undefined;
-}
-/**
- * Find key for use storing data in ShapeDB or API Indexing this allows renaming of properties without db migration
- * Mapping must be using the shapedb service id
- * @param schema
- */
-function getStorageKey(schema) {
-    const first = findMapping(schema, (mapping) => mapping.startsWith('shapedb:'));
-    return first ? splitMapping(first)[1] : undefined;
-}
-function getPropertyService(schema) {
-    const first = getFirstMapping(schema);
-    const split = first?.split(':');
-    return split ? `${split[0]}:${split[1]}` : undefined;
-}
-function emptySchema(projectId) {
-    return {
-        projectId,
-        defaultLocale: 'en-us',
-        locales: ['en-us'],
-        apiVersion: '2',
-        schemaVersion: versions_1.CURRENT_SCHEMA_VERSION,
-        queries: {},
-        mutations: {},
-        shapes: {},
-        workflows: {},
-        forms: {}
-    };
-}
-function createLayerSchema(partialSchema) {
-    return {
-        schemaVersion: versions_1.CURRENT_SCHEMA_VERSION,
-        queries: {},
-        mutations: {},
-        shapes: {},
-        ...partialSchema
-    };
-}
-function getShapesById(projectSchema) {
-    return (0, keyBy_js_1.default)(Object.values(projectSchema.shapes), 'id');
-}
-/**
- * Walk through the project schema and return an array of all
- * referenced shape names that are in a service namespace.
- *
- * @param projectSchema A V3 project schema.
- *
- * @returns A `string` array with all the shapes that are in namespaces.
- */
-function getAllNamespaceShapes(projectSchema) {
-    const isServiceRef = (refItem) => Boolean(refItem.serviceNamespace);
-    return (0, uniq_js_1.default)(getAllValidRefs(projectSchema, isServiceRef).map(refs_1.refItemToNamespacedShapeName));
-}
-/**
- * Returns a list of all shape names in a service namespace, excluding any
- * that have been set directly in the project schema
- *
- * @todo It's unsound to discard dependencies in this way, should avoid
- *       collisions with aliases or similar any remote shape that collides,
- *       e.g., Shopify_Product -> Shopify_Product_2
- *
- * @param projectSchema A V3 project schema with remote service configs.
- *
- * @returns A `Set` of shape names.
- */
-function getNamespacedShapeNameList(projectSchema) {
-    const requiredShapeNames = new Set();
-    // All the shape names
-    const existingShapeNames = new Set(Object.keys(projectSchema.shapes));
-    // All the referenced shape names with namespaces that belong to a service
-    const namespacedShapeNames = new Set(getAllNamespaceShapes(projectSchema));
-    // Add all namespaced shapes to the schema if they are not already present,
-    // e.g. Shopify_Product
-    for (const name of namespacedShapeNames) {
-        if (!existingShapeNames.has(name)) {
-            requiredShapeNames.add(name);
-        }
-    }
-    return requiredShapeNames;
-}
-/**
- * Filter the service map to return only services passing the GraphQL Service
- * typeguard.
- *
- * @param serviceMap A service map.
- *
- * @returns A new map with the filtered list of services
- */
-function filterGraphQLServiceMap(serviceMap) {
-    const filtered = new Map();
-    for (const [serviceKey, serviceConfig] of serviceMap) {
-        if (serviceConfig.serviceType === 'graphql') {
-            filtered.set(serviceKey, serviceConfig);
-        }
-    }
-    return filtered;
-}
-/**
- * Creates a schema property list chainable fn, allowing you to manipulate and
- * iterate the properties in a schema.
- */
-exports.createSchemaPropertyList = (0, curry_js_1.default)((context, shapeOrSchema) => {
-    const propSchema = isShape(shapeOrSchema) ? shapeOrSchema.schema : shapeOrSchema;
-    const schema = (0, refs_1.dereferenceSchema)(context, propSchema, isShape(shapeOrSchema) ? ['shapes', shapeOrSchema.name] : undefined);
-    const propertyIterator = new Map((0, types_1.isObjectSchema)(schema) ? Object.entries(schema.properties) : undefined);
-    const defaultOrderByIteratees = [(n) => n[0]];
-    const defaultOrderByOrders = ['asc'];
-    const _orderBy = (iteratees = defaultOrderByIteratees, orders = defaultOrderByOrders) => {
-        self._propertyIterator = new Map((0, orderBy_js_1.default)(iteratees, orders, Array.from(self._propertyIterator)));
-        return self;
-    };
-    const _sortWith = (comparator) => {
-        self._propertyIterator = new Map(Array.from(self._propertyIterator).sort(comparator));
-        return self;
-    };
-    const _sortByNamesWithList = (comparatorArray) => {
-        // If no array is provided, the original sort is preserved
-        if (comparatorArray) {
-            self._propertyIterator = new Map(Array.from(self._propertyIterator)
-                .filter(([name]) => comparatorArray.includes(name))
-                .sort(([nameA], [nameB]) => {
-                const indexA = comparatorArray.indexOf(nameA);
-                const indexB = comparatorArray.indexOf(nameB);
-                return ((indexA > -1 ? indexA : Number.POSITIVE_INFINITY) - (indexB > -1 ? indexB : Number.POSITIVE_INFINITY));
-            }));
-        }
-        return self;
-    };
-    const _filterBy = (predicate) => {
-        self._propertyIterator = new Map(Array.from(self._propertyIterator).filter(predicate));
-        return self;
-    };
-    const _forEach = (iteratee) => {
-        Array.from(self._propertyIterator).forEach(iteratee);
-        return self;
-    };
-    const _getNodes = () => {
-        return Array.from(self._propertyIterator);
-    };
-    const _getObject = () => {
-        return Array.from(self._propertyIterator).reduce((curr, node) => Object.assign(curr, { [node[0]]: node[1] }), {});
-    };
-    const _getNames = () => {
-        return Array.from(self._propertyIterator, ([name]) => name);
-    };
-    const _getValues = () => {
-        return Array.from(self._propertyIterator, ([, value]) => value);
-    };
-    const self = {
-        _propertyIterator: propertyIterator,
-        orderBy: _orderBy,
-        sortWith: _sortWith,
-        sortByNamesWithList: _sortByNamesWithList,
-        filterBy: _filterBy,
-        forEach: _forEach,
-        getNodes: _getNodes,
-        getObject: _getObject,
-        getNames: _getNames,
-        getValues: _getValues
-    };
-    return self;
-});
-function isShape(shapeOrSchema) {
-    return 'schema' in shapeOrSchema;
-}
-class SchemaPropertyAccessor {
-    schema;
-    properties;
-    entries;
-    constructor(context, shapeOrSchema) {
-        const propSchema = isShape(shapeOrSchema) ? shapeOrSchema.schema : shapeOrSchema;
-        this.schema = (0, refs_1.dereferenceSchema)(context, propSchema, isShape(shapeOrSchema) ? ['shapes', shapeOrSchema.name] : undefined);
-        this.entries = (0, types_1.isObjectSchema)(this.schema) ? Object.entries(this.schema.properties) : [];
-        this.properties = new Map(this.entries);
-    }
-    getValue(propertyName) {
-        return this.properties.get(propertyName);
-    }
-    findValue(predicate) {
-        return this.entries.find(predicate)?.[1];
-    }
-    findName(predicate) {
-        return this.entries.find(predicate)?.[0];
-    }
-    getKey(propertyName) {
-        const value = this.properties.get(propertyName);
-        if (value) {
-            return getStorageKey(value);
-        }
-    }
-}
-/**
- * Creates a schema property accessor, allowing you to safely access schema
- * properties.
- */
-exports.createSchemaPropertyAccessor = (0, curry_js_1.default)((context, shapeOrSchema) => {
-    return new SchemaPropertyAccessor(context, shapeOrSchema);
-});
-function findQueryHelper(slice, shapeName, resolver, type) {
-    const schemaPath = type === 'query' ? 'queries' : 'mutations';
-    return Object.keys(slice[schemaPath]).find((queryName) => {
-        const queryOrMutation = slice[schemaPath][queryName];
-        return (queryOrMutation.resolver.name === resolver &&
-            queryOrMutation.resolver.shapeName === shapeName);
-    });
-}
-function ensureQueryHelper(slice, shapeName, resolver, type) {
-    const foundQuery = findQueryHelper(slice, shapeName, resolver, type);
-    if (!foundQuery) {
-        throw new Error(`Failed to find a "${resolver}" ${type} for shape "${shapeName}"`);
-    }
-    return foundQuery;
-}
-/**
- * Find the query in the schema that corresponds to the given shape and resolver.
- */
-const findQueryByShape = (projectSchema, shapeName, resolver) => findQueryHelper(projectSchema, shapeName, resolver, 'query');
-exports.findQueryByShape = findQueryByShape;
-/**
- * Find the query in the schema that corresponds to the given shape and resolver.
- */
-const findMutationByShape = (projectSchema, shapeName, resolver) => findQueryHelper(projectSchema, shapeName, resolver, 'mutation');
-exports.findMutationByShape = findMutationByShape;
-/**
- * Find the query in the schema that corresponds to the given shape and resolver.
- * Throw an error if that query does not exist
- */
-const ensureQueryByShape = (projectSchema, shapeName, resolver) => ensureQueryHelper(projectSchema, shapeName, resolver, 'query');
-exports.ensureQueryByShape = ensureQueryByShape;
-/**
- * Find the mutation in the schema that corresponds to the given shape and resolver.
- * Throw an error if that mutation does not exist
- */
-const ensureMutationByShape = (projectSchema, shapeName, resolver) => ensureQueryHelper(projectSchema, shapeName, resolver, 'mutation');
-exports.ensureMutationByShape = ensureMutationByShape;
-/**
- * Find the query in the schema that corresponds to the given shape and resolver.
- */
-const getDefaultMutationName = (shapeName, resolver) => {
-    const action = resolver.substring(resolver.indexOf(':') + 1);
-    return `${action}${shapeName}`;
-};
-exports.getDefaultMutationName = getDefaultMutationName;
-function createShape(name, schema, rest) {
-    return {
-        name,
-        id: name,
-        title: name,
-        schema,
-        ...rest
-    };
-}
-function queryToPropertySchema(projectSchema, query) {
-    let mapping;
-    if ((0, types_1.isGraphqlResolver)(query.resolver)) {
-        mapping = (0, refs_1.serializePropertyRef)({
-            serviceId: query.resolver.service,
-            shapeName: 'Query',
-            propertyName: query.resolver.fieldName
-        });
-    }
-    return {
-        ...(0, refs_1.returnShapeToSchema)(projectSchema, query.shape),
-        ...(mapping ? { '@mapping': mapping } : {}),
-        '@resolver': query.resolver,
-        '@args': query.args
-    };
-}
-function getQueriesShape(projectSchema, operation) {
-    return createShape((0, util_1.pascalCase)(operation), {
-        type: 'object',
-        properties: (0, mapValues_js_1.default)(projectSchema[operation === 'query' ? 'queries' : 'mutations'], (query) => queryToPropertySchema(projectSchema, query))
-    });
-}
-function fieldMappingContainsKey(fieldMapping, key) {
-    if ((0, isArray_js_1.default)(fieldMapping)) {
-        return (0, some_js_1.default)(fieldMapping, (mapping) => parseMapping(mapping).key === key);
-    }
-    return parseMapping(fieldMapping).key === key;
-}
-/**
- * Return true if `schemaWithRef` is a ref to a shape named `shapeName`
- */
-function schemaMatchesShapeName(workingCopy, propertySchema, shapeName) {
-    const arrayOfShapeRef = (0, refs_1.getRef)(workingCopy, propertySchema);
-    return Boolean(arrayOfShapeRef && (0, refs_1.refItemToNamespacedShapeName)(arrayOfShapeRef) === shapeName);
-}
-/**
- * Return true if `shape` has a property that is an array of refs to `shapeName`
- */
-const shapeHasArrayPropOfShape = (projectSchema, shape, shapeName) => {
-    if (shape && (0, types_1.isObjectSchema)(shape.schema)) {
-        for (const propName in shape.schema.properties) {
-            if (Object.hasOwn(shape.schema.properties, propName)) {
-                const propSchema = shape.schema.properties[propName];
-                if (propSchema.items &&
-                    (0, types_1.isRefSchema)(propSchema.items) &&
-                    schemaMatchesShapeName(projectSchema, propSchema.items, shapeName)) {
-                    return true;
-                }
-            }
-        }
-    }
-    return false;
-};
-exports.shapeHasArrayPropOfShape = shapeHasArrayPropOfShape;
-const getQueryMapName = (type) => {
-    return type === 'query' ? 'queries' : 'mutations';
-};
-exports.getQueryMapName = getQueryMapName;