@takeshape/schema 8.37.0 → 8.38.0

package/es/template-shapes/where.js

@@ -0,0 +1,501 @@
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+import { pascalCase, isDefined } from '@takeshape/util';
+import isEqual from 'lodash/isEqual';
+import get from 'lodash/get';
+import unset from 'lodash/unset';
+import isFunction from 'lodash/isFunction';
+import { createSchemaPropertyList, createShape, getAllRefsInShapes, getShapeById, isIndexedRemoteShape } from '../schema-util';
+import { workflowsEnabled } from '../api-version';
+import { followRef, getRefOrItemsRef, hasRefProperty, hasResolvableRef, refItemToShapeName } from '../refs';
+import { enumerateOneOfKeys, isUnionSchema } from '../unions';
+import { isObjectSchema } from '../types';
+export const MAX_RELATIONSHIP_DEPTH = 1;
+export const exceededRelationshipDepth = (depth = 0) => depth >= MAX_RELATIONSHIP_DEPTH;
+
+class ShapeCache {
+  constructor() {
+    _defineProperty(this, "thunks", new Map());
+
+    _defineProperty(this, "unresolved", new Set());
+  }
+
+  has(shapeName) {
+    return this.thunks.has(shapeName);
+  }
+
+  set(shapeName, thunk) {
+    this.thunks.set(shapeName, thunk);
+
+    if (isFunction(thunk)) {
+      this.unresolved.add(shapeName);
+    }
+  }
+
+  resolveAll() {
+    while (this.unresolved.size) {
+      const shapeName = this.unresolved.values().next().value;
+      const thunk = this.thunks.get(shapeName);
+
+      if (isFunction(thunk)) {
+        this.thunks.set(shapeName, thunk());
+        this.unresolved.delete(shapeName);
+      }
+    }
+
+    const result = {};
+
+    for (const [shapeName, shape] of this.thunks) {
+      result[shapeName] = shape;
+    }
+
+    return result;
+  }
+
+}
+
+export const fieldTypeComparison = {
+  id: {
+    comparators: ['eq', 'in'],
+    type: 'string'
+  },
+  boolean: {
+    comparators: ['eq'],
+    type: 'boolean'
+  },
+  string: {
+    comparators: ['eq', 'in', 'match', 'regexp'],
+    type: 'string'
+  },
+  date: {
+    comparators: ['eq', 'lt', 'lte', 'gt', 'gte'],
+    type: 'string'
+  },
+  number: {
+    comparators: ['eq', 'lt', 'lte', 'gt', 'gte', 'in'],
+    type: 'number'
+  },
+  integer: {
+    comparators: ['eq', 'lt', 'lte', 'gt', 'gte', 'in'],
+    type: 'integer'
+  },
+  workflow: {
+    comparators: ['eq', 'lt', 'lte', 'gt', 'gte', 'in'],
+    type: 'string'
+  },
+  draftjs: {
+    comparators: ['match'],
+    type: 'string'
+  },
+  mdx: {
+    comparators: ['match'],
+    type: 'string'
+  }
+};
+export const comparatorDescriptions = {
+  eq: 'Exact match',
+  gt: 'Greater than',
+  gte: 'Greater than or equal',
+  lt: 'Less than',
+  lte: 'Less than or equal',
+  in: 'Array of possible exact match values.',
+  match: 'Full text searching with fuzzy matching.',
+  regexp: 'Regular expression string matching. Use of * wildcards could degrade performance.'
+};
+export const booleanOperators = ['AND', 'OR', 'NOT'];
+export const boolOpDescriptionMap = {
+  AND: 'AND takes an array of conditions that must appear in the matching results. Nested boolean operators can be used to create complex filters.',
+  OR: 'OR takes an array of conditions that should appear in the matching results. Nested boolean operators can be used to create complex filters.',
+  NOT: 'NOT takes a single condition that must not appear in the matching results.'
+};
+
+const getConflictingProperties = (projectSchema, shapes) => {
+  let conflicts = [];
+  const allProps = {};
+
+  for (const shape of Object.values(shapes)) {
+    const shapeConflicts = createSchemaPropertyList(projectSchema, shape.schema).filterBy(([name, prop]) => name in allProps && (allProps[name].type !== prop.type || !isEqual(get(allProps, [name, '@relationship', 'shapeIds']), get(prop, ['@relationship', 'shapeIds'])))).getNames();
+    conflicts = conflicts.concat(shapeConflicts);
+
+    if (isObjectSchema(shape.schema)) {
+      Object.assign(allProps, shape.schema.properties);
+    }
+  }
+
+  return conflicts;
+};
+
+export function getFieldTypeComparison(fieldType) {
+  const comparison = fieldTypeComparison[fieldType];
+
+  if (!comparison) {
+    return undefined;
+  }
+
+  const {
+    comparators,
+    type
+  } = comparison;
+  const result = {};
+
+  for (const op of comparators) {
+    const description = comparatorDescriptions[op];
+    result[op] = op === 'in' ? {
+      type: 'array',
+      items: {
+        type
+      },
+      description
+    } : {
+      description,
+      type
+    };
+  }
+
+  return result;
+}
+
+function isId(name) {
+  return name === '_id' || name === '_contentTypeId' || name === '_shapeId';
+}
+
+function isNonRelationshipRef(prop) {
+  return Boolean(hasRefProperty(prop) && !prop['@relationship']);
+}
+
+function getPropType(projectSchema, name, prop) {
+  if (prop['@workflow']) {
+    return 'workflow';
+  }
+
+  if (prop['@tag'] === 'draftjs') {
+    return 'draftjs';
+  }
+
+  if (prop['@tag'] === 'mdx') {
+    return 'mdx';
+  }
+
+  if (prop.format === 'date-time') {
+    return 'date';
+  }
+
+  if (isId(name)) {
+    return 'id';
+  }
+
+  if (isNonRelationshipRef(prop)) {
+    const followed = followRef(projectSchema, prop);
+
+    if (followed.enum) {
+      return 'string';
+    }
+
+    return 'object';
+  }
+
+  return prop.type;
+}
+
+function getRelatedShapeNames(prop, projectSchema) {
+  var _prop$Relationship;
+
+  const names = (_prop$Relationship = prop['@relationship']) === null || _prop$Relationship === void 0 ? void 0 : _prop$Relationship.shapeIds.map(id => {
+    const shape = getShapeById(projectSchema, id);
+    return pascalCase(shape ? shape.name : '');
+  }).sort().join('');
+
+  if (!names) {
+    throw new Error(`Relationship property ${prop.title} is missing related shapes`);
+  }
+
+  return names;
+}
+
+function joinShapeNames(shapes) {
+  return shapes.sort().join('');
+}
+
+function getTypeName(name, prop, shapeName, context) {
+  const {
+    projectSchema,
+    relationshipDepth,
+    conflictingProperties
+  } = context;
+  let type = getPropType(projectSchema, name, prop);
+
+  if (isId(name)) {
+    return `TSWhereID`;
+  }
+
+  if (prop['@relationship']) {
+    const shapeNames = getRelatedShapeNames(prop, projectSchema);
+    return `TSWhere${shapeNames}Relationship`;
+  }
+
+  if (isUnionSchema(prop)) {
+    if (prop.oneOf.length > 1) {
+      const shapeNames = joinShapeNames(enumerateOneOfKeys(projectSchema, prop.oneOf).map(child => child.shapeName));
+      return `TSWhere${shapeNames}Union`;
+    }
+
+    type = 'object';
+    prop = prop.oneOf[0];
+  }
+
+  if (type === 'object' || type === 'array') {
+    const prefix = `TS${relationshipDepth >= MAX_RELATIONSHIP_DEPTH ? 'Shallow' : ''}Where`;
+    const fieldName = `${conflictingProperties.includes(name) ? '_' : ''}${pascalCase(name)}`;
+    const refItem = getRefOrItemsRef(projectSchema, prop);
+    const suffix = refItem ? refItemToShapeName(refItem) : `${shapeName}${fieldName}`;
+    return `${prefix}${suffix}`;
+  }
+
+  return `TSWhere${pascalCase(type)}`;
+}
+
+function skipField(name, prop, projectSchema, exceededRelationshipDepth) {
+  return Boolean(prop['@user'] || prop['@sensitive'] || prop['@resolver'] || prop['@relationship'] && exceededRelationshipDepth || (name === '_enabled' || name === '_enabledAt') && workflowsEnabled(projectSchema.apiVersion));
+}
+
+export function getFields(typeName, shapes, context) {
+  const {
+    shapeCache,
+    relationshipDepth,
+    booleanOperators,
+    projectSchema
+  } = context;
+  const result = {};
+  const tooDeep = exceededRelationshipDepth(relationshipDepth);
+
+  for (const shape of shapes) {
+    const nodes = createSchemaPropertyList(projectSchema, shape.schema).filterBy(([name, property]) => !skipField(name, property, projectSchema, tooDeep)).getNodes();
+
+    for (const [name, property] of nodes) {
+      Object.assign(result, getPropertyComparisonType(name, property, shape.name, context));
+    }
+  }
+
+  return tooDeep || booleanOperators === false ? result : Object.assign(result, getBooleanOperatorTypes(result, typeName, shapeCache));
+}
+
+function getBooleanOperatorTypes(fields, typeName, shapeCache) {
+  const result = {};
+
+  for (const op of booleanOperators) {
+    const name = `${typeName}${pascalCase(op)}Operator`;
+
+    if (!shapeCache.has(name)) {
+      shapeCache.set(name, () => createShape(name, {
+        type: 'object',
+        properties: { ...fields,
+          ...(op !== 'NOT' && getBooleanOperatorTypes(fields, typeName, shapeCache))
+        }
+      }, {
+        description: boolOpDescriptionMap[op]
+      }));
+    }
+
+    const refSchema = {
+      '@ref': `local:${name}`
+    };
+    result[op] = op === 'NOT' ? refSchema : {
+      type: 'array',
+      items: refSchema
+    };
+  }
+
+  return result;
+}
+
+export function getPropertyComparisonType(name, prop, shapeName, context) {
+  const {
+    shapeCache,
+    projectSchema,
+    relationshipDepth,
+    conflictingProperties
+  } = context;
+
+  if (skipField(name, prop, projectSchema, exceededRelationshipDepth(relationshipDepth))) {
+    return undefined;
+  }
+
+  const fieldType = getPropType(projectSchema, name, prop) ?? 'string';
+  const typeName = getTypeName(name, prop, shapeName, context);
+
+  if (hasRefProperty(prop.items ?? prop)) {
+    if (!hasResolvableRef(projectSchema, prop.items ?? prop)) {
+      return undefined;
+    }
+
+    if (prop.items) {
+      prop = { ...prop,
+        items: followRef(projectSchema, prop.items)
+      };
+    } else {
+      prop = followRef(projectSchema, prop);
+    }
+  }
+
+  if (!shapeCache.has(typeName)) {
+    shapeCache.set(typeName, () => {
+      var _prop$items;
+
+      let props;
+      const propOrItems = prop.items ?? prop;
+
+      if (isId(name)) {
+        props = getFieldTypeComparison('id');
+      } else if (prop['@relationship']) {
+        const shapes = prop['@relationship'].shapeIds.map(id => getShapeById(projectSchema, id)).filter(isDefined);
+        props = getFields(typeName, shapes, { ...context,
+          conflictingProperties: getConflictingProperties(context.projectSchema, shapes),
+          relationshipDepth: relationshipDepth + 1
+        });
+      } else if (isUnionSchema(propOrItems)) {
+        const shapes = enumerateOneOfKeys(projectSchema, propOrItems.oneOf).map(option => projectSchema.shapes[option.shapeName]);
+        props = getFields(typeName, shapes, { ...context,
+          conflictingProperties: getConflictingProperties(context.projectSchema, shapes),
+          relationshipDepth,
+          booleanOperators: false
+        });
+      } else if (fieldType === 'object' || fieldType === 'array' && ((_prop$items = prop.items) === null || _prop$items === void 0 ? void 0 : _prop$items.type) === 'object') {
+        var _prop$items2;
+
+        const properties = ((_prop$items2 = prop.items) === null || _prop$items2 === void 0 ? void 0 : _prop$items2.properties) ?? prop.properties;
+
+        if (properties) {
+          for (const propName of Object.keys(properties)) {
+            props = { ...props,
+              ...getPropertyComparisonType(propName, properties[propName], shapeName, context)
+            };
+          }
+        }
+      } else {
+        var _prop$items3;
+
+        // Treat non-object arrays as their base type
+        let type;
+
+        if (typeof ((_prop$items3 = prop.items) === null || _prop$items3 === void 0 ? void 0 : _prop$items3.type) === 'string') {
+          type = prop.items.type;
+        } else {
+          type = fieldType;
+        }
+
+        props = getFieldTypeComparison(type);
+      }
+
+      return createShape(typeName, {
+        type: 'object',
+        properties: props ?? {}
+      });
+    });
+  }
+
+  if (shapeCache.has(typeName)) {
+    const fieldName = `${conflictingProperties.includes(name) ? `${shapeName}_` : ''}${name}`;
+    return {
+      [fieldName]: {
+        '@ref': `local:${typeName}`
+      }
+    };
+  }
+}
+
+function findEmpty(shapes) {
+  const empty = new Set();
+
+  for (const [shapeName, shape] of Object.entries(shapes)) {
+    if (isObjectSchema(shape.schema) && Object.keys(shape.schema.properties).length === 0) {
+      empty.add(shapeName);
+    }
+  }
+
+  return empty;
+}
+
+function getRefSummary(shapes) {
+  const result = {};
+
+  for (const ref of getAllRefsInShapes({
+    shapes,
+    services: {}
+  })) {
+    const path = ref.path.slice(1, ref.path.length - 1);
+
+    if (result[ref.typeName]) {
+      result[ref.typeName].push(path);
+    } else {
+      result[ref.typeName] = [path];
+    }
+  }
+
+  return result;
+}
+
+function pruneEmpty(shapes) {
+  let toPrune = findEmpty(shapes);
+
+  if (toPrune.size) {
+    const refSummary = getRefSummary(shapes);
+
+    while (toPrune.size) {
+      for (const shapeName of toPrune) {
+        unset(shapes, shapeName);
+
+        for (const path of refSummary[shapeName] ?? []) {
+          unset(shapes, path);
+        }
+      }
+
+      toPrune = findEmpty(shapes);
+    }
+  }
+
+  return shapes;
+}
+
+export function getWhereShape(projectSchema, shapes) {
+  const isManyContentTypes = shapes.length > 1;
+  const shapeName = isManyContentTypes ? 'TSWhereInput' : `TSWhere${pascalCase(shapes[0].name)}Input`;
+  const shapeCache = new ShapeCache();
+  const conflictingProperties = getConflictingProperties(projectSchema, shapes);
+  const fields = getFields(shapeName, shapes, {
+    projectSchema,
+    shapeCache,
+    conflictingProperties,
+    relationshipDepth: 0
+  });
+  return {
+    shapeName,
+    dependencies: pruneEmpty({
+      [shapeName]: createShape(shapeName, {
+        type: 'object',
+        properties: { ...fields,
+          ...(isManyContentTypes && getBooleanOperatorTypes(fields, shapeName, shapeCache))
+        }
+      }),
+      ...shapeCache.resolveAll()
+    })
+  };
+}
+export function getWhereSearchArg(projectSchema, shapes) {
+  const {
+    shapeName,
+    dependencies
+  } = getWhereShape(projectSchema, shapes.filter(s => s.model !== undefined || isIndexedRemoteShape(projectSchema, s)));
+  const schema = {
+    type: 'object',
+    properties: {
+      where: {
+        '@ref': `local:${shapeName}`,
+        description: 'The where clause uses the boolean AND, OR, and NOT parameters to construct complex filters based on the values of your fields. It applies an implicit AND to all the top-level keys. To avoid this, use a single OR or NOT key as the only top-level key.'
+      }
+    }
+  };
+  return {
+    schema,
+    dependencies
+  };
+}

package/es/validate.js

@@ -11,9 +11,9 @@ import { allProjectSchemas } from './schemas';
 import authSchemas from './schemas/auth-schemas.json';
 import { getAllNamespaceShapes, visitShapeProperties, getAllRefsInShapes } from './schema-util';
 import { builtInShapes } from './builtin-schema';
-import { isValidTemplate, parseReturnShape } from './template-shapes';
+import { isValidTemplate } from './template-shapes';
 import { isBasicResolver, isComposeResolver } from './types/utils';
-import { refItemToAtRef, refItemToShapeName } from './refs';
+import { refItemToAtRef, refItemToShapeName, parseReturnShape } from './refs';
 import { scalars } from './scalars';
 import { enumerateOneOfKeys, isUnionSchema } from './unions';
 import { isEnumLikeSchema } from './enum';

package/lib/flatten-templates.d.ts

@@ -0,0 +1,3 @@
+import { ProjectSchema } from './project-schema';
+export declare function flattenTemplates(projectSchema: ProjectSchema): ProjectSchema;
+//# sourceMappingURL=flatten-templates.d.ts.map

package/lib/flatten-templates.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"flatten-templates.d.ts","sourceRoot":"","sources":["../../src/flatten-templates.ts"],"names":[],"mappings":"AACA,OAAO,EAAC,aAAa,EAAC,MAAM,kBAAkB,CAAC;AAK/C,wBAAgB,gBAAgB,CAAC,aAAa,EAAE,aAAa,GAAG,aAAa,CAgB5E"}

package/lib/flatten-templates.js

@@ -0,0 +1,39 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.flattenTemplates = flattenTemplates;
+
+var _templateShapes = require("./template-shapes");
+
+var _schemaUtil = require("./schema-util");
+
+var _set = _interopRequireDefault(require("lodash/set"));
+
+var _util = require("@takeshape/util");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function flattenTemplates(projectSchema) {
+  const templateRefs = (0, _schemaUtil.getAllRefs)(projectSchema, ref => Boolean(ref.template));
+
+  if (!templateRefs.length) {
+    return projectSchema;
+  }
+
+  const newSchema = (0, _util.deepClone)(projectSchema);
+
+  for (const ref of templateRefs) {
+    if (ref.template && (0, _templateShapes.isValidTemplate)(ref.template)) {
+      const {
+        shapeName,
+        dependencies
+      } = (0, _templateShapes.resolveTemplate)(projectSchema, ref.template, ref.typeName);
+      (0, _set.default)(newSchema, ref.path, shapeName);
+      Object.assign(newSchema.shapes, dependencies);
+    }
+  }
+
+  return newSchema;
+}

package/lib/index.d.ts

@@ -24,4 +24,5 @@ export * from './enum';
 export * from './patterns';
 export * from './types/types';
 export * from './types/utils';
+export * from './flatten-templates';
 //# sourceMappingURL=index.d.ts.map

package/lib/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,YAAY,EAAC,mBAAmB,EAAE,6BAA6B,EAAC,MAAM,mBAAmB,CAAC;AAE1F,YAAY,EAAC,IAAI,EAAC,MAAM,eAAe,CAAC;AACxC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,eAAe,CAAC;AAC9B,cAAc,kBAAkB,CAAC;AACjC,cAAc,eAAe,CAAC;AAC9B,cAAc,YAAY,CAAC;AAC3B,cAAc,mBAAmB,CAAC;AAClC,cAAc,cAAc,CAAC;AAC7B,cAAc,aAAa,CAAC;AAC5B,cAAc,kBAAkB,CAAC;AACjC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,eAAe,CAAC;AAC9B,cAAc,aAAa,CAAC;AAC5B,cAAc,YAAY,CAAC;AAC3B,OAAO,EAAC,aAAa,EAAC,MAAM,kBAAkB,CAAC;AAC/C,cAAc,YAAY,CAAC;AAC3B,cAAc,SAAS,CAAC;AACxB,cAAc,QAAQ,CAAC;AACvB,cAAc,WAAW,CAAC;AAC1B,cAAc,QAAQ,CAAC;AACvB,cAAc,UAAU,CAAC;AACzB,cAAc,QAAQ,CAAC;AACvB,cAAc,YAAY,CAAC;AAC3B,cAAc,eAAe,CAAC;AAC9B,cAAc,eAAe,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,YAAY,EAAC,mBAAmB,EAAE,6BAA6B,EAAC,MAAM,mBAAmB,CAAC;AAE1F,YAAY,EAAC,IAAI,EAAC,MAAM,eAAe,CAAC;AACxC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,eAAe,CAAC;AAC9B,cAAc,kBAAkB,CAAC;AACjC,cAAc,eAAe,CAAC;AAC9B,cAAc,YAAY,CAAC;AAC3B,cAAc,mBAAmB,CAAC;AAClC,cAAc,cAAc,CAAC;AAC7B,cAAc,aAAa,CAAC;AAC5B,cAAc,kBAAkB,CAAC;AACjC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,eAAe,CAAC;AAC9B,cAAc,aAAa,CAAC;AAC5B,cAAc,YAAY,CAAC;AAC3B,OAAO,EAAC,aAAa,EAAC,MAAM,kBAAkB,CAAC;AAC/C,cAAc,YAAY,CAAC;AAC3B,cAAc,SAAS,CAAC;AACxB,cAAc,QAAQ,CAAC;AACvB,cAAc,WAAW,CAAC;AAC1B,cAAc,QAAQ,CAAC;AACvB,cAAc,UAAU,CAAC;AACzB,cAAc,QAAQ,CAAC;AACvB,cAAc,YAAY,CAAC;AAC3B,cAAc,eAAe,CAAC;AAC9B,cAAc,eAAe,CAAC;AAC9B,cAAc,qBAAqB,CAAC"}

package/lib/index.js

@@ -333,4 +333,18 @@ Object.keys(_utils).forEach(function (key) {
       return _utils[key];
     }
   });
+});
+
+var _flattenTemplates = require("./flatten-templates");
+
+Object.keys(_flattenTemplates).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _flattenTemplates[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _flattenTemplates[key];
+    }
+  });
 });

package/lib/layers/layers.js

@@ -25,7 +25,7 @@ var _visitor = require("./visitor");
 
 var _set = _interopRequireDefault(require("lodash/set"));
 
-var _templateShapes = require("../template-shapes");
+var _refs2 = require("../refs");
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
@@ -281,7 +281,7 @@ function rewriteLayerId(localShapes, layerId, query) {
 
   if (query.args) {
     if (typeof query.args === 'string') {
-      const [argsLayerId, shapeName] = (0, _refs.splitAtRef)((0, _templateShapes.parseTemplateShape)(query.args).shapeName);
+      const [argsLayerId, shapeName] = (0, _refs.splitAtRef)((0, _refs2.parseTemplateShape)(query.args).shapeName);
 
       if (argsLayerId === 'local' && !localShapes[shapeName]) {
         newQuery.args = `${layerId}:${shapeName}`;
@@ -292,7 +292,7 @@ function rewriteLayerId(localShapes, layerId, query) {
   }
 
   if (typeof query.shape === 'string') {
-    const [argsLayerId, shapeName] = (0, _refs.splitAtRef)((0, _templateShapes.parseTemplateShape)(query.shape).shapeName);
+    const [argsLayerId, shapeName] = (0, _refs.splitAtRef)((0, _refs2.parseTemplateShape)(query.shape).shapeName);
 
     if (argsLayerId === 'local' && !localShapes[shapeName]) {
       newQuery.shape = `${layerId}:${shapeName}`;

package/lib/layers/refs.js

@@ -23,7 +23,7 @@ exports.splitAtRef = splitAtRef;
 
 var _typeUtils = require("./type-utils");
 
-var _templateShapes = require("../template-shapes");
+var _refs = require("../refs");
 
 var _assign = _interopRequireDefault(require("lodash/fp/assign"));
 
@@ -47,7 +47,7 @@ function refExpressionToRefItem(refExpression) {
   const {
     shapeName,
     template
-  } = (0, _templateShapes.parseTemplateShape)(refExpression);
+  } = (0, _refs.parseTemplateShape)(refExpression);
   return atRefToRefItem(shapeName, template);
 }
 /**

package/lib/refs.d.ts

@@ -1,7 +1,8 @@
 /// <reference types="lodash" />
-import type { SchemaPath, SchemaWithRef, ProjectSchemaV3X } from './types/types';
+import type { SchemaPath, SchemaWithRef, ProjectSchemaV3X } from './types';
 import type { PropertySchema, Shape, ShapeSchema } from './project-schema';
 import type { Maybe } from '@takeshape/util';
+import { ReturnShape } from './project-schema';
 export declare type ServicesContext = Pick<ProjectSchemaV3X, 'services'>;
 export declare type ServicesShapesContext = Pick<ProjectSchemaV3X, 'services' | 'shapes'>;
 /**
@@ -22,6 +23,30 @@ export interface RefItem {
 export interface RefItemWithPath extends RefItem {
     path: SchemaPath;
 }
+/**
+ * Parse a template like `PaginatedList<Post>` and return both the template and the shape name.
+ */
+export declare function parseTemplateShape(shapeExpression: string): {
+    template: string | undefined;
+    shapeName: string;
+};
+export interface ParsedReturnShape {
+    isArray: boolean;
+    template?: string;
+    shapeName: string;
+    ref?: RefItem;
+}
+export declare function parseReturnShape(projectSchema: ServicesContext, shape: ReturnShape): ParsedReturnShape;
+/**
+ * Create a template string like `PaginatedList<Post>` from a template and shape name.
+ */
+export declare function createTemplateShapeName(template: string, shapeName: string): string;
+/**
+ * If the string is a template like `PaginatedList<Post>`, return the shape name,
+ * in this case `Post`. Otherwise return the input.
+ */
+export declare const untemplate: (input: string) => string;
+export declare function getFlattenedTemplateShapeName(shapeName: string, template?: string): string;
 export declare function $refToAtRef($ref: string, service: string, namespace?: string): string;
 export declare function refSchemaToPath(context: ServicesContext, refSchema: SchemaWithRef): string[];
 /**