@takeshape/schema 7.194.0

package/es/schema-util.js

@@ -0,0 +1,1197 @@
+import find from 'lodash/find';
+import mapValues from 'lodash/mapValues';
+import omitBy from 'lodash/omitBy';
+import omit from 'lodash/fp/omit';
+import assign from 'lodash/fp/assign';
+import pickBy from 'lodash/pickBy';
+import get from 'lodash/get';
+import union from 'lodash/union';
+import keyBy from 'lodash/keyBy';
+import isEmpty from 'lodash/isEmpty';
+import isObject from 'lodash/isObject';
+import curry from 'lodash/fp/curry';
+import orderBy from 'lodash/fp/orderBy';
+import uniq from 'lodash/uniq';
+import { deepClone, isDefined } from '@takeshape/util';
+import { mergeWithArrayConcat } from '@takeshape/util/lib/merge';
+import { defaultWorkflow, getStatusField } from './workflows';
+import { CURRENT_API_VERSION, CURRENT_SCHEMA_VERSION } from './versions';
+import { workflowsEnabled } from './api-version';
+import { builtInShapes, builtInForms } from './builtin-schema';
+import { createTemplateShapeName, parseReturnShape } from './template-shapes';
+import { getArgsType, isObjectSchema, isAllOfSchema, isRefSchema, isOneOfSchema, isContentObjectSchema, isBasicResolver } from './types';
+import { getStoredServiceConfig } from './services';
+import { followRef, getRef, getRefOrItemsRef, getRefShapeName, getRefWithPath, omitRefAndExtend, refExpressionToRefItem, refItemToShape, refItemToShapeName, refItemToShapeSchema } from './refs';
+import isEqual from 'lodash/isEqual';
+export const SERVICE_OBJECT_PATTERN_NAME = 'pattern:service-object';
+export function isBuiltinShape(shapeName) {
+  return Boolean(builtInShapes[shapeName]);
+}
+const builtInQueriesAndMutations = getShapeQueriesAndMutations(Object.values(builtInShapes));
+export function isBuiltinQuery(name) {
+  return builtInQueriesAndMutations.queries[name] !== undefined;
+}
+export function isBuiltinMutation(name) {
+  return builtInQueriesAndMutations.mutations[name] !== undefined;
+}
+export function isBuiltinType(projectSchema, refSchema) {
+  const shapeName = getRefShapeName(projectSchema, refSchema);
+  return shapeName !== undefined && isBuiltinShape(shapeName);
+}
+export const schemaMetadataKeys = ['$comment', 'title', 'description', '@l10n', '@deprecationReason', '@tag', '@tags', '@syncLocaleStructure', '@sensitive'];
+export const commonSchemaKeys = ['type', 'default', 'readOnly', ...schemaMetadataKeys];
+export const scalarSchemaKeys = [...commonSchemaKeys, 'format', 'oneOf', 'multipleOf', 'maximum', 'exclusiveMaximum', 'minimum', 'exclusiveMinimum', 'maxLength', 'minLength', 'pattern'];
+export const objectSchemaKeys = [...commonSchemaKeys, 'properties', 'required'];
+export const arraySchemaKeys = [...commonSchemaKeys, 'items', 'additionalItems', 'maxItems', 'minItems', 'uniqueItems'];
+export const multipleRelationshipSchemaKeys = [...schemaMetadataKeys, 'maxItems', 'minItems']; // all properties except properties, items, additionalItems
+
+export const nonStructuralSchemaKeys = [...scalarSchemaKeys, '@relationship', 'required', 'maxItems', 'minItems', 'uniqueItems'];
+const commonProperties = {
+  _id: {
+    title: 'Id',
+    type: 'string'
+  },
+  _version: {
+    title: 'Version',
+    type: 'integer'
+  },
+  _shapeId: {
+    title: 'Shape Id',
+    type: 'string'
+  },
+  _shapeName: {
+    title: 'Shape Name',
+    type: 'string'
+  },
+  _createdAt: {
+    title: 'Created',
+    type: 'string',
+    format: 'date-time'
+  },
+  _createdBy: {
+    title: 'Created By',
+    type: 'string',
+    '@user': true
+  },
+  _updatedAt: {
+    title: 'Updated',
+    type: 'string',
+    format: 'date-time'
+  },
+  _updatedBy: {
+    title: 'Updated By',
+    type: 'string',
+    '@user': true
+  },
+  _schemaVersion: {
+    title: 'Schema Version',
+    type: 'number'
+  }
+};
+export function getServiceIdFieldName(serviceFieldName) {
+  return `${serviceFieldName}Id`;
+}
+const generatorVersions = {
+  [SERVICE_OBJECT_PATTERN_NAME]: '1'
+};
+export function getGeneratorVersion(generator) {
+  return generatorVersions[generator];
+} // Returns info for all services found in shape, keyed by provider
+
+export function getServiceInfo(projectSchema, shape) {
+  const result = {};
+  const depShapes = getShapeDependencies(projectSchema, shape).map(name => projectSchema.shapes[name]);
+  const shapesToCheck = [shape, ...depShapes];
+  shapesToCheck.forEach(thisShape => {
+    createSchemaPropertyList(projectSchema, thisShape.schema).forEach(([key, value]) => {
+      const resolver = value['@resolver'];
+
+      if (!isBasicResolver(resolver)) {
+        return;
+      }
+
+      const serviceConfig = getStoredServiceConfig(projectSchema, resolver.service);
+
+      if (!serviceConfig) {
+        return;
+      }
+
+      const provider = serviceConfig.provider;
+      const generators = {};
+      const tag = value['@tag'];
+
+      if (tag !== null && tag !== void 0 && tag.startsWith(SERVICE_OBJECT_PATTERN_NAME)) {
+        var _resolver$options;
+
+        const idFieldName = getServiceIdFieldName(key);
+        const version = tag.substr(tag.lastIndexOf(':') + 1);
+        generators[SERVICE_OBJECT_PATTERN_NAME] = {
+          version,
+          currentVersion: getGeneratorVersion(SERVICE_OBJECT_PATTERN_NAME),
+          idFieldName,
+          serviceObjectType: (_resolver$options = resolver.options) === null || _resolver$options === void 0 ? void 0 : _resolver$options.fieldName
+        };
+      }
+
+      const serviceInfo = {
+        service: resolver.service,
+        fieldName: key,
+        path: pathBetween(shape, thisShape, projectSchema),
+        generators
+      };
+
+      if (Array.isArray(result[provider])) {
+        // dedupe service info
+        if (!result[provider].find(existingServiceInfo => isEqual(existingServiceInfo, serviceInfo))) {
+          result[provider].push(serviceInfo);
+        }
+      } else {
+        result[provider] = [serviceInfo];
+      }
+    });
+  });
+  return result;
+} // Follow refs to find the path between two shapes in a schema
+
+export function pathBetween(fromShape, toShape, projectSchema) {
+  if (fromShape.name === toShape.name) {
+    return [];
+  }
+
+  const toShapeName = toShape.name;
+  let shortestPath;
+  let shortestPathLength = Number.MAX_SAFE_INTEGER;
+
+  const pathBetweenHelper = (schema, pathSoFar, seen) => {
+    const refItem = getRefOrItemsRef(projectSchema, schema);
+
+    if (refItem) {
+      const referenced = refItemToShape(projectSchema, refItem);
+
+      if (referenced) {
+        if (referenced.name === toShapeName && pathSoFar.length < shortestPathLength) {
+          shortestPath = pathSoFar;
+          shortestPathLength = pathSoFar.length;
+        } else if (!seen.has(referenced.name)) {
+          pathBetweenHelper(referenced.schema, pathSoFar, new Set([...seen, referenced.name]));
+        }
+      }
+    } else if (pathSoFar.length + 1 < shortestPathLength && (schema.oneOf || schema.allOf || schema.properties)) {
+      if (schema.oneOf) {
+        for (const itemSchema of schema.oneOf) {
+          pathBetweenHelper(itemSchema, pathSoFar, seen);
+        }
+      } else {
+        for (const [propName, propSchema] of createSchemaPropertyList(projectSchema, schema).getNodes()) {
+          pathBetweenHelper(propSchema, pathSoFar.concat(String(propName)), seen);
+        }
+      }
+    }
+  };
+
+  pathBetweenHelper(fromShape.schema, [], new Set([fromShape.name]));
+
+  if (!shortestPath) {
+    throw new Error(`No path between ${fromShape.name} and ${toShape.name}`);
+  }
+
+  return shortestPath;
+}
+export function getShapeQueriesAndMutations(shapeList) {
+  const queries = {};
+  const mutations = {};
+
+  for (const shape of shapeList) {
+    const {
+      name,
+      model
+    } = shape;
+    const service = stringifyQuerySource('takeshape', 'local');
+
+    if (model) {
+      const isSingleton = model.type === 'single';
+      queries[`get${name}`] = {
+        shape: name,
+        resolver: {
+          name: 'takeshape:get',
+          service,
+          options: {
+            model: name
+          }
+        },
+        description: `Get a ${name} by ID`,
+        args: isSingleton ? createTemplateShapeName('TSGetSingletonArgs', name) : createTemplateShapeName('TSGetArgs', name)
+      };
+      mutations[`update${name}`] = {
+        shape: createTemplateShapeName('UpdateResult', name),
+        resolver: {
+          name: 'takeshape:update',
+          service,
+          options: {
+            model: name
+          }
+        },
+        description: `Update ${name}`,
+        args: createTemplateShapeName('UpdateArgs', name)
+      };
+
+      if (!isSingleton) {
+        queries[`get${name}List`] = {
+          shape: createTemplateShapeName('PaginatedList', name),
+          resolver: {
+            name: 'takeshape:list',
+            service,
+            options: {
+              model: name
+            }
+          },
+          description: `Returns a list ${name} in natural order.`,
+          args: createTemplateShapeName('TSListArgs', name)
+        };
+        mutations[`create${name}`] = {
+          shape: createTemplateShapeName('CreateResult', name),
+          resolver: {
+            name: 'takeshape:create',
+            service,
+            options: {
+              model: name
+            }
+          },
+          description: `Create ${name}`,
+          args: createTemplateShapeName('CreateArgs', name)
+        };
+        mutations[`duplicate${name}`] = {
+          shape: createTemplateShapeName('DuplicateResult', name),
+          resolver: {
+            name: 'takeshape:duplicate',
+            service,
+            options: {
+              model: name
+            }
+          },
+          description: `Duplicate ${name}`,
+          args: createTemplateShapeName('DuplicateArgs', name)
+        };
+        mutations[`delete${name}`] = {
+          shape: createTemplateShapeName('DeleteResult', name),
+          resolver: {
+            name: 'takeshape:delete',
+            service,
+            options: {
+              model: name
+            }
+          },
+          description: `Delete ${name}`,
+          args: createTemplateShapeName('DeleteArgs', name)
+        };
+      }
+    }
+  }
+
+  return {
+    queries,
+    mutations
+  };
+}
+export function getBuiltInProperties(apiVersion = CURRENT_API_VERSION) {
+  const showV1Deprecation = apiVersion !== '1';
+  return { ...commonProperties,
+    _enabled: {
+      title: 'Enabled',
+      type: 'boolean',
+      '@deprecationReason': showV1Deprecation ? 'Use _status instead' : undefined
+    },
+    _enabledAt: {
+      title: 'Enabled Date',
+      type: 'string',
+      format: 'date-time',
+      '@deprecationReason': showV1Deprecation ? 'Use a custom date field instead' : undefined
+    }
+  };
+}
+/**
+ * Return all the built in property names,
+ */
+
+export const getBuiltInPropertyNames = (apiVersion = CURRENT_API_VERSION) => new Set([...Object.keys(getBuiltInProperties()), workflowsEnabled(apiVersion) ? '_status' : undefined].filter(isDefined));
+export function applyBuiltinPropertiesToShape(projectSchema, shape) {
+  return { ...shape,
+    schema: { ...shape.schema,
+      properties: { ...omitBy(dereferenceObjectSchema(projectSchema, shape.schema).properties, (_, name) => name.startsWith('_')),
+        ...getBuiltInProperties(projectSchema.apiVersion),
+        ...(workflowsEnabled(projectSchema.apiVersion) && {
+          _status: getStatusField(projectSchema.workflows, shape)
+        })
+      }
+    }
+  };
+}
+export function mergeSchemaProperties(base, overrides) {
+  const result = { ...base,
+    properties: { ...base.properties,
+      ...overrides.properties
+    }
+  };
+  const required = union(base.required, overrides.required);
+
+  if (required.length) {
+    result.required = required;
+  }
+
+  return result;
+}
+export function mergeFormProperties(base, overrides) {
+  const result = { ...base,
+    properties: { ...base.properties,
+      ...overrides.properties
+    }
+  };
+  const order = union(base.order, overrides.order);
+
+  if (order.length) {
+    result.order = order;
+  }
+
+  return result;
+}
+export function applyDefaultsToSchema(projectSchema) {
+  return { ...projectSchema,
+    workflows: { ...projectSchema.workflows,
+      ...(workflowsEnabled(projectSchema.apiVersion) && {
+        default: defaultWorkflow
+      })
+    },
+    queries: { ...builtInQueriesAndMutations.queries,
+      ...projectSchema.queries
+    },
+    mutations: { ...builtInQueriesAndMutations.mutations,
+      ...projectSchema.mutations
+    },
+    shapes: mapValues({ ...builtInShapes,
+      ...projectSchema.shapes
+    }, shape => {
+      const builtInShape = builtInShapes[shape.name];
+
+      if (builtInShape && builtInShape !== shape) {
+        shape = { ...shape,
+          schema: mergeSchemaProperties(dereferenceObjectSchema(projectSchema, shape.schema), dereferenceObjectSchema(projectSchema, builtInShape.schema))
+        };
+      }
+
+      return isModelShape(shape) ? applyBuiltinPropertiesToShape(projectSchema, shape) : shape;
+    }),
+    forms: mapValues({ ...builtInForms,
+      ...projectSchema.forms
+    }, (formsConfig, shapeName) => {
+      const builtInFormsConfig = builtInForms[shapeName];
+
+      if (builtInFormsConfig && builtInFormsConfig !== formsConfig) {
+        formsConfig = { ...formsConfig,
+          default: mergeFormProperties(formsConfig.default, builtInFormsConfig.default)
+        };
+      }
+
+      return formsConfig;
+    })
+  };
+}
+
+function addRelationship(relationships, id, env) {
+  if (!relationships[id]) {
+    relationships[id] = [];
+  }
+
+  relationships[id].push(env);
+}
+/**
+ * Finds all relationships in the schema and returns an object indexed by shape.id that lists all of the shapes
+ * properties that reference it
+ */
+
+
+export function findExistingRelationships(projectSchema, shapes) {
+  const relationships = {};
+  const shapeArray = Object.values(shapes);
+  const shapesSeen = new Set();
+  const shapeIds = new Set(shapeArray.map(shape => shape.id));
+
+  const findRelationships = (schema, path) => {
+    const shapeName = getRefShapeName(projectSchema, schema);
+
+    if (shapeName && !shapes[shapeName]) {
+      return;
+    }
+
+    const prop = shapeName ? followRef(projectSchema, schema) : schema;
+
+    if (prop['@relationship']) {
+      const {
+        shapeIds: relatedShapeIds,
+        relatedName
+      } = prop['@relationship'];
+
+      for (const shapeId of relatedShapeIds) {
+        if (shapeIds.has(shapeId)) {
+          addRelationship(relationships, shapeId, {
+            relatedName,
+            path: path.slice(1),
+            shapeId: path[0]
+          });
+        }
+      }
+    }
+
+    if (shapeName) {
+      // skip shapes we have already seen to avoid cycles
+      if (shapesSeen.has(shapeName)) {
+        return;
+      }
+
+      shapesSeen.add(shapeName);
+    }
+
+    if (prop.properties) {
+      for (const name of Object.keys(prop.properties)) {
+        findRelationships(prop.properties[name], path.concat(name));
+      }
+    } else if (prop.items) {
+      findRelationships(prop.items, path);
+    }
+  };
+
+  for (const shape of shapeArray) {
+    if (isModelShape(shape)) {
+      const {
+        schema,
+        id
+      } = shape;
+      findRelationships(schema, [id]);
+    }
+  }
+
+  return relationships;
+}
+export function stringifyQuerySource(providerId, serviceId) {
+  return `${providerId}:${serviceId}`;
+}
+export function parseQuerySource(source) {
+  const [providerId, serviceId] = source.split(':');
+  return {
+    providerId,
+    serviceId
+  };
+}
+export function parseQueryResolver(resolver) {
+  const [providerId, verb] = resolver.split(':');
+  return {
+    providerId,
+    verb
+  };
+}
+export function getShapeById(projectSchema, shapeId) {
+  return find(projectSchema.shapes, shape => shape.id === shapeId);
+}
+export function isModelShape(shape) {
+  return Boolean(shape.model);
+}
+export function getArgsReference(projectSchema, argsSchema) {
+  var _argsSchema$Args;
+
+  const args = (_argsSchema$Args = argsSchema['@args']) !== null && _argsSchema$Args !== void 0 ? _argsSchema$Args : argsSchema.args;
+
+  if (args && typeof args === 'string') {
+    // @args: ShapeName OR Namespace_TypeName
+    return refExpressionToRefItem(projectSchema, args);
+  }
+}
+export function getArgsReferenceWithPath(projectSchema, argsSchema, schemaPath = []) {
+  const refItem = getArgsReference(projectSchema, argsSchema);
+
+  if (refItem) {
+    const argsType = getArgsType(argsSchema);
+    return { ...refItem,
+      path: schemaPath.concat([argsType])
+    };
+  }
+}
+export function getArgsShapeSchema(projectSchema, argsSchema) {
+  var _argsSchema$Args2;
+
+  const args = (_argsSchema$Args2 = argsSchema['@args']) !== null && _argsSchema$Args2 !== void 0 ? _argsSchema$Args2 : argsSchema.args;
+
+  if (args && typeof args === 'string') {
+    const refItem = getArgsReference(projectSchema, argsSchema);
+
+    if (refItem) {
+      return refItemToShapeSchema(projectSchema, refItem);
+    }
+  } else if (args) {
+    return 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);
+
+const createShapeToContentSchema = (projectSchema, definitions, definitionNames, useShapeIdDiscriminator = true) => {
+  const rewriteRefs = (shape, addDiscriminator = false) => {
+    const shapeSchemaCopy = dereferenceObjectSchema(projectSchema, deepClone(shape.schema));
+
+    if (useShapeIdDiscriminator) {
+      if (addDiscriminator && shapeSchemaCopy.properties) {
+        shapeSchemaCopy.properties._shapeId = {
+          type: 'string',
+          enum: [shape.id]
+        };
+      }
+
+      if (addDiscriminator && shape.title) {
+        shapeSchemaCopy.title = shape.title;
+      }
+    }
+
+    const handleSchema = (propSchema, addDiscriminator = false) => {
+      var _propSchema$items;
+
+      // unwrap array schema
+      propSchema = (_propSchema$items = propSchema.items) !== null && _propSchema$items !== void 0 ? _propSchema$items : propSchema;
+
+      if (isOneOfSchema(propSchema)) {
+        propSchema.oneOf.forEach(schema => {
+          handleSchema(schema, true);
+        });
+        return;
+      } // Add workflow validation
+
+
+      if (propSchema['@workflow']) {
+        const workflowName = propSchema['@workflow'];
+        const workflow = projectSchema.workflows[workflowName] || defaultWorkflow;
+        propSchema.oneOf = workflow.steps.map(step => ({
+          enum: [step.key, step.name],
+          title: step.title
+        }));
+      }
+
+      const refItem = getRef(projectSchema, propSchema);
+
+      if (refItem) {
+        const shapeName = refItemToShapeName(refItem);
+        const shape = refItemToShape(projectSchema, refItem);
+
+        if (shape) {
+          delete propSchema['@ref'];
+          propSchema.$ref = `#/definitions/${shapeName}`;
+
+          if (!definitionNames.has(shapeName)) {
+            definitionNames.add(shapeName);
+            definitions[shapeName] = rewriteRefs(shape, addDiscriminator);
+          }
+        }
+      }
+    };
+
+    Object.values(shapeSchemaCopy.properties).forEach(schema => {
+      handleSchema(schema);
+    });
+    return shapeSchemaCopy;
+  };
+
+  return rewriteRefs;
+};
+
+export function shapeToContentSchema(projectSchema, shape) {
+  const definitions = {};
+  const definitionNames = new Set();
+  const convert = createShapeToContentSchema(projectSchema, definitions, definitionNames);
+  return { ...convert(shape),
+    definitions
+  };
+}
+export function projectSchemaToJSONSchema(projectSchema) {
+  const definitions = {};
+  const definitionNames = new Set();
+  const convert = createShapeToContentSchema(projectSchema, definitions, definitionNames, false);
+
+  for (const shape of Object.values(projectSchema.shapes)) {
+    definitions[shape.name] = convert(shape);
+    definitionNames.add(shape.name);
+  }
+
+  return {
+    definitions
+  };
+}
+export function getShapeDependencies(projectSchema, shape) {
+  const shapeNames = new Set();
+
+  const findDependencies = schema => {
+    var _schema$items;
+
+    schema = (_schema$items = schema.items) !== null && _schema$items !== void 0 ? _schema$items : schema;
+    const refItem = getRef(projectSchema, schema);
+
+    if (refItem) {
+      const refShape = refItemToShape(projectSchema, refItem);
+
+      if (refShape && !shapeNames.has(refShape.name)) {
+        shapeNames.add(refShape.name);
+        findDependencies(dereferenceSchema(projectSchema, refShape.schema));
+      }
+    } else if (isObjectSchema(schema) || isAllOfSchema(schema) || isOneOfSchema(schema)) {
+      visitSchemaProperties(schema, [], findDependencies);
+    }
+  };
+
+  findDependencies(shape.schema);
+  return [...shapeNames];
+}
+export function getRelevantShapes(projectSchema, params) {
+  const {
+    shapeIds,
+    shapeNames,
+    byId = false,
+    includeDependencies = true
+  } = params;
+
+  if (shapeNames !== null && shapeNames !== void 0 && shapeNames.length || shapeIds !== null && shapeIds !== void 0 && shapeIds.length) {
+    const ids = new Set(shapeIds);
+    const names = new Set(shapeNames);
+    const shapes = {};
+
+    for (const shape of Object.values(projectSchema.shapes)) {
+      if (ids.has(shape.id) || names.has(shape.name)) {
+        const shapeNames = includeDependencies ? [shape.name].concat(getShapeDependencies(projectSchema, shape)) : [shape.name];
+
+        for (const shapeName of shapeNames) {
+          const dependentShape = projectSchema.shapes[shapeName];
+          shapes[byId ? dependentShape.id : dependentShape.name] = dependentShape;
+        }
+      }
+    }
+
+    return shapes;
+  }
+
+  return {};
+}
+export function visitSchemaProperties(schema, path, callback) {
+  if (isObjectSchema(schema)) {
+    for (const [name, propSchema] of Object.entries(schema.properties)) {
+      const newPath = [...path, 'properties', name];
+      callback(propSchema, newPath);
+
+      if (isObjectSchema(propSchema) || isAllOfSchema(propSchema) || isOneOfSchema(propSchema)) {
+        visitSchemaProperties(propSchema, newPath, callback);
+      }
+    }
+  } else if (isAllOfSchema(schema)) {
+    for (const [index, propSchema] of Object.entries(schema.allOf)) {
+      const newPath = [...path, 'allOf', index];
+      callback(propSchema, newPath);
+
+      if (isObjectSchema(propSchema) || isAllOfSchema(propSchema) || isOneOfSchema(propSchema)) {
+        visitSchemaProperties(propSchema, newPath, callback);
+      }
+    }
+  } else if (isOneOfSchema(schema)) {
+    for (const [index, propSchema] of Object.entries(schema.oneOf)) {
+      const newPath = [...path, 'oneOf', index];
+      callback(propSchema, newPath);
+
+      if (isObjectSchema(propSchema) || isAllOfSchema(propSchema) || isOneOfSchema(propSchema)) {
+        visitSchemaProperties(propSchema, newPath, callback);
+      }
+    }
+  } else {
+    callback(schema, path);
+  }
+}
+export function visitShapeProperties(shapes, callback) {
+  for (const [shapeName, shape] of Object.entries(shapes)) {
+    visitSchemaProperties(shape.schema, ['shapes', shapeName, 'schema'], callback);
+  }
+}
+
+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(projectSchema, predicate) {
+  const items = [];
+
+  const shapeVisitor = (schema, schemaPath) => {
+    var _schema$items2;
+
+    if (schema['@args'] && typeof schema['@args'] === 'object') {
+      visitSchemaProperties(schema['@args'], schemaPath.concat(['@args']), (argSchema, argPath) => {
+        addRef(items, getRefOrItemsRef(projectSchema, argSchema, argPath), predicate);
+      });
+    }
+
+    addRef(items, getArgsReferenceWithPath(projectSchema, schema, schemaPath), predicate);
+    const newPath = schema.items ? schemaPath.concat('items') : schemaPath;
+    const newSchema = (_schema$items2 = schema.items) !== null && _schema$items2 !== void 0 ? _schema$items2 : schema;
+
+    if (isRefSchema(newSchema)) {
+      addRef(items, getRefOrItemsRef(projectSchema, newSchema, newPath), predicate);
+    } else if (isObjectSchema(newSchema) || isAllOfSchema(newSchema) || isOneOfSchema(newSchema)) {
+      visitSchemaProperties(newSchema, newPath, shapeVisitor);
+    }
+  };
+
+  for (const [shapeName, shape] of Object.entries(projectSchema.shapes)) {
+    visitSchemaProperties(shape.schema, ['shapes', shapeName, 'schema'], shapeVisitor);
+  }
+
+  return items;
+}
+/**
+ * Get all refs
+ */
+
+export function getAllRefsInQuery(projectSchema, queryPath, query, predicate) {
+  const refItems = [];
+
+  const propertyVisitor = (propSchema, propSchemaPath) => {
+    addRef(refItems, getRefOrItemsRef(projectSchema, propSchema, propSchemaPath), predicate);
+  };
+
+  if (query.args && typeof query.args === 'string') {
+    addRef(refItems, getArgsReferenceWithPath(projectSchema, query, queryPath), predicate);
+  }
+
+  if (query.args && typeof query.args === 'object') {
+    visitSchemaProperties(dereferenceObjectSchema(projectSchema, query.args), queryPath, propertyVisitor);
+  }
+
+  if (query.shape) {
+    const refItem = parseReturnShape(projectSchema, query.shape).ref;
+
+    if (refItem) {
+      addRef(refItems, { ...refItem,
+        path: queryPath.concat(['shape'])
+      }, predicate);
+    }
+  }
+
+  return refItems;
+}
+/**
+ * Collect refs from `queries` or `mutations`.
+ */
+
+export function getAllRefsInQueries(projectSchema, rootPropertyName, predicate) {
+  const refItems = [];
+  const rootPath = [rootPropertyName];
+
+  for (const [queryName, query] of Object.entries(projectSchema[rootPropertyName])) {
+    const queryPath = rootPath.concat([queryName]);
+    const queryRefs = getAllRefsInQuery(projectSchema, 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, predicate), ...getAllRefsInQueries(projectSchema, 'queries', predicate), ...getAllRefsInQueries(projectSchema, 'mutations', predicate)];
+}
+export function parseMapping(mapping) {
+  const [providerId, serviceId, coordinate] = mapping.split(':');
+  const [shapeName, key] = coordinate.split('.');
+  return {
+    providerId,
+    serviceId,
+    shapeName,
+    key
+  };
+}
+export function splitMapping(mapping) {
+  return mapping.split('.');
+}
+export function findMapping(schema, predicate) {
+  const mapping = schema['@mapping'];
+
+  if (Array.isArray(mapping)) {
+    return mapping.find(predicate);
+  }
+
+  return mapping && predicate(mapping) ? mapping : undefined;
+}
+export function getFirstMapping(schema) {
+  return Array.isArray(schema['@mapping']) ? schema['@mapping'][0] : schema['@mapping'];
+}
+export function getFullyQualifiedShapeName(schema) {
+  const first = getFirstMapping(schema);
+  return first ? splitMapping(first)[0] : undefined;
+}
+export function getKey(schema) {
+  const first = getFirstMapping(schema);
+  return first ? splitMapping(first)[1] : undefined;
+}
+export function getPropertyService(schema) {
+  const first = getFirstMapping(schema);
+  const split = first === null || first === void 0 ? void 0 : first.split(':');
+  return split ? `${split[0]}:${split[1]}` : undefined;
+}
+export function emptySchema(projectId, dataKey) {
+  const now = new Date().toISOString();
+  return {
+    projectId,
+    dataKey,
+    version: 1,
+    created: now,
+    updated: now,
+    defaultLocale: 'en-us',
+    locales: ['en-us'],
+    apiVersion: '2',
+    schemaVersion: CURRENT_SCHEMA_VERSION,
+    queries: {},
+    mutations: {},
+    shapes: {},
+    workflows: {},
+    forms: {}
+  };
+}
+export function getShapesById(projectSchema) {
+  return keyBy(Object.values(projectSchema.shapes), 'id');
+}
+/**
+ * Walk through the project schema and return an array of all
+ * referenced shape names that are in a service namespace.
+ *
+ * @param projectSchema A V3 project schema.
+ *
+ * @returns A `string` array with all the shapes that are in namespaces.
+ */
+
+export function getAllNamespaceShapes(projectSchema) {
+  return uniq(getAllRefs(projectSchema, refItem => Boolean(refItem.serviceNamespace)).map(refItemToShapeName));
+}
+/**
+ * Returns a list of all shape names in a service namespace, excluding any
+ * that have been set directly in the project schema
+ *
+ * @todo It's unsound to discard dependencies in this way, should avoid
+ *       collisions with aliases or similar any remote shape that collides,
+ *       e.g., Shopify_Product -> Shopify_Product_2
+ *
+ * @param projectSchema A V3 project schema with remote service configs.
+ *
+ * @returns A `Set` of shape names.
+ */
+
+export function getNamespacedShapeNameList(projectSchema) {
+  const requiredShapeNames = new Set(); // All the shape names
+
+  const existingShapeNames = new Set(Object.keys(projectSchema.shapes)); // All the referenced shape names with namespaces that belong to a service
+
+  const namespacedShapeNames = new Set(getAllNamespaceShapes(projectSchema)); // Add all namespaced shapes to the schema if they are not already present,
+  // e.g. Shopify_Product
+
+  namespacedShapeNames.forEach(name => {
+    if (!existingShapeNames.has(name)) {
+      requiredShapeNames.add(name);
+    }
+  });
+  return requiredShapeNames;
+}
+/**
+ * Filter the service map to return only services passing the GraphQL Service
+ * typeguard.
+ *
+ * @param serviceMap A service map.
+ *
+ * @returns A new map with the filtered list of services
+ */
+
+export function filterGraphQLServiceMap(serviceMap) {
+  const filtered = new Map();
+
+  for (const [serviceKey, serviceConfig] of serviceMap) {
+    if (serviceConfig.serviceType === 'graphql') {
+      filtered.set(serviceKey, serviceConfig);
+    }
+  }
+
+  return filtered;
+}
+/**
+ * Add all referenced shape names to the refSet meant to be used as a callback to visitSchemaProperties
+ */
+
+export function collectReferencedShapeNames(projectSchema, refSet) {
+  const collect = schema => {
+    const args = schema['@args'];
+
+    if (args && isObject(args) && isObjectSchema(args)) {
+      Object.values(args.properties).forEach(collect);
+    }
+
+    const argsRefItem = getArgsReference(projectSchema, schema);
+
+    if (argsRefItem) {
+      refSet.add(refItemToShapeName(argsRefItem));
+    }
+
+    const refItem = getRefOrItemsRef(projectSchema, schema);
+
+    if (refItem) {
+      refSet.add(refItemToShapeName(refItem));
+    }
+  };
+
+  return collect;
+}
+/**
+ * Get the subset of a schema that was automatically created or should otherwise
+ * have special protection against editing or deleting.
+ */
+
+export function getProtectedSchema(schema) {
+  const shapeQueriesAndMutations = getShapeQueriesAndMutations(Object.values({ ...builtInShapes,
+    ...schema.shapes
+  }));
+  const namespaceShapes = getAllNamespaceShapes(schema);
+  return {
+    shapes: pickBy(schema.shapes, (_, key) => {
+      return namespaceShapes.includes(key) || isBuiltinShape(key);
+    }),
+    queries: pickBy(schema.queries, (_, key) => {
+      return shapeQueriesAndMutations.queries[key] !== undefined;
+    }),
+    mutations: pickBy(schema.mutations, (_, key) => {
+      return shapeQueriesAndMutations.mutations[key] !== undefined;
+    })
+  };
+}
+/**
+ * Given a schema, will resolve any `allOf` or `ref` objects. This function has
+ * to fully resolve all refs, because attempting to extend an object schema with
+ * a ref property would create an invalid schema, potentially containing both
+ * a ref and properties.
+ *
+ * If it can't create a valid schema it returns the input.
+ */
+
+export function dereferenceSchema(context, shapeOrFieldSchema, schemaPath = []) {
+  var _resolveAll;
+
+  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(context, resolveSchema);
+
+        if (!refItem) {
+          throw new Error('ref could not be parsed');
+        }
+
+        const refSchema = refItemToShapeSchema(context, 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 = resolveAll(shapeOrFieldSchema, schemaPath)) !== null && _resolveAll !== void 0 ? _resolveAll : shapeOrFieldSchema;
+}
+export function dereferenceObjectSchema(context, shapeOrFieldSchema, schemaPath = []) {
+  const schema = dereferenceSchema(context, shapeOrFieldSchema, schemaPath);
+
+  if (!isObjectSchema(schema)) {
+    throw new Error(`provided schema at '${schemaPath.join('.')}' could not be resolved to an object schema`);
+  }
+
+  return schema;
+}
+/**
+ * Creates a schema property list chainable fn, allowing you to manipulate and
+ * iterate the properties in a schema.
+ */
+
+export const createSchemaPropertyList = curry((context, shapeOrFieldSchema) => {
+  const schema = isContentObjectSchema(shapeOrFieldSchema) ? dereferenceSchema(context, shapeOrFieldSchema) : shapeOrFieldSchema;
+  const propertyIterator = new Map(isObjectSchema(schema) ? Object.entries(schema.properties) : undefined);
+  const defaultOrderByIteratees = [n => n[0]];
+  const defaultOrderByOrders = ['asc'];
+
+  const _orderBy = (iteratees = defaultOrderByIteratees, orders = defaultOrderByOrders) => {
+    self._propertyIterator = new Map(orderBy(iteratees, orders, Array.from(self._propertyIterator)));
+    return self;
+  };
+
+  const _sortWith = comparator => {
+    self._propertyIterator = new Map(Array.from(self._propertyIterator).sort(comparator));
+    return self;
+  };
+
+  const _sortByNamesWithList = comparatorArray => {
+    // If no array is provided, the original sort is preserved
+    if (comparatorArray) {
+      self._propertyIterator = new Map(Array.from(self._propertyIterator).filter(([name]) => comparatorArray.includes(name)).sort(([nameA], [nameB]) => {
+        const indexA = comparatorArray.indexOf(nameA);
+        const indexB = comparatorArray.indexOf(nameB);
+        return (indexA > -1 ? indexA : Infinity) - (indexB > -1 ? indexB : Infinity);
+      }));
+    }
+
+    return self;
+  };
+
+  const _filterBy = predicate => {
+    self._propertyIterator = new Map(Array.from(self._propertyIterator).filter(predicate));
+    return self;
+  };
+
+  const _forEach = iteratee => {
+    Array.from(self._propertyIterator).forEach(iteratee);
+    return self;
+  };
+
+  const _getNodes = () => {
+    return Array.from(self._propertyIterator);
+  };
+
+  const _getObject = () => {
+    return Array.from(self._propertyIterator).reduce((curr, node) => Object.assign(curr, {
+      [node[0]]: node[1]
+    }), {});
+  };
+
+  const _getNames = () => {
+    return Array.from(self._propertyIterator, ([name]) => name);
+  };
+
+  const _getValues = () => {
+    return Array.from(self._propertyIterator, ([, value]) => value);
+  };
+
+  const self = {
+    _propertyIterator: propertyIterator,
+    orderBy: _orderBy,
+    sortWith: _sortWith,
+    sortByNamesWithList: _sortByNamesWithList,
+    filterBy: _filterBy,
+    forEach: _forEach,
+    getNodes: _getNodes,
+    getObject: _getObject,
+    getNames: _getNames,
+    getValues: _getValues
+  };
+  return self;
+});
+/**
+ * Creates a schema property accessor, allowing you to safely access schema
+ * properties.
+ */
+
+export const createSchemaPropertyAccessor = curry((context, shapeOrFieldSchema) => {
+  const schema = isContentObjectSchema(shapeOrFieldSchema) ? dereferenceSchema(context, shapeOrFieldSchema) : shapeOrFieldSchema;
+  const propertyIterator = new Map(isObjectSchema(schema) ? Object.entries(schema.properties) : undefined);
+
+  const _getValue = propertyName => {
+    return propertyIterator.get(propertyName);
+  };
+
+  const _findValue = predicate => {
+    var _Array$from$find;
+
+    return (_Array$from$find = Array.from(propertyIterator).find(predicate)) === null || _Array$from$find === void 0 ? void 0 : _Array$from$find[1];
+  };
+
+  const _findName = predicate => {
+    var _Array$from$find2;
+
+    return (_Array$from$find2 = Array.from(propertyIterator).find(predicate)) === null || _Array$from$find2 === void 0 ? void 0 : _Array$from$find2[0];
+  };
+
+  const _getKey = propertyName => {
+    const value = propertyIterator.get(propertyName);
+
+    if (value) {
+      return getKey(value);
+    }
+  };
+
+  return {
+    getValue: _getValue,
+    findValue: _findValue,
+    findName: _findName,
+    getKey: _getKey
+  };
+});
+
+const findHelper = (projectSchema, shapeName, resolver, type) => {
+  const schemaPath = type === 'query' ? 'queries' : 'mutations';
+  const foundQuery = Object.keys(projectSchema[schemaPath]).find(queryName => {
+    var _options;
+
+    const queryOrMutation = projectSchema[schemaPath][queryName];
+    return queryOrMutation.resolver.name === resolver && ((_options = queryOrMutation.resolver.options) === null || _options === void 0 ? void 0 : _options.model) === shapeName;
+  });
+
+  if (!foundQuery) {
+    throw new Error(`Failed find a "${resolver}" ${type} for shape "${shapeName}"`);
+  }
+
+  return foundQuery;
+};
+/**
+ * Find the query in the schema that corresponds to the given shape and resolver.
+ */
+
+
+export const findQuery = (projectSchema, shapeName, resolver) => {
+  return findHelper(projectSchema, shapeName, resolver, 'query');
+};
+/**
+ * Find the query in the schema that corresponds to the given shape and resolver.
+ */
+
+export const findMutation = (projectSchema, shapeName, resolver) => {
+  return findHelper(projectSchema, shapeName, resolver, 'mutation');
+};
+/**
+ * Find the form config for a given shape name and the form key.
+ */
+
+export function findShapeFormConfig(projectSchema, shapeName, formName) {
+  return get(projectSchema, ['forms', shapeName, formName]);
+}
+
+/**
+ * Find the query in the schema that corresponds to the given shape and resolver.
+ */
+export const getDefaultMutationName = (shapeName, resolver) => {
+  const action = resolver.substring(resolver.indexOf(':') + 1);
+  return `${action}${shapeName}`;
+};