@takeshape/schema 7.194.0

package/es/types.js

@@ -0,0 +1,202 @@
+import eq from 'semver/functions/eq';
+import coerce from 'semver/functions/coerce';
+import has from 'lodash/has';
+import isString from 'lodash/isString';
+import isObject from 'lodash/isObject';
+import isArray from 'lodash/isArray';
+import isPlainObject from 'lodash/isPlainObject';
+import { CURRENT_SCHEMA_VERSION } from './versions';
+export function isBasicResolver(resolver) {
+  return resolver ? isString(resolver.name) && isString(resolver.service) : false;
+}
+export function isComposeResolver(resolver) {
+  return resolver ? resolver.compose !== undefined : false;
+}
+/**
+ * Remote service configuration types
+ */
+
+/**
+ * Old service authentication
+ * @deprecated
+ */
+
+/**
+ * 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 isRESTServiceConfig(maybeConfig) {
+  return isAnyServiceConfig(maybeConfig) && maybeConfig.serviceType === 'rest';
+}
+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 isOpenAPIServiceConfig(maybeConfig) {
+  return isAnyServiceConfig(maybeConfig) && maybeConfig.serviceType === 'openapi';
+}
+export function isEncryptedServiceConfig(maybeConfig) {
+  return isAnyServiceConfig(maybeConfig) && isString(maybeConfig.authentication);
+}
+export function isServiceAuthentication(maybeAuthentication) {
+  return maybeAuthentication && isObject(maybeAuthentication);
+}
+export function isBearerAuthentication(maybeAuthentication) {
+  return isServiceAuthentication(maybeAuthentication) && isString(maybeAuthentication.token);
+}
+export function isBasicAuthentication(maybeAuthentication) {
+  return isServiceAuthentication(maybeAuthentication) && (isString(maybeAuthentication.username) || isString(maybeAuthentication.password));
+}
+export function isSearchParamsAuthentication(maybeAuthentication) {
+  return isArray(maybeAuthentication) && maybeAuthentication.every(value => isObject(value) && Object.entries(value).every(([k, v]) => (k === 'name' || k === 'value') && isString(v)));
+}
+export function isOAuth2Authentication(maybeAuthentication) {
+  return isServiceAuthentication(maybeAuthentication) && isString(maybeAuthentication.clientId);
+}
+export function isServiceConfigWithOAuth2Authentication(maybeServiceConfig) {
+  return isAnyServiceConfig(maybeServiceConfig) && maybeServiceConfig.authenticationType === 'oauth2' && isOAuth2Authentication(maybeServiceConfig.authentication);
+}
+export function isServiceConfigWithCustomAuthentication(maybeServiceConfig) {
+  return isAnyServiceConfig(maybeServiceConfig) && maybeServiceConfig.authenticationType === 'custom' && isServiceAuthentication(maybeServiceConfig.authentication);
+}
+export function isProjectSchemaWithServices(schema) {
+  return typeof schema.dataKey !== 'undefined' && typeof schema.services !== 'undefined';
+}
+/**
+ * Types of refs
+ */
+
+export let RefType;
+/**
+ * Stub of a ContentSchema that may contain a `$ref` or `@ref`.
+ */
+
+(function (RefType) {
+  RefType["@ref"] = "@ref";
+  RefType["$ref"] = "$ref";
+})(RefType || (RefType = {}));
+
+/**
+ * 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;
+  }
+};
+/**
+ * Types of args
+ */
+
+export let ArgsType;
+
+(function (ArgsType) {
+  ArgsType["@args"] = "@args";
+  ArgsType["args"] = "args";
+})(ArgsType || (ArgsType = {}));
+
+/**
+ * A utility to return the type of args present on a schema.
+ *
+ * @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;
+  }
+};
+/**
+ * Typeguards for different types of shape schemas
+ */
+
+export function isRefSchema(maybeRefSchema) {
+  return isString(maybeRefSchema['@ref']) || isString(maybeRefSchema.$ref);
+}
+export function isRefSchemaLegacy(maybeRefSchema) {
+  return isString(maybeRefSchema.$ref);
+}
+export function isAllOfSchema(maybeExtendableSchema) {
+  return isArray(maybeExtendableSchema.allOf);
+}
+export function isOneOfSchema(maybeExclusiveOrSchema) {
+  return isArray(maybeExclusiveOrSchema.oneOf);
+}
+export function isArraySchema(maybeArraySchema) {
+  return maybeArraySchema.type === 'array' && isObject(maybeArraySchema.items);
+}
+export function isObjectSchema(maybeObjectSchema) {
+  return maybeObjectSchema.type === 'object' && isObject(maybeObjectSchema.properties);
+}
+export function isContentObjectSchema(maybeSchema) {
+  return isRefSchema(maybeSchema) || isAllOfSchema(maybeSchema) || isObjectSchema(maybeSchema);
+}
+
+function createVersionPredicate(schemaVersion) {
+  const expectedSemver = coerce(schemaVersion);
+  return projectSchema => {
+    var _projectSchema$schema;
+
+    const schemaSemver = coerce((_projectSchema$schema = projectSchema.schemaVersion) !== null && _projectSchema$schema !== void 0 ? _projectSchema$schema : '1');
+    return Boolean(expectedSemver && schemaSemver && eq(schemaSemver, expectedSemver));
+  };
+}
+
+export const isProjectSchemaV1 = createVersionPredicate('1');
+export const isProjectSchemaV3 = createVersionPredicate('3');
+export const isProjectSchemaV3_1 = createVersionPredicate('3.1.0');
+export const isProjectSchemaV3_2 = createVersionPredicate('3.2.0');
+export const isProjectSchemaV3_3 = createVersionPredicate('3.3.0');
+export const isProjectSchemaV3_4 = createVersionPredicate('3.4.0');
+export const isProjectSchemaV3_5 = createVersionPredicate('3.5.0');
+export const isProjectSchemaV3_5_1 = createVersionPredicate('3.5.1');
+export const isProjectSchemaV3_6 = createVersionPredicate('3.6.0');
+export const isLatestProjectSchema = createVersionPredicate(CURRENT_SCHEMA_VERSION);
+/**
+ * Determine whether a given project schema is any project schema.
+ */
+
+export function isAnyProjectSchema(maybeSchema) {
+  return isObject(maybeSchema) && isString(maybeSchema.projectId) && (isProjectSchemaV1(maybeSchema) || isProjectSchemaV3(maybeSchema) || isProjectSchemaV3_1(maybeSchema) || isProjectSchemaV3_2(maybeSchema) || isProjectSchemaV3_3(maybeSchema) || isProjectSchemaV3_4(maybeSchema) || isProjectSchemaV3_5(maybeSchema) || isProjectSchemaV3_5_1(maybeSchema) || isProjectSchemaV3_6(maybeSchema));
+}
+/**
+ * Types supporting schema iterators
+ */
+
+export function isShopifyServiceConfig(maybeShopify) {
+  return maybeShopify.provider === 'shopify';
+}
+
+/**
+ * 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]) && isObject(maybeConfig[0][1]);
+}

package/es/unions.js

@@ -0,0 +1,137 @@
+import { getRef, refItemToShapeName } from './refs';
+import { camelCase, isObject } from '@takeshape/util';
+import omit from 'lodash/omit';
+import { getContentTransform, toName } from './content-schema-transform';
+import { isRefSchema } from './types';
+import { BadDataError } from '@takeshape/errors';
+import { getShapeById } from './schema-util';
+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({
+          propName: camelCase(refItem.typeName),
+          propSchema: child,
+          shapeName,
+          shapeId
+        });
+      }
+    }
+  }
+
+  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'),
+    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 (isObject(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 (isObject(propValue)) {
+        const transformedPropValue = next(propValue, propSchema, name);
+
+        if (isObject(transformedPropValue)) {
+          return { ...transformedPropValue,
+            _shapeId: shapeId
+          };
+        }
+      }
+    }
+  }
+}; // eslint-disable-next-line max-params
+
+export const createWrapTransform = projectSchema => (obj, schema, name, shape, next) => {
+  if (isObject(obj) && typeof obj._shapeId === 'string') {
+    const shape = getShapeById(projectSchema, obj._shapeId);
+
+    if (shape) {
+      return {
+        [camelCase(shape.name)]: next(omit(obj, '_shapeId'), shape.schema, name)
+      };
+    }
+  }
+};
+export function transformOneOf(process) {
+  return (projectSchema, schema, obj) => {
+    const transform = getContentTransform({
+      sourceKeyTransform: toName,
+      keyTransform: toName,
+      passThrough: true,
+      projectSchema,
+      transforms: {
+        '*': [{
+          filter: isUnionSchema,
+          process: process(projectSchema)
+        }]
+      }
+    });
+    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/detect-cycles.js

@@ -0,0 +1,54 @@
+import { getRef, refItemToShape } from '../refs';
+
+function immutableSetAdd(set, str) {
+  const result = new Set(set);
+  result.add(str);
+  return result;
+}
+/**
+ * Use a basic depth-first search to dertermine whether a schema contains a cycle
+ */
+
+
+export function hasCycle(projectSchema, schema, shapesSeen = new Set()) {
+  var _ref, _schema$oneOf;
+
+  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
+
+    if (!refShape) {
+      return false;
+    }
+
+    if (shapesSeen.has(refShape.name)) {
+      return true;
+    }
+
+    return hasCycle(projectSchema, refShape.schema, immutableSetAdd(shapesSeen, refShape.name));
+  }
+
+  const combo = (_ref = (_schema$oneOf = schema.oneOf) !== null && _schema$oneOf !== void 0 ? _schema$oneOf : schema.allOf) !== null && _ref !== void 0 ? _ref : schema.anyOf;
+
+  if (combo) {
+    return combo.some(childSchema => hasCycle(projectSchema, childSchema, shapesSeen));
+  }
+
+  if (schema.items) {
+    return hasCycle(projectSchema, schema.items, shapesSeen);
+  }
+
+  const {
+    properties
+  } = schema;
+
+  if (properties) {
+    return Object.keys(properties).some(name => {
+      const propSchema = properties[name];
+      return hasCycle(projectSchema, propSchema, shapesSeen);
+    });
+  }
+
+  return false;
+}

package/es/util/index.js

@@ -0,0 +1 @@
+export * from './detect-cycles';