@takeshape/schema 9.80.4 → 9.81.0

package/es/schema-util.js

@@ -42,8 +42,9 @@ export const commonSchemaKeys = ['type', 'default', 'readOnly', ...schemaMetadat
 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 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`;
@@ -53,33 +54,30 @@ const generatorVersions = {
 };
 export function getGeneratorVersion(generator) {
   return generatorVersions[generator];
-} // Returns info for all services found in shape, keyed by provider
+}
 
+// 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 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 !== null && tag !== void 0 && tag.startsWith(SERVICE_OBJECT_PATTERN_NAME)) {
         const idFieldName = getServiceIdFieldName(key);
         const version = tag.substr(tag.lastIndexOf(':') + 1);
@@ -90,14 +88,12 @@ export function getServiceInfo(projectSchema, shape) {
           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))) {
@@ -109,32 +105,27 @@ export function getServiceInfo(projectSchema, shape) {
     });
   });
   return result;
-} // Follow refs to find the path between two shapes in a schema
+}
 
+// 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;
@@ -155,26 +146,21 @@ export function pathBetween(fromShape, toShape, projectSchema, depthLimit = 4) {
       }
     }
   };
-
   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}`] = {
@@ -197,7 +183,6 @@ export function getShapeQueriesAndMutations(shapes) {
         description: `Update ${name}`,
         args: createTemplateShapeName('UpdateArgs', name)
       };
-
       if (!isSingleton) {
         queries[`get${name}List`] = {
           shape: createTemplateShapeName('PaginatedList', name),
@@ -242,7 +227,6 @@ export function getShapeQueriesAndMutations(shapes) {
       }
     }
   }
-
   return {
     queries,
     mutations
@@ -252,18 +236,15 @@ export function getBuiltinPropertiesSet(shape) {
   if (isModelShape(shape)) {
     return 'model';
   }
-
   if (isCachedShape(shape)) {
     return 'indexed';
   }
-
   return 'none';
 }
 export function getBuiltinProperties(shapeId, builtinPropertiesSet, apiVersion = CURRENT_API_VERSION) {
   if (builtinPropertiesSet === 'none') {
     return {};
   }
-
   const commonFields = {
     _shapeId: {
       type: 'string',
@@ -275,13 +256,12 @@ export function getBuiltinProperties(shapeId, builtinPropertiesSet, apiVersion =
       type: 'string'
     }
   };
-
   if (builtinPropertiesSet === 'indexed') {
     return commonFields;
   }
-
   const showV1Deprecation = apiVersion !== '1';
-  return { ...commonFields,
+  return {
+    ...commonFields,
     _version: {
       title: 'Version',
       type: 'integer'
@@ -339,21 +319,22 @@ export function getBuiltinProperties(shapeId, builtinPropertiesSet, apiVersion =
     }
   };
 }
+
 /**
  * Return all the built in property names,
  */
-
 export const getBuiltinPropertyNames = (builtinPropertiesSet, apiVersion = CURRENT_API_VERSION) => new Set([...Object.keys(getBuiltinProperties('shape-id', builtinPropertiesSet, apiVersion)), workflowsEnabled(apiVersion) ? '_status' : undefined].filter(isDefined));
 export function applyBuiltinPropertiesToShape(projectSchema, shape) {
   const builtinSet = getBuiltinPropertiesSet(shape);
-
   if (builtinSet === 'none') {
     return shape;
   }
-
-  return { ...shape,
-    schema: { ...shape.schema,
-      properties: { ...omitBy(dereferenceObjectSchema(projectSchema, shape.schema, ['shapes', shape.name]).properties, (_, name) => name.startsWith('_')),
+  return {
+    ...shape,
+    schema: {
+      ...shape.schema,
+      properties: {
+        ...omitBy(dereferenceObjectSchema(projectSchema, shape.schema, ['shapes', shape.name]).properties, (_, name) => name.startsWith('_')),
         ...getBuiltinProperties(shape.id, builtinSet, projectSchema.apiVersion),
         ...(builtinSet === 'model' && workflowsEnabled(projectSchema.apiVersion) && {
           _status: getStatusField(projectSchema.workflows, shape)
@@ -361,18 +342,20 @@ export function applyBuiltinPropertiesToShape(projectSchema, shape) {
       }
     }
   };
-} // Dependencies of these built-in shapes are automatically added by getBuiltinsUsed
+}
 
+// 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(refItemToShapeName)));
-  const schemaWithAllBuiltins = { ...emptySchema('project-id'),
+  const schemaWithAllBuiltins = {
+    ...emptySchema('project-id'),
     shapes: builtInShapes
   };
   shapeNames.forEach(builtinShapeName => {
@@ -385,42 +368,46 @@ export function getBuiltinsUsed(projectSchema) {
 }
 export function applyDefaultsToSchema(projectSchema) {
   const builtinsUsed = getBuiltinsUsed(projectSchema);
-  return { ...projectSchema,
-    workflows: { ...projectSchema.workflows,
+  return {
+    ...projectSchema,
+    workflows: {
+      ...projectSchema.workflows,
       ...(workflowsEnabled(projectSchema.apiVersion) && {
         default: defaultWorkflow
       })
     },
-    queries: { ...builtInQueriesAndMutations.queries,
+    queries: {
+      ...builtInQueriesAndMutations.queries,
       ...projectSchema.queries
     },
-    mutations: { ...builtInQueriesAndMutations.mutations,
+    mutations: {
+      ...builtInQueriesAndMutations.mutations,
       ...projectSchema.mutations
     },
-    shapes: mapValues({ ...builtinsUsed,
+    shapes: mapValues({
+      ...builtinsUsed,
       ...projectSchema.shapes
     }, shape => {
       const builtInShape = builtinsUsed[shape.name];
-
       if (builtInShape && builtInShape !== shape) {
-        shape = { ...shape,
+        shape = {
+          ...shape,
           schema: mergeSchemaProperties(dereferenceObjectSchema(projectSchema, shape.schema), dereferenceObjectSchema(projectSchema, builtInShape.schema))
         };
       }
-
       return applyBuiltinPropertiesToShape(projectSchema, shape);
     }),
-    forms: mapValues({ ...builtInForms,
+    forms: mapValues({
+      ...builtInForms,
       ...projectSchema.forms
     }, (formsConfig, shapeName) => {
       const builtInFormsConfig = builtInForms[shapeName];
-
       if (builtInFormsConfig && builtInFormsConfig !== formsConfig) {
-        formsConfig = { ...formsConfig,
+        formsConfig = {
+          ...formsConfig,
           default: mergeFormProperties(formsConfig.default, builtInFormsConfig.default)
         };
       }
-
       return formsConfig;
     })
   };
@@ -433,11 +420,9 @@ export function getShapeByRef(projectSchema, shapeRef) {
 }
 export function ensureShapeById(projectSchema, shapeId) {
   const shape = getShapeById(projectSchema, shapeId);
-
   if (!shape) {
     throw new NotFoundError(`Shape ${shapeId} Not found`);
   }
-
   return shape;
 }
 export function getShape(context, name) {
@@ -448,12 +433,10 @@ export function isModelShape(shape) {
 }
 export function isCachedShape(shape) {
   var _shape$cache;
-
   return ((_shape$cache = shape.cache) === null || _shape$cache === void 0 ? void 0 : _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);
@@ -461,21 +444,19 @@ export function getArgsReference(projectSchema, argsSchema) {
 }
 export function getArgsReferenceWithPath(context, argsSchema, schemaPath = []) {
   const refItem = getArgsReference(context, argsSchema);
-
   if (refItem) {
     const argsType = getArgsType(argsSchema);
-    return { ...refItem,
+    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);
       }
@@ -484,7 +465,6 @@ export function getArgsShapeSchema(context, argsSchema) {
     }
   }
 }
-
 const createShapeToPropertySchema = (projectSchema, definitions, definitionNames, {
   useShapeIdDiscriminator
 }) => {
@@ -492,24 +472,21 @@ const createShapeToPropertySchema = (projectSchema, definitions, definitionNames
     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
-
+      }
 
+      // Add workflow validation
       if (propSchema['@workflow']) {
         const workflowName = propSchema['@workflow'];
         const workflow = projectSchema.workflows[workflowName] || defaultWorkflow;
@@ -518,67 +495,54 @@ const createShapeToPropertySchema = (projectSchema, definitions, definitionNames
           title: step.title
         }));
       }
-
       const refItem = getRef(projectSchema, propSchema);
-
       if (refItem) {
         const shapeName = refItemToShapeName(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),
+  return {
+    ...convert(shape),
     definitions
   };
 }
@@ -588,29 +552,23 @@ export function projectSchemaToJSONSchema(projectSchema) {
   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]));
@@ -619,10 +577,8 @@ export function getShapeDependencies(projectSchema, shape, predicate) {
         visitSchemaProperties(schema, [], findDependencies);
       }
     }
-
     return shouldFollow;
   };
-
   findDependencies(shape.schema);
   return [...shapeNames];
 }
@@ -633,39 +589,31 @@ export function getRelevantShapes(projectSchema, params) {
     byId = false,
     includeDependencies = true
   } = params;
-
   if (shapeNames !== null && shapeNames !== void 0 && shapeNames.length || shapeIds !== null && shapeIds !== void 0 && 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 visitSchemaPropertiesHelper(entries, path, callback) {
   for (const [name, propSchema] of entries) {
     const newPath = [...path, name];
-
     if (callback(propSchema, newPath) !== false && (isObjectSchema(propSchema) || isExtendsSchema(propSchema) || isAllOfSchema(propSchema) || isOneOfSchema(propSchema))) {
       visitSchemaProperties(propSchema, newPath, callback);
     }
   }
 }
-
 export function visitSchemaProperties(schema, path, callback) {
   if (isArraySchema(schema)) {
     visitSchemaPropertiesHelper(Object.entries(schema.items), [...path, 'items'], callback);
@@ -686,17 +634,15 @@ export function visitShapeProperties(shapes, callback) {
     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'];
@@ -707,93 +653,85 @@ export function getAllRefsInShapes(projectSchema, predicate) {
     if (!isString(ref)) {
       return;
     }
-
     const propName = refPath[refPath.length - 1];
     const path = ['shapes', ...refPath];
     let refItem = {};
-
     if (propName === '@ref') {
       const {
         shapeName,
         template
       } = parseTemplateShape(ref);
-      refItem = { ...atRefToRefItem(projectSchema, shapeName, template),
+      refItem = {
+        ...atRefToRefItem(projectSchema, shapeName, template),
         path
       };
     } else if (propName === '$ref') {
-      refItem = { ...refToRefItem(projectSchema, ref),
+      refItem = {
+        ...refToRefItem(projectSchema, ref),
         path
       };
     } else if (propName === '@args' || propName === 'args') {
-      refItem = { ...refExpressionToRefItem(projectSchema, ref),
+      refItem = {
+        ...refExpressionToRefItem(projectSchema, ref),
         path
       };
     }
-
     if (isRefItemWithPath(refItem)) {
       addRef(items, refItem, 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,
+      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)];
 }
@@ -812,11 +750,9 @@ export function splitMapping(mapping) {
 }
 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) {
@@ -826,12 +762,12 @@ 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;
@@ -858,6 +794,7 @@ export function emptySchema(projectId) {
 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.
@@ -866,12 +803,11 @@ export function getShapesById(projectSchema) {
  *
  * @returns A `string` array with all the shapes that are in namespaces.
  */
-
 export function getAllNamespaceShapes(projectSchema) {
   const isServiceRef = refItem => Boolean(refItem.serviceNamespace);
-
   return uniq(getAllRefs(projectSchema, isServiceRef).map(refItemToShapeName));
 }
+
 /**
  * Returns a list of all shape names in a service namespace, excluding any
  * that have been set directly in the project schema
@@ -884,15 +820,17 @@ export function getAllNamespaceShapes(projectSchema) {
  *
  * @returns A `Set` of shape names.
  */
-
 export function getNamespacedShapeNameList(projectSchema) {
-  const requiredShapeNames = new Set(); // All the shape names
+  const requiredShapeNames = new Set();
 
-  const existingShapeNames = new Set(Object.keys(projectSchema.shapes)); // All the referenced shape names with namespaces that belong to a service
+  // All the shape names
+  const existingShapeNames = new Set(Object.keys(projectSchema.shapes));
 
-  const namespacedShapeNames = new Set(getAllNamespaceShapes(projectSchema)); // Add all namespaced shapes to the schema if they are not already present,
-  // e.g. Shopify_Product
+  // 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);
@@ -900,6 +838,7 @@ export function getNamespacedShapeNameList(projectSchema) {
   });
   return requiredShapeNames;
 }
+
 /**
  * Filter the service map to return only services passing the GraphQL Service
  * typeguard.
@@ -908,71 +847,58 @@ export function getNamespacedShapeNameList(projectSchema) {
  *
  * @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;
 }
+
 /**
  * Add all referenced shape names to the refSet meant to be used as a callback to visitSchemaProperties
  */
-
 export function collectReferencedShapeNames(context, shapeNames) {
   const addRef = refItem => {
     shapeNames.add(refItemToShapeName(refItem));
   };
-
   const collect = schema => {
     const args = schema['@args'];
-
     if (args && isObject(args) && isObjectSchema(args)) {
       Object.values(args.properties).forEach(collect);
     }
-
     const argsRefItem = getArgsReference(context, schema);
-
     if (argsRefItem) {
       addRef(argsRefItem);
     }
-
     const refItem = getRefOrItemsRef(context, schema);
-
     if (refItem) {
       addRef(refItem);
     }
   };
-
   return collect;
 }
+
 /**
  * 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) {
@@ -982,38 +908,30 @@ export const createSchemaPropertyList = curry((context, shapeOrSchema) => {
         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,
@@ -1028,11 +946,9 @@ export const createSchemaPropertyList = curry((context, shapeOrSchema) => {
   };
   return self;
 });
-
 function isShape(shapeOrSchema) {
   return 'schema' in shapeOrSchema;
 }
-
 class SchemaPropertyAccessor {
   constructor(context, shapeOrSchema) {
     const propSchema = isShape(shapeOrSchema) ? shapeOrSchema.schema : shapeOrSchema;
@@ -1040,33 +956,24 @@ class SchemaPropertyAccessor {
     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) {
     var _this$entries$find;
-
     return (_this$entries$find = this.entries.find(predicate)) === null || _this$entries$find === void 0 ? void 0 : _this$entries$find[1];
   }
-
   findName(predicate) {
     var _this$entries$find2;
-
     return (_this$entries$find2 = this.entries.find(predicate)) === null || _this$entries$find2 === void 0 ? void 0 : _this$entries$find2[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.
@@ -1074,7 +981,6 @@ class SchemaPropertyAccessor {
 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 => {
@@ -1082,40 +988,33 @@ function findQueryHelper(slice, shapeName, resolver, type) {
     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.
  */
@@ -1134,7 +1033,6 @@ export function createShape(name, schema, rest) {
 }
 export function queryToPropertySchema(projectSchema, query) {
   let mapping;
-
   if (isGraphqlResolver(query.resolver)) {
     mapping = serializePropertyRef({
       serviceId: query.resolver.service,
@@ -1142,8 +1040,8 @@ export function queryToPropertySchema(projectSchema, query) {
       propertyName: query.resolver.fieldName
     });
   }
-
-  return { ...returnShapeToSchema(projectSchema, query.shape),
+  return {
+    ...returnShapeToSchema(projectSchema, query.shape),
     ...(mapping ? {
       '@mapping': mapping
     } : {}),
@@ -1161,35 +1059,32 @@ 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 const schemaMatchesShapeName = (workingCopy, schemaWithRef, shapeName) => {
   const arrayOfShapeRef = getRef(workingCopy, schemaWithRef);
   invariant(arrayOfShapeRef);
   const arrayOfShapeName = refItemToShapeName(arrayOfShapeRef);
   return arrayOfShapeName === 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.prototype.hasOwnProperty.call(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;
 };