@takeshape/schema 11.40.0 → 11.41.0

package/es/util/get-conflicting-properties.js

@@ -1,54 +0,0 @@
-import { isDefined, setIsEqual } from '@takeshape/util';
-import { dereferenceSchema, getRef, refItemToAtRef } from '../refs';
-import { isObjectSchema } from '../types';
-
-/**
- * Normalize ref, oneOf and array schemas and get a list of @ref expressions
- */
-function getRefStrings(context, propertySchema) {
-  const schema = propertySchema.items ?? propertySchema;
-  const schemas = schema.oneOf ? schema.oneOf : [schema];
-  return schemas.map(propertySchema => {
-    const ref = getRef(context, propertySchema);
-    return ref ? refItemToAtRef(ref) : undefined;
-  }).filter(isDefined);
-}
-function isRefEqual(context, a, b) {
-  return setIsEqual(getRefStrings(context, a), getRefStrings(context, b));
-}
-
-/**
- * Given a list of shapes find the conflicting props
- */
-export function getConflictingProperties(context, shapes) {
-  const conflicts = new Set();
-  const allProps = {};
-  for (const shape of Object.values(shapes)) {
-    const schema = dereferenceSchema(context, shape.schema, ['shapes', shape.name]);
-    if (!isObjectSchema(schema)) {
-      continue;
-    }
-    const required = new Set(schema.required ?? []);
-    for (const [name, prop] of Object.entries(schema.properties)) {
-      // skip props that we know already have  conflict
-      if (conflicts.has(name)) {
-        continue;
-      }
-      const isRequired = required.has(name);
-      if (allProps[name]) {
-        if (
-        // same type
-        allProps[name][0].type !== prop.type ||
-        // same refs
-        !isRefEqual(context, allProps[name][0], prop) ||
-        // same nullability
-        isRequired !== allProps[name][1]) {
-          conflicts.add(name);
-        }
-      } else {
-        allProps[name] = [prop, isRequired];
-      }
-    }
-  }
-  return conflicts;
-}

package/es/util/get-return-shape.js

@@ -1,31 +0,0 @@
-import { getRef, parseReturnShape, refItemToShape } from '../refs';
-function isQuery(propOrQuery) {
-  return 'shape' in propOrQuery && 'resolver' in propOrQuery;
-}
-function getReturnShapeHelper(projectSchema, propOrQuery) {
-  let shape;
-  if (isQuery(propOrQuery)) {
-    const {
-      shapeName
-    } = parseReturnShape(projectSchema, propOrQuery.shape);
-    shape = projectSchema.shapes[shapeName];
-  } else {
-    const ref = getRef(projectSchema, propOrQuery);
-    if (ref) {
-      shape = refItemToShape(projectSchema, ref);
-    }
-  }
-  return shape;
-}
-export function getReturnShapeRef(context, propOrQuery) {
-  return isQuery(propOrQuery) ? parseReturnShape(context, propOrQuery.shape).ref : getRef(context, propOrQuery);
-}
-const cache = new WeakMap();
-export function getReturnShape(projectSchema, propOrQuery) {
-  let result = cache.get(propOrQuery);
-  if (result === undefined) {
-    result = getReturnShapeHelper(projectSchema, propOrQuery);
-    cache.set(propOrQuery, result ?? null);
-  }
-  return result ?? undefined;
-}

package/es/util/has-arg.js

@@ -1,13 +0,0 @@
-import { findSchemaAtPath } from './find-shape-at-path';
-export function getArgs(prop) {
-  return '@args' in prop ? prop['@args'] : 'args' in prop ? prop.args : undefined;
-}
-export function hasArg(projectSchema, prop, argPath) {
-  const args = getArgs(prop);
-  if (!args) {
-    return false;
-  }
-  const schema = typeof args === 'string' ? projectSchema.shapes[args]?.schema : args;
-  const pathArray = Array.isArray(argPath) ? argPath : argPath.split('.');
-  return Boolean(findSchemaAtPath(projectSchema, schema, pathArray));
-}

package/es/util/index.js

@@ -1,10 +0,0 @@
-export * from './api-indexing';
-export * from './detect-cycles';
-export * from './find-shape-at-path';
-export * from './get-conflicting-properties';
-export * from './get-return-shape';
-export * from './has-arg';
-export * from './merge';
-export * from './form-config';
-export * from './patch-schema';
-export * from './ai-tools';

package/es/util/merge.js

@@ -1,293 +0,0 @@
-import { deepClone, isDefined, rebaseArray, rebaseObject, assert } from '@takeshape/util';
-import union from 'lodash/union';
-import difference from 'lodash/difference';
-import isEqual from 'lodash/isEqual';
-import unset from 'lodash/unset';
-import set from 'lodash/set';
-import last from 'lodash/last';
-import omit from 'lodash/omit';
-import pickBy from 'lodash/pickBy';
-import { assignWith } from 'lodash';
-import { isExtendsSchema, isObjectSchema, isRefSchema } from '../types';
-export function mergeObjectSchemas(...args) {
-  return args.filter(isDefined).reduce((parent, schemas) => mergeSchemaProperties(parent, schemas), {
-    type: 'object',
-    properties: {}
-  });
-}
-export function mergeDeepObjectSchemas(...args) {
-  return args.filter(isDefined).reduce((parent, schemas) => mergeSchemaProperties(parent, schemas, true), {
-    type: 'object',
-    properties: {}
-  });
-}
-export function mergeSchemaProperties(parent, overrides, deep = false) {
-  const result = {
-    ...parent,
-    properties: deep ? assignWith({}, parent.properties, overrides.properties, (objValue, srcValue) => {
-      // merge objects if possible
-      if (objValue !== undefined && srcValue !== undefined) {
-        if (isObjectSchema(objValue) && isObjectSchema(srcValue)) {
-          return mergeObjectSchemas(objValue, srcValue);
-        }
-        if ((isObjectSchema(objValue) || isRefSchema(objValue)) && (isObjectSchema(srcValue) || isRefSchema(srcValue))) {
-          return {
-            allOf: [objValue, srcValue]
-          };
-        }
-      }
-    }) : {
-      ...parent.properties,
-      ...overrides.properties
-    }
-  };
-  const required = union(parent.required, overrides.required);
-  if (required.length) {
-    result.required = required;
-  }
-  return result;
-}
-export function rebaseSchemaProperties(base, parent, head) {
-  const {
-    properties: toProperties,
-    required: toRequired,
-    ...toOther
-  } = base;
-  const {
-    properties: baseProperties,
-    required: baseRequired,
-    ...baseOther
-  } = parent;
-  const {
-    properties: fromProperties,
-    required: fromRequired,
-    ...fromOther
-  } = head;
-  const newSchema = {
-    ...rebaseObject(toOther, baseOther, fromOther),
-    type: 'object',
-    properties: rebaseObject(toProperties, baseProperties, fromProperties)
-  };
-  const required = rebaseArray(toRequired ?? [], baseRequired ?? [], fromRequired ?? []);
-  if (required.length) {
-    newSchema.required = required;
-  }
-  return newSchema;
-}
-export function mergeFormProperties(parent, overrides) {
-  const result = {
-    ...parent,
-    properties: {
-      ...parent.properties,
-      ...overrides.properties
-    }
-  };
-  const order = union(parent.order, overrides.order);
-  if (order.length) {
-    result.order = order;
-  }
-  return result;
-}
-export function rebaseFormProperties(base, parent, head) {
-  const {
-    properties: toProperties,
-    order: toOrder,
-    ...toOther
-  } = base;
-  const {
-    properties: baseProperties,
-    order: baseOrder,
-    ...baseOther
-  } = parent;
-  const {
-    properties: fromProperties,
-    order: fromOrder,
-    ...fromOther
-  } = head;
-  const newForm = {
-    ...rebaseObject(toOther, baseOther, fromOther),
-    properties: rebaseObject(toProperties, baseProperties, fromProperties)
-  };
-  const order = rebaseArray(toOrder ?? [], baseOrder ?? [], fromOrder ?? []);
-  if (order.length) {
-    newForm.order = order;
-  }
-  return newForm;
-}
-export function mergeFormConfigs(...configs) {
-  return configs.reduce(mergeFormProperties, {
-    properties: {},
-    order: []
-  });
-}
-const mergeableSections = ['shapes', 'mutations', 'queries', 'forms', 'services'];
-const isMergeableSection = str => {
-  return mergeableSections.includes(str);
-};
-const pickUnmergeable = projectSchema => {
-  return pickBy(projectSchema, (_value, key) => !isMergeableSection(key));
-};
-function compareSection(section, original, updated) {
-  const changes = [];
-  const originalKeys = Object.keys(original);
-  const updatedKeys = Object.keys(updated);
-  for (const removedKey of difference(originalKeys, updatedKeys)) {
-    changes.push({
-      path: [section, removedKey],
-      section,
-      op: 'remove'
-    });
-  }
-  for (const [key, value] of Object.entries(updated)) {
-    if (!original[key]) {
-      changes.push({
-        path: [section, key],
-        section,
-        op: 'add',
-        value
-      });
-    } else if (!isEqual(original[key], updated[key])) {
-      changes.push({
-        path: [section, key],
-        section,
-        op: 'update',
-        value
-      });
-    }
-  }
-  return changes;
-}
-function compareSections(parent, branch) {
-  return mergeableSections.flatMap(section => parent[section] ?? branch[section] ? compareSection(section, parent[section] ?? {}, branch[section] ?? {}) : []);
-}
-function findChangedShape(schema, change) {
-  return schema.shapes[change.path[1]];
-}
-function getChangedShape(schema, change) {
-  const shape = findChangedShape(schema, change);
-  assert(shape, 'Expected shape not found');
-  return shape;
-}
-function rebaseShapeProperties(toShape, fromShape, baseShape) {
-  return baseShape ? rebaseObject(omit(toShape, 'schema'), omit(baseShape, 'schema'), omit(fromShape, 'schema')) : {
-    ...toShape,
-    ...fromShape
-  };
-}
-
-// eslint-disable-next-line complexity
-function attemptToMerge(base, parent, head, change) {
-  const toShape = getChangedShape(base, change);
-  const fromShape = getChangedShape(head, change);
-  const toSchema = toShape.schema;
-  const fromSchema = fromShape.schema;
-  if (isEqual(toSchema, fromSchema)) {
-    const baseShape = findChangedShape(parent, change);
-    return {
-      ...rebaseShapeProperties(toShape, fromShape, baseShape),
-      schema: toSchema
-    };
-  }
-  if (isObjectSchema(toSchema) && isObjectSchema(fromSchema)) {
-    const baseShape = findChangedShape(parent, change);
-    const baseSchema = baseShape?.schema;
-    return {
-      ...rebaseShapeProperties(toShape, fromShape, baseShape),
-      schema: change.op === 'update' && baseSchema && isObjectSchema(baseSchema) ? rebaseSchemaProperties(toSchema, baseSchema, fromSchema) : mergeSchemaProperties(toSchema, fromSchema)
-    };
-  }
-  if (isExtendsSchema(toSchema) && isExtendsSchema(fromSchema) && toSchema.extends.length === fromSchema.extends.length) {
-    const fromExtends = fromSchema.extends;
-    const toObj = last(toSchema.extends);
-    const fromObj = last(fromSchema.extends);
-    if (toObj && isObjectSchema(toObj) && fromObj && isObjectSchema(fromObj) && toSchema.extends.slice(0, toSchema.extends.length - 1).every((item, i) => isEqual(item, fromExtends[i]))) {
-      let mergedObjSchema;
-      const baseShape = findChangedShape(parent, change);
-      const baseSchema = baseShape?.schema;
-      if (change.op === 'update' && baseSchema && isExtendsSchema(baseSchema)) {
-        const baseObj = last(baseSchema.extends);
-        if (baseObj && isObjectSchema(baseObj)) {
-          mergedObjSchema = rebaseSchemaProperties(toObj, baseObj, fromObj);
-        }
-      }
-      mergedObjSchema ||= mergeSchemaProperties(toObj, fromObj);
-      return {
-        ...rebaseShapeProperties(toShape, fromShape, baseShape),
-        schema: {
-          extends: [...toSchema.extends.slice(0, toSchema.extends.length - 1), mergedObjSchema]
-        }
-      };
-    }
-  }
-}
-function applyChange(base, parent, head, change) {
-  if (change.op === 'remove') {
-    unset(base, change.path);
-  } else if (change.op === 'add') {
-    set(base, change.path, change.value);
-  } else if (change.op === 'update') {
-    if (change.section === 'shapes') {
-      const mergedShape = attemptToMerge(base, parent, head, change);
-      if (mergedShape) {
-        set(base, change.path, mergedShape);
-        return;
-      }
-    } else if (change.section === 'forms') {
-      const shapeName = change.path[1];
-      const toForm = base.forms?.[shapeName]?.default;
-      const fromForm = head.forms?.[shapeName]?.default;
-      if (toForm && fromForm) {
-        const baseForm = parent.forms?.[shapeName]?.default;
-        set(base, change.path, {
-          default: baseForm ? rebaseFormProperties(toForm, baseForm, fromForm) : mergeFormConfigs(toForm, fromForm)
-        });
-        return;
-      }
-    }
-    set(base, change.path, change.value);
-  }
-}
-export function mergeProjectSchemas(base, parent, head) {
-  const changesTo = compareSections(parent, base);
-  const changesFrom = compareSections(parent, head);
-  const mergedSchema = deepClone(base);
-  for (let change of changesFrom) {
-    const potentialConflict = changesTo.find(changeTo => isEqual(changeTo.path, change.path));
-    if (potentialConflict) {
-      if (potentialConflict.op === 'remove' && change.op !== 'remove') {
-        return {
-          error: `Attempting to ${change.op} ${change.path.join('.')} which has already been removed`,
-          mergedSchema: undefined
-        };
-      }
-      if (potentialConflict.op === 'add' && change.op === 'add' || potentialConflict.op === 'update' && change.op === 'update') {
-        if (change.section === 'shapes') {
-          const mergedValue = attemptToMerge(base, parent, head, change);
-          // eslint-disable-next-line max-depth
-          if (!mergedValue) {
-            return {
-              error: `Unable to merge ${change.path.join('.')} schemas conflict`,
-              mergedSchema: undefined
-            };
-          }
-          change = {
-            ...change,
-            op: 'add',
-            value: mergedValue
-          };
-        } else if (change.section === 'forms') {
-          change = {
-            ...change,
-            op: 'update'
-          };
-        }
-      }
-    }
-    applyChange(mergedSchema, parent, head, change);
-  }
-  Object.assign(mergedSchema, rebaseObject(pickUnmergeable(base), pickUnmergeable(parent), pickUnmergeable(head)));
-  return {
-    error: undefined,
-    mergedSchema
-  };
-}

package/es/util/patch-schema.js

@@ -1,44 +0,0 @@
-import forIn from 'lodash/forIn';
-import omit from 'lodash/omit';
-const schemaUpdateMergedKeys = ['queries', 'mutations', 'shapes', 'workflows', 'forms', 'services'];
-export function shallowMerge(original, update) {
-  const result = {
-    ...original
-  };
-  if (update) {
-    forIn(update, (obj, key) => {
-      // Null is a sentinel value to indicate delete
-      if (obj === null) {
-        // eslint-disable-next-line @typescript-eslint/no-dynamic-delete
-        delete result[key];
-      } else {
-        result[key] = obj;
-      }
-    });
-  }
-  return result;
-}
-
-/**
- * Apply a schema update to a schema.
- * Resulting schema is not assumed to be valid and should be validated if appropriate.
- */
-export function patchSchema(projectSchema, update) {
-  // Patch old schema with update
-  const updatedSchema = {
-    ...projectSchema,
-    ...omit(update, [...schemaUpdateMergedKeys, 'ai-experimental'])
-  };
-  for (const key of schemaUpdateMergedKeys) {
-    if (update[key]) {
-      updatedSchema[key] = shallowMerge(projectSchema[key], update[key]);
-    }
-  }
-  if (update['ai-experimental']?.agents) {
-    const ai = {
-      agents: shallowMerge(projectSchema['ai-experimental']?.agents, update['ai-experimental'].agents)
-    };
-    updatedSchema['ai-experimental'] = ai;
-  }
-  return updatedSchema;
-}