@takeshape/schema 11.40.0 → 11.41.0

package/es/layers/layers.js

@@ -1,311 +0,0 @@
-import minimatch from 'minimatch';
-import { deepClone, isDefined, isRecord } from '@takeshape/util';
-import uniq from 'lodash/uniq';
-import set from 'lodash/set';
-import { parseTemplateShape } from '../refs';
-import { getArgsReferenceWithPath, getRefOrItemsRef, dereferenceSchema, parseReturnShape, refItemToString, splitAtRef } from './refs';
-import { isAllOfSchema, isObjectSchema, isOneOfSchema, isRefSchema } from './type-utils';
-import { visitSchemaProperties } from './visitor';
-const layerDefaults = {
-  namespace: '',
-  visibility: []
-};
-function filterMap(prefix, fields, filters) {
-  const result = {};
-  for (const [name, value] of Object.entries(fields)) {
-    for (const filter of filters) {
-      if (minimatch(`${prefix}.${name}`, filter)) {
-        result[name] = value;
-      }
-    }
-  }
-  return result;
-}
-function filterLayer(layerSchema, filters) {
-  return {
-    ...layerSchema,
-    queries: filterMap('queries', layerSchema.queries ?? {}, filters),
-    mutations: filterMap('mutations', layerSchema.mutations ?? {}, filters),
-    shapes: filterMap('shapes', layerSchema.shapes ?? {}, filters),
-    workflows: filterMap('workflows', layerSchema.workflows ?? {}, filters)
-  };
-}
-
-// TODO use non-versioned util eventually
-export function isObjectSchemaV4_0_0(maybeObjectSchema) {
-  return maybeObjectSchema.type === 'object' && isRecord(maybeObjectSchema.properties);
-}
-function mergeShape(a, b) {
-  if (b.override === 'extend') {
-    if (isObjectSchemaV4_0_0(a.schema) && isObjectSchemaV4_0_0(b.schema)) {
-      const combinedRequired = uniq((a.schema.required ?? []).concat(b.schema.required ?? []));
-      const combinedSchema = {
-        type: 'object',
-        properties: {
-          ...a.schema.properties,
-          ...b.schema.properties
-        }
-      };
-      if (combinedRequired.length) {
-        combinedSchema.required = combinedRequired;
-      }
-      return {
-        ...a,
-        ...b,
-        schema: combinedSchema
-      };
-    }
-  }
-  return b;
-}
-function assignShapes(flattenedShapes, layerShapes) {
-  for (const [shapeName, shape] of Object.entries(layerShapes)) {
-    flattenedShapes[shapeName] = flattenedShapes[shapeName] ? mergeShape(flattenedShapes[shapeName], shape) : shape;
-  }
-}
-function addRef(refs, ref, predicate) {
-  if (ref && (!predicate || predicate(ref))) {
-    refs.push(ref);
-  }
-}
-
-/**
- * Walk through a `ProjectSchema` and collect all the `ref`s.
- */
-export function getAllRefsInShapes(shapes, predicate) {
-  const items = [];
-  const shapeVisitor = (schema, schemaPath) => {
-    if (schema['@args'] && typeof schema['@args'] === 'object') {
-      visitSchemaProperties(schema['@args'], schemaPath.concat(['@args']), (argSchema, argPath) => {
-        addRef(items, getRefOrItemsRef(argSchema, argPath), predicate);
-      });
-    }
-    addRef(items, getArgsReferenceWithPath(schema, schemaPath), predicate);
-    const newPath = schema.items ? schemaPath.concat('items') : schemaPath;
-    const newSchema = schema.items ?? schema;
-    if (isRefSchema(newSchema)) {
-      addRef(items, getRefOrItemsRef(newSchema, newPath), predicate);
-    } else if (isObjectSchema(newSchema) || isAllOfSchema(newSchema) || isOneOfSchema(newSchema)) {
-      visitSchemaProperties(newSchema, newPath, shapeVisitor);
-    }
-  };
-  for (const [shapeName, shape] of Object.entries(shapes)) {
-    visitSchemaProperties(shape.schema, ['shapes', shapeName, 'schema'], shapeVisitor);
-  }
-  return items;
-}
-
-/**
- * Get all refs
- */
-export function getAllRefsInQuery(shapes, queryPath, query, predicate) {
-  const refItems = [];
-  const propertyVisitor = (propSchema, propSchemaPath) => {
-    addRef(refItems, getRefOrItemsRef(propSchema, propSchemaPath), predicate);
-  };
-  if (query.args && typeof query.args === 'string') {
-    addRef(refItems, getArgsReferenceWithPath(query, queryPath), predicate);
-  }
-  if (query.args && typeof query.args === 'object') {
-    visitSchemaProperties(dereferenceSchema(shapes, query.args), queryPath, propertyVisitor);
-  }
-  if (query.shape) {
-    const refItem = parseReturnShape(query.shape).ref;
-    if (refItem) {
-      addRef(refItems, {
-        ...refItem,
-        path: queryPath.concat(['shape'])
-      }, predicate);
-    }
-  }
-  return refItems;
-}
-/**
- * Collect refs from `queries` or `mutations`.
- */
-export function getAllRefsInQueries(context, rootPropertyName, predicate) {
-  const refItems = [];
-  const rootPath = [rootPropertyName];
-  for (const [queryName, query] of Object.entries(context[rootPropertyName])) {
-    const queryPath = rootPath.concat([queryName]);
-    const queryRefs = getAllRefsInQuery(context.shapes, queryPath, query, predicate);
-    if (queryRefs.length) {
-      refItems.push(...queryRefs);
-    }
-  }
-  return refItems;
-}
-
-/**
- * Get all refs in a ProjectSchema
- * @param predicate return true to include the ref in
- */
-export function getAllRefs(projectSchema, predicate) {
-  return [...getAllRefsInShapes(projectSchema.shapes, predicate), ...getAllRefsInQueries(projectSchema, 'queries', predicate), ...getAllRefsInQueries(projectSchema, 'mutations', predicate)];
-}
-export function collectReferencedShapeNames(layerId, refSet) {
-  const addLayerId = ref => ({
-    ...ref,
-    layerId
-  });
-  const collect = schema => {
-    const args = schema['@args'];
-    if (args && typeof args === 'object') {
-      Object.values(args.properties).forEach(collect);
-    }
-    const argsRefItem = getArgsReferenceWithPath(schema);
-    if (argsRefItem) {
-      refSet.add(refItemToString(addLayerId(argsRefItem)));
-    }
-    const refItem = getRefOrItemsRef(schema);
-    if (refItem) {
-      refSet.add(refItemToString(addLayerId(refItem)));
-    }
-  };
-  return collect;
-}
-function collectServiceRefs(flattenedSchema, getLayer) {
-  const refs = new Set(getAllRefs(flattenedSchema, refItem => refItem.layerId !== 'local').map(refItemToString));
-  if (refs.size) {
-    for (const ref of refs) {
-      const [layerId, shapeName] = splitAtRef(ref);
-      if (layerId !== 'local') {
-        const layer = getLayer(layerId);
-        const shape = layer?.shapes?.[shapeName];
-        if (shape) {
-          visitSchemaProperties(shape.schema, ['schema'], collectReferencedShapeNames(layerId, refs));
-        }
-      }
-    }
-  }
-  return refs;
-}
-function ensureServiceLayer(flattenedSchema, layerId) {
-  flattenedSchema.serviceLayers ||= {};
-  let serviceLayer = flattenedSchema.serviceLayers[layerId];
-  if (!serviceLayer) {
-    serviceLayer = {
-      layerId,
-      schemaVersion: '4.0.0',
-      shapes: {},
-      queries: {},
-      mutations: {}
-    };
-    flattenedSchema.serviceLayers[layerId] = serviceLayer;
-  }
-  return serviceLayer;
-}
-function rewriteLayerId(localShapes, layerId, query) {
-  const newQuery = deepClone(query);
-  const propertyVisitor = (propSchema, propSchemaPath) => {
-    const ref = (propSchema.items ?? propSchema)['@ref'];
-    if (ref) {
-      const [argsLayerId, shapeName] = splitAtRef(ref);
-      if (argsLayerId === 'local' && !localShapes[shapeName]) {
-        const path = propSchemaPath.concat(propSchema.items ? ['items', '@ref'] : ['@ref']);
-        set(newQuery, path, `${layerId}:${shapeName}`);
-      }
-    }
-  };
-  if (query.args) {
-    if (typeof query.args === 'string') {
-      const [argsLayerId, shapeName] = splitAtRef(parseTemplateShape(query.args).shapeName);
-      if (argsLayerId === 'local' && !localShapes[shapeName]) {
-        newQuery.args = `${layerId}:${shapeName}`;
-      }
-    } else {
-      visitSchemaProperties(query.args, ['args'], propertyVisitor);
-    }
-  }
-  if (typeof query.shape === 'string') {
-    const [argsLayerId, shapeName] = splitAtRef(parseTemplateShape(query.shape).shapeName);
-    if (argsLayerId === 'local' && !localShapes[shapeName]) {
-      newQuery.shape = `${layerId}:${shapeName}`;
-    }
-  } else {
-    const ref = query.shape.items['@ref'];
-    if (ref) {
-      const [argsLayerId, shapeName] = splitAtRef(ref);
-      if (argsLayerId === 'local' && !localShapes[shapeName]) {
-        set(newQuery, ['shape', 'items', '@ref'], `${layerId}:${shapeName}`);
-      }
-    }
-  }
-  return newQuery;
-}
-function assignQueries(localShapes, queries, layerId, layerQueries) {
-  for (const [queryName, query] of Object.entries(layerQueries)) {
-    queries[queryName] = rewriteLayerId(localShapes, layerId, query);
-  }
-}
-export function flattenSchema(projectSchema, getLayer) {
-  const {
-    layers,
-    ...rest
-  } = projectSchema;
-  const flattenedSchema = {
-    ...rest,
-    shapes: {},
-    queries: {},
-    mutations: {},
-    workflows: {},
-    forms: {}
-  };
-  const filteredLayers = layers.reverse().map(layer => {
-    const config = typeof layer === 'string' ? {
-      ...layerDefaults,
-      id: layer
-    } : layer;
-    const layerSchema = getLayer(config.id);
-    if (!layerSchema) {
-      throw new Error(`Unable to flatten schema for project ${projectSchema.projectId}. Cannot get layer ${config.id}`);
-    }
-    return config.visibility?.length ? filterLayer(layerSchema, config.visibility) : undefined;
-  }).filter(isDefined);
-  for (const filteredLayer of filteredLayers) {
-    const {
-      layerId
-    } = filteredLayer;
-    // Preserve original queries
-    if (projectSchema.services?.[layerId]) {
-      const serviceLayer = ensureServiceLayer(flattenedSchema, layerId);
-      if (serviceLayer.queries && filteredLayer.queries) {
-        Object.assign(serviceLayer.queries, filteredLayer.queries);
-      }
-      if (serviceLayer.mutations && filteredLayer.mutations) {
-        Object.assign(serviceLayer.mutations, filteredLayer.mutations);
-      }
-    }
-    if (filteredLayer.workflows) {
-      Object.assign(flattenedSchema.workflows, filteredLayer.workflows);
-    }
-    if (flattenedSchema.forms && filteredLayer.forms) {
-      Object.assign(flattenedSchema.forms, filteredLayer.forms);
-    }
-    if (filteredLayer.shapes) {
-      assignShapes(flattenedSchema.shapes, filteredLayer.shapes);
-    }
-  }
-  for (const filteredLayer of filteredLayers) {
-    if (filteredLayer.queries) {
-      assignQueries(flattenedSchema.shapes, flattenedSchema.queries, filteredLayer.layerId, filteredLayer.queries);
-    }
-    if (filteredLayer.mutations) {
-      assignQueries(flattenedSchema.shapes, flattenedSchema.mutations, filteredLayer.layerId, filteredLayer.mutations);
-    }
-  }
-
-  // Preserve original service schema shapes
-  for (const refStr of collectServiceRefs(flattenedSchema, getLayer)) {
-    const [layerId, shapeName] = splitAtRef(refStr);
-    if (layerId !== 'local') {
-      const shape = getLayer(layerId)?.shapes?.[shapeName];
-      if (shape) {
-        const serviceLayer = ensureServiceLayer(flattenedSchema, layerId);
-        serviceLayer.shapes ||= {};
-        serviceLayer.shapes[shapeName] = shape;
-      }
-    }
-  }
-  return flattenedSchema;
-}

package/es/layers/refs.js

@@ -1,256 +0,0 @@
-import assign from 'lodash/fp/assign';
-import omit from 'lodash/fp/omit';
-import { mergeWithArrayConcat } from '@takeshape/util';
-import isEmpty from 'lodash/isEmpty';
-import { parseTemplateShape } from '../refs';
-import { isAllOfSchema, isOneOfSchema, isRefSchema } from './type-utils';
-
-/**
- * This interface describes a parsed `@ref` or `$ref`.
- * The intended usage is to convert a schema with a ref to a RefItem which can then
- * be passed to the various rich utilities in this file.
- */
-
-/**
- * Adds a schema path, needed when visiting a whole schema to report errors.
- */
-
-/**
- * Safely turn a "template" shape reference (`@args`, `args`, `shape`) into a `RefItem`
- *
- * @param context A partial project schema
- * @param refExpression
- * A ref expression might include "template" name and refer to a local or remote
- * shape, `Foo` or `CreateArgs<Foo>` or `CreateArgs<remote:Foo>`.*
- */
-export function refExpressionToRefItem(refExpression) {
-  const {
-    shapeName,
-    template
-  } = parseTemplateShape(refExpression);
-  return atRefToRefItem(shapeName, template);
-}
-
-/**
- * Sugar for converting a `refExpression` directly into a shape, without the
- * intermediate `refItem`.
- *
- * @param context A partial project schema
- * @param refExpression
- * A ref expression might include "template" name and refer to a local or remote
- * shape, `Foo` or `CreateArgs<Foo>` or `CreateArgs<remote:Foo>`.
- */
-export function refExpressionToShape(shapes, refExpression) {
-  return refItemToShape(shapes, refExpressionToRefItem(refExpression));
-}
-
-/**
- * Provided a service name and a referenced type. Supports 2 or 3 part
- * references, e.g., `shopify:my-store:ProductInput` or `my-store:ProductInput`.
- *
- * @returns
- * A 2 member array, where 0 is the service name, 1 is the referenced type.
- */
-export function splitAtRef(atRef) {
-  const refParts = atRef.split(':');
-  if (refParts.length === 1) {
-    return ['local', atRef];
-  }
-  if (refParts.length === 2) {
-    return [refParts[0], refParts[1]];
-  }
-  throw new Error(`Invalid ref string ${atRef}`);
-}
-
-/**
- * Parses and returns a typeName, serviceKey, and potentially a namespace for
- * the type.
- */
-export function atRefToRefItem(atRef, template) {
-  const [serviceKey, typeName] = splitAtRef(atRef);
-  return {
-    typeName,
-    layerId: serviceKey,
-    template
-  };
-}
-
-/**
- * Given a content schema and project schema, finds a `@ref` or `$ref` and
- * returns a `RefItem` suitable for loading a referenced schema...
- */
-export function getRef(refSchema) {
-  if (refSchema['@ref']) {
-    // @ref: my-service:ShapeName
-    return atRefToRefItem(refSchema['@ref']);
-  }
-}
-export function getRefWithPath(refSchema, schemaPath = []) {
-  const refItem = getRef(refSchema);
-  if (refItem) {
-    return {
-      ...refItem,
-      path: schemaPath.concat(['@ref'])
-    };
-  }
-}
-
-/**
- * Tests for a `@ref` or `$ref` property directly on the passed schema.
- *
- * @param schema Any schema that might could have a ref property.
- */
-export function hasRefProperty(schema) {
-  return Boolean(schema['@ref'] ?? schema.$ref);
-}
-
-/**
- * From a schema with a ref, will return the top-level ref, and potentially
- * a ref item from a nested `items` property.
- */
-export function getRefOrItemsRef(refSchema, schemaPath = []) {
-  const refItem = getRefWithPath(refSchema, schemaPath);
-  if (refItem) {
-    return refItem;
-  }
-  if (refSchema.items) {
-    return getRefOrItemsRef(refSchema.items, schemaPath.concat(['items']));
-  }
-}
-
-/**
- * Turns a `RefItem` into an `@ref`.
- */
-export function refItemToString(refItem) {
-  return `${refItem.layerId}:${refItem.typeName}`;
-}
-
-/**
- * Get a Shape referenced by a `RefItem`.
- */
-export function refItemToShape(shapes, refItem) {
-  return shapes[refItemToString(refItem)];
-}
-
-/**
- * Helper fn to omit `ref` props from the target schema, and then extend it with the source schema.
- */
-export const omitRefAndExtend = (targetSchema, sourceSchema) => assign(omit(['@ref', '$ref'], targetSchema), sourceSchema);
-
-/**
- * If there is a $ref, this will insert a content schema from the top level
- * in place of the reference.
- */
-export function followRef(shapes, contentSchema) {
-  const refItem = getRef(contentSchema);
-  if (refItem) {
-    const referencedSchema = refItemToShape(shapes, refItem)?.schema;
-    if (referencedSchema) {
-      return omitRefAndExtend(contentSchema, referencedSchema);
-    }
-  }
-  return contentSchema;
-}
-
-/**
- * Returns whether a schema has refs.
- */
-export function hasRef(contentSchema) {
-  if (isRefSchema(contentSchema)) {
-    return true;
-  }
-  if (isAllOfSchema(contentSchema)) {
-    return Boolean(contentSchema.allOf.find(hasRef));
-  }
-  if (isOneOfSchema(contentSchema)) {
-    return Boolean(contentSchema.oneOf.find(hasRef));
-  }
-  return false;
-}
-
-/**
- * Returns whether a schema has refs which can be followed.
- */
-export function hasResolvableRef(shapes, contentSchema) {
-  if (isRefSchema(contentSchema)) {
-    return Boolean(refItemToShape(shapes, getRef(contentSchema)));
-  }
-  if (isAllOfSchema(contentSchema)) {
-    return Boolean(contentSchema.allOf.find(s => hasResolvableRef(shapes, s)));
-  }
-  if (isOneOfSchema(contentSchema)) {
-    return Boolean(contentSchema.oneOf.find(s => hasResolvableRef(shapes, s)));
-  }
-  return false;
-}
-export function getArgsReferenceWithPath(argsSchema, schemaPath = []) {
-  const isQuery = 'args' in argsSchema;
-  const args = isQuery ? argsSchema.args : argsSchema['@args'];
-  const refItem = typeof args === 'string' ? refExpressionToRefItem(args) : undefined;
-  if (refItem) {
-    return {
-      ...refItem,
-      path: schemaPath.concat([isQuery ? 'args' : '@args'])
-    };
-  }
-}
-
-/*
- * Helper fn to omit `allOf` props from the target schema, and then extend it with the source schema.
- */
-const omitAllOfAndExtend = (targetSchema, sourceSchema) => assign(omit(['allOf'], targetSchema), sourceSchema);
-export function dereferenceSchema(shapes, shapeOrFieldSchema, schemaPath = []) {
-  const resolveAll = (resolveSchema, resolvePath) => {
-    try {
-      if (isAllOfSchema(resolveSchema)) {
-        const allOfSchema = resolveSchema.allOf.map((stub, index) => resolveAll(stub, [...resolvePath, 'allOf', index])).reduce((prev, curr) => mergeWithArrayConcat(prev, curr), {});
-        return isEmpty(allOfSchema) ? undefined : omitAllOfAndExtend(resolveSchema, allOfSchema);
-      }
-      if (isRefSchema(resolveSchema)) {
-        const refItem = getRefWithPath(resolveSchema);
-        if (!refItem) {
-          throw new Error('ref could not be parsed');
-        }
-        const refSchema = refItemToShape(shapes, refItem);
-        if (refSchema) {
-          return resolveAll(omitRefAndExtend(resolveSchema, refSchema), refItem.path);
-        }
-        return;
-      }
-      return resolveSchema;
-    } catch (err) {
-      throw new Error(`error at '${resolvePath.join('.')}', ${err.message}`);
-    }
-  };
-  return resolveAll(shapeOrFieldSchema, schemaPath) ?? shapeOrFieldSchema;
-}
-export function parseReturnShape(shape) {
-  if (typeof shape === 'object') {
-    if (isRefSchema(shape.items)) {
-      const ref = getRef(shape.items);
-      if (!ref) {
-        throw new Error(`Could not parse ${JSON.stringify(shape.items)}: invalid ref`);
-      }
-      return {
-        isArray: true,
-        ref,
-        shapeName: refItemToString(ref)
-      };
-    }
-    if (typeof shape.items.type !== 'string') {
-      throw new Error(`Could not parse ${JSON.stringify(shape.items)}: invalid type`);
-    }
-    return {
-      isArray: true,
-      shapeName: shape.items.type
-    };
-  }
-  const ref = refExpressionToRefItem(shape);
-  const shapeName = refItemToString(ref);
-  return {
-    isArray: false,
-    shapeName,
-    ref,
-    template: ref.template
-  };
-}

package/es/layers/type-utils.js

@@ -1,138 +0,0 @@
-import { isRecord } from '@takeshape/util';
-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.
- */
-export function isBasicResolver(resolver) {
-  return isString(resolver?.name) && isString(resolver.service);
-}
-export function isComposeResolver(resolver) {
-  return Boolean(isArray(resolver?.compose) && resolver.compose.length && resolver.compose.every(isBasicResolver));
-}
-const {
-  definitions: {
-    takeshapeResolver,
-    utilResolver,
-    graphqlResolver,
-    restResolver,
-    awsLambdaResolver
-  }
-} = latestSchemaJson;
-export function isTakeshapeResolver(resolver) {
-  return takeshapeResolver.properties.name.enum.includes(resolver.name);
-}
-export function isGraphqlResolver(resolver) {
-  return graphqlResolver.properties.name.enum.includes(resolver.name);
-}
-export function isRestResolver(resolver) {
-  return restResolver.properties.name.enum.includes(resolver.name);
-}
-export function isAwsLambdaResolver(resolver) {
-  return awsLambdaResolver.properties.name.enum.includes(resolver.name);
-}
-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) {
-  return isString(maybeRefSchema['@ref']) || isString(maybeRefSchema.$ref);
-}
-export function isAllOfSchema(schema) {
-  return isArray(schema.allOf);
-}
-export function isOneOfSchema(schema) {
-  return isArray(schema.oneOf);
-}
-export function isArraySchema(schema) {
-  return schema.type === 'array' && isRecord(schema.items);
-}
-export function isObjectSchema(schema) {
-  return schema.type === 'object' && isRecord(schema.properties);
-}