@takeshape/schema 9.80.3 → 9.81.0

package/dist/types/utils.js

@@ -55,27 +55,16 @@ exports.isShopifyServiceConfig = isShopifyServiceConfig;
 exports.isTakeshapeResolver = isTakeshapeResolver;
 exports.isUtilResolver = isUtilResolver;
 exports.listCachedShapes = listCachedShapes;
-
 var _util = require("@takeshape/util");
-
 var _types = require("./types");
-
 var _isPlainObject = _interopRequireDefault(require("lodash/isPlainObject"));
-
 var _isString = _interopRequireDefault(require("lodash/isString"));
-
 var _isArray = _interopRequireDefault(require("lodash/isArray"));
-
 var _has = _interopRequireDefault(require("lodash/has"));
-
 var _schemas = require("../schemas");
-
 var _isUndefined = _interopRequireDefault(require("lodash/isUndefined"));
-
 var _schemaUtil = require("../schema-util");
-
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
 /** Resolver Type Utils **/
 
 /**
@@ -84,15 +73,12 @@ function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { de
 function isBasicResolver(resolver) {
   return (0, _util.isRecord)(resolver) && (0, _isString.default)(resolver.name);
 }
-
 function isServiceResolver(resolver) {
   return (0, _util.isRecord)(resolver) && (0, _isString.default)(resolver.name) && (0, _isString.default)(resolver.service);
 }
-
 function isComposeResolver(resolver) {
   return Boolean((0, _isArray.default)(resolver === null || resolver === void 0 ? void 0 : resolver.compose) && resolver.compose.length && resolver.compose.every(isBasicResolver));
 }
-
 const {
   definitions: {
     takeshapeResolver,
@@ -103,252 +89,206 @@ const {
     awsLambdaResolver
   }
 } = _schemas.latestSchemaJson;
-
 function isTakeshapeResolver(resolver) {
   return isBasicResolver(resolver) && takeshapeResolver.properties.name.enum.includes(resolver.name);
 }
-
 function isShapedbResolver(resolver) {
   return isBasicResolver(resolver) && shapedbResolver.properties.name.enum.includes(resolver.name);
 }
-
 function isGraphqlResolver(resolver) {
   return isBasicResolver(resolver) && graphqlResolver.properties.name.enum.includes(resolver.name);
 }
-
 function isRestResolver(resolver) {
   return isBasicResolver(resolver) && restResolver.properties.name.enum.includes(resolver.name);
 }
-
 function isAwsLambdaResolver(resolver) {
   return isBasicResolver(resolver) && awsLambdaResolver.properties.name.enum.includes(resolver.name);
 }
-
 function isUtilResolver(resolver) {
   return isBasicResolver(resolver) && utilResolver.properties.name.enum.includes(resolver.name);
 }
-
 function isProjectSchemaWithServices(schema) {
   return !(0, _isUndefined.default)(schema.services);
 }
+
 /** Directive Mapping Utils **/
 
 /**
  * Determine whether the ambiguous Directive structure is a DirectiveMappingMap
  */
-
-
 function isDirectiveMappingMap(maybeMap) {
   return (0, _isPlainObject.default)(maybeMap) && Object.keys(maybeMap).length > 0;
 }
+
 /**
  * Determine whether the ambiguous Directive structure is a DirectiveMappingArray
  */
-
-
 function isDirectiveMappingArray(maybeArray) {
   return (0, _isArray.default)(maybeArray) && (0, _isArray.default)(maybeArray[0]) && (0, _isString.default)(maybeArray[0][0]) && (0, _isArray.default)(maybeArray[0][1]);
 }
+
 /**
  * Determine whether the ambiguous Directive structure is a DirectiveConfig array
  */
-
-
 function isDirectiveConfig(maybeConfig) {
   return (0, _isArray.default)(maybeConfig) && (0, _isArray.default)(maybeConfig[0]) && (0, _isString.default)(maybeConfig[0][0]) && (0, _util.isRecord)(maybeConfig[0][1]);
 }
+
 /**
  * Determine whether a ParameterSerializeOption is a content type serializer
  */
-
-
 function isParameterSerializeContentOptions(maybeContent) {
   return Boolean(maybeContent.contentType);
 }
+
 /**
  * Determine whether an unknown variable is a `ParameterOp`
  */
-
-
 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`
  */
-
-
 function isParameterOpNested(maybeOp) {
   return Boolean(maybeOp.ops);
 }
+
 /**
  * Determine whether a `ParameterOp` is a `ParameterOpMapping`
  */
-
-
 function isParameterOpMapping(maybeOp) {
   return Boolean(maybeOp.mapping);
 }
+
 /**
  * Determine whether a `ParameterOp` is a `ParameterOpMapping`
  */
-
-
 function isParameterOpValue(maybeOp) {
   return Boolean(maybeOp.value);
 }
+
 /**
  * Determine whether a `ParameterOp` is a `ParameterOpOp`
  */
-
-
 function isParameterOpOp(maybeOp) {
   const op = maybeOp;
-
   if (!op.op) {
     return false;
   }
-
   return !(isParameterOpNested(op) || isParameterOpMapping(op) || isParameterOpValue(op));
 }
-
 const {
   definitions: {
     parameterSerializeStyleOptionsForSearchParams,
     parameterSerializeStyleOptionsForPathParams
   }
 } = _schemas.latestSchemaJson;
-
 function isParameterSerializeStyleForSearchParams(maybeParam) {
   return Boolean(maybeParam && parameterSerializeStyleOptionsForSearchParams.properties.style.enum.includes(maybeParam));
 }
-
 function isParameterSerializeStyleForPathParams(maybeParam) {
   return Boolean(maybeParam && parameterSerializeStyleOptionsForPathParams.properties.style.enum.includes(maybeParam));
 }
+
 /**
  * Determine whether a ParameterSerializeOption is a style serializer
  */
-
-
 function isParameterSerializeStyleOptions(maybeStyle) {
   return Boolean(maybeStyle.style);
 }
-/** Typeguards for different types of shape schemas **/
 
+/** Typeguards for different types of shape schemas **/
 
 function isRefSchema(propertySchema) {
   return (0, _isString.default)(propertySchema['@ref']) || (0, _isString.default)(propertySchema.$ref);
 }
-
 function isRefSchemaLegacy(propertySchema) {
   return (0, _isString.default)(propertySchema.$ref);
 }
-
 function isAllOfSchema(propertySchema) {
   return (0, _isArray.default)(propertySchema.allOf);
 }
-
 function isExtendsSchema(propertySchema) {
   return (0, _util.isRecord)(propertySchema) && (0, _isArray.default)(propertySchema.extends);
 }
-
 function isOneOfSchema(propertySchema) {
   return (0, _isArray.default)(propertySchema.oneOf);
 }
-
 function isEnumSchema(obj) {
   return (0, _isArray.default)(obj.enum);
 }
-
 function isArraySchema(propertySchema) {
   return propertySchema.type === 'array' && (0, _util.isRecord)(propertySchema.items);
 }
-
 function isReturnShapeArraySchema(returnShape) {
   return typeof returnShape === 'object' && returnShape.type === 'array';
 }
-
 function isObjectSchema(propertySchema) {
   return (0, _util.isRecord)(propertySchema) && propertySchema.type === 'object' && (0, _util.isRecord)(propertySchema.properties);
 }
+
 /** Service Config Utils **/
 
 /**
  * Test all required props, currently:
  * "name", "slug", "provider", "serviceType", "authenticationType"
  */
-
-
 function isAnyServiceConfig(maybeConfig) {
   return maybeConfig && (0, _isString.default)(maybeConfig.title) && (0, _isString.default)(maybeConfig.id) && (0, _isString.default)(maybeConfig.provider) && (0, _isString.default)(maybeConfig.serviceType) && (0, _isString.default)(maybeConfig.authenticationType);
 }
-
 function isGraphQLServiceConfig(maybeConfig) {
   var _maybeConfig$options;
-
   return isAnyServiceConfig(maybeConfig) && maybeConfig.serviceType === 'graphql' && (0, _isString.default)((_maybeConfig$options = maybeConfig.options) === null || _maybeConfig$options === void 0 ? void 0 : _maybeConfig$options.endpoint);
 }
-
 function isRESTServiceConfig(maybeConfig) {
   return isAnyServiceConfig(maybeConfig) && maybeConfig.serviceType === 'rest';
 }
-
 function isOpenAPIServiceConfig(maybeConfig) {
   return isAnyServiceConfig(maybeConfig) && maybeConfig.serviceType === 'openapi';
 }
-
 function isShopifyServiceConfig(maybeShopify) {
   return maybeShopify.provider === 'shopify';
 }
-
 function isEncryptedServiceConfig(maybeConfig) {
   return isAnyServiceConfig(maybeConfig) && (0, _isString.default)(maybeConfig.authentication);
 }
-
 function isServiceConfigWithOAuth2Authentication(maybeServiceConfig) {
   return isAnyServiceConfig(maybeServiceConfig) && isServiceAuthentication(maybeServiceConfig.authentication) && isOAuth2Authentication(maybeServiceConfig.authentication);
 }
-
 function isServiceConfigWithCustomAuthentication(maybeServiceConfig) {
   return isAnyServiceConfig(maybeServiceConfig) && isServiceAuthentication(maybeServiceConfig.authentication) && isCustomAuthentication(maybeServiceConfig.authentication);
 }
-/** Authentication Utils **/
 
+/** Authentication Utils **/
 
 function isServiceAuthentication(maybeAuthentication) {
   return maybeAuthentication === null || maybeAuthentication === void 0 ? void 0 : maybeAuthentication.type;
 }
-
 function isBearerAuthentication(authentication) {
   return (authentication === null || authentication === void 0 ? void 0 : authentication.type) === 'bearer';
 }
-
 function isBasicAuthentication(authentication) {
   return (authentication === null || authentication === void 0 ? void 0 : authentication.type) === 'basic';
 }
-
 function isSearchParamsAuthentication(authentication) {
   return (authentication === null || authentication === void 0 ? void 0 : authentication.type) === 'searchParams';
 }
-
 function isOAuth2Authentication(authentication) {
   return (authentication === null || authentication === void 0 ? void 0 : authentication.type) === 'oauth2';
 }
-
 function isOAuth2BearerAuthentication(authentication) {
   return (authentication === null || authentication === void 0 ? void 0 : authentication.type) === 'oauth2Bearer';
 }
-
 function isCustomAuthentication(authentication) {
   return (authentication === null || authentication === void 0 ? void 0 : authentication.type) === 'custom';
 }
+
 /** Miscellaneous Utils **/
 
 /**
@@ -356,60 +296,46 @@ function isCustomAuthentication(authentication) {
  *
  * @param argsSchema Any schema that may have an `args` property.
  */
-
-
 const getArgsType = argsSchema => {
   if ((0, _has.default)(argsSchema, '@args')) {
     return _types.ArgsType['@args'];
   }
-
   if ((0, _has.default)(argsSchema, 'args')) {
     return _types.ArgsType.args;
   }
 };
+
 /**
  * A utility to return the type of ref present on a schema.
  *
  * @param refSchema Any schema that may have a `ref` property.
  */
-
-
 exports.getArgsType = getArgsType;
-
 const getRefType = refSchema => {
   if ((0, _has.default)(refSchema, '@ref')) {
     return _types.RefType['@ref'];
   }
-
   if ((0, _has.default)(refSchema, '$ref')) {
     return _types.RefType.$ref;
   }
 };
-
 exports.getRefType = getRefType;
-
 function isPropertySchemaWithRelationship(schema) {
   var _schema$Resolver;
-
   return ((_schema$Resolver = schema['@resolver']) === null || _schema$Resolver === void 0 ? void 0 : _schema$Resolver.name) === 'shapedb:getRelated';
 }
-
 function listCachedShapes(shapes) {
   return Object.values(shapes).filter(_schemaUtil.isCachedShape);
 }
-
 function getCachedShapeMap(shapes) {
   const results = {};
-
   for (const shape of Object.values(shapes)) {
     if ((0, _schemaUtil.isCachedShape)(shape)) {
       results[shape.name] = shape;
     }
   }
-
   return results;
 }
-
 function isMeshShape(shape) {
   return Boolean(shape.joins);
 }

package/dist/unions.js

@@ -9,34 +9,21 @@ exports.isUnionSchema = isUnionSchema;
 exports.oneOfToObject = oneOfToObject;
 exports.transformOneOf = transformOneOf;
 exports.wrapOneOfObjects = exports.unwrapOneOfObjects = void 0;
-
 var _refs = require("./refs");
-
 var _util = require("@takeshape/util");
-
 var _omit = _interopRequireDefault(require("lodash/omit"));
-
 var _contentSchemaTransform = require("./content-schema-transform");
-
 var _utils = require("./types/utils");
-
 var _errors = require("@takeshape/errors");
-
 var _schemaUtil = require("./schema-util");
-
 var _templates = require("./template-shapes/templates");
-
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
 function enumerateOneOfKeys(projectSchema, oneOf) {
   const result = [];
-
   for (const child of oneOf) {
     const refItem = (0, _refs.getRef)(projectSchema, child);
-
     if (refItem) {
       const shapeName = (0, _refs.refItemToShapeName)(refItem);
-
       if (projectSchema.shapes[shapeName]) {
         const shapeId = projectSchema.shapes[shapeName].id;
         result.push({
@@ -48,82 +35,68 @@ 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;
 }
-
 function isUnionSchema(schema) {
   var _schema$oneOf;
-
   return Boolean((_schema$oneOf = schema.oneOf) === null || _schema$oneOf === void 0 ? void 0 : _schema$oneOf.every(_utils.isRefSchema));
 }
-
 function oneOfToObject(projectSchema, schema) {
   const properties = {};
-
   for (const {
     propName,
     propSchema: child
   } of enumerateOneOfKeys(projectSchema, getOneOf(schema))) {
     properties[propName] = child;
   }
-
-  return { ...(0, _omit.default)(schema, 'oneOf'),
+  return {
+    ...(0, _omit.default)(schema, 'oneOf'),
     type: 'object',
     properties
   };
 }
-
 function formatKeys(keys) {
   return keys.map(k => `"${k}"`).join(', ');
 }
-
 // eslint-disable-next-line max-params
 const createUnwrapTransform = projectSchema => (obj, schema, name, shape, next) => {
   if ((0, _util.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 _errors.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 ((0, _util.isRecord)(propValue)) {
         const transformedPropValue = next(propValue, propSchema, name);
-
         if ((0, _util.isRecord)(transformedPropValue)) {
-          return { ...transformedPropValue,
+          return {
+            ...transformedPropValue,
             _shapeId: shapeId
           };
         }
       }
     }
   }
-}; // eslint-disable-next-line max-params
-
+};
 
+// eslint-disable-next-line max-params
 exports.createUnwrapTransform = createUnwrapTransform;
-
 const createWrapTransform = projectSchema => (obj, schema, name, shape, next) => {
   if ((0, _util.isRecord)(obj) && typeof obj._shapeId === 'string') {
     const shape = (0, _schemaUtil.getShapeById)(projectSchema, obj._shapeId);
-
     if (shape) {
       return {
         [(0, _util.camelCase)(shape.name)]: next((0, _omit.default)(obj, '_shapeId'), shape.schema, name)
@@ -131,9 +104,7 @@ const createWrapTransform = projectSchema => (obj, schema, name, shape, next) =>
     }
   }
 };
-
 exports.createWrapTransform = createWrapTransform;
-
 function transformOneOf(process) {
   return (projectSchema, schema, obj) => {
     const transform = (0, _contentSchemaTransform.getContentTransform)({
@@ -151,20 +122,19 @@ 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`
  */
-
-
 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`
  */
-
 exports.unwrapOneOfObjects = unwrapOneOfObjects;
 const wrapOneOfObjects = transformOneOf(createWrapTransform);
 exports.wrapOneOfObjects = wrapOneOfObjects;

package/dist/util/api-indexing.js

@@ -7,55 +7,43 @@ exports.getGetQueryIndexConfig = void 0;
 exports.getIndexedServices = getIndexedServices;
 exports.getListQueryIndexConfigs = void 0;
 exports.serviceHasIndexedShapes = serviceHasIndexedShapes;
-
 var _types = require("../types");
-
 var _util = require("@takeshape/util");
-
 var _services = require("../services");
-
 var _schemaUtil = require("../schema-util");
-
 var _refs = require("../refs");
-
 function serviceHasIndexedShapes(schema, serviceId) {
   for (const shape of Object.values(schema.shapes ?? {})) {
     var _shape$loaders;
-
     const indexingEnabled = (0, _schemaUtil.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 (0, _util.ensureArray)(listConfigs)) {
         const resolved = (0, _refs.getQuery)(schema, queryRef);
-
         if (resolved && (0, _types.isServiceResolver)(resolved.query.resolver) && resolved.query.resolver.service === serviceId) {
           return true;
         }
       }
     }
   }
-
   return false;
 }
-
 function getIndexedServices(projectSchema, configs) {
   return (0, _util.ensureArray)(configs).reduce((services, queryConfig) => {
     const resolved = queryConfig !== null && queryConfig !== void 0 && queryConfig.query ? (0, _refs.getQuery)(projectSchema, queryConfig.query) : undefined;
     return resolved !== null && resolved !== void 0 && resolved.query ? [...services, ...(0, _services.getResolverServices)(resolved.query.resolver)] : services;
   }, []);
 }
-
 function flattenListQueryConfigs(base, queryConfig, maybeConfigArray) {
-  return maybeConfigArray && (0, _util.ensureArray)(maybeConfigArray).flatMap(config => (0, _util.ensureArray)(config.args).map(args => ({ ...base,
+  return maybeConfigArray && (0, _util.ensureArray)(maybeConfigArray).flatMap(config => (0, _util.ensureArray)(config.args).map(args => ({
+    ...base,
     ...queryConfig,
     ...config,
     args
   })));
 }
-
 function getQueryIndexConfigHelper(op) {
   return ({
     shapes
@@ -64,19 +52,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,
@@ -88,7 +72,6 @@ function getQueryIndexConfigHelper(op) {
     }
   };
 }
-
 const getListQueryIndexConfigs = getQueryIndexConfigHelper('list');
 exports.getListQueryIndexConfigs = getListQueryIndexConfigs;
 const getGetQueryIndexConfig = getQueryIndexConfigHelper('get');

package/dist/util/detect-cycles.js

@@ -4,17 +4,13 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.hasCycle = hasCycle;
-
 var _refs = require("../refs");
-
 var _util = require("@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
  */
@@ -23,46 +19,36 @@ function hasCycle(projectSchema, schema, predicate = (0, _util.value)(true)) {
     if (!predicate(projectSchema, schema, shapeName, propName)) {
       return false;
     }
-
     const refItem = (0, _refs.getRef)(projectSchema, schema);
-
     if (refItem) {
-      const refShape = (0, _refs.refItemToShape)(projectSchema, refItem); // If we have a refItem, but no shape, this is a dangling ref and has no cycles
+      const refShape = (0, _refs.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);
 }