@takeshape/schema 9.80.3 → 9.81.0

package/es/template-shapes/where.js

@@ -11,45 +11,34 @@ import { isObjectSchema, isPropertySchemaWithRelationship } from '../types/utils
 import { isEqualRelationship, getRelationship, getRelationshipShapes } from '../relationships';
 export const MAX_RELATIONSHIP_DEPTH = 1;
 export const exceededRelationshipDepth = (depth = 0) => depth >= MAX_RELATIONSHIP_DEPTH;
-
 class ShapeCache {
   thunks = new Map();
   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'],
@@ -104,39 +93,31 @@ export const boolOpDescriptionMap = {
   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.'
 };
-
 function getConflictingProperties(projectSchema, shapes) {
   const conflicts = new Set();
   const allProps = {};
-
   for (const shape of Object.values(shapes)) {
     for (const [name, prop] of createSchemaPropertyList(projectSchema, shape).getNodes()) {
       if (name in allProps && (allProps[name].type !== prop.type || !isEqualRelationship(allProps[name], prop))) {
         conflicts.add(name);
       }
     }
-
     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' ? {
@@ -150,73 +131,57 @@ export function getFieldTypeComparison(fieldType) {
       type
     };
   }
-
   return result;
 }
-
 function isId(name) {
   return name === '_id' || name === '_contentTypeId' || name === '_shapeId';
 }
-
 function isNonRelationshipRef(prop) {
   return Boolean(hasRefProperty(prop) && !getRelationship(prop));
 }
-
 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 truncateNames(names) {
   // For unions of many types hash the names this reduces shape name size while still allowing reuse
   return names.length > 80 ? md5(names) : names;
 }
+
 /**
  * Get a formatted string of related shape names from a property schema with a
  * relationship resolver
  */
-
-
 function getRelationshipShapeName(refs) {
   return refs.map(ref => {
     const shapeName = ref.split(':')[1];
     return formatShapeName(shapeName);
   }).sort().join('');
 }
-
 function joinShapeNames(shapes) {
   return shapes.sort().join('');
 }
-
 function getTypeName(name, prop, shapeName, context) {
   const {
     projectSchema,
@@ -224,34 +189,26 @@ function getTypeName(name, prop, shapeName, context) {
     conflictingProperties
   } = context;
   let type = getPropType(projectSchema, name, prop);
-
   if (isId(name)) {
     return `TSWhereID`;
   }
-
   const relationship = getRelationship(prop);
-
   if (relationship) {
     const relationshipName = getRelationshipShapeName(relationship.refs);
-
     if (!relationshipName) {
       throw new Error(`Relationship property "${prop.title ?? ''}" is missing related shapes`);
     }
-
     const shapeNames = truncateNames(relationshipName);
     return `TSWhere${shapeNames}Relationship`;
   }
-
   if (isUnionSchema(prop)) {
     if (prop.oneOf.length > 1) {
       const shapeNames = truncateNames(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 !== null && conflictingProperties !== void 0 && conflictingProperties.has(name) ? '_' : ''}${formatShapeName(name)}`;
@@ -259,10 +216,8 @@ function getTypeName(name, prop, shapeName, context) {
     const suffix = refItem ? refItemToShapeName(refItem) : `${shapeName}${fieldName}`;
     return `${prefix}${suffix}`;
   }
-
   return `TSWhere${pascalCase(type)}`;
 }
-
 function skipField({
   name,
   prop,
@@ -273,7 +228,6 @@ function skipField({
   const isRelationship = isPropertySchemaWithRelationship(prop);
   return Boolean(prop['@sensitive'] || prop['@resolver'] && !isIndexedShape && !isRelationship || isRelationship && exceededRelationshipDepth || (name === '_enabled' || name === '_enabledAt') && workflowsEnabled);
 }
-
 export function getFields(typeName, shapes, context) {
   const {
     relationshipDepth,
@@ -283,10 +237,10 @@ export function getFields(typeName, shapes, context) {
   const result = {};
   const tooDeep = exceededRelationshipDepth(relationshipDepth);
   const conflictingProperties = shapes.length ? getConflictingProperties(projectSchema, shapes) : undefined;
-  const fieldContext = { ...context,
+  const fieldContext = {
+    ...context,
     conflictingProperties
   };
-
   for (const shape of shapes) {
     const nodes = createSchemaPropertyList(projectSchema, shape).filterBy(([name, prop]) => !skipField({
       name,
@@ -295,18 +249,14 @@ export function getFields(typeName, shapes, context) {
       isIndexedShape: isCachedShape(shape),
       exceededRelationshipDepth: exceededRelationshipDepth(relationshipDepth)
     })).getNodes();
-
     for (const [name, property] of nodes) {
       Object.assign(result, getPropertyComparisonType(name, property, shape.name, fieldContext));
     }
   }
-
   return tooDeep || booleanOperators === false ? result : Object.assign(result, getBooleanOperatorTypes(typeName));
 }
-
 function getBooleanOperatorTypes(typeName) {
   const result = {};
-
   for (const op of booleanOperators) {
     const refSchema = {
       '@ref': `local:${typeName}`
@@ -316,10 +266,8 @@ function getBooleanOperatorTypes(typeName) {
       items: refSchema
     };
   }
-
   return result;
 }
-
 export function getPropertyComparisonType(name, prop, shapeName, context) {
   const {
     shapeCache,
@@ -327,7 +275,6 @@ export function getPropertyComparisonType(name, prop, shapeName, context) {
     relationshipDepth,
     conflictingProperties
   } = context;
-
   if (skipField({
     name,
     prop,
@@ -337,54 +284,49 @@ export function getPropertyComparisonType(name, prop, shapeName, context) {
   })) {
     return undefined;
   }
-
   const fieldType = getPropType(projectSchema, name, prop) ?? 'string';
   const typeName = getTypeName(name, prop, shapeName, context);
   const relationship = getRelationship(prop);
-
   if (hasRefProperty(prop.items ?? prop)) {
     if (!hasResolvableRef(projectSchema, prop.items ?? prop)) {
       return undefined;
     }
-
     if (prop.items) {
-      prop = { ...prop,
+      prop = {
+        ...prop,
         items: followRef(projectSchema, prop.items)
       };
     } else {
       prop = followRef(projectSchema, prop);
     }
   }
-
   if (!shapeCache.has(typeName) && !projectSchema.shapes[typeName]) {
     shapeCache.set(typeName, () => {
       var _prop$items;
-
       let props;
       const propOrItems = prop.items ?? prop;
-
       if (isId(name)) {
         props = getFieldTypeComparison('id');
       } else if (relationship) {
         const shapes = getRelationshipShapes(projectSchema.shapes, relationship.refs);
-        props = getFields(typeName, shapes, { ...context,
+        props = getFields(typeName, shapes, {
+          ...context,
           relationshipDepth: relationshipDepth + 1
         });
       } else if (isUnionSchema(propOrItems)) {
         const shapes = enumerateOneOfKeys(projectSchema, propOrItems.oneOf).map(option => projectSchema.shapes[option.shapeName]);
-        props = getFields(typeName, shapes, { ...context,
+        props = getFields(typeName, shapes, {
+          ...context,
           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) {
           props = props ?? {};
-          const fieldContext = { ...context,
+          const fieldContext = {
+            ...context,
             conflictingProperties: undefined // non-union objects have no conflicts
-
           };
 
           for (const propName of Object.keys(properties)) {
@@ -393,26 +335,21 @@ export function getPropertyComparisonType(name, prop, 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) || projectSchema.shapes[typeName]) {
     const fieldName = `${conflictingProperties !== null && conflictingProperties !== void 0 && conflictingProperties.has(name) ? `${shapeName}_` : ''}${name}`;
     return {
@@ -422,85 +359,67 @@ export function getPropertyComparisonType(name, prop, shapeName, context) {
     };
   }
 }
-
 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;
 }
-
 function getReferencedShape(context) {
   return prop => {
     const ref = getRef(context, prop);
     return ref && refItemToShape(context, ref);
   };
 }
+
 /**
  * Expand union shapes
  */
-
-
 function expandUnionShapes(projectSchema, shapes) {
   return uniqBy(shapes.flatMap(shape => isUnionSchema(shape.schema) ? shape.schema.oneOf.map(getReferencedShape(projectSchema)).filter(isDefined) : shape), 'name');
 }
-
 export function getWhereShape(projectSchema, selectedShapes) {
   const shapeName = selectedShapes.length === 1 ? `TSWhere${pascalCase(selectedShapes[0].name)}Input` : 'TSWhereInput';
-
   if (projectSchema.shapes[shapeName]) {
     return {
       shapeName,
       dependencies: {}
     };
   }
-
   const expandedShapes = expandUnionShapes(projectSchema, selectedShapes);
   const isManyContentTypes = expandedShapes.length > 1;
   const shapeCache = new ShapeCache();
@@ -514,7 +433,8 @@ export function getWhereShape(projectSchema, selectedShapes) {
     dependencies: pruneEmpty({
       [shapeName]: createShape(shapeName, {
         type: 'object',
-        properties: { ...fields,
+        properties: {
+          ...fields,
           ...(isManyContentTypes && getBooleanOperatorTypes(shapeName))
         }
       }),

package/es/types/types.js

@@ -2,24 +2,57 @@ export const projectSchemaImportOptionalProps = ['projectId', 'locales', 'defaul
 export const legacyProjectSchemaImportOptionalProps = ['created', 'updated', 'version', 'dataKey'];
 
 /**
- * Types of refs
+ * Remote service configuration types
  */
-export let RefType;
 /**
- * Stub of a PropertySchema that may contain a `$ref` or `@ref`.
+ * Old service authentication
+ * @deprecated
  */
-
-(function (RefType) {
+/**
+ * Support null sentinels for authentication
+ */
+/**
+ * A type suitable for service object updates, mostly concerns authentication
+ * requirements.
+ */
+/**
+ * Types of refs
+ */
+export let RefType = /*#__PURE__*/function (RefType) {
   RefType["@ref"] = "@ref";
   RefType["$ref"] = "$ref";
-})(RefType || (RefType = {}));
+  return RefType;
+}({});
 
 /**
- * Types of args
+ * Stub of a PropertySchema that may contain a `$ref` or `@ref`.
  */
-export let ArgsType;
 
-(function (ArgsType) {
+/**
+ * Types of args
+ */
+export let ArgsType = /*#__PURE__*/function (ArgsType) {
   ArgsType["@args"] = "@args";
   ArgsType["args"] = "args";
-})(ArgsType || (ArgsType = {}));
+  return ArgsType;
+}({});
+
+/**
+ * Types supporting schema iterators
+ */
+
+/**
+ * Shapes
+ */
+
+/**
+ * Relationships
+ */
+
+/**
+ * New relationship data, drawn from a PropertySchema.
+ */
+
+/**
+ * The old relationship format, used in client UI.
+ */