@takeshape/schema 8.31.0 → 8.35.2

package/es/index.js

@@ -1,3 +1,4 @@
+// Only export User here since AccessPolicyDocument is in auth-schemas
 export * from './content-schema-transform';
 export * from './get-is-leaf';
 export * from './project-schema';
@@ -7,10 +8,9 @@ export * from './template-shapes';
 export * from './taxonomies';
 export * from './workflows';
 export * from './builtin-schema';
-export * from './auth-schemas'; // Only export User here since AccessPolicyDocument is in auth-schemas
-
+export * from './auth-schemas';
 export * from './api-version';
-export { listTypePrefix, ensureLatest, normalizeSchemaVersion, getRelationshipSchema, migrateToLatestProjectSchema } from './migration';
+export * from './migration';
 export * from './validate';
 export { builtInShapes } from './builtin-schema';
 export * from './versions';

package/es/migration/index.js

@@ -0,0 +1,82 @@
+import { isLatestProjectSchema, isProjectSchemaV1, isProjectSchemaV3, isProjectSchemaV3_1, isProjectSchemaV3_2, isProjectSchemaV3_3, isProjectSchemaV3_4, isProjectSchemaV3_5, isProjectSchemaV3_5_1, isProjectSchemaV3_6, isProjectSchemaV3_7, isProjectSchemaV3_8, isProjectSchemaV3_9, isProjectSchemaV3_10 } from '../types/utils';
+import migrateToV3 from './to/v3.0.0';
+import migrateToV3_1 from './to/v3.1.0';
+import migrateToV3_2 from './to/v3.2.0';
+import migrateToV3_3 from './to/v3.3.0';
+import migrateToV3_4 from './to/v3.4.0';
+import migrateToV3_5 from './to/v3.5.0';
+import migrateToV3_5_1 from './to/v3.5.1';
+import migrateToV3_6 from './to/v3.6.0';
+import migrateToV3_7 from './to/v3.7.0';
+import migrateToV3_8 from './to/v3.8.0';
+import migrateToV3_9_0 from './to/v3.9.0';
+import migrateToV3_10 from './to/v3.10.0';
+import migrateToV3_11_0 from './to/v3.11.0';
+export * from './utils';
+export const listTypePrefix = 'PaginatedList';
+export async function migrateToLatestProjectSchema(context, projectSchema) {
+  if (projectSchema.schemaVersion === '4.0.0') {
+    throw new Error('You are using an unreleased schema version. Migration is not possible');
+  }
+
+  if (isProjectSchemaV1(projectSchema)) {
+    projectSchema = migrateToV3(projectSchema);
+  }
+
+  if (isProjectSchemaV3(projectSchema)) {
+    projectSchema = await migrateToV3_1(context, projectSchema);
+  }
+
+  if (isProjectSchemaV3_1(projectSchema)) {
+    projectSchema = migrateToV3_2(projectSchema);
+  }
+
+  if (isProjectSchemaV3_2(projectSchema)) {
+    projectSchema = await migrateToV3_3(context, projectSchema);
+  }
+
+  if (isProjectSchemaV3_3(projectSchema)) {
+    projectSchema = migrateToV3_4(projectSchema);
+  }
+
+  if (isProjectSchemaV3_4(projectSchema)) {
+    projectSchema = migrateToV3_5(projectSchema);
+  }
+
+  if (isProjectSchemaV3_5(projectSchema)) {
+    projectSchema = migrateToV3_5_1(projectSchema);
+  }
+
+  if (isProjectSchemaV3_5_1(projectSchema)) {
+    projectSchema = migrateToV3_6(projectSchema);
+  }
+
+  if (isProjectSchemaV3_6(projectSchema)) {
+    projectSchema = migrateToV3_7(projectSchema);
+  }
+
+  if (isProjectSchemaV3_7(projectSchema)) {
+    projectSchema = migrateToV3_8(projectSchema);
+  }
+
+  if (isProjectSchemaV3_8(projectSchema)) {
+    projectSchema = migrateToV3_9_0(projectSchema);
+  }
+
+  if (isProjectSchemaV3_9(projectSchema)) {
+    projectSchema = migrateToV3_10(projectSchema);
+  }
+
+  if (isProjectSchemaV3_10(projectSchema)) {
+    projectSchema = migrateToV3_11_0(context, projectSchema);
+  }
+
+  return projectSchema;
+}
+export async function ensureLatest(context, schema) {
+  if (!schema || isLatestProjectSchema(schema)) {
+    return schema;
+  }
+
+  return migrateToLatestProjectSchema(context, schema);
+}

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

@@ -0,0 +1,245 @@
+import forEach from 'lodash/forEach';
+import pick from 'lodash/pick';
+import { pascalCase, deepClone } from '@takeshape/util';
+import { arraySchemaKeys, getShapeQueriesAndMutations, multipleRelationshipSchemaKeys, objectSchemaKeys, scalarSchemaKeys, schemaMetadataKeys } from '../../schema-util';
+import { formatDate, getRelationshipSchema } from '../utils';
+const annotationMap = {
+  l10n: '@l10n',
+  sensitive: '@sensitive',
+  syncLocaleStructure: '@syncLocaleStructure'
+};
+
+function isColor(schema) {
+  const {
+    type,
+    properties
+  } = 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';
+} // eslint-disable-next-line complexity
+
+
+function migrateToContentSchemaV3(params) {
+  const {
+    schema,
+    service,
+    name,
+    key,
+    setSource,
+    omitAllSources
+  } = params;
+  const {
+    type
+  } = schema;
+  const mapping = !omitAllSources && key && setSource !== false && name !== key ? `${service}.${key}` : undefined;
+  forEach(schema, (value, key) => {
+    if (annotationMap[key]) {
+      const newAnnotation = annotationMap[key];
+      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),
+        '@mapping': mapping
+      }
+    };
+  }
+
+  const {
+    relationship
+  } = schema;
+
+  if (relationship) {
+    const {
+      contentTypeIds,
+      type: relationshipType,
+      relatedName
+    } = relationship;
+    return {
+      schema: { ...pick(schema, relationshipType === 'multiple' ? multipleRelationshipSchemaKeys : schemaMetadataKeys),
+        '@mapping': mapping,
+        ...getRelationshipSchema({
+          shapeIds: contentTypeIds,
+          type: relationshipType ?? 'single',
+          // Type is optional on assets
+          relatedName
+        })
+      }
+    };
+  }
+
+  if (type === 'object' && schema.draftjs) {
+    return {
+      schema: { ...pick(schema, scalarSchemaKeys),
+        '@mapping': mapping,
+        '@tag': 'draftjs'
+      }
+    };
+  }
+
+  if (isColor(schema)) {
+    return {
+      schema: { ...pick(schema, scalarSchemaKeys),
+        $ref: '#/shapes/TSColor/schema',
+        '@mapping': mapping
+      }
+    };
+  }
+
+  if (type === 'object' && schema.properties) {
+    const properties = {};
+    const shapes = {};
+    const shapeTitle = [params.shapeTitle, pascalCase(schema.title ?? params.name)].filter(Boolean).join(' ');
+    const shapeName = `${params.shapeName}${pascalCase(params.name)}`;
+    const contentSourceId = `takeshape:local:${shapeName}`;
+    forEach(schema.properties, (propSchema, name) => {
+      const {
+        schema: migratedPropSchema,
+        hoistedShapes
+      } = migrateToContentSchemaV3({ ...params,
+        shapeName,
+        shapeTitle,
+        depth: params.depth + 1,
+        schema: propSchema,
+        parentSchema: schema,
+        service: contentSourceId,
+        key: propSchema.key ?? name,
+        name,
+        setSource: true
+      });
+      properties[name] = migratedPropSchema;
+      Object.assign(shapes, hoistedShapes);
+    });
+
+    if (params.depth > 0) {
+      const {
+        title,
+        description,
+        ...rest
+      } = schema;
+      return {
+        schema: {
+          title,
+          description,
+          '@mapping': mapping,
+          $ref: `#/shapes/${shapeName}/schema`
+        },
+        hoistedShapes: { ...shapes,
+          [shapeName]: {
+            id: name === key ? shapeName : key,
+            name: shapeName,
+            title: shapeTitle,
+            schema: { ...pick(rest, objectSchemaKeys),
+              type: 'object',
+              properties
+            }
+          }
+        }
+      };
+    }
+
+    return {
+      schema: { ...pick(schema, objectSchemaKeys),
+        properties,
+        '@mapping': mapping
+      },
+      hoistedShapes: shapes
+    };
+  }
+
+  if (schema.type === 'array' && schema.items) {
+    const {
+      schema: itemSchema,
+      hoistedShapes
+    } = migrateToContentSchemaV3({ ...params,
+      schema: schema.items,
+      parentSchema: schema,
+      service: 'parent',
+      setSource: false
+    });
+    return {
+      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);
+  const contentSourceId = `takeshape:local:${name}`;
+  const {
+    schema,
+    hoistedShapes
+  } = migrateToContentSchemaV3({
+    shapeName: name,
+    shapeTitle: title,
+    schema: contentType.schema,
+    service: contentSourceId,
+    name: '',
+    key: '',
+    depth: 0
+  });
+  return {
+    [name]: {
+      id: contentTypeId,
+      name,
+      title,
+      model: {
+        type: getModelType(contentType)
+      },
+      workflow: contentType.workflow,
+      schema: schema
+    },
+    ...hoistedShapes
+  };
+}
+
+function migrateToV3_0_0(projectSchema) {
+  const {
+    contentTypes,
+    created,
+    updated,
+    ...rest
+  } = projectSchema;
+  const shapes = {};
+  const forms = {};
+  Object.keys(contentTypes).forEach(contentTypeId => {
+    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
+  // 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,
+    ...getShapeQueriesAndMutations(Object.values(shapes)),
+    schemaVersion: '3',
+    created: formatDate(created),
+    updated: formatDate(updated),
+    shapes,
+    forms
+  });
+}
+
+export default migrateToV3_0_0;

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

@@ -0,0 +1,218 @@
+import pReduce from 'p-reduce';
+import isObject from 'lodash/isObject';
+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 {
+    provider: parts.length > 1 ? parts[0] : undefined,
+    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;
+  const serviceParams = serviceConfig.params || {};
+  let {
+    provider: serviceKeyProvider,
+    id: serviceKeyId
+  } = 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
+
+
+  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';
+    serviceType = 'graphql';
+    namespace = serviceParams.namespace ?? 'Shopify';
+  } else if (serviceKeyProvider === 'takeshape') {
+    provider = 'takeshape';
+    authenticationType = 'none';
+    serviceType = 'takeshape';
+    namespace = serviceParams.namespace ?? 'TakeShape';
+  } else if (serviceKeyProvider === 'bigcommerce') {
+    provider = 'bigcommerce';
+    authenticationType = 'bearer';
+    serviceType = 'graphql';
+    namespace = serviceParams.namespace ?? 'BigCommerce';
+  } else if (serviceKeyProvider === 'rest') {
+    provider = 'generic';
+    authenticationType = mapAuthType(authType, auth);
+    serviceType = 'rest';
+    namespace = serviceParams.namespace ?? pascalCase(title);
+  } else if (serviceKeyProvider === 'graphql') {
+    provider = 'generic';
+    authenticationType = mapAuthType(authType, auth);
+    serviceType = 'graphql';
+    namespace = serviceParams.namespace ?? pascalCase(title);
+  } else if (serviceKeyProvider === 'vercel') {
+    provider = 'vercel';
+    authenticationType = 'oauth2Bearer';
+    serviceType = 'deployment';
+  } else if (serviceKeyProvider === 'netlify') {
+    provider = 'netlify';
+    authenticationType = 'oauth2Bearer';
+    serviceType = 'deployment';
+  } else {
+    provider = 'generic';
+    authenticationType = mapAuthType(authType, auth);
+    serviceType = 'unknown';
+    namespace = serviceParams.namespace ?? pascalCase(title);
+  }
+
+  const updatedServiceConfig = {
+    title,
+    id: serviceKey,
+    provider,
+    namespace,
+    serviceType,
+    authenticationType,
+    options: { ...serviceParams
+    }
+  };
+
+  if (serviceConfig.auth && isObject(serviceConfig.auth)) {
+    const authentication = updateServiceAuthentication(updatedServiceConfig.authenticationType, serviceConfig.auth, serviceParams);
+    return { ...updatedServiceConfig,
+      authentication
+    };
+  }
+
+  return updatedServiceConfig;
+}
+/**
+ * V1/V3 unencrypted `auth` -> V3.1 `authentication
+ */
+
+
+function updateServiceAuthentication(authenticationType, legacyAuth, legacyParams) {
+  if (authenticationType === 'oauth2Bearer') {
+    return {
+      token: legacyAuth.accessToken,
+      scope: legacyAuth.scope,
+      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 {
+      username,
+      password
+    };
+  }
+
+  if (authenticationType === 'bearer') {
+    return {
+      token: legacyAuth.accessToken,
+      header: legacyParams.authHeader
+    };
+  }
+}
+
+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';
+}
+
+async function migrateToV3_1(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,
+        auth
+      }, serviceKey);
+      const authentication = updatedServiceConfig === null || updatedServiceConfig === void 0 ? void 0 : updatedServiceConfig.authentication;
+      serviceMap[serviceKey] = { ...updatedServiceConfig,
+        authentication: authentication && isObject(authentication) ? encryptFn(authentication) : authentication
+      };
+      return serviceMap;
+    }, {});
+  }
+
+  return deepClone({ ...projectSchema,
+    services,
+    schemaVersion: '3.1.0'
+  });
+}
+
+export default migrateToV3_1;

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

@@ -0,0 +1,56 @@
+import mapValues from 'lodash/mapValues';
+
+function migrateQueryToV3_10(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' && !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
+
+  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,
+    schema: newSchema
+  };
+}
+
+function migrateToV3_10(projectSchema) {
+  const {
+    queries,
+    mutations,
+    shapes,
+    schemaVersion,
+    ...rest
+  } = projectSchema;
+  return { ...rest,
+    queries: mapValues(queries, migrateQueryToV3_10),
+    mutations: mapValues(mutations, migrateQueryToV3_10),
+    shapes: mapValues(shapes, migrateShapeToV3_10),
+    schemaVersion: '3.10.0'
+  };
+}
+
+export default migrateToV3_10;