@takeshape/schema 11.40.0 → 11.41.0

package/es/types/utils.js

@@ -1,298 +0,0 @@
-import { isRecord } from '@takeshape/util';
-import isPlainObject from 'lodash/isPlainObject';
-import isString from 'lodash/isString';
-import isArray from 'lodash/isArray';
-import has from 'lodash/has';
-import isUndefined from 'lodash/isUndefined';
-import { latestSchemaJson } from '../schemas';
-import { isCachedShape } from '../schema-util';
-import { ArgsType, RefType } from './types';
-/** 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 isRecord(resolver) && isString(resolver.name);
-}
-export function isServiceResolver(resolver) {
-  return isRecord(resolver) && 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,
-    shapedbResolver,
-    utilResolver,
-    graphqlResolver,
-    restResolver,
-    awsLambdaResolver
-  }
-} = latestSchemaJson;
-export function isTakeshapeResolver(resolver) {
-  return isBasicResolver(resolver) && takeshapeResolver.properties.name.enum.includes(resolver.name);
-}
-export function isShapedbResolver(resolver) {
-  return isBasicResolver(resolver) && shapedbResolver.properties.name.enum.includes(resolver.name);
-}
-export function isGraphqlResolver(resolver) {
-  return isBasicResolver(resolver) && graphqlResolver.properties.name.enum.includes(resolver.name);
-}
-export function isRestResolver(resolver) {
-  return isBasicResolver(resolver) && restResolver.properties.name.enum.includes(resolver.name);
-}
-export function isAwsLambdaResolver(resolver) {
-  return isBasicResolver(resolver) && awsLambdaResolver.properties.name.enum.includes(resolver.name);
-}
-export function isUtilResolver(resolver) {
-  return isBasicResolver(resolver) && utilResolver.properties.name.enum.includes(resolver.name);
-}
-export const aiResolverNames = ['ai:generateText', 'ai:chat'];
-export function isAIResolverName(name) {
-  return name ? aiResolverNames.includes(name) : false;
-}
-export function isAIResolver(resolver) {
-  return isBasicResolver(resolver) && isAIResolverName(resolver.name);
-}
-export function isAIAgentStateExecution(agentExecution) {
-  return agentExecution.type === 'generate' || agentExecution.type === 'chat';
-}
-export function isProjectSchemaWithServices(schema) {
-  return !isUndefined(schema.services);
-}
-export function containsResolver(resolver, predicate) {
-  if (isBasicResolver(resolver)) {
-    return predicate(resolver);
-  }
-  return Boolean(resolver.compose.find(resolver => containsResolver(resolver, predicate)));
-}
-
-/** 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(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(maybeOp.ops);
-}
-
-/**
- * Determine whether a `ParameterOp` is a `ParameterOpMapping`
- */
-export function isParameterOpMapping(maybeOp) {
-  return Boolean(maybeOp.mapping);
-}
-
-/**
- * Determine whether a `ParameterOp` is a `ParameterOpValue`
- */
-export function isParameterOpValue(maybeOp) {
-  return Boolean(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));
-}
-const {
-  definitions: {
-    parameterSerializeStyleOptionsForSearchParams,
-    parameterSerializeStyleOptionsForPathParams
-  }
-} = latestSchemaJson;
-export function isParameterSerializeStyleForSearchParams(maybeParam) {
-  return Boolean(maybeParam && parameterSerializeStyleOptionsForSearchParams.properties.style.enum.includes(maybeParam));
-}
-export function isParameterSerializeStyleForPathParams(maybeParam) {
-  return Boolean(maybeParam && parameterSerializeStyleOptionsForPathParams.properties.style.enum.includes(maybeParam));
-}
-
-/**
- * Determine whether a ParameterSerializeOption is a style serializer
- */
-export function isParameterSerializeStyleOptions(maybeStyle) {
-  return Boolean(maybeStyle.style);
-}
-
-/** Typeguards for different types of shape schemas **/
-
-export function isRefSchema(propertySchema) {
-  return isString(propertySchema['@ref']) || isString(propertySchema.$ref);
-}
-export function isRefSchemaLegacy(propertySchema) {
-  return isString(propertySchema.$ref);
-}
-export function isAllOfSchema(propertySchema) {
-  return isArray(propertySchema.allOf);
-}
-export function isExtendsSchema(propertySchema) {
-  return isRecord(propertySchema) && isArray(propertySchema.extends);
-}
-export function isOneOfSchema(propertySchema) {
-  return isArray(propertySchema.oneOf);
-}
-export function isEnumSchema(obj) {
-  return isArray(obj.enum);
-}
-export function isArraySchema(propertySchema) {
-  return propertySchema.type === 'array' && isRecord(propertySchema.items);
-}
-export function isReturnShapeArraySchema(returnShape) {
-  return typeof returnShape === 'object' && returnShape.type === 'array';
-}
-export function isObjectSchema(propertySchema) {
-  return isRecord(propertySchema) && propertySchema.type === 'object' && isRecord(propertySchema.properties);
-}
-
-/** Service Config Utils **/
-
-/**
- * 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 isGraphQLServiceConfig(maybeConfig) {
-  return isAnyServiceConfig(maybeConfig) && maybeConfig.serviceType === 'graphql' && isString(maybeConfig.options?.endpoint);
-}
-export function isRESTServiceConfig(maybeConfig) {
-  return isAnyServiceConfig(maybeConfig) && maybeConfig.serviceType === 'rest';
-}
-export function isOpenAPIServiceConfig(maybeConfig) {
-  return isAnyServiceConfig(maybeConfig) && maybeConfig.serviceType === 'openapi';
-}
-export function isShopifyServiceConfig(maybeShopify) {
-  return maybeShopify.provider === 'shopify';
-}
-export function isEncryptedServiceConfig(maybeConfig) {
-  return isAnyServiceConfig(maybeConfig) && isString(maybeConfig.authentication);
-}
-export function isServiceConfigWithOAuth2Authentication(maybeServiceConfig) {
-  return isAnyServiceConfig(maybeServiceConfig) && isServiceAuthentication(maybeServiceConfig.authentication) && isOAuth2Authentication(maybeServiceConfig.authentication);
-}
-export function isServiceConfigWithCustomAuthentication(maybeServiceConfig) {
-  return isAnyServiceConfig(maybeServiceConfig) && isServiceAuthentication(maybeServiceConfig.authentication) && isCustomAuthentication(maybeServiceConfig.authentication);
-}
-
-/** Authentication Utils **/
-
-export function isServiceAuthentication(maybeAuthentication) {
-  return maybeAuthentication?.type;
-}
-export function isBearerAuthentication(authentication) {
-  return authentication?.type === 'bearer';
-}
-export function isBasicAuthentication(authentication) {
-  return authentication?.type === 'basic';
-}
-export function isSearchParamsAuthentication(authentication) {
-  return authentication?.type === 'searchParams';
-}
-export function isOAuth2Authentication(authentication) {
-  return authentication?.type === 'oauth2';
-}
-export function isOAuth2BearerAuthentication(authentication) {
-  return authentication?.type === 'oauth2Bearer';
-}
-export function isGoogleAuthentication(authentication) {
-  return authentication?.type === 'google';
-}
-export function isCustomAuthentication(authentication) {
-  return authentication?.type === 'custom';
-}
-
-/** Miscellaneous Utils **/
-
-/**
- * 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;
-  }
-};
-
-/**
- * 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;
-  }
-};
-export function isPropertySchemaWithRelationship(schema) {
-  return schema['@resolver']?.name === 'shapedb:getRelated';
-}
-export function listCachedShapes(shapes) {
-  return Object.values(shapes).filter(isCachedShape);
-}
-export function getCachedShapeMap(shapes) {
-  const results = {};
-  for (const shape of Object.values(shapes)) {
-    if (isCachedShape(shape)) {
-      results[shape.name] = shape;
-    }
-  }
-  return results;
-}
-export function isMeshShape(shape) {
-  return Boolean(shape.joins);
-}

package/es/unions.js

@@ -1,123 +0,0 @@
-import { camelCase, isRecord } from '@takeshape/util';
-import omit from 'lodash/omit';
-import { BadDataError } from '@takeshape/errors';
-import { getRef, refItemToNamespacedShapeName } from './refs';
-import { getContentTransform, toName } from './content-schema-transform';
-import { isRefSchema } from './types/utils';
-import { getShapeById } from './schema-util';
-import { getOutputShapeName } from './template-shapes/templates';
-export function enumerateOneOfKeys(projectSchema, oneOf) {
-  const result = [];
-  for (const child of oneOf) {
-    const refItem = getRef(projectSchema, child);
-    if (refItem) {
-      const shapeName = refItemToNamespacedShapeName(refItem);
-      if (projectSchema.shapes[shapeName]) {
-        const shapeId = projectSchema.shapes[shapeName].id;
-        result.push({
-          propName: getOutputShapeName(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) {
-  return Boolean(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 (isRecord(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 (isRecord(propValue)) {
-        const transformedPropValue = next(propValue, propSchema, name);
-        if (isRecord(transformedPropValue)) {
-          return {
-            ...transformedPropValue,
-            _shapeId: shapeId
-          };
-        }
-      }
-    }
-  }
-};
-
-// eslint-disable-next-line max-params
-export const createWrapTransform = projectSchema => (obj, schema, name, shape, next) => {
-  if (isRecord(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/user-schema.js

@@ -1 +0,0 @@
-export {};

package/es/util/ai-tools.js

@@ -1,8 +0,0 @@
-export function getToolRef(tool) {
-  return typeof tool === 'string' ? tool : tool.ref;
-}
-export function normalizeToolConfig(tool) {
-  return typeof tool === 'string' ? {
-    ref: tool
-  } : tool;
-}

package/es/util/api-indexing.js

@@ -1,66 +0,0 @@
-import { ensureArray } from '@takeshape/util';
-import { isServiceResolver } from '../types';
-import { getResolverServices } from '../services';
-import { getIdField, isCachedShape } from '../schema-util';
-import { getQuery } from '../refs';
-export function serviceHasIndexedShapes(schema, serviceId) {
-  for (const shape of Object.values(schema.shapes ?? {})) {
-    const indexingEnabled = isCachedShape(shape);
-    const listConfigs = shape.loaders?.list;
-    if (indexingEnabled && listConfigs) {
-      for (const {
-        query: queryRef
-      } of ensureArray(listConfigs)) {
-        const resolved = getQuery(schema, queryRef);
-        if (resolved && isServiceResolver(resolved.query.resolver) && resolved.query.resolver.service === serviceId) {
-          return true;
-        }
-      }
-    }
-  }
-  return false;
-}
-export function getIndexedServices(projectSchema, configs) {
-  return ensureArray(configs).reduce((services, queryConfig) => {
-    const resolved = queryConfig?.query ? getQuery(projectSchema, queryConfig.query) : undefined;
-    return resolved?.query ? [...services, ...getResolverServices(resolved.query.resolver)] : services;
-  }, []);
-}
-function flattenListQueryConfigs(base, queryConfig, maybeConfigArray) {
-  return maybeConfigArray && ensureArray(maybeConfigArray).flatMap(config => ensureArray(config.args).map(args => ({
-    ...base,
-    ...queryConfig,
-    ...config,
-    args
-  })));
-}
-function getQueryIndexConfigHelper(op) {
-  return ({
-    shapes
-  }, shapeName) => {
-    const {
-      cache,
-      loaders
-    } = shapes[shapeName] ?? {};
-    if (cache && loaders) {
-      const idField = getIdField(cache);
-      if (op === 'list') {
-        return flattenListQueryConfigs({
-          shapeName,
-          idField
-        }, cache.fragment, loaders.list);
-      }
-      const queryConfig = loaders.get;
-      if (queryConfig) {
-        return {
-          idField,
-          shapeName,
-          ...cache.fragment,
-          ...queryConfig
-        };
-      }
-    }
-  };
-}
-export const getListQueryIndexConfigs = getQueryIndexConfigHelper('list');
-export const getGetQueryIndexConfig = getQueryIndexConfigHelper('get');

package/es/util/detect-cycles.js

@@ -1,48 +0,0 @@
-import { value } from '@takeshape/util';
-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 determine whether a schema contains a cycle
- */
-export function hasCycle(projectSchema, schema, predicate = value(true)) {
-  const hasCycleHelper = (schema, shapesSeen = new Set(), shapeName, propName) => {
-    if (!predicate(projectSchema, schema, shapeName, propName)) {
-      return false;
-    }
-    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 hasCycleHelper(refShape.schema, immutableSetAdd(shapesSeen, refShape.name), refShape.name);
-    }
-    const combo = schema.oneOf ?? schema.allOf ?? schema.extends;
-    if (combo) {
-      return combo.some(childSchema => hasCycleHelper(childSchema, shapesSeen, shapeName, propName));
-    }
-    if (schema.items) {
-      return hasCycleHelper(schema.items, shapesSeen, shapeName, propName);
-    }
-    const {
-      properties
-    } = schema;
-    if (properties) {
-      return Object.keys(properties).some(name => {
-        const propSchema = properties[name];
-        return hasCycleHelper(propSchema, shapesSeen, shapeName, name);
-      });
-    }
-    return false;
-  };
-  return hasCycleHelper(schema);
-}

package/es/util/find-shape-at-path.js

@@ -1,55 +0,0 @@
-import { isArraySchema, isObjectSchema, isRefSchema } from '../types';
-import { getRef, refItemToShape, refItemToShapeSchema } from '../refs';
-
-/**
- *
- * @param projectSchema
- * @param schema
- * @param queryPath
- *
- * @example
- * findShapeAtPath(projectSchema, projectSchema.shapes.Shopify_ProductConnection.shape, ['edges', 'node']) // finds {'@ref': Shopify_Product}
- */
-export function findSchemaAtPath(projectSchema, schema, queryPath) {
-  if (queryPath.length === 0) {
-    return schema;
-  }
-  const [prop, ...rest] = queryPath;
-  if (isRefSchema(schema)) {
-    const ref = getRef(projectSchema, schema);
-    if (ref) {
-      const shapeSchema = refItemToShapeSchema(projectSchema, ref);
-      if (shapeSchema) {
-        return findSchemaAtPath(projectSchema, shapeSchema, queryPath);
-      }
-    }
-    return undefined;
-  }
-  if (isArraySchema(schema)) {
-    return findSchemaAtPath(projectSchema, schema.items, queryPath);
-  }
-  if (isObjectSchema(schema)) {
-    const propSchema = schema.properties[prop];
-    if (propSchema) {
-      return findSchemaAtPath(projectSchema, propSchema, rest);
-    }
-  }
-  return undefined;
-}
-
-/**
- *
- * @param projectSchema
- * @param propSchema
- * @param queryPath
- *
- * @example
- * findShapeAtPath(projectSchema, projectSchema.shapes.Shopify_ProductConnection.shape, ['edges', 'node']) // finds Shopify_Product
- */
-export function findShapeAtPath(projectSchema, propSchema, queryPath) {
-  const result = findSchemaAtPath(projectSchema, propSchema, queryPath);
-  if (result) {
-    const refItem = getRef(projectSchema, result.items ?? result);
-    return refItem && refItemToShape(projectSchema, refItem);
-  }
-}

package/es/util/form-config.js

@@ -1,73 +0,0 @@
-import { deepClone } from '@takeshape/util';
-import { getRefOrItemsRef, refItemToNamespacedShapeName } from '../refs';
-import { createSchemaPropertyAccessor } from '../schema-util';
-
-/**
- * If there any non-normal (nested) forms in the schema, create forms for referenced shapes.
- * The original forms are left intact.
- */
-export function normalizeForms(projectSchema) {
-  const normalizedForms = {};
-  const {
-    forms = {}
-  } = projectSchema;
-  const storeSourceForm = (shapeName, formConfig, propName) => {
-    // Leave original forms intact for backwards compatibility
-    if (!forms[shapeName]) {
-      normalizedForms[shapeName] ||= {
-        default: deepClone(formConfig)
-      };
-
-      // Remove prop now that it has been normalized
-      // eslint-disable-next-line @typescript-eslint/no-dynamic-delete
-      delete normalizedForms[shapeName].default.properties[propName];
-    }
-  };
-  const normalizeNested = (shapeName, formConfig) => {
-    const shape = projectSchema.shapes[shapeName];
-    if (!shape || !formConfig.properties) {
-      return;
-    }
-    const propertyAccessor = createSchemaPropertyAccessor(projectSchema, shape);
-    for (const propName of Object.keys(formConfig.properties)) {
-      const propConfig = formConfig.properties[propName];
-      const propSchema = propertyAccessor.getValue(propName);
-      if (propSchema) {
-        const ref = getRefOrItemsRef(projectSchema, propSchema);
-        if (ref && propConfig.properties) {
-          const nestedShapeName = refItemToNamespacedShapeName(ref);
-          normalizedForms[nestedShapeName] = {
-            default: deepClone(propConfig)
-          };
-          storeSourceForm(shapeName, formConfig, propName);
-          normalizeNested(nestedShapeName, propConfig);
-        }
-      }
-    }
-  };
-  if (forms) {
-    for (const shapeName of Object.keys(forms)) {
-      normalizeNested(shapeName, forms[shapeName].default);
-
-      // copy forms with no changes
-      normalizedForms[shapeName] ||= forms[shapeName];
-    }
-  }
-  return normalizedForms;
-}
-const cache = new WeakMap();
-
-/**
- * Find the form config for a given shape name and the form key.
- */
-export function findShapeFormConfig(projectSchema, shapeName, formName) {
-  if (!projectSchema.forms) {
-    return;
-  }
-  let normalizedForms = cache.get(projectSchema);
-  if (!normalizedForms) {
-    normalizedForms = normalizeForms(projectSchema);
-    cache.set(projectSchema, normalizedForms);
-  }
-  return normalizedForms[shapeName]?.[formName];
-}