@takeshape/schema 9.80.4 → 9.81.0

package/dist/schema-util.js

@@ -62,79 +62,47 @@ 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 _omitBy = _interopRequireDefault(require("lodash/omitBy"));
-
 var _keyBy = _interopRequireDefault(require("lodash/keyBy"));
-
 var _isObject = _interopRequireDefault(require("lodash/isObject"));
-
 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 _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 _isEqual = _interopRequireDefault(require("lodash/isEqual"));
-
 var _isString = _interopRequireDefault(require("lodash/isString"));
-
 var _unions = require("./unions");
-
 var _util2 = require("./util");
-
 var _errors = require("@takeshape/errors");
-
 var _isArray = _interopRequireDefault(require("lodash/isArray"));
-
 var _some = _interopRequireDefault(require("lodash/some"));
-
 var _tinyInvariant = _interopRequireDefault(require("tiny-invariant"));
-
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
 const SERVICE_OBJECT_PATTERN_NAME = 'pattern:service-object';
 exports.SERVICE_OBJECT_PATTERN_NAME = SERVICE_OBJECT_PATTERN_NAME;
-
 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 = ['$comment', 'title', 'description', '@l10n', '@deprecationReason', '@tag', '@tags', '@syncLocaleStructure', '@sensitive'];
 exports.schemaMetadataKeys = schemaMetadataKeys;
 const commonSchemaKeys = ['type', 'default', 'readOnly', ...schemaMetadataKeys];
@@ -145,50 +113,44 @@ const objectSchemaKeys = [...commonSchemaKeys, 'properties', 'required'];
 exports.objectSchemaKeys = objectSchemaKeys;
 const arraySchemaKeys = [...commonSchemaKeys, 'items', 'additionalItems', 'maxItems', 'minItems', 'uniqueItems'];
 exports.arraySchemaKeys = arraySchemaKeys;
-const multipleRelationshipSchemaKeys = [...schemaMetadataKeys, 'maxItems', 'minItems']; // All properties except properties, items, additionalItems
+const multipleRelationshipSchemaKeys = [...schemaMetadataKeys, 'maxItems', 'minItems'];
 
+// All properties except properties, items, additionalItems
 exports.multipleRelationshipSchemaKeys = multipleRelationshipSchemaKeys;
 const nonStructuralSchemaKeys = [...scalarSchemaKeys, '@resolver', '@input', '@output', '@backreference', '@args', 'required', 'maxItems', 'minItems', 'uniqueItems'];
 exports.nonStructuralSchemaKeys = nonStructuralSchemaKeys;
-
 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
-
+}
 
+// 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 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 !== null && tag !== void 0 && tag.startsWith(SERVICE_OBJECT_PATTERN_NAME)) {
         const idFieldName = getServiceIdFieldName(key);
         const version = tag.substr(tag.lastIndexOf(':') + 1);
@@ -199,14 +161,12 @@ 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 => (0, _isEqual.default)(existingServiceInfo, serviceInfo))) {
@@ -218,33 +178,27 @@ 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
 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;
@@ -265,27 +219,21 @@ 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;
 }
-
 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}`] = {
@@ -308,7 +256,6 @@ function getShapeQueriesAndMutations(shapes) {
         description: `Update ${name}`,
         args: (0, _refs.createTemplateShapeName)('UpdateArgs', name)
       };
-
       if (!isSingleton) {
         queries[`get${name}List`] = {
           shape: (0, _refs.createTemplateShapeName)('PaginatedList', name),
@@ -353,30 +300,24 @@ function getShapeQueriesAndMutations(shapes) {
       }
     }
   }
-
   return {
     queries,
     mutations
   };
 }
-
 function getBuiltinPropertiesSet(shape) {
   if (isModelShape(shape)) {
     return 'model';
   }
-
   if (isCachedShape(shape)) {
     return 'indexed';
   }
-
   return 'none';
 }
-
 function getBuiltinProperties(shapeId, builtinPropertiesSet, apiVersion = _versions.CURRENT_API_VERSION) {
   if (builtinPropertiesSet === 'none') {
     return {};
   }
-
   const commonFields = {
     _shapeId: {
       type: 'string',
@@ -388,13 +329,12 @@ function getBuiltinProperties(shapeId, builtinPropertiesSet, apiVersion = _versi
       type: 'string'
     }
   };
-
   if (builtinPropertiesSet === 'indexed') {
     return commonFields;
   }
-
   const showV1Deprecation = apiVersion !== '1';
-  return { ...commonFields,
+  return {
+    ...commonFields,
     _version: {
       title: 'Version',
       type: 'integer'
@@ -452,25 +392,23 @@ function getBuiltinProperties(shapeId, builtinPropertiesSet, apiVersion = _versi
     }
   };
 }
+
 /**
  * Return all the built in property names,
  */
-
-
 const getBuiltinPropertyNames = (builtinPropertiesSet, apiVersion = _versions.CURRENT_API_VERSION) => new Set([...Object.keys(getBuiltinProperties('shape-id', builtinPropertiesSet, apiVersion)), (0, _apiVersion.workflowsEnabled)(apiVersion) ? '_status' : undefined].filter(_util.isDefined));
-
 exports.getBuiltinPropertyNames = getBuiltinPropertyNames;
-
 function applyBuiltinPropertiesToShape(projectSchema, shape) {
   const builtinSet = getBuiltinPropertiesSet(shape);
-
   if (builtinSet === 'none') {
     return shape;
   }
-
-  return { ...shape,
-    schema: { ...shape.schema,
-      properties: { ...(0, _omitBy.default)((0, _refs.dereferenceObjectSchema)(projectSchema, shape.schema, ['shapes', shape.name]).properties, (_, name) => name.startsWith('_')),
+  return {
+    ...shape,
+    schema: {
+      ...shape.schema,
+      properties: {
+        ...(0, _omitBy.default)((0, _refs.dereferenceObjectSchema)(projectSchema, shape.schema, ['shapes', shape.name]).properties, (_, name) => name.startsWith('_')),
         ...getBuiltinProperties(shape.id, builtinSet, projectSchema.apiVersion),
         ...(builtinSet === 'model' && (0, _apiVersion.workflowsEnabled)(projectSchema.apiVersion) && {
           _status: (0, _workflows.getStatusField)(projectSchema.workflows, shape)
@@ -478,19 +416,20 @@ 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.
  */
-
 function getBuiltinsUsed(projectSchema) {
   const builtinsUsed = {};
   const shapeNames = (0, _uniq.default)(requiredBuiltinShapes.concat(getAllRefs(projectSchema, refItem => refItem.serviceKey === 'local' && isBuiltinShape(refItem.typeName)).map(_refs.refItemToShapeName)));
-  const schemaWithAllBuiltins = { ...emptySchema('project-id'),
+  const schemaWithAllBuiltins = {
+    ...emptySchema('project-id'),
     shapes: _builtinSchema.builtInShapes
   };
   shapeNames.forEach(builtinShapeName => {
@@ -501,109 +440,97 @@ function getBuiltinsUsed(projectSchema) {
   });
   return builtinsUsed;
 }
-
 function applyDefaultsToSchema(projectSchema) {
   const builtinsUsed = getBuiltinsUsed(projectSchema);
-  return { ...projectSchema,
-    workflows: { ...projectSchema.workflows,
+  return {
+    ...projectSchema,
+    workflows: {
+      ...projectSchema.workflows,
       ...((0, _apiVersion.workflowsEnabled)(projectSchema.apiVersion) && {
         default: _workflows.defaultWorkflow
       })
     },
-    queries: { ...builtInQueriesAndMutations.queries,
+    queries: {
+      ...builtInQueriesAndMutations.queries,
       ...projectSchema.queries
     },
-    mutations: { ...builtInQueriesAndMutations.mutations,
+    mutations: {
+      ...builtInQueriesAndMutations.mutations,
       ...projectSchema.mutations
     },
-    shapes: (0, _mapValues.default)({ ...builtinsUsed,
+    shapes: (0, _mapValues.default)({
+      ...builtinsUsed,
       ...projectSchema.shapes
     }, shape => {
       const builtInShape = builtinsUsed[shape.name];
-
       if (builtInShape && builtInShape !== shape) {
-        shape = { ...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,
+    forms: (0, _mapValues.default)({
+      ..._builtinSchema.builtInForms,
       ...projectSchema.forms
     }, (formsConfig, shapeName) => {
       const builtInFormsConfig = _builtinSchema.builtInForms[shapeName];
-
       if (builtInFormsConfig && builtInFormsConfig !== formsConfig) {
-        formsConfig = { ...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 ${shapeId} Not found`);
   }
-
   return shape;
 }
-
 function getShape(context, name) {
   return context.shapes[name];
 }
-
 function isModelShape(shape) {
   return Boolean(shape.model);
 }
-
 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;
 }
-
 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,
+    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);
       }
@@ -612,7 +539,6 @@ function getArgsShapeSchema(context, argsSchema) {
     }
   }
 }
-
 const createShapeToPropertySchema = (projectSchema, definitions, definitionNames, {
   useShapeIdDiscriminator
 }) => {
@@ -620,24 +546,21 @@ const createShapeToPropertySchema = (projectSchema, definitions, definitionNames
     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
-
+      }
 
+      // Add workflow validation
       if (propSchema['@workflow']) {
         const workflowName = propSchema['@workflow'];
         const workflow = projectSchema.workflows[workflowName] || _workflows.defaultWorkflow;
@@ -646,101 +569,80 @@ const createShapeToPropertySchema = (projectSchema, definitions, definitionNames
           title: step.title
         }));
       }
-
       const refItem = (0, _refs.getRef)(projectSchema, propSchema);
-
       if (refItem) {
         const shapeName = (0, _refs.refItemToShapeName)(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),
+  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]));
@@ -749,14 +651,11 @@ function getShapeDependencies(projectSchema, shape, predicate) {
         visitSchemaProperties(schema, [], findDependencies);
       }
     }
-
     return shouldFollow;
   };
-
   findDependencies(shape.schema);
   return [...shapeNames];
 }
-
 function getRelevantShapes(projectSchema, params) {
   const {
     shapeIds,
@@ -764,39 +663,31 @@ 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 && ((0, _utils.isObjectSchema)(propSchema) || (0, _utils.isExtendsSchema)(propSchema) || (0, _utils.isAllOfSchema)(propSchema) || (0, _utils.isOneOfSchema)(propSchema))) {
       visitSchemaProperties(propSchema, newPath, callback);
     }
   }
 }
-
 function visitSchemaProperties(schema, path, callback) {
   if ((0, _utils.isArraySchema)(schema)) {
     visitSchemaPropertiesHelper(Object.entries(schema.items), [...path, 'items'], callback);
@@ -812,23 +703,20 @@ function visitSchemaProperties(schema, path, callback) {
     callback(schema, 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'];
@@ -839,100 +727,88 @@ function getAllRefsInShapes(projectSchema, predicate) {
     if (!(0, _isString.default)(ref)) {
       return;
     }
-
     const propName = refPath[refPath.length - 1];
     const path = ['shapes', ...refPath];
     let refItem = {};
-
     if (propName === '@ref') {
       const {
         shapeName,
         template
       } = (0, _refs.parseTemplateShape)(ref);
-      refItem = { ...(0, _refs.atRefToRefItem)(projectSchema, shapeName, template),
+      refItem = {
+        ...(0, _refs.atRefToRefItem)(projectSchema, shapeName, template),
         path
       };
     } else if (propName === '$ref') {
-      refItem = { ...(0, _refs.refToRefItem)(projectSchema, ref),
+      refItem = {
+        ...(0, _refs.refToRefItem)(projectSchema, ref),
         path
       };
     } else if (propName === '@args' || propName === 'args') {
-      refItem = { ...(0, _refs.refExpressionToRefItem)(projectSchema, ref),
+      refItem = {
+        ...(0, _refs.refExpressionToRefItem)(projectSchema, ref),
         path
       };
     }
-
     if ((0, _refs.isRefItemWithPath)(refItem)) {
       addRef(items, refItem, 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,
+      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 parseMapping(mapping) {
   const [providerId, serviceId, coordinate] = mapping.split(':');
   const [shapeName, key] = coordinate.split('.');
@@ -943,47 +819,38 @@ function parseMapping(mapping) {
     key
   };
 }
-
 function splitMapping(mapping) {
   return mapping.split('.');
 }
-
 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 === null || first === void 0 ? void 0 : first.split(':');
   return split ? `${split[0]}:${split[1]}` : undefined;
 }
-
 function emptySchema(projectId) {
   return {
     projectId,
@@ -998,10 +865,10 @@ function emptySchema(projectId) {
     forms: {}
   };
 }
-
 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.
@@ -1010,13 +877,11 @@ function getShapesById(projectSchema) {
  *
  * @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)(getAllRefs(projectSchema, isServiceRef).map(_refs.refItemToShapeName));
 }
+
 /**
  * Returns a list of all shape names in a service namespace, excluding any
  * that have been set directly in the project schema
@@ -1029,16 +894,17 @@ function getAllNamespaceShapes(projectSchema) {
  *
  * @returns A `Set` of shape names.
  */
-
-
 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);
@@ -1046,6 +912,7 @@ function getNamespacedShapeNameList(projectSchema) {
   });
   return requiredShapeNames;
 }
+
 /**
  * Filter the service map to return only services passing the GraphQL Service
  * typeguard.
@@ -1054,74 +921,58 @@ function getNamespacedShapeNameList(projectSchema) {
  *
  * @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;
 }
+
 /**
  * Add all referenced shape names to the refSet meant to be used as a callback to visitSchemaProperties
  */
-
-
 function collectReferencedShapeNames(context, shapeNames) {
   const addRef = refItem => {
     shapeNames.add((0, _refs.refItemToShapeName)(refItem));
   };
-
   const collect = schema => {
     const args = schema['@args'];
-
     if (args && (0, _isObject.default)(args) && (0, _utils.isObjectSchema)(args)) {
       Object.values(args.properties).forEach(collect);
     }
-
     const argsRefItem = getArgsReference(context, schema);
-
     if (argsRefItem) {
       addRef(argsRefItem);
     }
-
     const refItem = (0, _refs.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.
  */
-
-
 const 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) {
@@ -1131,38 +982,30 @@ const createSchemaPropertyList = (0, _curry.default)((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,
@@ -1178,11 +1021,9 @@ const createSchemaPropertyList = (0, _curry.default)((context, shapeOrSchema) =>
   return self;
 });
 exports.createSchemaPropertyList = createSchemaPropertyList;
-
 function isShape(shapeOrSchema) {
   return 'schema' in shapeOrSchema;
 }
-
 class SchemaPropertyAccessor {
   constructor(context, shapeOrSchema) {
     const propSchema = isShape(shapeOrSchema) ? shapeOrSchema.schema : shapeOrSchema;
@@ -1190,33 +1031,24 @@ class SchemaPropertyAccessor {
     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) {
     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.
@@ -1225,7 +1057,6 @@ const createSchemaPropertyAccessor = (0, _curry.default)((context, shapeOrSchema
   return new SchemaPropertyAccessor(context, shapeOrSchema);
 });
 exports.createSchemaPropertyAccessor = createSchemaPropertyAccessor;
-
 function findQueryHelper(slice, shapeName, resolver, type) {
   const schemaPath = type === 'query' ? 'queries' : 'mutations';
   return Object.keys(slice[schemaPath]).find(queryName => {
@@ -1233,51 +1064,37 @@ 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.
  */
-
-
 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.
  */
@@ -1285,9 +1102,7 @@ const getDefaultMutationName = (shapeName, resolver) => {
   const action = resolver.substring(resolver.indexOf(':') + 1);
   return `${action}${shapeName}`;
 };
-
 exports.getDefaultMutationName = getDefaultMutationName;
-
 function createShape(name, schema, rest) {
   return {
     name,
@@ -1297,10 +1112,8 @@ function createShape(name, schema, rest) {
     ...rest
   };
 }
-
 function queryToPropertySchema(projectSchema, query) {
   let mapping;
-
   if ((0, _utils.isGraphqlResolver)(query.resolver)) {
     mapping = (0, _refs.serializePropertyRef)({
       serviceId: query.resolver.service,
@@ -1308,8 +1121,8 @@ function queryToPropertySchema(projectSchema, query) {
       propertyName: query.resolver.fieldName
     });
   }
-
-  return { ...(0, _refs.returnShapeToSchema)(projectSchema, query.shape),
+  return {
+    ...(0, _refs.returnShapeToSchema)(projectSchema, query.shape),
     ...(mapping ? {
       '@mapping': mapping
     } : {}),
@@ -1317,53 +1130,44 @@ function queryToPropertySchema(projectSchema, query) {
     '@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`
  */
-
-
 const schemaMatchesShapeName = (workingCopy, schemaWithRef, shapeName) => {
   const arrayOfShapeRef = (0, _refs.getRef)(workingCopy, schemaWithRef);
   (0, _tinyInvariant.default)(arrayOfShapeRef);
   const arrayOfShapeName = (0, _refs.refItemToShapeName)(arrayOfShapeRef);
   return arrayOfShapeName === shapeName;
 };
+
 /**
  * Return true if `shape` has a property that is an array of refs to `shapeName`
  */
-
-
 exports.schemaMatchesShapeName = schemaMatchesShapeName;
-
 const shapeHasArrayPropOfShape = (projectSchema, shape, shapeName) => {
   if (shape && (0, _utils.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 && (0, _utils.isRefSchema)(propSchema.items) && schemaMatchesShapeName(projectSchema, propSchema.items, shapeName)) {
           return true;
         }
       }
     }
   }
-
   return false;
 };
-
 exports.shapeHasArrayPropOfShape = shapeHasArrayPropOfShape;