@takeshape/schema 7.194.0

package/es/content-schema-transform.js

@@ -0,0 +1,192 @@
+import forEach from 'lodash/forEach';
+import difference from 'lodash/difference';
+import pick from 'lodash/pick';
+import { getKey, dereferenceSchema } from './schema-util';
+import { isArraySchema, isObjectSchema } from './types';
+import { getRefShapeName } from './refs';
+import { enumerateOneOfKeys, isUnionSchema } from './unions';
+const typeCache = new WeakMap();
+export function getType(schema) {
+  let type = typeCache.get(schema);
+
+  if (type) {
+    return type;
+  }
+
+  type = schema.type; // handle nullable types for example: ['object', 'null']
+
+  if (Array.isArray(type)) {
+    const filtered = type.filter(name => name !== 'null');
+
+    if (!filtered.length) {
+      throw new Error(`Invalid schema`);
+    }
+
+    type = filtered[0];
+  }
+
+  typeCache.set(schema, type);
+  return type;
+}
+export function toName(name) {
+  return name;
+}
+
+function ensureArray(value) {
+  return Array.isArray(value) ? value : [value];
+}
+
+export function preferKey(name, schema) {
+  var _getKey;
+
+  return (_getKey = getKey(schema)) !== null && _getKey !== void 0 ? _getKey : name;
+}
+export function findTransforms(pluginMap, schema, name, shape) {
+  const type = getType(schema);
+
+  if (pluginMap && (pluginMap[type] || pluginMap['*'])) {
+    var _pluginMap$type, _pluginMap$;
+
+    const plugins = ((_pluginMap$type = pluginMap[type]) !== null && _pluginMap$type !== void 0 ? _pluginMap$type : []).concat((_pluginMap$ = pluginMap['*']) !== null && _pluginMap$ !== void 0 ? _pluginMap$ : []);
+    return plugins.find(plugin => plugin.filter(schema, name, shape));
+  }
+
+  return undefined;
+}
+export function getContentTransform({
+  transforms,
+  accumulators,
+  keyTransform = preferKey,
+  sourceKeyTransform = preferKey,
+  passThrough = true,
+  projectSchema
+}) {
+  const prepare = (schema, obj, name = '') => {
+    const shapeName = getRefShapeName(projectSchema, schema);
+    schema = dereferenceSchema(projectSchema, schema);
+
+    if (accumulators) {
+      accumulators.forEach(accumulator => {
+        accumulator.accumulate(obj, schema, name);
+      });
+    }
+
+    const shape = shapeName ? projectSchema.shapes[shapeName] : undefined;
+    const transform = findTransforms(transforms, schema, name, shape);
+
+    if (transform) {
+      const next = (value, schema, name) => prepare(schema, value, name);
+
+      return transform.process(obj, schema, name, shape, next);
+    }
+
+    if (obj && isUnionSchema(schema)) {
+      for (const {
+        shapeId,
+        propSchema
+      } of enumerateOneOfKeys(projectSchema, schema.oneOf)) {
+        if (obj._shapeId === shapeId) {
+          return prepare(propSchema, obj, name);
+        }
+      }
+    }
+
+    if (obj && isObjectSchema(schema)) {
+      const result = {};
+      const assigned = new Set();
+      forEach(schema.properties, (fieldSchema, name) => {
+        const sourceKeys = ensureArray(sourceKeyTransform(name, fieldSchema));
+
+        for (const sourceKey of sourceKeys) {
+          const value = prepare(fieldSchema, obj === null || obj === void 0 ? void 0 : obj[sourceKey], name);
+
+          if (value !== undefined) {
+            assigned.add(sourceKey);
+            const transform = findTransforms(transforms, dereferenceSchema(projectSchema, fieldSchema), name);
+            const getKey = transform !== null && transform !== void 0 && transform.keyTransform ? transform.keyTransform : keyTransform;
+            result[getKey(name, fieldSchema, sourceKey)] = value;
+          }
+        }
+      });
+
+      if (passThrough && obj) {
+        const keys = difference(Object.keys(obj), [...assigned]);
+
+        if (keys.length) {
+          Object.assign(result, pick(obj, keys));
+        }
+      }
+
+      return result;
+    }
+
+    if (isArraySchema(schema)) {
+      const itemSchema = schema.items;
+
+      if (Array.isArray(obj)) {
+        return obj.map(item => prepare(itemSchema, item, name));
+      }
+
+      if (obj === undefined) {
+        prepare(itemSchema, obj, name);
+      }
+    } // allow properties that have not been transformed
+
+
+    return passThrough ? obj : undefined;
+  };
+
+  return prepare;
+}
+
+function transformKey(transforms, propSchema, name, transform = preferKey) {
+  const schemaTransform = findTransforms(transforms, propSchema, name);
+
+  if (schemaTransform !== null && schemaTransform !== void 0 && schemaTransform.keyTransform) {
+    transform = schemaTransform.keyTransform;
+  }
+
+  return transform(name, propSchema);
+}
+
+export function getPropertyInfo(context, schema, path) {
+  const {
+    projectSchema,
+    transforms,
+    keyTransform
+  } = context;
+  const result = [];
+
+  const findProperty = (currentSchema, name, rest, path) => {
+    if (isObjectSchema(currentSchema)) {
+      const propSchema = currentSchema.properties[name];
+
+      if (!propSchema) {
+        return;
+      }
+
+      const refSchema = dereferenceSchema(projectSchema, propSchema);
+      const nextPath = path.concat(transformKey(transforms, refSchema, name, keyTransform));
+
+      if (rest.length) {
+        const [nextName, ...nextRest] = rest;
+        findProperty(refSchema, nextName, nextRest, nextPath);
+      } else {
+        result.push({
+          schema: refSchema,
+          key: nextPath.join('.')
+        });
+      }
+    } else if (isUnionSchema(currentSchema)) {
+      for (const optionSchema of currentSchema.oneOf) {
+        findProperty(dereferenceSchema(projectSchema, optionSchema), name, rest, path);
+      }
+    } else if (isArraySchema(currentSchema)) {
+      findProperty(dereferenceSchema(projectSchema, currentSchema.items), name, rest, path);
+    }
+  };
+
+  const [first, ...rest] = path.split('.');
+  findProperty(dereferenceSchema(projectSchema, schema), first, rest, []);
+  return result;
+}

package/es/enum.js

@@ -0,0 +1,11 @@
+export function isEnumSchema(schema) {
+  if (schema.enum) {
+    return true;
+  }
+
+  if (schema.oneOf) {
+    return schema.oneOf.every(optionSchema => optionSchema.title !== undefined && (optionSchema.enum || optionSchema.const));
+  }
+
+  return false;
+}

package/es/get-is-leaf.js

@@ -0,0 +1,58 @@
+import { getType } from './content-schema-transform';
+import { getKey, isBuiltinType } from './schema-util';
+import { followRef, getRefShapeName } from './refs';
+const scalarTags = new Set(['draftjs']);
+
+function isLeafTypeV3(projectSchema, contentSchema) {
+  const type = getType(contentSchema);
+  return Boolean( // must have key
+  getKey(contentSchema) && ( // if is not a structure, then is a leaf
+  !['object', 'array'].includes(type) || // if is relationship, then is a leaf
+  contentSchema['@relationship'] || contentSchema['@tag'] && scalarTags.has(contentSchema['@tag']) || // if is array, then should not be a synchronized structure
+  type === 'array' && !contentSchema['@syncLocaleStructure'] || isBuiltinType(projectSchema, contentSchema)));
+}
+
+export function getIsLeaf(projectSchema, shapeSchema) {
+  const leafMap = new Set();
+  const shapesSeen = new Set();
+
+  const collectLeaves = schema => {
+    var _schema$oneOf;
+
+    const shapeName = getRefShapeName(projectSchema, schema);
+    schema = shapeName ? followRef(projectSchema, schema) : schema;
+    const key = getKey(schema);
+
+    if (key && isLeafTypeV3(projectSchema, schema)) {
+      leafMap.add(key);
+    }
+
+    if (shapeName) {
+      // skip shapes we have already seen to avoid cycles
+      if (shapesSeen.has(shapeName)) {
+        return;
+      }
+
+      shapesSeen.add(shapeName);
+    }
+
+    const combo = (_schema$oneOf = schema.oneOf) !== null && _schema$oneOf !== void 0 ? _schema$oneOf : schema.allOf;
+
+    if (combo) {
+      combo.map(collectLeaves);
+    } else if (schema.properties) {
+      for (const name of Object.keys(schema.properties)) {
+        collectLeaves(schema.properties[name]);
+      }
+    } else if (schema.items) {
+      collectLeaves(schema.items);
+    }
+  };
+
+  collectLeaves(shapeSchema);
+  return key => {
+    // remove locale suffix
+    key = key ? key.split(':')[0] : key;
+    return Boolean(key && leafMap.has(key));
+  };
+}

package/es/index.js

@@ -0,0 +1,25 @@
+export * from './content-schema-transform';
+export * from './get-is-leaf';
+export * from './project-schema';
+export * from './schema-util';
+export * from './services';
+export * from './template-shapes';
+export * from './taxonomies';
+export * from './types';
+export * from './workflows';
+export * from './builtin-schema';
+export * from './auth-schemas'; // Only export User here since AccessPolicyDocument is in auth-schemas
+
+export * from './api-version';
+export { listTypePrefix, ensureLatest, normalizeSchemaVersion, getRelationshipSchema, migrateToLatestProjectSchema } from './migration';
+export * from './validate';
+export { builtInShapes } from './builtin-schema';
+export * from './versions';
+export * from './mocks';
+export * from './util';
+export * from './resolvers';
+export * from './scalars';
+export * from './refs';
+export * from './unions';
+export * from './enum';
+export * from './patterns';

package/es/migration.js

@@ -0,0 +1,413 @@
+import pReduce from 'p-reduce';
+import forEach from 'lodash/forEach';
+import pick from 'lodash/pick';
+import { upperCamel, deepClone } from '@takeshape/util';
+import { arraySchemaKeys, getShapeQueriesAndMutations, multipleRelationshipSchemaKeys, objectSchemaKeys, scalarSchemaKeys, schemaMetadataKeys } from './schema-util';
+import { updateServiceConfigV3ToV3_1 } from './services';
+import { isProjectSchemaV1, isProjectSchemaV3, isLatestProjectSchema, isServiceAuthentication, isProjectSchemaV3_1, isProjectSchemaV3_2, isProjectSchemaV3_3, isProjectSchemaV3_4, isProjectSchemaV3_5, isProjectSchemaV3_5_1 } from './types';
+export const listTypePrefix = 'PaginatedList';
+const annotationMap = {
+  l10n: '@l10n',
+  sensitive: '@sensitive',
+  syncLocaleStructure: '@syncLocaleStructure'
+};
+export function getRelationshipSchema(relationship) {
+  const itemSchema = {
+    $ref: '#/shapes/TSRelationship/schema'
+  };
+
+  if (relationship.type === 'multiple') {
+    return {
+      type: 'array',
+      items: itemSchema,
+      '@relationship': relationship
+    };
+  }
+
+  return { ...itemSchema,
+    '@relationship': relationship
+  };
+}
+
+function isColor(schema) {
+  const {
+    type,
+    properties
+  } = schema;
+  return Boolean(type === 'object' && properties && properties.hsl && properties.hsv && properties.rgb && properties.hex);
+} // eslint-disable-next-line complexity
+
+
+export 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 !== null && relationshipType !== void 0 ? 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) {
+    var _schema$title;
+
+    const properties = {};
+    let shapes = {};
+    const shapeTitle = [params.shapeTitle, upperCamel((_schema$title = schema.title) !== null && _schema$title !== void 0 ? _schema$title : params.name)].filter(Boolean).join(' ');
+    const shapeName = `${params.shapeName}${upperCamel(params.name)}`;
+    const contentSourceId = `takeshape:local:${shapeName}`;
+    forEach(schema.properties, (propSchema, name) => {
+      var _propSchema$key;
+
+      const {
+        schema: migratedPropSchema,
+        hoistedShapes
+      } = migrateToContentSchemaV3({ ...params,
+        shapeName,
+        shapeTitle,
+        depth: params.depth + 1,
+        schema: propSchema,
+        parentSchema: schema,
+        service: contentSourceId,
+        key: (_propSchema$key = propSchema.key) !== null && _propSchema$key !== void 0 ? _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 getModelType(contentType) {
+  if (contentType.single) {
+    return 'single';
+  }
+
+  if (contentType.taxonomy) {
+    return 'taxonomy';
+  }
+
+  return 'multiple';
+}
+
+export function contentTypeToShape(contentType, contentTypeId) {
+  var _contentType$title;
+
+  const title = (_contentType$title = contentType.title) !== null && _contentType$title !== void 0 ? _contentType$title : contentType.name;
+  const name = upperCamel(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 formatDate(timestamp) {
+  return (timestamp ? new Date(timestamp) : new Date()).toISOString();
+}
+
+export function migrateToV3(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[upperCamel(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 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: isServiceAuthentication(authentication) ? encryptFn(authentication) : authentication
+      };
+      return serviceMap;
+    }, {});
+  }
+
+  return deepClone({ ...projectSchema,
+    services,
+    schemaVersion: '3.1.0'
+  });
+}
+export function migrateToV3_2(projectSchema) {
+  /**
+   * No migration needed all changes are backwards compatible.
+   */
+  return { ...projectSchema,
+    schemaVersion: '3.2.0'
+  };
+}
+export async function migrateToV3_3(context, projectSchema) {
+  const {
+    generateDataKeyFn
+  } = context;
+  const dataKey = projectSchema.dataKey ? projectSchema.dataKey : await generateDataKeyFn();
+  /**
+   * Generate a dataKey if none is present.
+   */
+
+  return { ...projectSchema,
+    schemaVersion: '3.3.0',
+    dataKey
+  };
+}
+export function migrateToV3_4(projectSchema) {
+  /**
+   * No migration needed all changes are backwards compatible.
+   */
+  return { ...projectSchema,
+    schemaVersion: '3.4.0'
+  };
+}
+export function migrateToV3_5(projectSchema) {
+  /**
+   * No migration needed all changes are backwards compatible.
+   */
+  return { ...projectSchema,
+    schemaVersion: '3.5.0'
+  };
+}
+export function migrateToV3_5_1(projectSchema) {
+  /**
+   * No migration needed all changes are backwards compatible.
+   */
+  return { ...projectSchema,
+    schemaVersion: '3.5.1'
+  };
+}
+export function migrateToV3_6(projectSchema) {
+  /**
+   * No migration needed all changes are backwards compatible.
+   */
+  return { ...projectSchema,
+    schemaVersion: '3.6.0'
+  };
+}
+export async function migrateToLatestProjectSchema(context, projectSchema) {
+  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);
+  }
+
+  return projectSchema;
+}
+export function normalizeSchemaVersion(version) {
+  return version === undefined ? '1' : version;
+}
+export function isV1Like(schema) {
+  return Boolean(schema.schemaVersion === '1' || schema.schemaVersion === undefined);
+}
+export function isV1(schema) {
+  return Boolean(isV1Like(schema));
+}
+export function isV3Like(schema) {
+  return schema.schemaVersion === '3';
+}
+export function isV3(schema) {
+  return isV3Like(schema);
+}
+export async function ensureLatest(context, schema) {
+  if (!schema || isLatestProjectSchema(schema)) {
+    return schema;
+  }
+
+  return migrateToLatestProjectSchema(context, schema);
+}