@takeshape/schema 11.40.0 → 11.41.0

package/es/schema-util.js

@@ -1,1166 +0,0 @@
-import find from 'lodash/find';
-import mapValues from 'lodash/mapValues';
-import keyBy from 'lodash/keyBy';
-import curry from 'lodash/fp/curry';
-import orderBy from 'lodash/fp/orderBy';
-import uniq from 'lodash/uniq';
-import { deepClone, visit, pascalCase, ensureArray } from '@takeshape/util';
-import isEqual from 'lodash/isEqual';
-import isString from 'lodash/isString';
-import { NotFoundError } from '@takeshape/errors';
-import isArray from 'lodash/isArray';
-import some from 'lodash/some';
-import { defaultWorkflow, getStatusField } from './workflows';
-import { CURRENT_API_VERSION, CURRENT_SCHEMA_VERSION } from './versions';
-import { workflowsEnabled } from './api-version';
-import { builtInShapes, builtInForms } from './builtin-schema';
-import { getArgsType, isObjectSchema, isAllOfSchema, isOneOfSchema, isExtendsSchema, isArraySchema, isServiceResolver, isGraphqlResolver, isRefSchema } from './types/utils';
-import { getStoredServiceConfig } from './services';
-import { createTemplateShapeName, dereferenceObjectSchema, dereferenceSchema, getRef, getRefOrItemsRef, getRefShapeName, parseReturnShape, refExpressionToRefItem, refItemToShape, refItemToNamespacedShapeName, refItemToShapeSchema, atRefToRefItem, refToRefItem, parseTemplateShape, returnShapeToSchema, serializePropertyRef } from './refs';
-import { isUnionSchema } from './unions';
-import { mergeFormProperties, mergeSchemaProperties, getArgs } from './util';
-export const SERVICE_OBJECT_PATTERN_NAME = 'pattern:service-object';
-export function isBuiltinShape(shapeName) {
-  return Boolean(builtInShapes[shapeName]);
-}
-const builtInQueriesAndMutations = getShapeQueriesAndMutations(Object.values(builtInShapes));
-export function isBuiltinQuery(name) {
-  return builtInQueriesAndMutations.queries[name] !== undefined;
-}
-export function isBuiltinMutation(name) {
-  return builtInQueriesAndMutations.mutations[name] !== undefined;
-}
-export function isBuiltinType(projectSchema, refSchema) {
-  const shapeName = getRefShapeName(projectSchema, refSchema);
-  return shapeName !== undefined && isBuiltinShape(shapeName);
-}
-export const schemaMetadataKeys = ['$comment', 'title', 'description', '@l10n', '@deprecationReason', '@tag', '@tags', '@syncLocaleStructure', '@sensitive'];
-export const commonSchemaKeys = ['type', 'default', 'readOnly', ...schemaMetadataKeys];
-export const scalarSchemaKeys = [...commonSchemaKeys, 'format', 'oneOf', 'multipleOf', 'maximum', 'exclusiveMaximum', 'minimum', 'exclusiveMinimum', 'maxLength', 'minLength', 'pattern'];
-export const objectSchemaKeys = [...commonSchemaKeys, 'properties', 'required'];
-export const arraySchemaKeys = [...commonSchemaKeys, 'items', 'additionalItems', 'maxItems', 'minItems', 'uniqueItems'];
-export const multipleRelationshipSchemaKeys = [...schemaMetadataKeys, 'maxItems', 'minItems'];
-
-// All properties except properties, items, additionalItems
-export const nonStructuralSchemaKeys = [...scalarSchemaKeys, '@resolver', '@input', '@output', '@backreference', '@args', 'required', 'maxItems', 'minItems', 'uniqueItems'];
-export function getServiceIdFieldName(serviceFieldName) {
-  return `${serviceFieldName}Id`;
-}
-const generatorVersions = {
-  [SERVICE_OBJECT_PATTERN_NAME]: '1'
-};
-export function getGeneratorVersion(generator) {
-  return generatorVersions[generator];
-}
-
-// Returns info for all services found in shape, keyed by provider
-export function getServiceInfo(projectSchema, shape) {
-  const result = {};
-
-  // Get inline dependencies by not following refs with @resolver
-  const inlineDepShapes = getShapeDependencies(projectSchema, shape, prop => !prop['@resolver']).map(name => projectSchema.shapes[name]);
-  const shapesToCheck = [shape, ...inlineDepShapes];
-  shapesToCheck.forEach(thisShape => {
-    createSchemaPropertyList(projectSchema, thisShape).forEach(([key, value]) => {
-      const resolver = value['@resolver'];
-      if (!isServiceResolver(resolver)) {
-        return;
-      }
-      const serviceConfig = getStoredServiceConfig(projectSchema, resolver.service);
-      if (!serviceConfig) {
-        return;
-      }
-      const {
-        provider
-      } = serviceConfig;
-      const generators = {};
-      const tag = value['@tag'];
-      if (tag?.startsWith(SERVICE_OBJECT_PATTERN_NAME)) {
-        const idFieldName = getServiceIdFieldName(key);
-        const version = tag.substr(tag.lastIndexOf(':') + 1);
-        generators[SERVICE_OBJECT_PATTERN_NAME] = {
-          version,
-          currentVersion: getGeneratorVersion(SERVICE_OBJECT_PATTERN_NAME),
-          idFieldName,
-          serviceObjectType: resolver.fieldName
-        };
-      }
-      const serviceInfo = {
-        service: resolver.service,
-        fieldName: key,
-        path: pathBetween(shape, thisShape, projectSchema),
-        generators
-      };
-      if (Array.isArray(result[provider])) {
-        // Dedupe service info
-        if (!result[provider].find(existingServiceInfo => isEqual(existingServiceInfo, serviceInfo))) {
-          result[provider].push(serviceInfo);
-        }
-      } else {
-        result[provider] = [serviceInfo];
-      }
-    });
-  });
-  return result;
-}
-
-// Follow refs to find the path between two shapes in a schema
-export 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 = getRef(projectSchema, schema);
-    if (refItem) {
-      const referenced = 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 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;
-}
-export function getShapeQueriesAndMutations(shapes) {
-  const queries = {};
-  const mutations = {};
-  for (const shape of 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 ? createTemplateShapeName('TSGetSingletonArgs', name) : createTemplateShapeName('TSGetArgs', name)
-      };
-      mutations[`update${name}`] = {
-        shape: createTemplateShapeName('UpdateResult', name),
-        resolver: {
-          name: 'shapedb:update',
-          service,
-          shapeName: name
-        },
-        description: `Update ${name}`,
-        args: createTemplateShapeName('UpdateArgs', name)
-      };
-      if (!isSingleton) {
-        queries[`get${name}List`] = {
-          shape: createTemplateShapeName('PaginatedList', name),
-          resolver: {
-            name: 'shapedb:list',
-            service,
-            shapeName: name
-          },
-          description: `Returns a list ${name} in natural order.`,
-          args: createTemplateShapeName('TSListArgs', name)
-        };
-        mutations[`create${name}`] = {
-          shape: createTemplateShapeName('CreateResult', name),
-          resolver: {
-            name: 'shapedb:create',
-            service,
-            shapeName: name
-          },
-          description: `Create ${name}`,
-          args: createTemplateShapeName('CreateArgs', name)
-        };
-        mutations[`duplicate${name}`] = {
-          shape: createTemplateShapeName('DuplicateResult', name),
-          resolver: {
-            name: 'shapedb:duplicate',
-            service,
-            shapeName: name
-          },
-          description: `Duplicate ${name}`,
-          args: createTemplateShapeName('DuplicateArgs', name)
-        };
-        mutations[`delete${name}`] = {
-          shape: createTemplateShapeName('DeleteResult', name),
-          resolver: {
-            name: 'shapedb:delete',
-            service,
-            shapeName: name
-          },
-          description: `Delete ${name}`,
-          args: createTemplateShapeName('DeleteArgs', name)
-        };
-      }
-    }
-  }
-  return {
-    queries,
-    mutations
-  };
-}
-export function getCommonBuiltInProperties(shape) {
-  return {
-    _id: {
-      title: 'Id',
-      type: 'string'
-    },
-    _shapeId: {
-      type: 'string',
-      title: 'Shape Id',
-      enum: [shape.id]
-    }
-  };
-}
-export const DEFAULT_ID_FIELD = 'id';
-export function getIdField(obj) {
-  return obj?.idField ?? 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']
-      } : {})
-    }
-  };
-}
-export function getModelBuiltInProperties(projectSchema, shape) {
-  const apiVersion = projectSchema.apiVersion ?? 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 (workflowsEnabled(apiVersion)) {
-    return {
-      ...properties,
-      _status: {
-        ...(projectSchema.workflows && getStatusField(projectSchema.workflows, shape))
-      }
-    };
-  }
-  return properties;
-}
-
-/**
- * Return all the built in property names,
- */
-export 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);
-}
-export let BuiltInPropertiesProfile = /*#__PURE__*/function (BuiltInPropertiesProfile) {
-  BuiltInPropertiesProfile[BuiltInPropertiesProfile["Model"] = 0] = "Model";
-  BuiltInPropertiesProfile[BuiltInPropertiesProfile["Cached"] = 1] = "Cached";
-  BuiltInPropertiesProfile[BuiltInPropertiesProfile["None"] = 2] = "None";
-  return BuiltInPropertiesProfile;
-}({});
-const BUILT_IN_PROPERTY_NAMES = {
-  [BuiltInPropertiesProfile.Model]: getBuiltInPropertyNames(BuiltInPropertiesProfile.Model),
-  [BuiltInPropertiesProfile.Cached]: getBuiltInPropertyNames(BuiltInPropertiesProfile.Cached),
-  [BuiltInPropertiesProfile.None]: getBuiltInPropertyNames(BuiltInPropertiesProfile.None)
-};
-export const isBuiltInPropertyName = (name, profile = BuiltInPropertiesProfile.Model) => {
-  return BUILT_IN_PROPERTY_NAMES[profile].has(name);
-};
-
-/**
- * Get the profile to use for loading built-in properties
- */
-function getBuiltInPropertiesProfile(shape) {
-  if (isModelShape(shape)) {
-    return BuiltInPropertiesProfile.Model;
-  }
-  if (isCachedShape(shape)) {
-    return BuiltInPropertiesProfile.Cached;
-  }
-  return BuiltInPropertiesProfile.None;
-}
-export function applyBuiltinPropertiesToShape(projectSchema, shape) {
-  const profile = getBuiltInPropertiesProfile(shape);
-  if (profile === BuiltInPropertiesProfile.None) {
-    return shape;
-  }
-  const shapeObjectSchema = 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.
- */
-export function getBuiltinsUsed(projectSchema) {
-  const builtinsUsed = {};
-  const shapeNames = uniq(requiredBuiltinShapes.concat(getAllRefs(projectSchema, refItem => refItem.serviceKey === 'local' && isBuiltinShape(refItem.typeName)).map(refItemToNamespacedShapeName)));
-  const schemaWithAllBuiltins = {
-    ...emptySchema('project-id'),
-    shapes: builtInShapes
-  };
-  shapeNames.forEach(builtinShapeName => {
-    builtinsUsed[builtinShapeName] = builtInShapes[builtinShapeName];
-    getShapeDependencies(schemaWithAllBuiltins, builtInShapes[builtinShapeName]).forEach(depShapeName => {
-      builtinsUsed[depShapeName] = builtInShapes[depShapeName];
-    });
-  });
-  return builtinsUsed;
-}
-export function applyDefaultsToSchema(projectSchema) {
-  const builtinsUsed = getBuiltinsUsed(projectSchema);
-  return {
-    ...projectSchema,
-    workflows: {
-      ...projectSchema.workflows,
-      ...(workflowsEnabled(projectSchema.apiVersion) && {
-        default: defaultWorkflow
-      })
-    },
-    queries: {
-      ...builtInQueriesAndMutations.queries,
-      ...projectSchema.queries
-    },
-    mutations: {
-      ...builtInQueriesAndMutations.mutations,
-      ...projectSchema.mutations
-    },
-    shapes: mapValues({
-      ...builtinsUsed,
-      ...projectSchema.shapes
-    }, shape => {
-      const builtInShape = builtinsUsed[shape.name];
-      if (builtInShape && builtInShape !== shape) {
-        shape = {
-          ...shape,
-          schema: mergeSchemaProperties(dereferenceObjectSchema(projectSchema, shape.schema), dereferenceObjectSchema(projectSchema, builtInShape.schema))
-        };
-      }
-      return applyBuiltinPropertiesToShape(projectSchema, shape);
-    }),
-    forms: mapValues({
-      ...builtInForms,
-      ...projectSchema.forms
-    }, (formsConfig, shapeName) => {
-      const builtInFormsConfig = builtInForms[shapeName];
-      if (builtInFormsConfig && builtInFormsConfig !== formsConfig) {
-        formsConfig = {
-          ...formsConfig,
-          default: mergeFormProperties(formsConfig.default, builtInFormsConfig.default)
-        };
-      }
-      return formsConfig;
-    })
-  };
-}
-export function getShapeById(projectSchema, shapeId) {
-  return find(projectSchema.shapes, shape => shape.id === shapeId);
-}
-export function getShapeByRef(projectSchema, shapeRef) {
-  return refItemToShape(projectSchema, atRefToRefItem(projectSchema, shapeRef));
-}
-export function ensureShapeById(projectSchema, shapeId) {
-  const shape = getShapeById(projectSchema, shapeId);
-  if (!shape) {
-    throw new NotFoundError(`Shape with id "${shapeId}" Not found`);
-  }
-  return shape;
-}
-export function getShape(context, name) {
-  return context.shapes[name];
-}
-export function ensureShape(projectSchema, name) {
-  const shape = getShape(projectSchema, name);
-  if (!shape) {
-    throw new NotFoundError(`Shape "${name}" Not found`);
-  }
-  return shape;
-}
-export function isModelShape(shape) {
-  return Boolean(shape.model);
-}
-export function isCachedShape(shape) {
-  return shape.cache?.enabled === true && shape.loaders !== undefined;
-}
-export function getArgsReference(projectSchema, argsSchema) {
-  const args = getArgs(argsSchema);
-  if (args && typeof args === 'string') {
-    // @args: ShapeName OR Namespace_TypeName
-    return refExpressionToRefItem(projectSchema, args);
-  }
-}
-export function getArgsReferenceWithPath(context, argsSchema, schemaPath = []) {
-  const refItem = getArgsReference(context, argsSchema);
-  if (refItem) {
-    const argsType = getArgsType(argsSchema);
-    return {
-      ...refItem,
-      path: schemaPath.concat([argsType])
-    };
-  }
-}
-export function getArgsShapeSchema(context, argsSchema) {
-  const args = getArgs(argsSchema);
-  if (args) {
-    if (typeof args === 'string') {
-      const refItem = getArgsReference(context, argsSchema);
-      if (refItem) {
-        return 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 (isOneOfSchema(propSchema)) {
-        const isUnion = isUnionSchema(propSchema);
-        if (useShapeIdDiscriminator && isUnion) {
-          propSchema.discriminator = {
-            propertyName: '_shapeId'
-          };
-          propSchema.required = ['_shapeId'];
-        }
-        propSchema.oneOf.forEach(schema => {
-          handleSchema(schema);
-        });
-        return;
-      }
-
-      // Add workflow validation
-      if (propSchema['@workflow']) {
-        const workflowName = propSchema['@workflow'];
-        const workflow = projectSchema.workflows[workflowName] || defaultWorkflow;
-        propSchema.oneOf = workflow.steps.map(step => ({
-          enum: [step.key, step.name],
-          title: step.title
-        }));
-      }
-      const refItem = getRef(projectSchema, propSchema);
-      if (refItem) {
-        const shapeName = refItemToNamespacedShapeName(refItem);
-        const shape = 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 && isObjectSchema(rewritten)) {
-              rewritten.properties._shapeId = {
-                type: 'string',
-                enum: [shape.id]
-              };
-            }
-            definitions[shapeName] = rewritten;
-          }
-        }
-      }
-    };
-    const shapeSchema = deepClone(shape.schema);
-    if (isOneOfSchema(shapeSchema)) {
-      handleSchema(shapeSchema);
-      return shapeSchema;
-    }
-    if (shapeSchema.enum) {
-      return shapeSchema;
-    }
-    const shapeSchemaCopy = dereferenceObjectSchema(projectSchema, shapeSchema);
-    if (shape.title) {
-      shapeSchemaCopy.title = shape.title;
-    }
-    Object.values(shapeSchemaCopy.properties).forEach(schema => {
-      handleSchema(schema);
-    });
-    return shapeSchemaCopy;
-  };
-  return rewriteRefs;
-};
-export function shapeToPropertySchema(projectSchema, shape) {
-  const definitions = {};
-  const definitionNames = new Set();
-  const convert = createShapeToPropertySchema(projectSchema, definitions, definitionNames, {
-    useShapeIdDiscriminator: true
-  });
-  return {
-    ...convert(shape),
-    definitions
-  };
-}
-export 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
-  };
-}
-export 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 = getRef(projectSchema, schema);
-      if (refItem) {
-        const refShape = refItemToShape(projectSchema, refItem);
-        if (refShape && !shapeNames.has(refShape.name)) {
-          shapeNames.add(refShape.name);
-          findDependencies(dereferenceSchema(projectSchema, refShape.schema, ['shapes', refShape.name]));
-        }
-      } else if (isObjectSchema(schema) || isAllOfSchema(schema) || isOneOfSchema(schema)) {
-        visitSchemaProperties(schema, [], findDependencies);
-      }
-    }
-    return shouldFollow;
-  };
-  findDependencies(shape.schema);
-  return [...shapeNames];
-}
-export 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 {};
-}
-
-/**
- * Visitor callback return false to stop iterating
- */
-
-export 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 (isArraySchema(schema)) {
-      visit(schema.items, [...path, 'items']);
-    } else if (isObjectSchema(schema)) {
-      visitEach(Object.entries(schema.properties), [...path, 'properties']);
-    } else if (isExtendsSchema(schema)) {
-      visitEach(Object.entries(schema.extends), [...path, 'extends']);
-    } else if (isAllOfSchema(schema)) {
-      visitEach(Object.entries(schema.allOf), [...path, 'allOf']);
-    } else if (isOneOfSchema(schema)) {
-      visitEach(Object.entries(schema.oneOf), [...path, 'oneOf']);
-    }
-  };
-  visit(root, path);
-}
-export 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.
- */
-export function getAllRefsInShapes(projectSchema, predicate) {
-  const items = [];
-  const refPropNames = ['$ref', '@ref', '@args', 'args', 'interfaces'];
-  visit(projectSchema.shapes, refPropNames, (interfaces, refPath) => {
-    const propName = refPath[refPath.length - 1];
-    const path = ['shapes', ...refPath];
-    if (propName === 'interfaces' && isArray(interfaces)) {
-      interfaces.forEach((interfaceRefExpression, index) => {
-        addRef(items, {
-          ...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 (!isString(interfaces)) {
-      return;
-    }
-    if (propName === '@ref') {
-      const {
-        shapeName,
-        template
-      } = parseTemplateShape(interfaces);
-      addRef(items, {
-        ...atRefToRefItem(projectSchema, shapeName, template),
-        path
-      }, predicate);
-    } else if (propName === '$ref') {
-      addRef(items, {
-        ...refToRefItem(projectSchema, interfaces),
-        path
-      }, predicate);
-    } else if (propName === '@args' || propName === 'args') {
-      addRef(items, {
-        ...refExpressionToRefItem(projectSchema, interfaces),
-        path
-      }, predicate);
-    }
-  });
-  return items;
-}
-
-/**
- * Get all refs
- */
-export function getAllRefsInQuery(projectSchema, queryPath, query, predicate) {
-  const refItems = [];
-  const propertyVisitor = (propSchema, propSchemaPath) => {
-    addRef(refItems, 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(dereferenceObjectSchema(projectSchema, query.args), [...queryPath, 'args'], propertyVisitor);
-  }
-  if (query.shape) {
-    const {
-      isArray,
-      ref
-    } = 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`.
- */
-export 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
- */
-export function getAllRefs(projectSchema, predicate) {
-  return [...getAllRefsInShapes(projectSchema, predicate), ...getAllRefsInQueries(projectSchema, 'queries', predicate), ...getAllRefsInQueries(projectSchema, 'mutations', predicate)];
-}
-export function isValidRefItem(refItem) {
-  return refItem.isValidService;
-}
-
-/**
- * Get all valid refs in a ProjectSchemaJSON
- * @param predicate return true to include the ref in
- */
-export function getAllValidRefs(projectSchema, predicate) {
-  return getAllRefs(projectSchema, predicate).filter(isValidRefItem);
-}
-export function parseMapping(mapping) {
-  const [providerId, serviceId, coordinate] = mapping.split(':');
-  const [shapeName, key] = coordinate.split('.');
-  return {
-    providerId,
-    serviceId,
-    shapeName,
-    key
-  };
-}
-export function splitMapping(mapping) {
-  const parts = mapping.split('.');
-  return [parts[0], parts.slice(1).join('.')];
-}
-export function findMapping(schema, predicate) {
-  const mapping = schema['@mapping'];
-  if (Array.isArray(mapping)) {
-    return mapping.find(predicate);
-  }
-  return mapping && predicate(mapping) ? mapping : undefined;
-}
-export function getFirstMapping(schema) {
-  return Array.isArray(schema['@mapping']) ? schema['@mapping'][0] : schema['@mapping'];
-}
-export 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
- */
-export function getStorageKey(schema) {
-  const first = findMapping(schema, mapping => mapping.startsWith('shapedb:'));
-  return first ? splitMapping(first)[1] : undefined;
-}
-export function getPropertyService(schema) {
-  const first = getFirstMapping(schema);
-  const split = first?.split(':');
-  return split ? `${split[0]}:${split[1]}` : undefined;
-}
-export function emptySchema(projectId) {
-  return {
-    projectId,
-    defaultLocale: 'en-us',
-    locales: ['en-us'],
-    apiVersion: '2',
-    schemaVersion: CURRENT_SCHEMA_VERSION,
-    queries: {},
-    mutations: {},
-    shapes: {},
-    workflows: {},
-    forms: {}
-  };
-}
-export function createLayerSchema(partialSchema) {
-  return {
-    schemaVersion: CURRENT_SCHEMA_VERSION,
-    queries: {},
-    mutations: {},
-    shapes: {},
-    ...partialSchema
-  };
-}
-export function getShapesById(projectSchema) {
-  return keyBy(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.
- */
-export function getAllNamespaceShapes(projectSchema) {
-  const isServiceRef = refItem => Boolean(refItem.serviceNamespace);
-  return uniq(getAllValidRefs(projectSchema, isServiceRef).map(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.
- */
-export 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
-  namespacedShapeNames.forEach(name => {
-    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
- */
-export 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.
- */
-export const createSchemaPropertyList = curry((context, shapeOrSchema) => {
-  const propSchema = isShape(shapeOrSchema) ? shapeOrSchema.schema : shapeOrSchema;
-  const schema = dereferenceSchema(context, propSchema, isShape(shapeOrSchema) ? ['shapes', shapeOrSchema.name] : undefined);
-  const propertyIterator = new Map(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(orderBy(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 : Infinity) - (indexB > -1 ? indexB : 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 {
-  constructor(context, shapeOrSchema) {
-    const propSchema = isShape(shapeOrSchema) ? shapeOrSchema.schema : shapeOrSchema;
-    this.schema = dereferenceSchema(context, propSchema, isShape(shapeOrSchema) ? ['shapes', shapeOrSchema.name] : undefined);
-    this.entries = 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.
- */
-export const createSchemaPropertyAccessor = curry((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.
- */
-export const findQueryByShape = (projectSchema, shapeName, resolver) => findQueryHelper(projectSchema, shapeName, resolver, 'query');
-/**
- * Find the query in the schema that corresponds to the given shape and resolver.
- */
-export const findMutationByShape = (projectSchema, shapeName, resolver) => findQueryHelper(projectSchema, shapeName, resolver, 'mutation');
-
-/**
- * Find the query in the schema that corresponds to the given shape and resolver.
- * Throw an error if that query does not exist
- */
-export const ensureQueryByShape = (projectSchema, shapeName, resolver) => ensureQueryHelper(projectSchema, shapeName, resolver, 'query');
-/**
- * Find the mutation in the schema that corresponds to the given shape and resolver.
- * Throw an error if that mutation does not exist
- */
-export const ensureMutationByShape = (projectSchema, shapeName, resolver) => ensureQueryHelper(projectSchema, shapeName, resolver, 'mutation');
-/**
- * Find the query in the schema that corresponds to the given shape and resolver.
- */
-export const getDefaultMutationName = (shapeName, resolver) => {
-  const action = resolver.substring(resolver.indexOf(':') + 1);
-  return `${action}${shapeName}`;
-};
-export function createShape(name, schema, rest) {
-  return {
-    name,
-    id: name,
-    title: name,
-    schema,
-    ...rest
-  };
-}
-export function queryToPropertySchema(projectSchema, query) {
-  let mapping;
-  if (isGraphqlResolver(query.resolver)) {
-    mapping = serializePropertyRef({
-      serviceId: query.resolver.service,
-      shapeName: 'Query',
-      propertyName: query.resolver.fieldName
-    });
-  }
-  return {
-    ...returnShapeToSchema(projectSchema, query.shape),
-    ...(mapping ? {
-      '@mapping': mapping
-    } : {}),
-    '@resolver': query.resolver,
-    '@args': query.args
-  };
-}
-export function getQueriesShape(projectSchema, operation) {
-  return createShape(pascalCase(operation), {
-    type: 'object',
-    properties: mapValues(projectSchema[operation === 'query' ? 'queries' : 'mutations'], query => queryToPropertySchema(projectSchema, query))
-  });
-}
-export function fieldMappingContainsKey(fieldMapping, key) {
-  if (isArray(fieldMapping)) {
-    return some(fieldMapping, mapping => parseMapping(mapping).key === key);
-  }
-  return parseMapping(fieldMapping).key === key;
-}
-
-/**
- * Return true if `schemaWithRef` is a ref to a shape named `shapeName`
- */
-export function schemaMatchesShapeName(workingCopy, propertySchema, shapeName) {
-  const arrayOfShapeRef = getRef(workingCopy, propertySchema);
-  return Boolean(arrayOfShapeRef && refItemToNamespacedShapeName(arrayOfShapeRef) === shapeName);
-}
-
-/**
- * Return true if `shape` has a property that is an array of refs to `shapeName`
- */
-export const shapeHasArrayPropOfShape = (projectSchema, shape, shapeName) => {
-  if (shape && 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 && isRefSchema(propSchema.items) && schemaMatchesShapeName(projectSchema, propSchema.items, shapeName)) {
-          return true;
-        }
-      }
-    }
-  }
-  return false;
-};
-export const getQueryMapName = type => {
-  return type === 'query' ? 'queries' : 'mutations';
-};