@takeshape/schema 9.80.4 → 9.81.3

package/es/types/utils.js

@@ -7,12 +7,12 @@ import has from 'lodash/has';
 import { latestSchemaJson } from '../schemas';
 import isUndefined from 'lodash/isUndefined';
 import { isCachedShape } from '../schema-util';
+
 /** Resolver Type Utils **/
 
 /**
  * Only tests that the shape is right, not that the name is correct. That's a job for the validator.
  */
-
 export function isBasicResolver(resolver) {
   return isRecord(resolver) && isString(resolver.name);
 }
@@ -53,81 +53,77 @@ export function isUtilResolver(resolver) {
 export function isProjectSchemaWithServices(schema) {
   return !isUndefined(schema.services);
 }
+
 /** Directive Mapping Utils **/
 
 /**
  * Determine whether the ambiguous Directive structure is a DirectiveMappingMap
  */
-
 export function isDirectiveMappingMap(maybeMap) {
   return isPlainObject(maybeMap) && Object.keys(maybeMap).length > 0;
 }
+
 /**
  * Determine whether the ambiguous Directive structure is a DirectiveMappingArray
  */
-
 export function isDirectiveMappingArray(maybeArray) {
   return isArray(maybeArray) && isArray(maybeArray[0]) && isString(maybeArray[0][0]) && isArray(maybeArray[0][1]);
 }
+
 /**
  * Determine whether the ambiguous Directive structure is a DirectiveConfig array
  */
-
 export function isDirectiveConfig(maybeConfig) {
   return isArray(maybeConfig) && isArray(maybeConfig[0]) && isString(maybeConfig[0][0]) && isRecord(maybeConfig[0][1]);
 }
+
 /**
  * Determine whether a ParameterSerializeOption is a content type serializer
  */
-
 export function isParameterSerializeContentOptions(maybeContent) {
   return Boolean(maybeContent.contentType);
 }
+
 /**
  * Determine whether an unknown variable is a `ParameterOp`
  */
-
 export function isParameterOp(maybeOp) {
   const op = maybeOp;
-
   if (!op.path) {
     return false;
   }
-
   return isParameterOpNested(op) || isParameterOpMapping(op) || isParameterOpValue(op) || isParameterOpOp(op);
 }
+
 /**
  * Determine whether a `ParameterOp` is a `ParameterOpNested`
  */
-
 export function isParameterOpNested(maybeOp) {
   return Boolean(maybeOp.ops);
 }
+
 /**
  * Determine whether a `ParameterOp` is a `ParameterOpMapping`
  */
-
 export function isParameterOpMapping(maybeOp) {
   return Boolean(maybeOp.mapping);
 }
+
 /**
  * Determine whether a `ParameterOp` is a `ParameterOpMapping`
  */
-
 export function isParameterOpValue(maybeOp) {
   return Boolean(maybeOp.value);
 }
+
 /**
  * Determine whether a `ParameterOp` is a `ParameterOpOp`
  */
-
 export function isParameterOpOp(maybeOp) {
   const op = maybeOp;
-
   if (!op.op) {
     return false;
   }
-
   return !(isParameterOpNested(op) || isParameterOpMapping(op) || isParameterOpValue(op));
 }
 const {
@@ -142,13 +138,14 @@ export function isParameterSerializeStyleForSearchParams(maybeParam) {
 export function isParameterSerializeStyleForPathParams(maybeParam) {
   return Boolean(maybeParam && parameterSerializeStyleOptionsForPathParams.properties.style.enum.includes(maybeParam));
 }
+
 /**
  * Determine whether a ParameterSerializeOption is a style serializer
  */
-
 export function isParameterSerializeStyleOptions(maybeStyle) {
   return Boolean(maybeStyle.style);
 }
+
 /** Typeguards for different types of shape schemas **/
 
 export function isRefSchema(propertySchema) {
@@ -178,19 +175,18 @@ export function isReturnShapeArraySchema(returnShape) {
 export function isObjectSchema(propertySchema) {
   return isRecord(propertySchema) && propertySchema.type === 'object' && isRecord(propertySchema.properties);
 }
+
 /** Service Config Utils **/
 
 /**
  * Test all required props, currently:
  * "name", "slug", "provider", "serviceType", "authenticationType"
  */
-
 export function isAnyServiceConfig(maybeConfig) {
   return maybeConfig && isString(maybeConfig.title) && isString(maybeConfig.id) && isString(maybeConfig.provider) && isString(maybeConfig.serviceType) && isString(maybeConfig.authenticationType);
 }
 export function isGraphQLServiceConfig(maybeConfig) {
   var _maybeConfig$options;
-
   return isAnyServiceConfig(maybeConfig) && maybeConfig.serviceType === 'graphql' && isString((_maybeConfig$options = maybeConfig.options) === null || _maybeConfig$options === void 0 ? void 0 : _maybeConfig$options.endpoint);
 }
 export function isRESTServiceConfig(maybeConfig) {
@@ -211,6 +207,7 @@ export function isServiceConfigWithOAuth2Authentication(maybeServiceConfig) {
 export function isServiceConfigWithCustomAuthentication(maybeServiceConfig) {
   return isAnyServiceConfig(maybeServiceConfig) && isServiceAuthentication(maybeServiceConfig.authentication) && isCustomAuthentication(maybeServiceConfig.authentication);
 }
+
 /** Authentication Utils **/
 
 export function isServiceAuthentication(maybeAuthentication) {
@@ -234,6 +231,7 @@ export function isOAuth2BearerAuthentication(authentication) {
 export function isCustomAuthentication(authentication) {
   return (authentication === null || authentication === void 0 ? void 0 : authentication.type) === 'custom';
 }
+
 /** Miscellaneous Utils **/
 
 /**
@@ -241,34 +239,30 @@ export function isCustomAuthentication(authentication) {
  *
  * @param argsSchema Any schema that may have an `args` property.
  */
-
 export const getArgsType = argsSchema => {
   if (has(argsSchema, '@args')) {
     return ArgsType['@args'];
   }
-
   if (has(argsSchema, 'args')) {
     return ArgsType.args;
   }
 };
+
 /**
  * A utility to return the type of ref present on a schema.
  *
  * @param refSchema Any schema that may have a `ref` property.
  */
-
 export const getRefType = refSchema => {
   if (has(refSchema, '@ref')) {
     return RefType['@ref'];
   }
-
   if (has(refSchema, '$ref')) {
     return RefType.$ref;
   }
 };
 export function isPropertySchemaWithRelationship(schema) {
   var _schema$Resolver;
-
   return ((_schema$Resolver = schema['@resolver']) === null || _schema$Resolver === void 0 ? void 0 : _schema$Resolver.name) === 'shapedb:getRelated';
 }
 export function listCachedShapes(shapes) {
@@ -276,13 +270,11 @@ export function listCachedShapes(shapes) {
 }
 export function getCachedShapeMap(shapes) {
   const results = {};
-
   for (const shape of Object.values(shapes)) {
     if (isCachedShape(shape)) {
       results[shape.name] = shape;
     }
   }
-
   return results;
 }
 export function isMeshShape(shape) {

package/es/unions.js

@@ -8,13 +8,10 @@ import { getShapeById } from './schema-util';
 import { getOutputShapeName } from './template-shapes/templates';
 export function enumerateOneOfKeys(projectSchema, oneOf) {
   const result = [];
-
   for (const child of oneOf) {
     const refItem = getRef(projectSchema, child);
-
     if (refItem) {
       const shapeName = refItemToShapeName(refItem);
-
       if (projectSchema.shapes[shapeName]) {
         const shapeId = projectSchema.shapes[shapeName].id;
         result.push({
@@ -26,78 +23,67 @@ export function enumerateOneOfKeys(projectSchema, oneOf) {
       }
     }
   }
-
   return result;
 }
-
 function getOneOf(schema) {
   if (!schema.oneOf) {
     throw new Error(`Expected ${JSON.stringify(schema)} to be a oneOf schema`);
   }
-
   return schema.oneOf;
 }
-
 export function isUnionSchema(schema) {
   var _schema$oneOf;
-
   return Boolean((_schema$oneOf = schema.oneOf) === null || _schema$oneOf === void 0 ? void 0 : _schema$oneOf.every(isRefSchema));
 }
 export function oneOfToObject(projectSchema, schema) {
   const properties = {};
-
   for (const {
     propName,
     propSchema: child
   } of enumerateOneOfKeys(projectSchema, getOneOf(schema))) {
     properties[propName] = child;
   }
-
-  return { ...omit(schema, 'oneOf'),
+  return {
+    ...omit(schema, 'oneOf'),
     type: 'object',
     properties
   };
 }
-
 function formatKeys(keys) {
   return keys.map(k => `"${k}"`).join(', ');
 }
-
 // eslint-disable-next-line max-params
 export const createUnwrapTransform = projectSchema => (obj, schema, name, shape, next) => {
   if (isRecord(obj)) {
     const oneOfKeys = enumerateOneOfKeys(projectSchema, getOneOf(schema));
     const objectKeys = Object.keys(obj);
-
     if (objectKeys.length !== 1) {
       const propNames = oneOfKeys.map(k => k.propName);
       throw new BadDataError(`Object should only specify one of the following keys: ${formatKeys(propNames)}, but found keys: ${formatKeys(objectKeys)}`);
     }
-
     for (const {
       propName,
       shapeId,
       propSchema
     } of oneOfKeys) {
       const propValue = obj[propName];
-
       if (isRecord(propValue)) {
         const transformedPropValue = next(propValue, propSchema, name);
-
         if (isRecord(transformedPropValue)) {
-          return { ...transformedPropValue,
+          return {
+            ...transformedPropValue,
             _shapeId: shapeId
           };
         }
       }
     }
   }
-}; // eslint-disable-next-line max-params
+};
 
+// eslint-disable-next-line max-params
 export const createWrapTransform = projectSchema => (obj, schema, name, shape, next) => {
   if (isRecord(obj) && typeof obj._shapeId === 'string') {
     const shape = getShapeById(projectSchema, obj._shapeId);
-
     if (shape) {
       return {
         [camelCase(shape.name)]: next(omit(obj, '_shapeId'), shape.schema, name)
@@ -122,17 +108,17 @@ export function transformOneOf(process) {
     return transform(schema, obj);
   };
 }
+
 /**
  * Unwrap oneOf objects in "GraphQL oneOf" style wrapper objects
  * See https://github.com/graphql/graphql-spec/pull/825 for more on "GraphQL oneOf"
  * Opposite of `wrapOneOfObjects`
  */
-
 export const unwrapOneOfObjects = transformOneOf(createUnwrapTransform);
+
 /**
  * Wrap oneOf objects in "GraphQL oneOf" style wrapper objects
  * See https://github.com/graphql/graphql-spec/pull/825 for more on "GraphQL oneOf"
  * Opposite of `unwrapOneOfObjects`
  */
-
 export const wrapOneOfObjects = transformOneOf(createWrapTransform);

package/es/util/api-indexing.js

@@ -6,23 +6,19 @@ import { getQuery } from '../refs';
 export function serviceHasIndexedShapes(schema, serviceId) {
   for (const shape of Object.values(schema.shapes ?? {})) {
     var _shape$loaders;
-
     const indexingEnabled = isCachedShape(shape);
     const listConfigs = (_shape$loaders = shape.loaders) === null || _shape$loaders === void 0 ? void 0 : _shape$loaders.list;
-
     if (indexingEnabled && listConfigs) {
       for (const {
         query: queryRef
       } of ensureArray(listConfigs)) {
         const resolved = getQuery(schema, queryRef);
-
         if (resolved && isServiceResolver(resolved.query.resolver) && resolved.query.resolver.service === serviceId) {
           return true;
         }
       }
     }
   }
-
   return false;
 }
 export function getIndexedServices(projectSchema, configs) {
@@ -31,15 +27,14 @@ export function getIndexedServices(projectSchema, configs) {
     return resolved !== null && resolved !== void 0 && resolved.query ? [...services, ...getResolverServices(resolved.query.resolver)] : services;
   }, []);
 }
-
 function flattenListQueryConfigs(base, queryConfig, maybeConfigArray) {
-  return maybeConfigArray && ensureArray(maybeConfigArray).flatMap(config => ensureArray(config.args).map(args => ({ ...base,
+  return maybeConfigArray && ensureArray(maybeConfigArray).flatMap(config => ensureArray(config.args).map(args => ({
+    ...base,
     ...queryConfig,
     ...config,
     args
   })));
 }
-
 function getQueryIndexConfigHelper(op) {
   return ({
     shapes
@@ -48,19 +43,15 @@ function getQueryIndexConfigHelper(op) {
       cache,
       loaders
     } = shapes[shapeName] ?? {};
-
     if (cache && loaders) {
       const idField = cache.idField ?? 'id';
-
       if (op === 'list') {
         return flattenListQueryConfigs({
           shapeName,
           idField
         }, cache.fragment, loaders.list);
       }
-
       const queryConfig = loaders.get;
-
       if (queryConfig) {
         return {
           idField,
@@ -72,6 +63,5 @@ function getQueryIndexConfigHelper(op) {
     }
   };
 }
-
 export const getListQueryIndexConfigs = getQueryIndexConfigHelper('list');
 export const getGetQueryIndexConfig = getQueryIndexConfigHelper('get');

package/es/util/detect-cycles.js

@@ -1,12 +1,10 @@
 import { getRef, refItemToShape } from '../refs';
 import { value } from '@takeshape/util';
-
 function immutableSetAdd(set, str) {
   const result = new Set(set);
   result.add(str);
   return result;
 }
-
 /**
  * Use a basic depth-first search to determine whether a schema contains a cycle
  */
@@ -15,46 +13,36 @@ export function hasCycle(projectSchema, schema, predicate = value(true)) {
     if (!predicate(projectSchema, schema, shapeName, propName)) {
       return false;
     }
-
     const refItem = getRef(projectSchema, schema);
-
     if (refItem) {
-      const refShape = refItemToShape(projectSchema, refItem); // If we have a refItem, but no shape, this is a dangling ref and has no cycles
+      const refShape = refItemToShape(projectSchema, refItem);
 
+      // If we have a refItem, but no shape, this is a dangling ref and has no cycles
       if (!refShape) {
         return false;
       }
-
       if (shapesSeen.has(refShape.name)) {
         return true;
       }
-
       return hasCycleHelper(refShape.schema, immutableSetAdd(shapesSeen, refShape.name), refShape.name);
     }
-
     const combo = schema.oneOf ?? schema.allOf ?? schema.extends;
-
     if (combo) {
       return combo.some(childSchema => hasCycleHelper(childSchema, shapesSeen, shapeName, propName));
     }
-
     if (schema.items) {
       return hasCycleHelper(schema.items, shapesSeen, shapeName, propName);
     }
-
     const {
       properties
     } = schema;
-
     if (properties) {
       return Object.keys(properties).some(name => {
         const propSchema = properties[name];
         return hasCycleHelper(propSchema, shapesSeen, shapeName, name);
       });
     }
-
     return false;
   };
-
   return hasCycleHelper(schema);
 }

package/es/util/find-shape-at-path.js

@@ -1,5 +1,6 @@
 import { isArraySchema, isObjectSchema, isRefSchema } from '../types';
 import { getRef, refItemToShape, refItemToShapeSchema } from '../refs';
+
 /**
  *
  * @param projectSchema
@@ -9,42 +10,33 @@ import { getRef, refItemToShape, refItemToShapeSchema } from '../refs';
  * @example
  * findShapeAtPath(projectSchema, projectSchema.shapes.Shopify_ProductConnection.shape, ['edges', 'node']) // finds {'@ref': Shopify_Product}
  */
-
 export function findSchemaAtPath(projectSchema, schema, queryPath) {
   if (queryPath.length === 0) {
     return schema;
   }
-
   const [prop, ...rest] = queryPath;
-
   if (isRefSchema(schema)) {
     const ref = getRef(projectSchema, schema);
-
     if (ref) {
       const shapeSchema = refItemToShapeSchema(projectSchema, ref);
-
       if (shapeSchema) {
         return findSchemaAtPath(projectSchema, shapeSchema, queryPath);
       }
     }
-
     return undefined;
   }
-
   if (isArraySchema(schema)) {
     return findSchemaAtPath(projectSchema, schema.items, queryPath);
   }
-
   if (isObjectSchema(schema)) {
     const propSchema = schema.properties[prop];
-
     if (propSchema) {
       return findSchemaAtPath(projectSchema, propSchema, rest);
     }
   }
-
   return undefined;
 }
+
 /**
  *
  * @param projectSchema
@@ -54,10 +46,8 @@ export function findSchemaAtPath(projectSchema, schema, queryPath) {
  * @example
  * findShapeAtPath(projectSchema, projectSchema.shapes.Shopify_ProductConnection.shape, ['edges', 'node']) // finds Shopify_Product
  */
-
 export function findShapeAtPath(projectSchema, propSchema, queryPath) {
   const result = findSchemaAtPath(projectSchema, propSchema, queryPath);
-
   if (result) {
     const refItem = getRef(projectSchema, result.items ?? result);
     return refItem && refItemToShape(projectSchema, refItem);

package/es/util/form-config.js

@@ -1,17 +1,16 @@
 import { deepClone } from '@takeshape/util';
 import { getRefOrItemsRef, refItemToShapeName } from '../refs';
 import { createSchemaPropertyAccessor } from '../schema-util';
+
 /**
  * If there any non-normal (nested) forms in the schema, create forms for referenced shapes.
  * The original forms are left intact.
  */
-
 export function normalizeForms(projectSchema) {
   const normalizedForms = {};
   const {
     forms = {}
   } = projectSchema;
-
   const storeSourceForm = (shapeName, formConfig, propName) => {
     // Leave original forms intact for backwards compatibility
     if (!forms[shapeName]) {
@@ -19,30 +18,24 @@ export function normalizeForms(projectSchema) {
         normalizedForms[shapeName] = {
           default: deepClone(formConfig)
         };
-      } // Remove prop now that it has been normalized
-      // eslint-disable-next-line @typescript-eslint/no-dynamic-delete
-
+      }
 
+      // Remove prop now that it has been normalized
+      // eslint-disable-next-line @typescript-eslint/no-dynamic-delete
       delete normalizedForms[shapeName].default.properties[propName];
     }
   };
-
   const normalizeNested = (shapeName, formConfig) => {
     const shape = projectSchema.shapes[shapeName];
-
     if (!shape || !formConfig.properties) {
       return;
     }
-
     const propertyAccessor = createSchemaPropertyAccessor(projectSchema, shape);
-
     for (const propName of Object.keys(formConfig.properties)) {
       const propConfig = formConfig.properties[propName];
       const propSchema = propertyAccessor.getValue(propName);
-
       if (propSchema) {
         const ref = getRefOrItemsRef(projectSchema, propSchema);
-
         if (ref && propConfig.properties) {
           const nestedShapeName = refItemToShapeName(ref);
           normalizedForms[nestedShapeName] = {
@@ -54,37 +47,32 @@ export function normalizeForms(projectSchema) {
       }
     }
   };
-
   if (forms) {
     for (const shapeName of Object.keys(forms)) {
-      normalizeNested(shapeName, forms[shapeName].default); // copy forms with no changes
+      normalizeNested(shapeName, forms[shapeName].default);
 
+      // copy forms with no changes
       if (!normalizedForms[shapeName]) {
         normalizedForms[shapeName] = forms[shapeName];
       }
     }
   }
-
   return normalizedForms;
 }
 const cache = new WeakMap();
+
 /**
  * Find the form config for a given shape name and the form key.
  */
-
 export function findShapeFormConfig(projectSchema, shapeName, formName) {
   var _normalizedForms$shap;
-
   if (!projectSchema.forms) {
     return;
   }
-
   let normalizedForms = cache.get(projectSchema);
-
   if (!normalizedForms) {
     normalizedForms = normalizeForms(projectSchema);
     cache.set(projectSchema, normalizedForms);
   }
-
   return (_normalizedForms$shap = normalizedForms[shapeName]) === null || _normalizedForms$shap === void 0 ? void 0 : _normalizedForms$shap[formName];
 }

package/es/util/get-conflicting-properties.js

@@ -1,10 +1,10 @@
 import { dereferenceSchema, getRef, refItemToAtRef } from '../refs';
 import { isDefined, setIsEqual } from '@takeshape/util';
 import { isObjectSchema } from '../types';
+
 /**
  * Normalize ref, oneOf and array schemas and get a list of @ref expressions
  */
-
 function getRefStrings(context, propertySchema) {
   const schema = propertySchema.items ?? propertySchema;
   const schemas = schema.oneOf ? schema.oneOf : [schema];
@@ -13,40 +13,35 @@ function getRefStrings(context, propertySchema) {
     return ref ? refItemToAtRef(ref) : undefined;
   }).filter(isDefined);
 }
-
 function isRefEqual(context, a, b) {
   return setIsEqual(getRefStrings(context, a), getRefStrings(context, b));
 }
+
 /**
  * Given a list of shapes find the conflicting props
  */
-
-
 export function getConflictingProperties(context, shapes) {
   const conflicts = new Set();
   const allProps = {};
-
   for (const shape of Object.values(shapes)) {
     const schema = dereferenceSchema(context, shape.schema, ['shapes', shape.name]);
-
     if (!isObjectSchema(schema)) {
       continue;
     }
-
     const required = new Set(schema.required ?? []);
-
     for (const [name, prop] of Object.entries(schema.properties)) {
       // skip props that we know already have  conflict
       if (conflicts.has(name)) {
         continue;
       }
-
       const isRequired = required.has(name);
-
       if (allProps[name]) {
-        if ( // same type
-        allProps[name][0].type !== prop.type || // same refs
-        !isRefEqual(context, allProps[name][0], prop) || // same nullability
+        if (
+        // same type
+        allProps[name][0].type !== prop.type ||
+        // same refs
+        !isRefEqual(context, allProps[name][0], prop) ||
+        // same nullability
         isRequired !== allProps[name][1]) {
           conflicts.add(name);
         }
@@ -55,6 +50,5 @@ export function getConflictingProperties(context, shapes) {
       }
     }
   }
-
   return conflicts;
 }