@takeshape/schema 7.194.0

package/lib/schema-util.js

@@ -0,0 +1,1353 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isBuiltinShape = isBuiltinShape;
+exports.isBuiltinQuery = isBuiltinQuery;
+exports.isBuiltinMutation = isBuiltinMutation;
+exports.isBuiltinType = isBuiltinType;
+exports.getServiceIdFieldName = getServiceIdFieldName;
+exports.getGeneratorVersion = getGeneratorVersion;
+exports.getServiceInfo = getServiceInfo;
+exports.pathBetween = pathBetween;
+exports.getShapeQueriesAndMutations = getShapeQueriesAndMutations;
+exports.getBuiltInProperties = getBuiltInProperties;
+exports.applyBuiltinPropertiesToShape = applyBuiltinPropertiesToShape;
+exports.mergeSchemaProperties = mergeSchemaProperties;
+exports.mergeFormProperties = mergeFormProperties;
+exports.applyDefaultsToSchema = applyDefaultsToSchema;
+exports.findExistingRelationships = findExistingRelationships;
+exports.stringifyQuerySource = stringifyQuerySource;
+exports.parseQuerySource = parseQuerySource;
+exports.parseQueryResolver = parseQueryResolver;
+exports.getShapeById = getShapeById;
+exports.isModelShape = isModelShape;
+exports.getArgsReference = getArgsReference;
+exports.getArgsReferenceWithPath = getArgsReferenceWithPath;
+exports.getArgsShapeSchema = getArgsShapeSchema;
+exports.shapeToContentSchema = shapeToContentSchema;
+exports.projectSchemaToJSONSchema = projectSchemaToJSONSchema;
+exports.getShapeDependencies = getShapeDependencies;
+exports.getRelevantShapes = getRelevantShapes;
+exports.visitSchemaProperties = visitSchemaProperties;
+exports.visitShapeProperties = visitShapeProperties;
+exports.getAllRefsInShapes = getAllRefsInShapes;
+exports.getAllRefsInQuery = getAllRefsInQuery;
+exports.getAllRefsInQueries = getAllRefsInQueries;
+exports.getAllRefs = getAllRefs;
+exports.parseMapping = parseMapping;
+exports.splitMapping = splitMapping;
+exports.findMapping = findMapping;
+exports.getFirstMapping = getFirstMapping;
+exports.getFullyQualifiedShapeName = getFullyQualifiedShapeName;
+exports.getKey = getKey;
+exports.getPropertyService = getPropertyService;
+exports.emptySchema = emptySchema;
+exports.getShapesById = getShapesById;
+exports.getAllNamespaceShapes = getAllNamespaceShapes;
+exports.getNamespacedShapeNameList = getNamespacedShapeNameList;
+exports.filterGraphQLServiceMap = filterGraphQLServiceMap;
+exports.collectReferencedShapeNames = collectReferencedShapeNames;
+exports.getProtectedSchema = getProtectedSchema;
+exports.dereferenceSchema = dereferenceSchema;
+exports.dereferenceObjectSchema = dereferenceObjectSchema;
+exports.findShapeFormConfig = findShapeFormConfig;
+exports.getDefaultMutationName = exports.findMutation = exports.findQuery = exports.createSchemaPropertyAccessor = exports.createSchemaPropertyList = exports.getBuiltInPropertyNames = exports.nonStructuralSchemaKeys = exports.multipleRelationshipSchemaKeys = exports.arraySchemaKeys = exports.objectSchemaKeys = exports.scalarSchemaKeys = exports.commonSchemaKeys = exports.schemaMetadataKeys = exports.SERVICE_OBJECT_PATTERN_NAME = void 0;
+
+var _find = _interopRequireDefault(require("lodash/find"));
+
+var _mapValues = _interopRequireDefault(require("lodash/mapValues"));
+
+var _omitBy = _interopRequireDefault(require("lodash/omitBy"));
+
+var _omit = _interopRequireDefault(require("lodash/fp/omit"));
+
+var _assign = _interopRequireDefault(require("lodash/fp/assign"));
+
+var _pickBy = _interopRequireDefault(require("lodash/pickBy"));
+
+var _get = _interopRequireDefault(require("lodash/get"));
+
+var _union = _interopRequireDefault(require("lodash/union"));
+
+var _keyBy = _interopRequireDefault(require("lodash/keyBy"));
+
+var _isEmpty = _interopRequireDefault(require("lodash/isEmpty"));
+
+var _isObject = _interopRequireDefault(require("lodash/isObject"));
+
+var _curry = _interopRequireDefault(require("lodash/fp/curry"));
+
+var _orderBy2 = _interopRequireDefault(require("lodash/fp/orderBy"));
+
+var _uniq = _interopRequireDefault(require("lodash/uniq"));
+
+var _util = require("@takeshape/util");
+
+var _merge = require("@takeshape/util/lib/merge");
+
+var _workflows = require("./workflows");
+
+var _versions = require("./versions");
+
+var _apiVersion = require("./api-version");
+
+var _builtinSchema = require("./builtin-schema");
+
+var _templateShapes = require("./template-shapes");
+
+var _types = require("./types");
+
+var _services = require("./services");
+
+var _refs = require("./refs");
+
+var _isEqual = _interopRequireDefault(require("lodash/isEqual"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+const SERVICE_OBJECT_PATTERN_NAME = 'pattern:service-object';
+exports.SERVICE_OBJECT_PATTERN_NAME = SERVICE_OBJECT_PATTERN_NAME;
+
+function isBuiltinShape(shapeName) {
+  return Boolean(_builtinSchema.builtInShapes[shapeName]);
+}
+
+const builtInQueriesAndMutations = getShapeQueriesAndMutations(Object.values(_builtinSchema.builtInShapes));
+
+function isBuiltinQuery(name) {
+  return builtInQueriesAndMutations.queries[name] !== undefined;
+}
+
+function isBuiltinMutation(name) {
+  return builtInQueriesAndMutations.mutations[name] !== undefined;
+}
+
+function isBuiltinType(projectSchema, refSchema) {
+  const shapeName = (0, _refs.getRefShapeName)(projectSchema, refSchema);
+  return shapeName !== undefined && isBuiltinShape(shapeName);
+}
+
+const schemaMetadataKeys = ['$comment', 'title', 'description', '@l10n', '@deprecationReason', '@tag', '@tags', '@syncLocaleStructure', '@sensitive'];
+exports.schemaMetadataKeys = schemaMetadataKeys;
+const commonSchemaKeys = ['type', 'default', 'readOnly', ...schemaMetadataKeys];
+exports.commonSchemaKeys = commonSchemaKeys;
+const scalarSchemaKeys = [...commonSchemaKeys, 'format', 'oneOf', 'multipleOf', 'maximum', 'exclusiveMaximum', 'minimum', 'exclusiveMinimum', 'maxLength', 'minLength', 'pattern'];
+exports.scalarSchemaKeys = scalarSchemaKeys;
+const objectSchemaKeys = [...commonSchemaKeys, 'properties', 'required'];
+exports.objectSchemaKeys = objectSchemaKeys;
+const arraySchemaKeys = [...commonSchemaKeys, 'items', 'additionalItems', 'maxItems', 'minItems', 'uniqueItems'];
+exports.arraySchemaKeys = arraySchemaKeys;
+const multipleRelationshipSchemaKeys = [...schemaMetadataKeys, 'maxItems', 'minItems']; // all properties except properties, items, additionalItems
+
+exports.multipleRelationshipSchemaKeys = multipleRelationshipSchemaKeys;
+const nonStructuralSchemaKeys = [...scalarSchemaKeys, '@relationship', 'required', 'maxItems', 'minItems', 'uniqueItems'];
+exports.nonStructuralSchemaKeys = nonStructuralSchemaKeys;
+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'
+  }
+};
+
+function getServiceIdFieldName(serviceFieldName) {
+  return `${serviceFieldName}Id`;
+}
+
+const generatorVersions = {
+  [SERVICE_OBJECT_PATTERN_NAME]: '1'
+};
+
+function getGeneratorVersion(generator) {
+  return generatorVersions[generator];
+} // Returns info for all services found in shape, keyed by provider
+
+
+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 (!(0, _types.isBasicResolver)(resolver)) {
+        return;
+      }
+
+      const serviceConfig = (0, _services.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 => (0, _isEqual.default)(existingServiceInfo, serviceInfo))) {
+          result[provider].push(serviceInfo);
+        }
+      } else {
+        result[provider] = [serviceInfo];
+      }
+    });
+  });
+  return result;
+} // Follow refs to find the path between two shapes in a schema
+
+
+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 = (0, _refs.getRefOrItemsRef)(projectSchema, schema);
+
+    if (refItem) {
+      const referenced = (0, _refs.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;
+}
+
+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 ? (0, _templateShapes.createTemplateShapeName)('TSGetSingletonArgs', name) : (0, _templateShapes.createTemplateShapeName)('TSGetArgs', name)
+      };
+      mutations[`update${name}`] = {
+        shape: (0, _templateShapes.createTemplateShapeName)('UpdateResult', name),
+        resolver: {
+          name: 'takeshape:update',
+          service,
+          options: {
+            model: name
+          }
+        },
+        description: `Update ${name}`,
+        args: (0, _templateShapes.createTemplateShapeName)('UpdateArgs', name)
+      };
+
+      if (!isSingleton) {
+        queries[`get${name}List`] = {
+          shape: (0, _templateShapes.createTemplateShapeName)('PaginatedList', name),
+          resolver: {
+            name: 'takeshape:list',
+            service,
+            options: {
+              model: name
+            }
+          },
+          description: `Returns a list ${name} in natural order.`,
+          args: (0, _templateShapes.createTemplateShapeName)('TSListArgs', name)
+        };
+        mutations[`create${name}`] = {
+          shape: (0, _templateShapes.createTemplateShapeName)('CreateResult', name),
+          resolver: {
+            name: 'takeshape:create',
+            service,
+            options: {
+              model: name
+            }
+          },
+          description: `Create ${name}`,
+          args: (0, _templateShapes.createTemplateShapeName)('CreateArgs', name)
+        };
+        mutations[`duplicate${name}`] = {
+          shape: (0, _templateShapes.createTemplateShapeName)('DuplicateResult', name),
+          resolver: {
+            name: 'takeshape:duplicate',
+            service,
+            options: {
+              model: name
+            }
+          },
+          description: `Duplicate ${name}`,
+          args: (0, _templateShapes.createTemplateShapeName)('DuplicateArgs', name)
+        };
+        mutations[`delete${name}`] = {
+          shape: (0, _templateShapes.createTemplateShapeName)('DeleteResult', name),
+          resolver: {
+            name: 'takeshape:delete',
+            service,
+            options: {
+              model: name
+            }
+          },
+          description: `Delete ${name}`,
+          args: (0, _templateShapes.createTemplateShapeName)('DeleteArgs', name)
+        };
+      }
+    }
+  }
+
+  return {
+    queries,
+    mutations
+  };
+}
+
+function getBuiltInProperties(apiVersion = _versions.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,
+ */
+
+
+const getBuiltInPropertyNames = (apiVersion = _versions.CURRENT_API_VERSION) => new Set([...Object.keys(getBuiltInProperties()), (0, _apiVersion.workflowsEnabled)(apiVersion) ? '_status' : undefined].filter(_util.isDefined));
+
+exports.getBuiltInPropertyNames = getBuiltInPropertyNames;
+
+function applyBuiltinPropertiesToShape(projectSchema, shape) {
+  return { ...shape,
+    schema: { ...shape.schema,
+      properties: { ...(0, _omitBy.default)(dereferenceObjectSchema(projectSchema, shape.schema).properties, (_, name) => name.startsWith('_')),
+        ...getBuiltInProperties(projectSchema.apiVersion),
+        ...((0, _apiVersion.workflowsEnabled)(projectSchema.apiVersion) && {
+          _status: (0, _workflows.getStatusField)(projectSchema.workflows, shape)
+        })
+      }
+    }
+  };
+}
+
+function mergeSchemaProperties(base, overrides) {
+  const result = { ...base,
+    properties: { ...base.properties,
+      ...overrides.properties
+    }
+  };
+  const required = (0, _union.default)(base.required, overrides.required);
+
+  if (required.length) {
+    result.required = required;
+  }
+
+  return result;
+}
+
+function mergeFormProperties(base, overrides) {
+  const result = { ...base,
+    properties: { ...base.properties,
+      ...overrides.properties
+    }
+  };
+  const order = (0, _union.default)(base.order, overrides.order);
+
+  if (order.length) {
+    result.order = order;
+  }
+
+  return result;
+}
+
+function applyDefaultsToSchema(projectSchema) {
+  return { ...projectSchema,
+    workflows: { ...projectSchema.workflows,
+      ...((0, _apiVersion.workflowsEnabled)(projectSchema.apiVersion) && {
+        default: _workflows.defaultWorkflow
+      })
+    },
+    queries: { ...builtInQueriesAndMutations.queries,
+      ...projectSchema.queries
+    },
+    mutations: { ...builtInQueriesAndMutations.mutations,
+      ...projectSchema.mutations
+    },
+    shapes: (0, _mapValues.default)({ ..._builtinSchema.builtInShapes,
+      ...projectSchema.shapes
+    }, shape => {
+      const builtInShape = _builtinSchema.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: (0, _mapValues.default)({ ..._builtinSchema.builtInForms,
+      ...projectSchema.forms
+    }, (formsConfig, shapeName) => {
+      const builtInFormsConfig = _builtinSchema.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
+ */
+
+
+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 = (0, _refs.getRefShapeName)(projectSchema, schema);
+
+    if (shapeName && !shapes[shapeName]) {
+      return;
+    }
+
+    const prop = shapeName ? (0, _refs.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;
+}
+
+function stringifyQuerySource(providerId, serviceId) {
+  return `${providerId}:${serviceId}`;
+}
+
+function parseQuerySource(source) {
+  const [providerId, serviceId] = source.split(':');
+  return {
+    providerId,
+    serviceId
+  };
+}
+
+function parseQueryResolver(resolver) {
+  const [providerId, verb] = resolver.split(':');
+  return {
+    providerId,
+    verb
+  };
+}
+
+function getShapeById(projectSchema, shapeId) {
+  return (0, _find.default)(projectSchema.shapes, shape => shape.id === shapeId);
+}
+
+function isModelShape(shape) {
+  return Boolean(shape.model);
+}
+
+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 (0, _refs.refExpressionToRefItem)(projectSchema, args);
+  }
+}
+
+function getArgsReferenceWithPath(projectSchema, argsSchema, schemaPath = []) {
+  const refItem = getArgsReference(projectSchema, argsSchema);
+
+  if (refItem) {
+    const argsType = (0, _types.getArgsType)(argsSchema);
+    return { ...refItem,
+      path: schemaPath.concat([argsType])
+    };
+  }
+}
+
+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 (0, _refs.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) => (0, _assign.default)((0, _omit.default)(['allOf'], targetSchema), sourceSchema);
+
+const createShapeToContentSchema = (projectSchema, definitions, definitionNames, useShapeIdDiscriminator = true) => {
+  const rewriteRefs = (shape, addDiscriminator = false) => {
+    const shapeSchemaCopy = dereferenceObjectSchema(projectSchema, (0, _util.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 ((0, _types.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] || _workflows.defaultWorkflow;
+        propSchema.oneOf = workflow.steps.map(step => ({
+          enum: [step.key, step.name],
+          title: step.title
+        }));
+      }
+
+      const refItem = (0, _refs.getRef)(projectSchema, propSchema);
+
+      if (refItem) {
+        const shapeName = (0, _refs.refItemToShapeName)(refItem);
+        const shape = (0, _refs.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;
+};
+
+function shapeToContentSchema(projectSchema, shape) {
+  const definitions = {};
+  const definitionNames = new Set();
+  const convert = createShapeToContentSchema(projectSchema, definitions, definitionNames);
+  return { ...convert(shape),
+    definitions
+  };
+}
+
+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
+  };
+}
+
+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 = (0, _refs.getRef)(projectSchema, schema);
+
+    if (refItem) {
+      const refShape = (0, _refs.refItemToShape)(projectSchema, refItem);
+
+      if (refShape && !shapeNames.has(refShape.name)) {
+        shapeNames.add(refShape.name);
+        findDependencies(dereferenceSchema(projectSchema, refShape.schema));
+      }
+    } else if ((0, _types.isObjectSchema)(schema) || (0, _types.isAllOfSchema)(schema) || (0, _types.isOneOfSchema)(schema)) {
+      visitSchemaProperties(schema, [], findDependencies);
+    }
+  };
+
+  findDependencies(shape.schema);
+  return [...shapeNames];
+}
+
+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 {};
+}
+
+function visitSchemaProperties(schema, path, callback) {
+  if ((0, _types.isObjectSchema)(schema)) {
+    for (const [name, propSchema] of Object.entries(schema.properties)) {
+      const newPath = [...path, 'properties', name];
+      callback(propSchema, newPath);
+
+      if ((0, _types.isObjectSchema)(propSchema) || (0, _types.isAllOfSchema)(propSchema) || (0, _types.isOneOfSchema)(propSchema)) {
+        visitSchemaProperties(propSchema, newPath, callback);
+      }
+    }
+  } else if ((0, _types.isAllOfSchema)(schema)) {
+    for (const [index, propSchema] of Object.entries(schema.allOf)) {
+      const newPath = [...path, 'allOf', index];
+      callback(propSchema, newPath);
+
+      if ((0, _types.isObjectSchema)(propSchema) || (0, _types.isAllOfSchema)(propSchema) || (0, _types.isOneOfSchema)(propSchema)) {
+        visitSchemaProperties(propSchema, newPath, callback);
+      }
+    }
+  } else if ((0, _types.isOneOfSchema)(schema)) {
+    for (const [index, propSchema] of Object.entries(schema.oneOf)) {
+      const newPath = [...path, 'oneOf', index];
+      callback(propSchema, newPath);
+
+      if ((0, _types.isObjectSchema)(propSchema) || (0, _types.isAllOfSchema)(propSchema) || (0, _types.isOneOfSchema)(propSchema)) {
+        visitSchemaProperties(propSchema, newPath, callback);
+      }
+    }
+  } else {
+    callback(schema, path);
+  }
+}
+
+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.
+ */
+
+
+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, (0, _refs.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 ((0, _types.isRefSchema)(newSchema)) {
+      addRef(items, (0, _refs.getRefOrItemsRef)(projectSchema, newSchema, newPath), predicate);
+    } else if ((0, _types.isObjectSchema)(newSchema) || (0, _types.isAllOfSchema)(newSchema) || (0, _types.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
+ */
+
+
+function getAllRefsInQuery(projectSchema, queryPath, query, predicate) {
+  const refItems = [];
+
+  const propertyVisitor = (propSchema, propSchemaPath) => {
+    addRef(refItems, (0, _refs.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 = (0, _templateShapes.parseReturnShape)(projectSchema, query.shape).ref;
+
+    if (refItem) {
+      addRef(refItems, { ...refItem,
+        path: queryPath.concat(['shape'])
+      }, predicate);
+    }
+  }
+
+  return refItems;
+}
+/**
+ * Collect refs from `queries` or `mutations`.
+ */
+
+
+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
+ */
+
+
+function getAllRefs(projectSchema, predicate) {
+  return [...getAllRefsInShapes(projectSchema, predicate), ...getAllRefsInQueries(projectSchema, 'queries', predicate), ...getAllRefsInQueries(projectSchema, 'mutations', predicate)];
+}
+
+function parseMapping(mapping) {
+  const [providerId, serviceId, coordinate] = mapping.split(':');
+  const [shapeName, key] = coordinate.split('.');
+  return {
+    providerId,
+    serviceId,
+    shapeName,
+    key
+  };
+}
+
+function splitMapping(mapping) {
+  return mapping.split('.');
+}
+
+function findMapping(schema, predicate) {
+  const mapping = schema['@mapping'];
+
+  if (Array.isArray(mapping)) {
+    return mapping.find(predicate);
+  }
+
+  return mapping && predicate(mapping) ? mapping : undefined;
+}
+
+function getFirstMapping(schema) {
+  return Array.isArray(schema['@mapping']) ? schema['@mapping'][0] : schema['@mapping'];
+}
+
+function getFullyQualifiedShapeName(schema) {
+  const first = getFirstMapping(schema);
+  return first ? splitMapping(first)[0] : undefined;
+}
+
+function getKey(schema) {
+  const first = getFirstMapping(schema);
+  return first ? splitMapping(first)[1] : undefined;
+}
+
+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;
+}
+
+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: _versions.CURRENT_SCHEMA_VERSION,
+    queries: {},
+    mutations: {},
+    shapes: {},
+    workflows: {},
+    forms: {}
+  };
+}
+
+function getShapesById(projectSchema) {
+  return (0, _keyBy.default)(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.
+ */
+
+
+function getAllNamespaceShapes(projectSchema) {
+  return (0, _uniq.default)(getAllRefs(projectSchema, refItem => Boolean(refItem.serviceNamespace)).map(_refs.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.
+ */
+
+
+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
+ */
+
+
+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
+ */
+
+
+function collectReferencedShapeNames(projectSchema, refSet) {
+  const collect = schema => {
+    const args = schema['@args'];
+
+    if (args && (0, _isObject.default)(args) && (0, _types.isObjectSchema)(args)) {
+      Object.values(args.properties).forEach(collect);
+    }
+
+    const argsRefItem = getArgsReference(projectSchema, schema);
+
+    if (argsRefItem) {
+      refSet.add((0, _refs.refItemToShapeName)(argsRefItem));
+    }
+
+    const refItem = (0, _refs.getRefOrItemsRef)(projectSchema, schema);
+
+    if (refItem) {
+      refSet.add((0, _refs.refItemToShapeName)(refItem));
+    }
+  };
+
+  return collect;
+}
+/**
+ * Get the subset of a schema that was automatically created or should otherwise
+ * have special protection against editing or deleting.
+ */
+
+
+function getProtectedSchema(schema) {
+  const shapeQueriesAndMutations = getShapeQueriesAndMutations(Object.values({ ..._builtinSchema.builtInShapes,
+    ...schema.shapes
+  }));
+  const namespaceShapes = getAllNamespaceShapes(schema);
+  return {
+    shapes: (0, _pickBy.default)(schema.shapes, (_, key) => {
+      return namespaceShapes.includes(key) || isBuiltinShape(key);
+    }),
+    queries: (0, _pickBy.default)(schema.queries, (_, key) => {
+      return shapeQueriesAndMutations.queries[key] !== undefined;
+    }),
+    mutations: (0, _pickBy.default)(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.
+ */
+
+
+function dereferenceSchema(context, shapeOrFieldSchema, schemaPath = []) {
+  var _resolveAll;
+
+  const resolveAll = (resolveSchema, resolvePath) => {
+    try {
+      if ((0, _types.isAllOfSchema)(resolveSchema)) {
+        const allOfSchema = resolveSchema.allOf.map((stub, index) => resolveAll(stub, [...resolvePath, 'allOf', index])).reduce((prev, curr) => (0, _merge.mergeWithArrayConcat)(prev, curr), {});
+        return (0, _isEmpty.default)(allOfSchema) ? undefined : omitAllOfAndExtend(resolveSchema, allOfSchema);
+      }
+
+      if ((0, _types.isRefSchema)(resolveSchema)) {
+        const refItem = (0, _refs.getRefWithPath)(context, resolveSchema);
+
+        if (!refItem) {
+          throw new Error('ref could not be parsed');
+        }
+
+        const refSchema = (0, _refs.refItemToShapeSchema)(context, refItem);
+
+        if (refSchema) {
+          return resolveAll((0, _refs.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;
+}
+
+function dereferenceObjectSchema(context, shapeOrFieldSchema, schemaPath = []) {
+  const schema = dereferenceSchema(context, shapeOrFieldSchema, schemaPath);
+
+  if (!(0, _types.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.
+ */
+
+
+const createSchemaPropertyList = (0, _curry.default)((context, shapeOrFieldSchema) => {
+  const schema = (0, _types.isContentObjectSchema)(shapeOrFieldSchema) ? dereferenceSchema(context, shapeOrFieldSchema) : shapeOrFieldSchema;
+  const propertyIterator = new Map((0, _types.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((0, _orderBy2.default)(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.
+ */
+
+exports.createSchemaPropertyList = createSchemaPropertyList;
+const createSchemaPropertyAccessor = (0, _curry.default)((context, shapeOrFieldSchema) => {
+  const schema = (0, _types.isContentObjectSchema)(shapeOrFieldSchema) ? dereferenceSchema(context, shapeOrFieldSchema) : shapeOrFieldSchema;
+  const propertyIterator = new Map((0, _types.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
+  };
+});
+exports.createSchemaPropertyAccessor = createSchemaPropertyAccessor;
+
+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.
+ */
+
+
+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.
+ */
+
+
+exports.findQuery = findQuery;
+
+const findMutation = (projectSchema, shapeName, resolver) => {
+  return findHelper(projectSchema, shapeName, resolver, 'mutation');
+};
+/**
+ * Find the form config for a given shape name and the form key.
+ */
+
+
+exports.findMutation = findMutation;
+
+function findShapeFormConfig(projectSchema, shapeName, formName) {
+  return (0, _get.default)(projectSchema, ['forms', shapeName, formName]);
+}
+
+/**
+ * Find the query in the schema that corresponds to the given shape and resolver.
+ */
+const getDefaultMutationName = (shapeName, resolver) => {
+  const action = resolver.substring(resolver.indexOf(':') + 1);
+  return `${action}${shapeName}`;
+};
+
+exports.getDefaultMutationName = getDefaultMutationName;