@takeshape/schema 11.40.0 → 11.41.0

package/dist/schema-util.js

@@ -1,1247 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.SERVICE_OBJECT_PATTERN_NAME = exports.DEFAULT_ID_FIELD = exports.BuiltInPropertiesProfile = void 0;
-exports.applyBuiltinPropertiesToShape = applyBuiltinPropertiesToShape;
-exports.applyDefaultsToSchema = applyDefaultsToSchema;
-exports.commonSchemaKeys = exports.arraySchemaKeys = void 0;
-exports.createLayerSchema = createLayerSchema;
-exports.createSchemaPropertyList = exports.createSchemaPropertyAccessor = void 0;
-exports.createShape = createShape;
-exports.emptySchema = emptySchema;
-exports.ensureQueryByShape = exports.ensureMutationByShape = void 0;
-exports.ensureShape = ensureShape;
-exports.ensureShapeById = ensureShapeById;
-exports.fieldMappingContainsKey = fieldMappingContainsKey;
-exports.filterGraphQLServiceMap = filterGraphQLServiceMap;
-exports.findMapping = findMapping;
-exports.findQueryByShape = exports.findMutationByShape = void 0;
-exports.getAllNamespaceShapes = getAllNamespaceShapes;
-exports.getAllRefs = getAllRefs;
-exports.getAllRefsInQueries = getAllRefsInQueries;
-exports.getAllRefsInQuery = getAllRefsInQuery;
-exports.getAllRefsInShapes = getAllRefsInShapes;
-exports.getAllValidRefs = getAllValidRefs;
-exports.getArgsReference = getArgsReference;
-exports.getArgsReferenceWithPath = getArgsReferenceWithPath;
-exports.getArgsShapeSchema = getArgsShapeSchema;
-exports.getBuiltInPropertyNames = getBuiltInPropertyNames;
-exports.getBuiltinsUsed = getBuiltinsUsed;
-exports.getCommonBuiltInProperties = getCommonBuiltInProperties;
-exports.getDefaultMutationName = void 0;
-exports.getFirstMapping = getFirstMapping;
-exports.getFullyQualifiedShapeName = getFullyQualifiedShapeName;
-exports.getGeneratorVersion = getGeneratorVersion;
-exports.getIdField = getIdField;
-exports.getModelBuiltInProperties = getModelBuiltInProperties;
-exports.getNamespacedShapeNameList = getNamespacedShapeNameList;
-exports.getPropertyService = getPropertyService;
-exports.getQueriesShape = getQueriesShape;
-exports.getQueryMapName = void 0;
-exports.getRelevantShapes = getRelevantShapes;
-exports.getServiceIdFieldName = getServiceIdFieldName;
-exports.getServiceInfo = getServiceInfo;
-exports.getShape = getShape;
-exports.getShapeById = getShapeById;
-exports.getShapeByRef = getShapeByRef;
-exports.getShapeDependencies = getShapeDependencies;
-exports.getShapeQueriesAndMutations = getShapeQueriesAndMutations;
-exports.getShapesById = getShapesById;
-exports.getStorageKey = getStorageKey;
-exports.isBuiltInPropertyName = void 0;
-exports.isBuiltinMutation = isBuiltinMutation;
-exports.isBuiltinQuery = isBuiltinQuery;
-exports.isBuiltinShape = isBuiltinShape;
-exports.isBuiltinType = isBuiltinType;
-exports.isCachedShape = isCachedShape;
-exports.isModelShape = isModelShape;
-exports.isValidRefItem = isValidRefItem;
-exports.objectSchemaKeys = exports.nonStructuralSchemaKeys = exports.multipleRelationshipSchemaKeys = void 0;
-exports.parseMapping = parseMapping;
-exports.pathBetween = pathBetween;
-exports.projectSchemaToJSONSchema = projectSchemaToJSONSchema;
-exports.queryToPropertySchema = queryToPropertySchema;
-exports.scalarSchemaKeys = void 0;
-exports.schemaMatchesShapeName = schemaMatchesShapeName;
-exports.shapeHasArrayPropOfShape = exports.schemaMetadataKeys = void 0;
-exports.shapeToPropertySchema = shapeToPropertySchema;
-exports.splitMapping = splitMapping;
-exports.visitSchemaProperties = visitSchemaProperties;
-exports.visitShapeProperties = visitShapeProperties;
-var _find = _interopRequireDefault(require("lodash/find"));
-var _mapValues = _interopRequireDefault(require("lodash/mapValues"));
-var _keyBy = _interopRequireDefault(require("lodash/keyBy"));
-var _curry = _interopRequireDefault(require("lodash/fp/curry"));
-var _orderBy2 = _interopRequireDefault(require("lodash/fp/orderBy"));
-var _uniq = _interopRequireDefault(require("lodash/uniq"));
-var _util = require("@takeshape/util");
-var _isEqual = _interopRequireDefault(require("lodash/isEqual"));
-var _isString = _interopRequireDefault(require("lodash/isString"));
-var _errors = require("@takeshape/errors");
-var _isArray = _interopRequireDefault(require("lodash/isArray"));
-var _some = _interopRequireDefault(require("lodash/some"));
-var _workflows = require("./workflows");
-var _versions = require("./versions");
-var _apiVersion = require("./api-version");
-var _builtinSchema = require("./builtin-schema");
-var _utils = require("./types/utils");
-var _services = require("./services");
-var _refs = require("./refs");
-var _unions = require("./unions");
-var _util2 = require("./util");
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
-const SERVICE_OBJECT_PATTERN_NAME = exports.SERVICE_OBJECT_PATTERN_NAME = 'pattern:service-object';
-function isBuiltinShape(shapeName) {
-  return Boolean(_builtinSchema.builtInShapes[shapeName]);
-}
-const builtInQueriesAndMutations = getShapeQueriesAndMutations(Object.values(_builtinSchema.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.getRefShapeName)(projectSchema, refSchema);
-  return shapeName !== undefined && isBuiltinShape(shapeName);
-}
-const schemaMetadataKeys = exports.schemaMetadataKeys = ['$comment', 'title', 'description', '@l10n', '@deprecationReason', '@tag', '@tags', '@syncLocaleStructure', '@sensitive'];
-const commonSchemaKeys = exports.commonSchemaKeys = ['type', 'default', 'readOnly', ...schemaMetadataKeys];
-const scalarSchemaKeys = exports.scalarSchemaKeys = [...commonSchemaKeys, 'format', 'oneOf', 'multipleOf', 'maximum', 'exclusiveMaximum', 'minimum', 'exclusiveMinimum', 'maxLength', 'minLength', 'pattern'];
-const objectSchemaKeys = exports.objectSchemaKeys = [...commonSchemaKeys, 'properties', 'required'];
-const arraySchemaKeys = exports.arraySchemaKeys = [...commonSchemaKeys, 'items', 'additionalItems', 'maxItems', 'minItems', 'uniqueItems'];
-const multipleRelationshipSchemaKeys = exports.multipleRelationshipSchemaKeys = [...schemaMetadataKeys, 'maxItems', 'minItems'];
-
-// All properties except properties, items, additionalItems
-const nonStructuralSchemaKeys = exports.nonStructuralSchemaKeys = [...scalarSchemaKeys, '@resolver', '@input', '@output', '@backreference', '@args', 'required', 'maxItems', 'minItems', 'uniqueItems'];
-function getServiceIdFieldName(serviceFieldName) {
-  return `${serviceFieldName}Id`;
-}
-const generatorVersions = {
-  [SERVICE_OBJECT_PATTERN_NAME]: '1'
-};
-function getGeneratorVersion(generator) {
-  return generatorVersions[generator];
-}
-
-// Returns info for all services found in shape, keyed by provider
-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 (!(0, _utils.isServiceResolver)(resolver)) {
-        return;
-      }
-      const serviceConfig = (0, _services.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 => (0, _isEqual.default)(existingServiceInfo, serviceInfo))) {
-          result[provider].push(serviceInfo);
-        }
-      } else {
-        result[provider] = [serviceInfo];
-      }
-    });
-  });
-  return result;
-}
-
-// 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.getRef)(projectSchema, schema);
-    if (refItem) {
-      const referenced = (0, _refs.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;
-}
-function getShapeQueriesAndMutations(shapes) {
-  const queries = {};
-  const mutations = {};
-  for (const shape of (0, _util.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.createTemplateShapeName)('TSGetSingletonArgs', name) : (0, _refs.createTemplateShapeName)('TSGetArgs', name)
-      };
-      mutations[`update${name}`] = {
-        shape: (0, _refs.createTemplateShapeName)('UpdateResult', name),
-        resolver: {
-          name: 'shapedb:update',
-          service,
-          shapeName: name
-        },
-        description: `Update ${name}`,
-        args: (0, _refs.createTemplateShapeName)('UpdateArgs', name)
-      };
-      if (!isSingleton) {
-        queries[`get${name}List`] = {
-          shape: (0, _refs.createTemplateShapeName)('PaginatedList', name),
-          resolver: {
-            name: 'shapedb:list',
-            service,
-            shapeName: name
-          },
-          description: `Returns a list ${name} in natural order.`,
-          args: (0, _refs.createTemplateShapeName)('TSListArgs', name)
-        };
-        mutations[`create${name}`] = {
-          shape: (0, _refs.createTemplateShapeName)('CreateResult', name),
-          resolver: {
-            name: 'shapedb:create',
-            service,
-            shapeName: name
-          },
-          description: `Create ${name}`,
-          args: (0, _refs.createTemplateShapeName)('CreateArgs', name)
-        };
-        mutations[`duplicate${name}`] = {
-          shape: (0, _refs.createTemplateShapeName)('DuplicateResult', name),
-          resolver: {
-            name: 'shapedb:duplicate',
-            service,
-            shapeName: name
-          },
-          description: `Duplicate ${name}`,
-          args: (0, _refs.createTemplateShapeName)('DuplicateArgs', name)
-        };
-        mutations[`delete${name}`] = {
-          shape: (0, _refs.createTemplateShapeName)('DeleteResult', name),
-          resolver: {
-            name: 'shapedb:delete',
-            service,
-            shapeName: name
-          },
-          description: `Delete ${name}`,
-          args: (0, _refs.createTemplateShapeName)('DeleteArgs', name)
-        };
-      }
-    }
-  }
-  return {
-    queries,
-    mutations
-  };
-}
-function getCommonBuiltInProperties(shape) {
-  return {
-    _id: {
-      title: 'Id',
-      type: 'string'
-    },
-    _shapeId: {
-      type: 'string',
-      title: 'Shape Id',
-      enum: [shape.id]
-    }
-  };
-}
-const DEFAULT_ID_FIELD = exports.DEFAULT_ID_FIELD = 'id';
-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']
-      } : {})
-    }
-  };
-}
-function getModelBuiltInProperties(projectSchema, shape) {
-  const apiVersion = projectSchema.apiVersion ?? _versions.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, _apiVersion.workflowsEnabled)(apiVersion)) {
-    return {
-      ...properties,
-      _status: {
-        ...(projectSchema.workflows && (0, _workflows.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);
-}
-let BuiltInPropertiesProfile = exports.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)
-};
-const isBuiltInPropertyName = (name, profile = BuiltInPropertiesProfile.Model) => {
-  return BUILT_IN_PROPERTY_NAMES[profile].has(name);
-};
-
-/**
- * Get the profile to use for loading built-in properties
- */
-exports.isBuiltInPropertyName = isBuiltInPropertyName;
-function getBuiltInPropertiesProfile(shape) {
-  if (isModelShape(shape)) {
-    return BuiltInPropertiesProfile.Model;
-  }
-  if (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.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.default)(requiredBuiltinShapes.concat(getAllRefs(projectSchema, refItem => refItem.serviceKey === 'local' && isBuiltinShape(refItem.typeName)).map(_refs.refItemToNamespacedShapeName)));
-  const schemaWithAllBuiltins = {
-    ...emptySchema('project-id'),
-    shapes: _builtinSchema.builtInShapes
-  };
-  shapeNames.forEach(builtinShapeName => {
-    builtinsUsed[builtinShapeName] = _builtinSchema.builtInShapes[builtinShapeName];
-    getShapeDependencies(schemaWithAllBuiltins, _builtinSchema.builtInShapes[builtinShapeName]).forEach(depShapeName => {
-      builtinsUsed[depShapeName] = _builtinSchema.builtInShapes[depShapeName];
-    });
-  });
-  return builtinsUsed;
-}
-function applyDefaultsToSchema(projectSchema) {
-  const builtinsUsed = getBuiltinsUsed(projectSchema);
-  return {
-    ...projectSchema,
-    workflows: {
-      ...projectSchema.workflows,
-      ...((0, _apiVersion.workflowsEnabled)(projectSchema.apiVersion) && {
-        default: _workflows.defaultWorkflow
-      })
-    },
-    queries: {
-      ...builtInQueriesAndMutations.queries,
-      ...projectSchema.queries
-    },
-    mutations: {
-      ...builtInQueriesAndMutations.mutations,
-      ...projectSchema.mutations
-    },
-    shapes: (0, _mapValues.default)({
-      ...builtinsUsed,
-      ...projectSchema.shapes
-    }, shape => {
-      const builtInShape = builtinsUsed[shape.name];
-      if (builtInShape && builtInShape !== shape) {
-        shape = {
-          ...shape,
-          schema: (0, _util2.mergeSchemaProperties)((0, _refs.dereferenceObjectSchema)(projectSchema, shape.schema), (0, _refs.dereferenceObjectSchema)(projectSchema, builtInShape.schema))
-        };
-      }
-      return applyBuiltinPropertiesToShape(projectSchema, shape);
-    }),
-    forms: (0, _mapValues.default)({
-      ..._builtinSchema.builtInForms,
-      ...projectSchema.forms
-    }, (formsConfig, shapeName) => {
-      const builtInFormsConfig = _builtinSchema.builtInForms[shapeName];
-      if (builtInFormsConfig && builtInFormsConfig !== formsConfig) {
-        formsConfig = {
-          ...formsConfig,
-          default: (0, _util2.mergeFormProperties)(formsConfig.default, builtInFormsConfig.default)
-        };
-      }
-      return formsConfig;
-    })
-  };
-}
-function getShapeById(projectSchema, shapeId) {
-  return (0, _find.default)(projectSchema.shapes, shape => shape.id === shapeId);
-}
-function getShapeByRef(projectSchema, shapeRef) {
-  return (0, _refs.refItemToShape)(projectSchema, (0, _refs.atRefToRefItem)(projectSchema, shapeRef));
-}
-function ensureShapeById(projectSchema, shapeId) {
-  const shape = getShapeById(projectSchema, shapeId);
-  if (!shape) {
-    throw new _errors.NotFoundError(`Shape with id "${shapeId}" Not found`);
-  }
-  return shape;
-}
-function getShape(context, name) {
-  return context.shapes[name];
-}
-function ensureShape(projectSchema, name) {
-  const shape = getShape(projectSchema, name);
-  if (!shape) {
-    throw new _errors.NotFoundError(`Shape "${name}" Not found`);
-  }
-  return shape;
-}
-function isModelShape(shape) {
-  return Boolean(shape.model);
-}
-function isCachedShape(shape) {
-  return shape.cache?.enabled === true && shape.loaders !== undefined;
-}
-function getArgsReference(projectSchema, argsSchema) {
-  const args = (0, _util2.getArgs)(argsSchema);
-  if (args && typeof args === 'string') {
-    // @args: ShapeName OR Namespace_TypeName
-    return (0, _refs.refExpressionToRefItem)(projectSchema, args);
-  }
-}
-function getArgsReferenceWithPath(context, argsSchema, schemaPath = []) {
-  const refItem = getArgsReference(context, argsSchema);
-  if (refItem) {
-    const argsType = (0, _utils.getArgsType)(argsSchema);
-    return {
-      ...refItem,
-      path: schemaPath.concat([argsType])
-    };
-  }
-}
-function getArgsShapeSchema(context, argsSchema) {
-  const args = (0, _util2.getArgs)(argsSchema);
-  if (args) {
-    if (typeof args === 'string') {
-      const refItem = getArgsReference(context, argsSchema);
-      if (refItem) {
-        return (0, _refs.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, _utils.isOneOfSchema)(propSchema)) {
-        const isUnion = (0, _unions.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] || _workflows.defaultWorkflow;
-        propSchema.oneOf = workflow.steps.map(step => ({
-          enum: [step.key, step.name],
-          title: step.title
-        }));
-      }
-      const refItem = (0, _refs.getRef)(projectSchema, propSchema);
-      if (refItem) {
-        const shapeName = (0, _refs.refItemToNamespacedShapeName)(refItem);
-        const shape = (0, _refs.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, _utils.isObjectSchema)(rewritten)) {
-              rewritten.properties._shapeId = {
-                type: 'string',
-                enum: [shape.id]
-              };
-            }
-            definitions[shapeName] = rewritten;
-          }
-        }
-      }
-    };
-    const shapeSchema = (0, _util.deepClone)(shape.schema);
-    if ((0, _utils.isOneOfSchema)(shapeSchema)) {
-      handleSchema(shapeSchema);
-      return shapeSchema;
-    }
-    if (shapeSchema.enum) {
-      return shapeSchema;
-    }
-    const shapeSchemaCopy = (0, _refs.dereferenceObjectSchema)(projectSchema, shapeSchema);
-    if (shape.title) {
-      shapeSchemaCopy.title = shape.title;
-    }
-    Object.values(shapeSchemaCopy.properties).forEach(schema => {
-      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.getRef)(projectSchema, schema);
-      if (refItem) {
-        const refShape = (0, _refs.refItemToShape)(projectSchema, refItem);
-        if (refShape && !shapeNames.has(refShape.name)) {
-          shapeNames.add(refShape.name);
-          findDependencies((0, _refs.dereferenceSchema)(projectSchema, refShape.schema, ['shapes', refShape.name]));
-        }
-      } else if ((0, _utils.isObjectSchema)(schema) || (0, _utils.isAllOfSchema)(schema) || (0, _utils.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 {};
-}
-
-/**
- * Visitor callback return false to stop iterating
- */
-
-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, _utils.isArraySchema)(schema)) {
-      visit(schema.items, [...path, 'items']);
-    } else if ((0, _utils.isObjectSchema)(schema)) {
-      visitEach(Object.entries(schema.properties), [...path, 'properties']);
-    } else if ((0, _utils.isExtendsSchema)(schema)) {
-      visitEach(Object.entries(schema.extends), [...path, 'extends']);
-    } else if ((0, _utils.isAllOfSchema)(schema)) {
-      visitEach(Object.entries(schema.allOf), [...path, 'allOf']);
-    } else if ((0, _utils.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.visit)(projectSchema.shapes, refPropNames, (interfaces, refPath) => {
-    const propName = refPath[refPath.length - 1];
-    const path = ['shapes', ...refPath];
-    if (propName === 'interfaces' && (0, _isArray.default)(interfaces)) {
-      interfaces.forEach((interfaceRefExpression, index) => {
-        addRef(items, {
-          ...(0, _refs.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.default)(interfaces)) {
-      return;
-    }
-    if (propName === '@ref') {
-      const {
-        shapeName,
-        template
-      } = (0, _refs.parseTemplateShape)(interfaces);
-      addRef(items, {
-        ...(0, _refs.atRefToRefItem)(projectSchema, shapeName, template),
-        path
-      }, predicate);
-    } else if (propName === '$ref') {
-      addRef(items, {
-        ...(0, _refs.refToRefItem)(projectSchema, interfaces),
-        path
-      }, predicate);
-    } else if (propName === '@args' || propName === 'args') {
-      addRef(items, {
-        ...(0, _refs.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.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.dereferenceObjectSchema)(projectSchema, query.args), [...queryPath, 'args'], propertyVisitor);
-  }
-  if (query.shape) {
-    const {
-      isArray,
-      ref
-    } = (0, _refs.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.CURRENT_SCHEMA_VERSION,
-    queries: {},
-    mutations: {},
-    shapes: {},
-    workflows: {},
-    forms: {}
-  };
-}
-function createLayerSchema(partialSchema) {
-  return {
-    schemaVersion: _versions.CURRENT_SCHEMA_VERSION,
-    queries: {},
-    mutations: {},
-    shapes: {},
-    ...partialSchema
-  };
-}
-function getShapesById(projectSchema) {
-  return (0, _keyBy.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.default)(getAllValidRefs(projectSchema, isServiceRef).map(_refs.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
-  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
- */
-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.
- */
-const createSchemaPropertyList = exports.createSchemaPropertyList = (0, _curry.default)((context, shapeOrSchema) => {
-  const propSchema = isShape(shapeOrSchema) ? shapeOrSchema.schema : shapeOrSchema;
-  const schema = (0, _refs.dereferenceSchema)(context, propSchema, isShape(shapeOrSchema) ? ['shapes', shapeOrSchema.name] : undefined);
-  const propertyIterator = new Map((0, _utils.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, _orderBy2.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 : 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 = (0, _refs.dereferenceSchema)(context, propSchema, isShape(shapeOrSchema) ? ['shapes', shapeOrSchema.name] : undefined);
-    this.entries = (0, _utils.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.
- */
-const createSchemaPropertyAccessor = exports.createSchemaPropertyAccessor = (0, _curry.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');
-/**
- * Find the query in the schema that corresponds to the given shape and resolver.
- */
-exports.findQueryByShape = findQueryByShape;
-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
- */
-exports.findMutationByShape = findMutationByShape;
-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
- */
-exports.ensureQueryByShape = ensureQueryByShape;
-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, _utils.isGraphqlResolver)(query.resolver)) {
-    mapping = (0, _refs.serializePropertyRef)({
-      serviceId: query.resolver.service,
-      shapeName: 'Query',
-      propertyName: query.resolver.fieldName
-    });
-  }
-  return {
-    ...(0, _refs.returnShapeToSchema)(projectSchema, query.shape),
-    ...(mapping ? {
-      '@mapping': mapping
-    } : {}),
-    '@resolver': query.resolver,
-    '@args': query.args
-  };
-}
-function getQueriesShape(projectSchema, operation) {
-  return createShape((0, _util.pascalCase)(operation), {
-    type: 'object',
-    properties: (0, _mapValues.default)(projectSchema[operation === 'query' ? 'queries' : 'mutations'], query => queryToPropertySchema(projectSchema, query))
-  });
-}
-function fieldMappingContainsKey(fieldMapping, key) {
-  if ((0, _isArray.default)(fieldMapping)) {
-    return (0, _some.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.getRef)(workingCopy, propertySchema);
-  return Boolean(arrayOfShapeRef && (0, _refs.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, _utils.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, _utils.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;