@takeshape/schema 8.36.2 → 8.38.2

package/es/flatten-templates.js

@@ -0,0 +1,26 @@
+import { resolveTemplate, isValidTemplate } from './template-shapes';
+import { getAllRefs } from './schema-util';
+import set from 'lodash/set';
+import { deepClone } from '@takeshape/util';
+export function flattenTemplates(projectSchema) {
+  const templateRefs = getAllRefs(projectSchema, ref => Boolean(ref.template));
+
+  if (!templateRefs.length) {
+    return projectSchema;
+  }
+
+  const newSchema = deepClone(projectSchema);
+
+  for (const ref of templateRefs) {
+    if (ref.template && isValidTemplate(ref.template)) {
+      const {
+        shapeName,
+        dependencies
+      } = resolveTemplate(projectSchema, ref.template, ref.typeName);
+      set(newSchema, ref.path, shapeName);
+      Object.assign(newSchema.shapes, dependencies);
+    }
+  }
+
+  return newSchema;
+}

package/es/index.js

@@ -22,4 +22,5 @@ export * from './unions';
 export * from './enum';
 export * from './patterns';
 export * from './types/types';
-export * from './types/utils';
+export * from './types/utils';
+export * from './flatten-templates';

package/es/layers/layers.js

@@ -5,7 +5,7 @@ import { getArgsReferenceWithPath, getRefOrItemsRef, dereferenceSchema, parseRet
 import { isAllOfSchema, isObjectSchema, isOneOfSchema, isRefSchema } from './type-utils';
 import { visitSchemaProperties } from './visitor';
 import set from 'lodash/set';
-import { parseTemplateShape } from '../template-shapes';
+import { parseTemplateShape } from '../refs';
 const layerDefaults = {
   namespace: '',
   visibility: []

package/es/layers/refs.js

@@ -1,5 +1,5 @@
 import { isAllOfSchema, isOneOfSchema, isRefSchema } from './type-utils';
-import { parseTemplateShape } from '../template-shapes';
+import { parseTemplateShape } from '../refs';
 import assign from 'lodash/fp/assign';
 import omit from 'lodash/fp/omit';
 import { mergeWithArrayConcat } from '@takeshape/util';

package/es/refs.js

@@ -1,9 +1,81 @@
-import { getRefType, isAllOfSchema, isOneOfSchema, isRefSchema, isRefSchemaLegacy } from './types/utils';
-import { parseTemplateShape } from './template-shapes';
+import { getRefType, isAllOfSchema, isOneOfSchema, isRefSchema, isRefSchemaLegacy } from './types';
 import get from 'lodash/get';
 import assign from 'lodash/fp/assign';
 import omit from 'lodash/fp/omit';
 import { getServiceNamespace, getServiceNamespaces } from './services';
+const templateShapeRegex = /^(\w+)<([\w:-]+)>$/;
+/**
+ * Parse a template like `PaginatedList<Post>` and return both the template and the shape name.
+ */
+
+export function parseTemplateShape(shapeExpression) {
+  const matches = templateShapeRegex.exec(shapeExpression);
+
+  if (matches) {
+    return {
+      shapeName: matches[2],
+      template: matches[1]
+    };
+  }
+
+  return {
+    shapeName: shapeExpression,
+    template: undefined
+  };
+}
+export function parseReturnShape(projectSchema, shape) {
+  if (typeof shape === 'object') {
+    if (isRefSchema(shape.items)) {
+      const ref = getRef(projectSchema, shape.items);
+
+      if (!ref) {
+        throw new Error(`Could not parse ${JSON.stringify(shape.items)}: invalid ref`);
+      }
+
+      return {
+        isArray: true,
+        ref,
+        shapeName: refItemToShapeName(ref)
+      };
+    }
+
+    if (typeof shape.items.type !== 'string') {
+      throw new Error(`Could not parse ${JSON.stringify(shape.items)}: invalid type`);
+    }
+
+    return {
+      isArray: true,
+      shapeName: shape.items.type
+    };
+  }
+
+  const ref = refExpressionToRefItem(projectSchema, shape);
+  const shapeName = refItemToShapeName(ref);
+  return {
+    isArray: false,
+    shapeName,
+    ref,
+    template: ref.template
+  };
+}
+/**
+ * Create a template string like `PaginatedList<Post>` from a template and shape name.
+ */
+
+export function createTemplateShapeName(template, shapeName) {
+  return `${template}<${shapeName}>`;
+}
+/**
+ * If the string is a template like `PaginatedList<Post>`, return the shape name,
+ * in this case `Post`. Otherwise return the input.
+ */
+
+export const untemplate = input => {
+  return parseTemplateShape(input).shapeName;
+};
+export function getFlattenedTemplateShapeName(shapeName, template) {
+  return `${shapeName}${template ?? ''}`;
+}
 
 function $refToPath(ref) {
   return ref.substr(2).split('/');

package/es/schema-util.js

@@ -17,10 +17,9 @@ import { defaultWorkflow, getStatusField } from './workflows';
 import { CURRENT_API_VERSION, CURRENT_SCHEMA_VERSION } from './versions';
 import { workflowsEnabled } from './api-version';
 import { builtInShapes, builtInForms } from './builtin-schema';
-import { createTemplateShapeName, parseReturnShape } from './template-shapes';
 import { getArgsType, isBasicResolver, isObjectSchema, isAllOfSchema, isRefSchema, isOneOfSchema } from './types/utils';
 import { getStoredServiceConfig } from './services';
-import { followRef, getRef, getRefOrItemsRef, getRefShapeName, getRefWithPath, omitRefAndExtend, refExpressionToRefItem, refItemToShape, refItemToShapeName, refItemToShapeSchema } from './refs';
+import { createTemplateShapeName, followRef, getRef, getRefOrItemsRef, getRefShapeName, getRefWithPath, omitRefAndExtend, parseReturnShape, refExpressionToRefItem, refItemToShape, refItemToShapeName, refItemToShapeSchema } from './refs';
 import isEqual from 'lodash/isEqual';
 import { isUnionSchema } from './unions';
 export const SERVICE_OBJECT_PATTERN_NAME = 'pattern:service-object';
@@ -521,8 +520,8 @@ export function getArgsReference(projectSchema, argsSchema) {
     return refExpressionToRefItem(projectSchema, args);
   }
 }
-export function getArgsReferenceWithPath(projectSchema, argsSchema, schemaPath = []) {
-  const refItem = getArgsReference(projectSchema, argsSchema);
+export function getArgsReferenceWithPath(context, argsSchema, schemaPath = []) {
+  const refItem = getArgsReference(context, argsSchema);
 
   if (refItem) {
     const argsType = getArgsType(argsSchema);
@@ -531,14 +530,14 @@ export function getArgsReferenceWithPath(projectSchema, argsSchema, schemaPath =
     };
   }
 }
-export function getArgsShapeSchema(projectSchema, argsSchema) {
+export function getArgsShapeSchema(context, argsSchema) {
   const args = argsSchema['@args'] ?? argsSchema.args;
 
   if (args && typeof args === 'string') {
-    const refItem = getArgsReference(projectSchema, argsSchema);
+    const refItem = getArgsReference(context, argsSchema);
 
     if (refItem) {
-      return refItemToShapeSchema(projectSchema, refItem);
+      return refItemToShapeSchema(context, refItem);
     }
   } else if (args) {
     return args;
@@ -648,22 +647,25 @@ export function projectSchemaToJSONSchema(projectSchema) {
     definitions
   };
 }
-export function getShapeDependencies(projectSchema, shape) {
+export function getShapeDependencies(projectSchema, shape, predicate) {
   const shapeNames = new Set();
 
   const findDependencies = schema => {
     schema = schema.items ?? schema;
-    const refItem = getRef(projectSchema, schema);
 
-    if (refItem) {
-      const refShape = refItemToShape(projectSchema, refItem);
+    if (!predicate || predicate(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));
+        if (refShape && !shapeNames.has(refShape.name)) {
+          shapeNames.add(refShape.name);
+          findDependencies(dereferenceSchema(projectSchema, refShape.schema));
+        }
+      } else if (isObjectSchema(schema) || isAllOfSchema(schema) || isOneOfSchema(schema)) {
+        visitSchemaProperties(schema, [], findDependencies);
       }
-    } else if (isObjectSchema(schema) || isAllOfSchema(schema) || isOneOfSchema(schema)) {
-      visitSchemaProperties(schema, [], findDependencies);
     }
   };
 
@@ -1222,4 +1224,13 @@ export function findShapeFormConfig(projectSchema, shapeName, formName) {
 export const getDefaultMutationName = (shapeName, resolver) => {
   const action = resolver.substring(resolver.indexOf(':') + 1);
   return `${action}${shapeName}`;
-};
+};
+export function createShape(name, schema, rest) {
+  return {
+    name,
+    id: name,
+    title: name,
+    schema,
+    ...rest
+  };
+}

package/es/template-shapes/index.js

@@ -0,0 +1,35 @@
+import { CreateArgs, CreateResult, DeleteArgs, DeleteResult, DuplicateArgs, DuplicateResult, PaginatedList, SearchResults, TSGetArgs, TSGetSingletonArgs, TSListArgs, TSSearchArgs, UpdateArgs, UpdateResult } from './templates';
+const templateMappings = {
+  TSGetArgs,
+  TSGetSingletonArgs,
+  TSListArgs,
+  TSSearchArgs,
+  CreateArgs,
+  UpdateArgs,
+  DuplicateArgs,
+  DeleteArgs,
+  PaginatedList,
+  SearchResults,
+  CreateResult,
+  UpdateResult,
+  DuplicateResult,
+  DeleteResult
+};
+export function resolveTemplate(projectSchema, templateName, shapeName) {
+  const mapping = templateMappings[templateName];
+
+  if (!mapping) {
+    throw new Error(`Invalid shape template ${templateName}`);
+  }
+
+  return mapping({
+    projectSchema
+  }, projectSchema.shapes[shapeName]);
+}
+/**
+ * Check if a string is a known template such as `PaginatedList`
+ */
+
+export function isValidTemplate(template) {
+  return Boolean(templateMappings[template]);
+}

package/es/template-shapes/templates.js

@@ -0,0 +1,379 @@
+import { listTypePrefix } from '../migration';
+import { isDefined, pascalCase } from '@takeshape/util';
+import keyBy from 'lodash/keyBy';
+import { createShape, getShapeDependencies, mergeSchemaProperties } from '../schema-util';
+import { getFlattenedTemplateShapeName, getRefShapeName } from '../refs';
+import { getWhereSearchArg } from './where';
+const CREATE = 'create';
+const UPDATE = 'update';
+const DELETE = 'delete';
+const DUPLICATE = 'duplicate';
+export const TSGetArgs = getIDQueryArgs('TSGetArgs');
+export const TSGetSingletonArgs = getIDQueryArgs('TSGetSingletonArgs');
+export const TSListArgs = getShapeListQueryArgs('TSListArgs', true);
+export const TSSearchArgs = getShapeListQueryArgs('TSSearchArgs', false);
+export const CreateArgs = getMutationArgs('CreateArgs', CREATE);
+export const UpdateArgs = getMutationArgs('UpdateArgs', UPDATE);
+export const DuplicateArgs = getMutationArgs('DuplicateArgs', DUPLICATE);
+export const DeleteArgs = getMutationArgs('DeleteArgs', DELETE);
+export const PaginatedList = getPaginatedListShape;
+export const SearchResults = getSearchResultsShape;
+export const CreateResult = getMutationResultType(CREATE);
+export const UpdateResult = getMutationResultType(UPDATE);
+export const DuplicateResult = getMutationResultType(DUPLICATE);
+export const DeleteResult = getMutationResultType(DELETE);
+export const TSSearchSortInput = createShape('TSSearchSortInput', {
+  type: 'object',
+  properties: {
+    field: {
+      type: 'string'
+    },
+    order: {
+      type: 'string',
+      description: '"asc" for ascending or "desc" for descending'
+    }
+  },
+  required: ['field', 'order']
+});
+export const commonSearchProps = {
+  terms: {
+    type: 'string'
+  },
+  from: {
+    type: 'integer',
+    description: 'The offset from the first result you want to fetch.'
+  },
+  size: {
+    type: 'integer',
+    description: 'The maximum number of items to return.'
+  },
+  filter: {
+    type: 'object',
+    description: 'An elasticsearch style filter. Overrides onlyEnabled.'
+  },
+  sort: {
+    type: 'array',
+    description: 'An list of fields to sort by.',
+    items: {
+      '@ref': `local:${TSSearchSortInput.name}`
+    }
+  }
+};
+export const localeProps = {
+  type: 'object',
+  properties: {
+    locale: {
+      type: 'string'
+    },
+    enableLocaleFallback: {
+      type: 'boolean',
+      default: true
+    }
+  }
+};
+export const termsProps = {
+  type: 'object',
+  properties: {
+    terms: {
+      type: 'string'
+    }
+  }
+};
+export const ContentStructureInput = createShape('ContentStructureInput', {
+  type: 'object',
+  properties: {
+    path: {
+      type: 'string',
+      description: 'A deep path to the array being updated (e.g. a.b[1].c).'
+    },
+    structure: {
+      type: 'array',
+      description: 'An array where the indices represent the to index, and the values represent the from index.' + 'For example to transform ["a","b","c","d"] into ["c","a"], this value would be [2,0].',
+      items: {
+        type: 'integer'
+      }
+    }
+  },
+  required: ['path']
+}, {
+  description: 'Describes a structural update to an array of data.'
+});
+export function getPaginatedListShape(context, shape) {
+  const shapeName = `${shape.name}${listTypePrefix}`;
+  return {
+    shapeName,
+    dependencies: {
+      [shapeName]: createShape(shapeName, {
+        type: 'object',
+        properties: {
+          items: {
+            type: 'array',
+            items: {
+              '@ref': `local:${shape.name}`
+            }
+          },
+          total: {
+            type: 'integer'
+          }
+        },
+        required: ['items', 'total']
+      })
+    }
+  };
+}
+export function getSearchResultsShape(context, shape) {
+  const shapeName = `${shape.name}SearchResults`;
+  return {
+    shapeName,
+    dependencies: {
+      [shapeName]: createShape(shapeName, {
+        type: 'object',
+        properties: {
+          results: {
+            type: 'array',
+            items: {
+              '@ref': `local:${shape.name}`
+            }
+          },
+          total: {
+            type: 'integer'
+          }
+        },
+        required: ['results', 'total']
+      }, {
+        description: `${shape.name} search results`
+      })
+    }
+  };
+}
+const contentStructureFields = {
+  type: 'object',
+  properties: {
+    structure: {
+      type: 'array',
+      items: {
+        '@ref': 'local:ContentStructureInput'
+      }
+    }
+  }
+};
+const idSchema = {
+  type: 'object',
+  properties: {
+    _id: {
+      type: 'string'
+    }
+  },
+  required: ['_id']
+};
+
+function rewriteSchema(shapeSchema) {
+  return JSON.parse(JSON.stringify(shapeSchema), (key, value) => {
+    var _value$required;
+
+    // Remove required
+    if (typeof value === 'object' && value.type === 'object' && (_value$required = value.required) !== null && _value$required !== void 0 && _value$required.length) {
+      delete value.required;
+    } // Remove default
+
+
+    if (typeof value === 'object' && value.type && value.default) {
+      delete value.default;
+    }
+
+    return value;
+  });
+}
+
+export function getIDQueryArgs(templateName) {
+  return (context, shape) => {
+    var _shape$model;
+
+    const schema = ((_shape$model = shape.model) === null || _shape$model === void 0 ? void 0 : _shape$model.type) !== 'single' ? mergeSchemaProperties(idSchema, localeProps) : localeProps;
+    const shapeName = getFlattenedTemplateShapeName(shape.name, templateName);
+    return {
+      shapeName,
+      dependencies: {
+        [shapeName]: createShape(shapeName, schema)
+      }
+    };
+  };
+}
+
+function mergeObjectSchemas(...args) {
+  return args.filter(isDefined).reduce(mergeSchemaProperties, {
+    type: 'object',
+    properties: {}
+  });
+}
+
+export function getMutationArgs(templateName, verb) {
+  return ({
+    projectSchema
+  }, shape) => {
+    const addLocale = verb === UPDATE || verb === DUPLICATE;
+    const addStructure = verb === UPDATE;
+    const inputName = pascalCase([verb, shape.name, 'input']);
+    const isSingleton = shape.model && shape.model.type === 'single';
+    const requireId = !isSingleton && (verb === UPDATE || verb === DELETE || verb === DUPLICATE);
+    const isUpdate = verb === UPDATE || verb === DUPLICATE;
+    const inputShape = createShape(inputName, mergeObjectSchemas(requireId ? idSchema : undefined, verb !== DELETE ? isUpdate ? rewriteSchema(shape.schema) : shape.schema : undefined), {
+      description: `${verb} ${shape.name} input`
+    });
+    const argsShapeName = getFlattenedTemplateShapeName(shape.name, templateName);
+    const argsShape = createShape(argsShapeName, mergeObjectSchemas({
+      type: 'object',
+      properties: {
+        input: {
+          '@ref': `local:${inputShape.name}`
+        },
+        clientMutationId: {
+          type: 'string'
+        }
+      },
+      required: ['input']
+    }, addStructure ? contentStructureFields : undefined, addLocale ? localeProps : undefined));
+
+    const getInputShapeName = shapeName => isUpdate ? `${shapeName}PartialInput` : `${shapeName}Input`;
+
+    return {
+      shapeName: argsShapeName,
+      dependencies: {
+        [inputName]: inputShape,
+        [argsShapeName]: argsShape,
+        ...(verb !== DELETE && keyBy(getShapeDependencies(projectSchema, shape, propSchema => {
+          if (!propSchema['@resolver']) {
+            return false;
+          }
+
+          const shapeName = getRefShapeName(projectSchema, propSchema);
+
+          if (shapeName) {
+            return !projectSchema.shapes[getInputShapeName(shapeName)];
+          }
+
+          return true;
+        }).map(shapeName => {
+          const shape = projectSchema.shapes[shapeName];
+          const name = getInputShapeName(shapeName);
+          return { ...shape,
+            name,
+            id: name,
+            schema: isUpdate ? rewriteSchema(shape.schema) : shape.schema
+          };
+        }), 'name')),
+        ...(addStructure ? {
+          ContentStructureInput
+        } : {})
+      }
+    };
+  };
+}
+export function getMutationResultType(verb) {
+  return (context, shape) => {
+    const shapeName = pascalCase([verb, shape.name, 'result']);
+    const result = verb === DELETE ? {
+      type: 'boolean'
+    } : {
+      '@ref': `local:${shape.name}`
+    };
+    return {
+      shapeName,
+      dependencies: {
+        [shapeName]: createShape(shapeName, {
+          type: 'object',
+          properties: {
+            clientMutationId: {
+              type: 'string'
+            },
+            result
+          }
+        })
+      }
+    };
+  };
+}
+export const commonSearchArgs = {
+  type: 'object',
+  properties: {
+    terms: {
+      type: 'string'
+    },
+    from: {
+      type: 'integer',
+      description: 'The offset from the first result you want to fetch.'
+    },
+    size: {
+      type: 'integer',
+      description: 'The maximum number of items to return.'
+    },
+    filter: {
+      type: 'object',
+      description: 'An elasticsearch style filter. Overrides onlyEnabled.'
+    },
+    sort: {
+      type: 'array',
+      description: 'An list of fields to sort by.',
+      items: {
+        '@ref': `local:${TSSearchSortInput.name}`
+      }
+    }
+  }
+};
+const legacyListArgs = {
+  type: 'object',
+  properties: {
+    onlyEnabled: {
+      type: 'boolean',
+      default: true,
+      description: 'Filter out content that is not enabled. Defaults to true.'
+    }
+  }
+};
+const shapeFilterProps = {
+  type: 'object',
+  properties: {
+    shapeNames: {
+      type: 'array',
+      items: {
+        type: 'string'
+      }
+    },
+    shapeIds: {
+      type: 'array',
+      items: {
+        type: 'string'
+      }
+    },
+    contentTypeNames: {
+      type: 'array',
+      items: {
+        type: 'string'
+      }
+    },
+    contentTypeIds: {
+      type: 'array',
+      items: {
+        type: 'string'
+      }
+    }
+  }
+};
+export function getShapeListQueryArgs(templateName, legacyArgs) {
+  return (context, shape) => {
+    const isAllShapes = shape.name === 'TSSearchable';
+    const shapeName = isAllShapes ? templateName : getFlattenedTemplateShapeName(shape.name, templateName);
+    const shapes = isAllShapes ? Object.values(context.projectSchema.shapes) : [shape];
+    const {
+      schema,
+      dependencies
+    } = getWhereSearchArg(context.projectSchema, shapes);
+    return {
+      shapeName,
+      dependencies: { ...dependencies,
+        TSSearchSortInput,
+        [shapeName]: createShape(shapeName, mergeObjectSchemas(commonSearchArgs, localeProps, legacyArgs ? legacyListArgs : undefined, isAllShapes ? shapeFilterProps : undefined, schema))
+      }
+    };
+  };
+}

package/es/template-shapes/types.js

@@ -0,0 +1 @@
+export {};