@takeshape/schema 9.80.4 → 9.81.3

package/dist/layers/layers.js

@@ -10,33 +10,21 @@ exports.getAllRefsInQueries = getAllRefsInQueries;
 exports.getAllRefsInQuery = getAllRefsInQuery;
 exports.getAllRefsInShapes = getAllRefsInShapes;
 exports.isObjectSchemaV4_0_0 = isObjectSchemaV4_0_0;
-
 var _minimatch = _interopRequireDefault(require("minimatch"));
-
 var _util = require("@takeshape/util");
-
 var _uniq = _interopRequireDefault(require("lodash/uniq"));
-
 var _refs = require("./refs");
-
 var _typeUtils = require("./type-utils");
-
 var _visitor = require("./visitor");
-
 var _set = _interopRequireDefault(require("lodash/set"));
-
 var _refs2 = require("../refs");
-
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
 const layerDefaults = {
   namespace: '',
   visibility: []
 };
-
 function filterMap(prefix, fields, filters) {
   const result = {};
-
   for (const [name, value] of Object.entries(fields)) {
     for (const filter of filters) {
       if ((0, _minimatch.default)(`${prefix}.${name}`, filter)) {
@@ -44,211 +32,173 @@ function filterMap(prefix, fields, filters) {
       }
     }
   }
-
   return result;
 }
-
 function filterLayer(layerSchema, filters) {
-  return { ...layerSchema,
+  return {
+    ...layerSchema,
     queries: filterMap('queries', layerSchema.queries ?? {}, filters),
     mutations: filterMap('mutations', layerSchema.mutations ?? {}, filters),
     shapes: filterMap('shapes', layerSchema.shapes ?? {}, filters),
     workflows: filterMap('workflows', layerSchema.workflows ?? {}, filters)
   };
-} // TODO use non-versioned util eventually
-
+}
 
+// TODO use non-versioned util eventually
 function isObjectSchemaV4_0_0(maybeObjectSchema) {
   return maybeObjectSchema.type === 'object' && (0, _util.isRecord)(maybeObjectSchema.properties);
 }
-
 function mergeShape(a, b) {
   if (b.override === 'extend') {
     if (isObjectSchemaV4_0_0(a.schema) && isObjectSchemaV4_0_0(b.schema)) {
       const combinedRequired = (0, _uniq.default)((a.schema.required ?? []).concat(b.schema.required ?? []));
       const combinedSchema = {
         type: 'object',
-        properties: { ...a.schema.properties,
+        properties: {
+          ...a.schema.properties,
           ...b.schema.properties
         }
       };
-
       if (combinedRequired.length) {
         combinedSchema.required = combinedRequired;
       }
-
-      return { ...a,
+      return {
+        ...a,
         ...b,
         schema: combinedSchema
       };
     }
   }
-
   return b;
 }
-
 function assignShapes(flattenedShapes, layerShapes) {
   for (const [shapeName, shape] of Object.entries(layerShapes)) {
     flattenedShapes[shapeName] = flattenedShapes[shapeName] ? mergeShape(flattenedShapes[shapeName], shape) : shape;
   }
 }
-
 function addRef(refs, ref, predicate) {
   if (ref && (!predicate || predicate(ref))) {
     refs.push(ref);
   }
 }
+
 /**
  * Walk through a `ProjectSchema` and collect all the `ref`s.
  */
-
-
 function getAllRefsInShapes(shapes, predicate) {
   const items = [];
-
   const shapeVisitor = (schema, schemaPath) => {
     if (schema['@args'] && typeof schema['@args'] === 'object') {
       (0, _visitor.visitSchemaProperties)(schema['@args'], schemaPath.concat(['@args']), (argSchema, argPath) => {
         addRef(items, (0, _refs.getRefOrItemsRef)(argSchema, argPath), predicate);
       });
     }
-
     addRef(items, (0, _refs.getArgsReferenceWithPath)(schema, schemaPath), predicate);
     const newPath = schema.items ? schemaPath.concat('items') : schemaPath;
     const newSchema = schema.items ?? schema;
-
     if ((0, _typeUtils.isRefSchema)(newSchema)) {
       addRef(items, (0, _refs.getRefOrItemsRef)(newSchema, newPath), predicate);
     } else if ((0, _typeUtils.isObjectSchema)(newSchema) || (0, _typeUtils.isAllOfSchema)(newSchema) || (0, _typeUtils.isOneOfSchema)(newSchema)) {
       (0, _visitor.visitSchemaProperties)(newSchema, newPath, shapeVisitor);
     }
   };
-
   for (const [shapeName, shape] of Object.entries(shapes)) {
     (0, _visitor.visitSchemaProperties)(shape.schema, ['shapes', shapeName, 'schema'], shapeVisitor);
   }
-
   return items;
 }
+
 /**
  * Get all refs
  */
-
-
 function getAllRefsInQuery(shapes, queryPath, query, predicate) {
   const refItems = [];
-
   const propertyVisitor = (propSchema, propSchemaPath) => {
     addRef(refItems, (0, _refs.getRefOrItemsRef)(propSchema, propSchemaPath), predicate);
   };
-
   if (query.args && typeof query.args === 'string') {
     addRef(refItems, (0, _refs.getArgsReferenceWithPath)(query, queryPath), predicate);
   }
-
   if (query.args && typeof query.args === 'object') {
     (0, _visitor.visitSchemaProperties)((0, _refs.dereferenceSchema)(shapes, query.args), queryPath, propertyVisitor);
   }
-
   if (query.shape) {
     const refItem = (0, _refs.parseReturnShape)(query.shape).ref;
-
     if (refItem) {
-      addRef(refItems, { ...refItem,
+      addRef(refItems, {
+        ...refItem,
         path: queryPath.concat(['shape'])
       }, predicate);
     }
   }
-
   return refItems;
 }
-
 /**
  * Collect refs from `queries` or `mutations`.
  */
 function getAllRefsInQueries(context, rootPropertyName, predicate) {
   const refItems = [];
   const rootPath = [rootPropertyName];
-
   for (const [queryName, query] of Object.entries(context[rootPropertyName])) {
     const queryPath = rootPath.concat([queryName]);
     const queryRefs = getAllRefsInQuery(context.shapes, queryPath, query, predicate);
-
     if (queryRefs.length) {
       refItems.push(...queryRefs);
     }
   }
-
   return refItems;
 }
+
 /**
  * Get all refs in a ProjectSchema
  * @param predicate return true to include the ref in
  */
-
-
 function getAllRefs(projectSchema, predicate) {
   return [...getAllRefsInShapes(projectSchema.shapes, predicate), ...getAllRefsInQueries(projectSchema, 'queries', predicate), ...getAllRefsInQueries(projectSchema, 'mutations', predicate)];
 }
-
 function collectReferencedShapeNames(layerId, refSet) {
-  const addLayerId = ref => ({ ...ref,
+  const addLayerId = ref => ({
+    ...ref,
     layerId
   });
-
   const collect = schema => {
     const args = schema['@args'];
-
     if (args && typeof args === 'object') {
       Object.values(args.properties).forEach(collect);
     }
-
     const argsRefItem = (0, _refs.getArgsReferenceWithPath)(schema);
-
     if (argsRefItem) {
       refSet.add((0, _refs.refItemToString)(addLayerId(argsRefItem)));
     }
-
     const refItem = (0, _refs.getRefOrItemsRef)(schema);
-
     if (refItem) {
       refSet.add((0, _refs.refItemToString)(addLayerId(refItem)));
     }
   };
-
   return collect;
 }
-
 function collectServiceRefs(flattenedSchema, getLayer) {
   const refs = new Set(getAllRefs(flattenedSchema, refItem => refItem.layerId !== 'local').map(_refs.refItemToString));
-
   if (refs.size) {
     for (const ref of refs) {
       const [layerId, shapeName] = (0, _refs.splitAtRef)(ref);
-
       if (layerId !== 'local') {
         var _layer$shapes;
-
         const layer = getLayer(layerId);
         const shape = layer === null || layer === void 0 ? void 0 : (_layer$shapes = layer.shapes) === null || _layer$shapes === void 0 ? void 0 : _layer$shapes[shapeName];
-
         if (shape) {
           (0, _visitor.visitSchemaProperties)(shape.schema, ['schema'], collectReferencedShapeNames(layerId, refs));
         }
       }
     }
   }
-
   return refs;
 }
-
 function ensureServiceLayer(flattenedSchema, layerId) {
   if (!flattenedSchema.serviceLayers) {
     flattenedSchema.serviceLayers = {};
   }
-
   let serviceLayer = flattenedSchema.serviceLayers[layerId];
-
   if (!serviceLayer) {
     serviceLayer = {
       layerId,
@@ -259,30 +209,23 @@ function ensureServiceLayer(flattenedSchema, layerId) {
     };
     flattenedSchema.serviceLayers[layerId] = serviceLayer;
   }
-
   return serviceLayer;
 }
-
 function rewriteLayerId(localShapes, layerId, query) {
   const newQuery = (0, _util.deepClone)(query);
-
   const propertyVisitor = (propSchema, propSchemaPath) => {
     const ref = (propSchema.items ?? propSchema)['@ref'];
-
     if (ref) {
       const [argsLayerId, shapeName] = (0, _refs.splitAtRef)(ref);
-
       if (argsLayerId === 'local' && !localShapes[shapeName]) {
         const path = propSchemaPath.concat(propSchema.items ? ['items', '@ref'] : ['@ref']);
         (0, _set.default)(newQuery, path, `${layerId}:${shapeName}`);
       }
     }
   };
-
   if (query.args) {
     if (typeof query.args === 'string') {
       const [argsLayerId, shapeName] = (0, _refs.splitAtRef)((0, _refs2.parseTemplateShape)(query.args).shapeName);
-
       if (argsLayerId === 'local' && !localShapes[shapeName]) {
         newQuery.args = `${layerId}:${shapeName}`;
       }
@@ -290,40 +233,34 @@ function rewriteLayerId(localShapes, layerId, query) {
       (0, _visitor.visitSchemaProperties)(query.args, ['args'], propertyVisitor);
     }
   }
-
   if (typeof query.shape === 'string') {
     const [argsLayerId, shapeName] = (0, _refs.splitAtRef)((0, _refs2.parseTemplateShape)(query.shape).shapeName);
-
     if (argsLayerId === 'local' && !localShapes[shapeName]) {
       newQuery.shape = `${layerId}:${shapeName}`;
     }
   } else {
     const ref = query.shape.items['@ref'];
-
     if (ref) {
       const [argsLayerId, shapeName] = (0, _refs.splitAtRef)(ref);
-
       if (argsLayerId === 'local' && !localShapes[shapeName]) {
         (0, _set.default)(newQuery, ['shape', 'items', '@ref'], `${layerId}:${shapeName}`);
       }
     }
   }
-
   return newQuery;
 }
-
 function assignQueries(localShapes, queries, layerId, layerQueries) {
   for (const [queryName, query] of Object.entries(layerQueries)) {
     queries[queryName] = rewriteLayerId(localShapes, layerId, query);
   }
 }
-
 function flattenSchema(projectSchema, getLayer) {
   const {
     layers,
     ...rest
   } = projectSchema;
-  const flattenedSchema = { ...rest,
+  const flattenedSchema = {
+    ...rest,
     shapes: {},
     queries: {},
     mutations: {},
@@ -332,81 +269,64 @@ function flattenSchema(projectSchema, getLayer) {
   };
   const filteredLayers = layers.reverse().map(layer => {
     var _config$visibility;
-
-    const config = typeof layer === 'string' ? { ...layerDefaults,
+    const config = typeof layer === 'string' ? {
+      ...layerDefaults,
       id: layer
     } : layer;
     const layerSchema = getLayer(config.id);
-
     if (!layerSchema) {
       throw new Error(`Unable to flatten schema for project ${projectSchema.projectId}. Cannot get layer ${config.id}`);
     }
-
     return (_config$visibility = config.visibility) !== null && _config$visibility !== void 0 && _config$visibility.length ? filterLayer(layerSchema, config.visibility) : undefined;
   }).filter(_util.isDefined);
-
   for (const filteredLayer of filteredLayers) {
     var _projectSchema$servic;
-
     const {
       layerId
-    } = filteredLayer; // Preserve original queries
-
+    } = filteredLayer;
+    // Preserve original queries
     if ((_projectSchema$servic = projectSchema.services) !== null && _projectSchema$servic !== void 0 && _projectSchema$servic[layerId]) {
       const serviceLayer = ensureServiceLayer(flattenedSchema, layerId);
-
       if (serviceLayer.queries && filteredLayer.queries) {
         Object.assign(serviceLayer.queries, filteredLayer.queries);
       }
-
       if (serviceLayer.mutations && filteredLayer.mutations) {
         Object.assign(serviceLayer.mutations, filteredLayer.mutations);
       }
     }
-
     if (filteredLayer.workflows) {
       Object.assign(flattenedSchema.workflows, filteredLayer.workflows);
     }
-
     if (flattenedSchema.forms && filteredLayer.forms) {
       Object.assign(flattenedSchema.forms, filteredLayer.forms);
     }
-
     if (filteredLayer.shapes) {
       assignShapes(flattenedSchema.shapes, filteredLayer.shapes);
     }
   }
-
   for (const filteredLayer of filteredLayers) {
     if (filteredLayer.queries) {
       assignQueries(flattenedSchema.shapes, flattenedSchema.queries, filteredLayer.layerId, filteredLayer.queries);
     }
-
     if (filteredLayer.mutations) {
       assignQueries(flattenedSchema.shapes, flattenedSchema.mutations, filteredLayer.layerId, filteredLayer.mutations);
     }
-  } // Preserve original service schema shapes
-
+  }
 
+  // Preserve original service schema shapes
   for (const refStr of collectServiceRefs(flattenedSchema, getLayer)) {
     const [layerId, shapeName] = (0, _refs.splitAtRef)(refStr);
-
     if (layerId !== 'local') {
       var _getLayer, _getLayer$shapes;
-
       const shape = (_getLayer = getLayer(layerId)) === null || _getLayer === void 0 ? void 0 : (_getLayer$shapes = _getLayer.shapes) === null || _getLayer$shapes === void 0 ? void 0 : _getLayer$shapes[shapeName];
-
       if (shape) {
         const serviceLayer = ensureServiceLayer(flattenedSchema, layerId);
-
         if (!serviceLayer.shapes) {
           serviceLayer.shapes = {};
         }
-
         serviceLayer.shapes[shapeName] = shape;
       }
     }
   }
-
   return flattenedSchema;
 }