@takeshape/schema 9.80.4 → 9.81.3

package/es/layers/type-utils.js

@@ -3,9 +3,7 @@ import isPlainObject from 'lodash/isPlainObject';
 import isString from 'lodash/isString';
 import isArray from 'lodash/isArray';
 import { latestSchemaJson } from '../schemas';
-
 /** Resolver Type Utils **/
-
 /**
  * Only tests that the shape is right, not that the name is correct. That's a job for the validator.
  */
@@ -39,90 +37,87 @@ export function isAwsLambdaResolver(resolver) {
 export function isUtilResolver(resolver) {
   return utilResolver.properties.name.enum.includes(resolver.name);
 }
+
 /** 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('contentType' in maybeContent && 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('ops' in maybeOp && maybeOp.ops);
 }
+
 /**
  * Determine whether a `ParameterOp` is a `ParameterOpMapping`
  */
-
 export function isParameterOpMapping(maybeOp) {
   return Boolean('mapping' in maybeOp && maybeOp.mapping);
 }
+
 /**
  * Determine whether a `ParameterOp` is a `ParameterOpMapping`
  */
-
 export function isParameterOpValue(maybeOp) {
   return Boolean('value' in maybeOp && 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));
 }
+
 /**
  * Determine whether a ParameterSerializeOption is a style serializer
  */
-
 export function isParameterSerializeStyleOptions(maybeStyle) {
   return Boolean('style' in maybeStyle && maybeStyle.style);
 }
+
 /** Typeguards for different types of shape schemas **/
 
 export function isRefSchema(maybeRefSchema) {

package/es/layers/visitor.js

@@ -4,7 +4,6 @@ export function visitSchemaProperties(schema, path, callback) {
     for (const [name, propSchema] of Object.entries(schema.properties)) {
       const newPath = [...path, 'properties', name];
       callback(propSchema, newPath);
-
       if (isObjectSchema(propSchema) || isAllOfSchema(propSchema) || isOneOfSchema(propSchema)) {
         visitSchemaProperties(propSchema, newPath, callback);
       }
@@ -13,7 +12,6 @@ export function visitSchemaProperties(schema, path, callback) {
     for (const [index, propSchema] of Object.entries(schema.allOf)) {
       const newPath = [...path, 'allOf', index];
       callback(propSchema, newPath);
-
       if (isObjectSchema(propSchema) || isAllOfSchema(propSchema) || isOneOfSchema(propSchema)) {
         visitSchemaProperties(propSchema, newPath, callback);
       }
@@ -22,7 +20,6 @@ export function visitSchemaProperties(schema, path, callback) {
     for (const [index, propSchema] of Object.entries(schema.oneOf)) {
       const newPath = [...path, 'oneOf', index];
       callback(propSchema, newPath);
-
       if (isObjectSchema(propSchema) || isAllOfSchema(propSchema) || isOneOfSchema(propSchema)) {
         visitSchemaProperties(propSchema, newPath, callback);
       }

package/es/migration/to/v3.0.0.js

@@ -8,7 +8,6 @@ const annotationMap = {
   sensitive: '@sensitive',
   syncLocaleStructure: '@syncLocaleStructure'
 };
-
 function isColor(schema) {
   const {
     type,
@@ -16,24 +15,19 @@ function isColor(schema) {
   } = schema;
   return Boolean(type === 'object' && properties && properties.hsl && properties.hsv && properties.rgb && properties.hex);
 }
-
 function getModelType(contentType) {
   if (contentType.single) {
     return 'single';
   }
-
   if (contentType.taxonomy) {
     return 'taxonomy';
   }
-
   return 'multiple';
 }
-
 function getRelationshipSchema(relationship) {
   const itemSchema = {
     $ref: '#/shapes/TSRelationship/schema'
   };
-
   if (relationship.type === 'multiple') {
     return {
       type: 'array',
@@ -41,13 +35,13 @@ function getRelationshipSchema(relationship) {
       '@relationship': relationship
     };
   }
-
-  return { ...itemSchema,
+  return {
+    ...itemSchema,
     '@relationship': relationship
   };
-} // eslint-disable-next-line complexity
-
+}
 
+// eslint-disable-next-line complexity
 function migrateToContentSchemaV3(params) {
   const {
     schema,
@@ -64,24 +58,22 @@ function migrateToContentSchemaV3(params) {
   forEach(schema, (value, key) => {
     if (annotationMap[key]) {
       const newAnnotation = annotationMap[key];
-      schema[newAnnotation] = value; // eslint-disable-next-line @typescript-eslint/no-dynamic-delete
-
+      schema[newAnnotation] = value;
+      // eslint-disable-next-line @typescript-eslint/no-dynamic-delete
       delete schema[key];
     }
   });
-
   if (type === 'string' || type === 'boolean' || type === 'number' || type === 'integer') {
     return {
-      schema: { ...pick(schema, scalarSchemaKeys),
+      schema: {
+        ...pick(schema, scalarSchemaKeys),
         '@mapping': mapping
       }
     };
   }
-
   const {
     relationship
   } = schema;
-
   if (relationship) {
     const {
       contentTypeIds,
@@ -89,7 +81,8 @@ function migrateToContentSchemaV3(params) {
       relatedName
     } = relationship;
     return {
-      schema: { ...pick(schema, relationshipType === 'multiple' ? multipleRelationshipSchemaKeys : schemaMetadataKeys),
+      schema: {
+        ...pick(schema, relationshipType === 'multiple' ? multipleRelationshipSchemaKeys : schemaMetadataKeys),
         '@mapping': mapping,
         ...getRelationshipSchema({
           shapeIds: contentTypeIds,
@@ -100,25 +93,24 @@ function migrateToContentSchemaV3(params) {
       }
     };
   }
-
   if (type === 'object' && schema.draftjs) {
     return {
-      schema: { ...pick(schema, scalarSchemaKeys),
+      schema: {
+        ...pick(schema, scalarSchemaKeys),
         '@mapping': mapping,
         '@tag': 'draftjs'
       }
     };
   }
-
   if (isColor(schema)) {
     return {
-      schema: { ...pick(schema, scalarSchemaKeys),
+      schema: {
+        ...pick(schema, scalarSchemaKeys),
         $ref: '#/shapes/TSColor/schema',
         '@mapping': mapping
       }
     };
   }
-
   if (type === 'object' && schema.properties) {
     const properties = {};
     const shapes = {};
@@ -129,7 +121,8 @@ function migrateToContentSchemaV3(params) {
       const {
         schema: migratedPropSchema,
         hoistedShapes
-      } = migrateToContentSchemaV3({ ...params,
+      } = migrateToContentSchemaV3({
+        ...params,
         shapeName,
         shapeTitle,
         depth: params.depth + 1,
@@ -143,7 +136,6 @@ function migrateToContentSchemaV3(params) {
       properties[name] = migratedPropSchema;
       Object.assign(shapes, hoistedShapes);
     });
-
     if (params.depth > 0) {
       const {
         title,
@@ -157,12 +149,14 @@ function migrateToContentSchemaV3(params) {
           '@mapping': mapping,
           $ref: `#/shapes/${shapeName}/schema`
         },
-        hoistedShapes: { ...shapes,
+        hoistedShapes: {
+          ...shapes,
           [shapeName]: {
             id: name === key ? shapeName : key,
             name: shapeName,
             title: shapeTitle,
-            schema: { ...pick(rest, objectSchemaKeys),
+            schema: {
+              ...pick(rest, objectSchemaKeys),
               type: 'object',
               properties
             }
@@ -170,38 +164,37 @@ function migrateToContentSchemaV3(params) {
         }
       };
     }
-
     return {
-      schema: { ...pick(schema, objectSchemaKeys),
+      schema: {
+        ...pick(schema, objectSchemaKeys),
         properties,
         '@mapping': mapping
       },
       hoistedShapes: shapes
     };
   }
-
   if (schema.type === 'array' && schema.items) {
     const {
       schema: itemSchema,
       hoistedShapes
-    } = migrateToContentSchemaV3({ ...params,
+    } = migrateToContentSchemaV3({
+      ...params,
       schema: schema.items,
       parentSchema: schema,
       service: 'parent',
       setSource: false
     });
     return {
-      schema: { ...pick(schema, arraySchemaKeys),
+      schema: {
+        ...pick(schema, arraySchemaKeys),
         items: itemSchema,
         '@mapping': mapping
       },
       hoistedShapes
     };
   }
-
   throw new Error(`Unknown schema type "${type}"`);
 }
-
 function contentTypeToShape(contentType, contentTypeId) {
   const title = contentType.title ?? contentType.name;
   const name = pascalCase(contentType.name);
@@ -232,7 +225,6 @@ function contentTypeToShape(contentType, contentTypeId) {
     ...hoistedShapes
   };
 }
-
 const migrate = async (_, projectSchema) => {
   const {
     contentTypes,
@@ -246,11 +238,13 @@ const migrate = async (_, projectSchema) => {
     const contentType = contentTypes[contentTypeId];
     Object.assign(shapes, contentTypeToShape(contentType, contentTypeId));
     forms[pascalCase(contentType.name)] = contentType.forms;
-  }); // Use deepClone to drop undefined values, this improves compatibility with validation and testing
+  });
+
+  // Use deepClone to drop undefined values, this improves compatibility with validation and testing
   // Schemas are typically saved in Dynamo or JSON files which also remove undefined values
   // Dropping them here is done for consistency's sake
-
-  return deepClone({ ...rest,
+  return deepClone({
+    ...rest,
     ...getShapeQueriesAndMutations(Object.values(shapes)),
     schemaVersion: '3',
     created: formatDate(created),
@@ -259,5 +253,4 @@ const migrate = async (_, projectSchema) => {
     forms
   });
 };
-
 export default migrate;

package/es/migration/to/v3.1.0.js

@@ -4,10 +4,10 @@ import isString from 'lodash/isString';
 import isUndefined from 'lodash/isUndefined';
 import { deepClone, pascalCase } from '@takeshape/util';
 import { isAnyServiceConfig } from '../../types/utils';
+
 /**
  * `graphql:my-key` `my-key`
  */
-
 function parseV3ServiceStr(service) {
   const parts = service.split(':');
   return {
@@ -15,22 +15,19 @@ function parseV3ServiceStr(service) {
     id: parts.length > 1 ? parts[1] : parts[0]
   };
 }
+
 /**
  * Ensures a consistent service config, inluding updating the service
  * authentication object.
  */
 // eslint-disable-next-line complexity
-
-
 function updateServiceConfigV3ToV3_1(serviceConfig, serviceKey) {
   if (isAnyServiceConfig(serviceConfig)) {
     if (isString(serviceConfig.authentication) || isUndefined(serviceConfig.authentication)) {
       return serviceConfig;
     }
-
     return serviceConfig;
   }
-
   const {
     auth
   } = serviceConfig;
@@ -41,25 +38,22 @@ function updateServiceConfigV3ToV3_1(serviceConfig, serviceKey) {
   } = parseV3ServiceStr(serviceKey);
   const authType = serviceParams.authType || undefined;
   const title = serviceParams.name || serviceKeyId;
-
   if (serviceKeyId === 'vercel') {
     serviceKeyProvider = 'vercel';
   } else if (serviceKeyId === 'netlify') {
     serviceKeyProvider = 'netlify';
-  } // Example schemas had this in params, which are untyped, so adding here just in case
-
+  }
 
+  // Example schemas had this in params, which are untyped, so adding here just in case
   if (serviceParams.type === 'rest') {
     serviceKeyProvider = 'rest';
   } else if (serviceParams.type === 'graphql' && serviceKeyProvider !== 'shopify') {
     serviceKeyProvider = 'graphql';
   }
-
   let provider;
   let authenticationType;
   let serviceType;
   let namespace;
-
   if (serviceKeyProvider === 'shopify') {
     provider = 'shopify';
     authenticationType = 'oauth2Bearer';
@@ -99,7 +93,6 @@ function updateServiceConfigV3ToV3_1(serviceConfig, serviceKey) {
     serviceType = 'unknown';
     namespace = serviceParams.namespace ?? pascalCase(title);
   }
-
   const updatedServiceConfig = {
     title,
     id: serviceKey,
@@ -107,24 +100,23 @@ function updateServiceConfigV3ToV3_1(serviceConfig, serviceKey) {
     namespace,
     serviceType,
     authenticationType,
-    options: { ...serviceParams
+    options: {
+      ...serviceParams
     }
   };
-
   if (serviceConfig.auth && isObject(serviceConfig.auth)) {
     const authentication = updateServiceAuthentication(updatedServiceConfig.authenticationType, serviceConfig.auth, serviceParams);
-    return { ...updatedServiceConfig,
+    return {
+      ...updatedServiceConfig,
       authentication
     };
   }
-
   return updatedServiceConfig;
 }
+
 /**
  * V1/V3 unencrypted `auth` -> V3.1 `authentication
  */
-
-
 function updateServiceAuthentication(authenticationType, legacyAuth, legacyParams) {
   if (authenticationType === 'oauth2Bearer') {
     return {
@@ -133,14 +125,12 @@ function updateServiceAuthentication(authenticationType, legacyAuth, legacyParam
       header: legacyParams.authHeader
     };
   }
-
   if (authenticationType === 'searchParams' && legacyParams.authProp) {
     return [{
       name: legacyParams.authProp,
       value: legacyAuth.accessToken
     }];
   }
-
   if (authenticationType === 'basic') {
     const [username, password] = Buffer.from(legacyAuth.accessToken, 'base64').toString('utf-8').split(':');
     return {
@@ -148,7 +138,6 @@ function updateServiceAuthentication(authenticationType, legacyAuth, legacyParam
       password
     };
   }
-
   if (authenticationType === 'bearer') {
     return {
       token: legacyAuth.accessToken,
@@ -156,63 +145,56 @@ function updateServiceAuthentication(authenticationType, legacyAuth, legacyParam
     };
   }
 }
-
 function mapAuthType(authType, auth) {
   if (authType === 'none') {
     return 'none';
   }
-
   if (authType === 'searchParams') {
     return 'searchParams';
   }
-
   if (authType === 'bearer') {
     return 'bearer';
   }
-
   if (authType === 'bearer') {
     return 'basic';
   }
-
   if (!auth) {
     return 'none';
   }
-
   if (auth) {
     return 'bearer';
   }
-
   return 'unknown';
 }
-
 const migrate = async (context, projectSchema) => {
   const {
     encryptFn,
     decryptFn
   } = context;
   let services;
+
   /**
    * Services can only be migrated if a dataKey is present, otherwise they will need to be discarded.
    */
-
   if (projectSchema.services) {
     services = await pReduce(Object.entries(projectSchema.services), async (serviceMap, [serviceKey, serviceConfig]) => {
       const auth = serviceConfig.auth && decryptFn(serviceConfig.auth);
-      const updatedServiceConfig = updateServiceConfigV3ToV3_1({ ...serviceConfig,
+      const updatedServiceConfig = updateServiceConfigV3ToV3_1({
+        ...serviceConfig,
         auth
       }, serviceKey);
       const authentication = updatedServiceConfig === null || updatedServiceConfig === void 0 ? void 0 : updatedServiceConfig.authentication;
-      serviceMap[serviceKey] = { ...updatedServiceConfig,
+      serviceMap[serviceKey] = {
+        ...updatedServiceConfig,
         authentication: authentication && isObject(authentication) ? encryptFn(authentication) : authentication
       };
       return serviceMap;
     }, {});
   }
-
-  return deepClone({ ...projectSchema,
+  return deepClone({
+    ...projectSchema,
     services,
     schemaVersion: '3.1.0'
   });
 };
-
 export default migrate;

package/es/migration/to/v3.10.0.js

@@ -1,14 +1,11 @@
 import mapValues from 'lodash/mapValues';
 import set from 'lodash/fp/set';
-
 function $refToPath(ref) {
   return ref.substr(2).split('/');
 }
-
 function $refToShapeName(ref) {
   return $refToPath(ref)[1];
 }
-
 function findServiceIdForNamespace(projectSchema, namespace) {
   if (projectSchema.services) {
     for (const [serviceId, service] of Object.entries(projectSchema.services)) {
@@ -17,64 +14,56 @@ function findServiceIdForNamespace(projectSchema, namespace) {
       }
     }
   }
-
   return 'local';
 }
-
 function updateRefSyntax(projectSchema, $ref) {
   const shapeName = $refToShapeName($ref);
   const parts = shapeName.split('_');
   const serviceId = parts.length === 1 ? 'local' : findServiceIdForNamespace(projectSchema, parts[0]);
   return `${serviceId}:${parts[parts.length - 1]}`;
 }
-
 function migrateQueryToV3_10(projectSchema) {
   return (query, queryName) => {
     const {
       args,
       shape
     } = query;
-
     if (typeof args === 'object' && ('oneOf' in args || 'allOf' in args || '$ref' in args || '@ref' in args)) {
       // As of 11/15/2021 no production schemas contained queries with these args
       throw new Error(`Query "${queryName}" contains an unsupported arg schema ${JSON.stringify(args)}. Please contact support`);
     }
-
     if (typeof shape === 'object') {
       if (shape.items.$ref) {
         return set('shape.items', {
           '@ref': updateRefSyntax(projectSchema, shape.items.$ref)
         }, query);
       }
-
       if (!shape.items['@ref']) {
         // As of 11/15/2021 no production schemas contained queries with array return shapes that are not @refs
         throw new Error(`Query "${queryName}" contains an unsupported shape schema ${JSON.stringify(shape)}. Please contact support`);
       }
     }
-
     return query;
   };
 }
-
 function migrateShapeToV3_10(shape) {
   const {
     schema,
     ...rest
-  } = shape; // As of 11/15/2021 no production schemas contained shapes with array schemas
+  } = shape;
 
+  // As of 11/15/2021 no production schemas contained shapes with array schemas
   if ('type' in schema && schema.type === 'array') {
     throw new Error(`Shape ${shape.name} uses an unsupported array schema. Please contact support`);
   }
-
   const newSchema = '$ref' in schema || '@ref' in schema ? {
     allOf: [schema]
   } : schema;
-  return { ...rest,
+  return {
+    ...rest,
     schema: newSchema
   };
 }
-
 const migrate = async (_, projectSchema) => {
   const {
     queries,
@@ -84,12 +73,12 @@ const migrate = async (_, projectSchema) => {
     ...rest
   } = projectSchema;
   const migrate = migrateQueryToV3_10(projectSchema);
-  return { ...rest,
+  return {
+    ...rest,
     queries: mapValues(queries, migrate),
     mutations: mapValues(mutations, migrate),
     shapes: mapValues(shapes, migrateShapeToV3_10),
     schemaVersion: '3.10.0'
   };
 };
-
 export default migrate;