@takeshape/schema 8.144.4 → 8.146.0

package/es/schemas/project-schema.json

@@ -75,6 +75,9 @@
     {
       "$ref": "https://schema.takeshape.io/project-schema/v3.17.1#"
     },
+    {
+      "$ref": "https://schema.takeshape.io/project-schema/v3.18.0#"
+    },
     {
       "$ref": "https://schema.takeshape.io/project-schema/v4.0.0#"
     }

package/es/template-shapes/templates.js

@@ -1,12 +1,13 @@
 import { TemplateVerbs } from './types';
 import { listTypePrefix } from '../migration';
-import { pascalCase } from '@takeshape/util';
+import { deepClone, pascalCase, visit } from '@takeshape/util';
 import keyBy from 'lodash/keyBy';
 import { createShape, getShapeDependencies, isIndexedRemoteShape } from '../schema-util';
 import { getFlattenedTemplateShapeName, getRefShapeName } from '../refs';
 import { getWhereSearchArg } from './where';
 import { mergeObjectSchemas, mergeSchemaProperties } from '../util';
 import { rewriteSchema } from '../rewrite';
+import get from 'lodash/get';
 export const TSGetArgs = getIDQueryArgs('TSGetArgs');
 export const TSGetSingletonArgs = getIDQueryArgs('TSGetSingletonArgs');
 export const TSListArgs = getShapeListQueryArgs('TSListArgs', true);
@@ -188,14 +189,39 @@ export function getMutationInputShapeName(verb) {
     return pascalCase([verb, shapeName, 'input']);
   };
 }
-
 /**
- * Create a shape name variant for an input. Updates will typically want a partial input.
+ * Create a shape name variant for an input.
  */
-function getInputShapeName(shapeName, {
-  isPartial
-}) {
-  return isPartial ? `${shapeName}PartialInput` : `${shapeName}Input`;
+
+export function getInputShapeName(shapeName) {
+  return shapeName === 'TSRelationship' ? shapeName : `${shapeName}Input`;
+}
+export function getOutputShapeName(name) {
+  return name.replace(/(?:Input|PartialInput)$/, '');
+}
+
+function rewriteRefs(shapeSchema, rewriteShapeName) {
+  const newSchema = deepClone(shapeSchema);
+  visit(newSchema, ['$ref', '@ref'], (_, path) => {
+    const parentPath = path.slice(0, -1);
+    const value = get(newSchema, parentPath);
+
+    if ((value['@ref'] || value.$ref) && !parentPath.includes('@input') && !parentPath.includes('@output')) {
+      if (value['@ref']) {
+        const ref = value['@ref'];
+        const parts = ref.split(':');
+        value['@ref'] = `local:${rewriteShapeName(parts[1])}`;
+      }
+
+      if (value.$ref) {
+        const ref = value.$ref;
+        const parts = ref.split('/');
+        parts[2] = rewriteShapeName(parts[2]);
+        value.$ref = parts.join('/');
+      }
+    }
+  });
+  return newSchema;
 }
 /**
  * Construct shapes for a mutation inputs, given source shape info.
@@ -213,14 +239,19 @@ export function getMutationArgs(templateName, verb) {
     const inputName = getShapeName(shape.name);
     const isSingleton = shape.model && shape.model.type === 'single';
     const shouldRequireId = !isSingleton && (verb === TemplateVerbs.Update || verb === TemplateVerbs.Delete || verb === TemplateVerbs.Duplicate);
-    const rewrittenSchema = verb !== TemplateVerbs.Delete ? rewriteSchema(shape.schema, isUpdate ? {
-      removeDefault: true,
-      removeRequired: true,
-      replaceInput: true
-    } : {
-      replaceInput: true
-    }) : undefined;
-    const inputShape = createShape(inputName, mergeObjectSchemas(shouldRequireId ? idSchema : undefined, rewrittenSchema), {
+    let rewrittenSchema;
+    let inputShapeSchema;
+
+    if (verb !== TemplateVerbs.Delete) {
+      rewrittenSchema = rewriteSchema(shape.schema, {
+        removeDefault: isUpdate,
+        removeRequired: isUpdate,
+        replaceInput: true
+      });
+      inputShapeSchema = rewriteRefs(rewrittenSchema, getInputShapeName);
+    }
+
+    const inputShape = createShape(inputName, mergeObjectSchemas(shouldRequireId ? idSchema : undefined, inputShapeSchema), {
       description: `${verb} ${shape.name} input`
     });
     const argsShapeName = getFlattenedTemplateShapeName(shape.name, templateName);
@@ -241,30 +272,25 @@ export function getMutationArgs(templateName, verb) {
       dependencies: {
         [inputName]: inputShape,
         [argsShapeName]: argsShape,
-        ...(verb !== TemplateVerbs.Delete && keyBy(getShapeDependencies(projectSchema, shape, propSchema => {
-          if (!propSchema['@resolver']) {
+        ...(verb !== TemplateVerbs.Delete && keyBy(getShapeDependencies(projectSchema, // get the shape dependencies of the shape with the @input swapped
+        createShape(inputShape.name, rewrittenSchema), propSchema => {
+          if (propSchema['@resolver']) {
             return false;
           }
 
           const shapeName = getRefShapeName(projectSchema, propSchema);
 
           if (shapeName) {
-            return shapeName !== 'TSRelationship' && !projectSchema.shapes[getInputShapeName(shapeName, {
-              isPartial: isUpdate
-            })];
+            return shapeName !== 'TSRelationship' && !projectSchema.shapes[getInputShapeName(shapeName)];
           }
 
           return true;
         }).map(shapeName => {
-          const shape = projectSchema.shapes[shapeName];
-          const name = getInputShapeName(shapeName, {
-            isPartial: isUpdate
-          });
-          return { ...shape,
-            name,
-            id: name,
-            schema: rewrittenSchema
-          };
+          const shape = projectSchema.shapes[shapeName]; // We only allow partial input at the top-level
+
+          return createShape(getInputShapeName(shapeName), rewriteRefs(rewriteSchema(shape.schema, {
+            replaceInput: true
+          }), getInputShapeName));
         }), 'name')),
         ...(addStructure ? {
           ContentStructureInput

package/es/template-shapes/where.js

@@ -1,14 +1,14 @@
-import { pascalCase, isDefined } from '@takeshape/util';
 import unset from 'lodash/unset';
 import isFunction from 'lodash/isFunction';
-import { createSchemaPropertyList, createShape, getAllRefsInShapes, getShapeById, isIndexedRemoteShape } from '../schema-util';
+import { createSchemaPropertyList, createShape, getAllRefsInShapes, isIndexedRemoteShape } from '../schema-util';
+import uniqBy from 'lodash/uniqBy';
+import md5 from 'blueimp-md5';
+import { pascalCase, isDefined } from '@takeshape/util';
 import { workflowsEnabled } from '../api-version';
 import { followRef, getRef, getRefOrItemsRef, hasRefProperty, hasResolvableRef, refItemToShape, refItemToShapeName } from '../refs';
 import { enumerateOneOfKeys, isUnionSchema } from '../unions';
-import { isObjectSchema } from '../types';
-import uniqBy from 'lodash/uniqBy';
-import md5 from 'blueimp-md5';
-import { isEqualRelationship } from '../relationships';
+import { isObjectSchema, isPropertySchemaWithRelationship } from '../types/utils';
+import { isEqualRelationship, getRelationship, getRelationshipShapes } from '../relationships';
 export const MAX_RELATIONSHIP_DEPTH = 1;
 export const exceededRelationshipDepth = (depth = 0) => depth >= MAX_RELATIONSHIP_DEPTH;
 
@@ -159,7 +159,7 @@ function isId(name) {
 }
 
 function isNonRelationshipRef(prop) {
-  return Boolean(hasRefProperty(prop) && !prop['@relationship']);
+  return Boolean(hasRefProperty(prop) && !getRelationship(prop));
 }
 
 function getPropType(projectSchema, name, prop) {
@@ -200,20 +200,17 @@ function truncateNames(names) {
   // For unions of many types hash the names this reduces shape name size while still allowing reuse
   return names.length > 80 ? md5(names) : names;
 }
+/**
+ * Get a formatted string of related shape names from a property schema with a
+ * relationship resolver
+ */
 
-function getRelatedShapeNames(projectSchema, prop) {
-  var _prop$Relationship;
 
-  const names = (_prop$Relationship = prop['@relationship']) === null || _prop$Relationship === void 0 ? void 0 : _prop$Relationship.shapeIds.map(id => {
-    const shape = getShapeById(projectSchema, id);
-    return pascalCase(shape ? shape.name : '');
+function getRelationshipShapeName(refs) {
+  return refs.map(ref => {
+    const shapeName = ref.split(':')[1];
+    return pascalCase(shapeName);
   }).sort().join('');
-
-  if (!names) {
-    throw new Error(`Relationship property ${prop.title} is missing related shapes`);
-  }
-
-  return names;
 }
 
 function joinShapeNames(shapes) {
@@ -232,8 +229,16 @@ function getTypeName(name, prop, shapeName, context) {
     return `TSWhereID`;
   }
 
-  if (prop['@relationship']) {
-    const shapeNames = truncateNames(getRelatedShapeNames(projectSchema, prop));
+  const relationship = getRelationship(prop);
+
+  if (relationship) {
+    const relationshipName = getRelationshipShapeName(relationship.refs);
+
+    if (!relationshipName) {
+      throw new Error(`Relationship property "${prop.title ?? ''}" is missing related shapes`);
+    }
+
+    const shapeNames = truncateNames(relationshipName);
     return `TSWhere${shapeNames}Relationship`;
   }
 
@@ -265,7 +270,7 @@ function skipField({
   exceededRelationshipDepth,
   isIndexedShape
 }) {
-  return Boolean(prop['@sensitive'] || !isIndexedShape && prop['@resolver'] || prop['@relationship'] && exceededRelationshipDepth || (name === '_enabled' || name === '_enabledAt') && workflowsEnabled);
+  return Boolean(prop['@sensitive'] || !isIndexedShape && prop['@resolver'] || isPropertySchemaWithRelationship(prop) && exceededRelationshipDepth || (name === '_enabled' || name === '_enabledAt') && workflowsEnabled);
 }
 
 export function getFields(typeName, shapes, context) {
@@ -355,11 +360,12 @@ export function getPropertyComparisonType(name, prop, shapeName, context) {
 
       let props;
       const propOrItems = prop.items ?? prop;
+      const relationship = getRelationship(prop);
 
       if (isId(name)) {
         props = getFieldTypeComparison('id');
-      } else if (prop['@relationship']) {
-        const shapes = prop['@relationship'].shapeIds.map(id => getShapeById(projectSchema, id)).filter(isDefined);
+      } else if (relationship) {
+        const shapes = getRelationshipShapes(projectSchema.shapes, relationship.refs);
         props = getFields(typeName, shapes, { ...context,
           relationshipDepth: relationshipDepth + 1
         });

package/es/types/utils.js

@@ -7,12 +7,12 @@ import isArray from 'lodash/isArray';
 import has from 'lodash/has';
 import { latestSchemaJson } from '../schemas';
 import satisfies from 'semver/functions/satisfies';
+
 /** Resolver Type Utils **/
 
 /**
  * Only tests that the shape is right, not that the name is correct. That's a job for the validator.
  */
-
 export function isBasicResolver(resolver) {
   return isString(resolver === null || resolver === void 0 ? void 0 : resolver.name) && isString(resolver.service);
 }
@@ -263,4 +263,10 @@ export const getRefType = refSchema => {
   if (has(refSchema, '$ref')) {
     return RefType.$ref;
   }
-};
+};
+export function isPropertySchemaWithRelationship(schema) {
+  var _schema$Resolver;
+
+  schema = schema['@output'] ?? schema;
+  return ((_schema$Resolver = schema['@resolver']) === null || _schema$Resolver === void 0 ? void 0 : _schema$Resolver.name) === 'takeshape:getRelated';
+}

package/es/unions.js

@@ -5,6 +5,7 @@ import { getContentTransform, toName } from './content-schema-transform';
 import { isRefSchema } from './types/utils';
 import { BadDataError } from '@takeshape/errors';
 import { getShapeById } from './schema-util';
+import { getOutputShapeName } from './template-shapes/templates';
 export function enumerateOneOfKeys(projectSchema, oneOf) {
   const result = [];
 
@@ -17,7 +18,7 @@ export function enumerateOneOfKeys(projectSchema, oneOf) {
       if (projectSchema.shapes[shapeName]) {
         const shapeId = projectSchema.shapes[shapeName].id;
         result.push({
-          propName: camelCase(refItem.typeName),
+          propName: getOutputShapeName(camelCase(refItem.typeName)),
           propSchema: child,
           shapeName,
           shapeId

package/es/util/detect-cycles.js

@@ -1,52 +1,60 @@
 import { getRef, refItemToShape } from '../refs';
+import { value } from '@takeshape/util';
 
 function immutableSetAdd(set, str) {
   const result = new Set(set);
   result.add(str);
   return result;
 }
+
 /**
  * Use a basic depth-first search to determine whether a schema contains a cycle
  */
+export function hasCycle(projectSchema, schema, predicate = value(true)) {
+  const hasCycleHelper = (schema, shapesSeen = new Set(), shapeName, propName) => {
+    if (!predicate(projectSchema, schema, shapeName, propName)) {
+      return false;
+    }
 
+    const refItem = getRef(projectSchema, schema);
 
-export function hasCycle(projectSchema, schema, shapesSeen = new Set()) {
-  const refItem = getRef(projectSchema, schema);
+    if (refItem) {
+      const refShape = refItemToShape(projectSchema, refItem); // If we have a refItem, but no shape, this is a dangling ref and has no cycles
 
-  if (refItem) {
-    const refShape = refItemToShape(projectSchema, refItem); // If we have a refItem, but no shape, this is a dangling ref and has no cycles
+      if (!refShape) {
+        return false;
+      }
 
-    if (!refShape) {
-      return false;
-    }
+      if (shapesSeen.has(refShape.name)) {
+        return true;
+      }
 
-    if (shapesSeen.has(refShape.name)) {
-      return true;
+      return hasCycleHelper(refShape.schema, immutableSetAdd(shapesSeen, refShape.name), refShape.name);
     }
 
-    return hasCycle(projectSchema, refShape.schema, immutableSetAdd(shapesSeen, refShape.name));
-  }
+    const combo = schema.oneOf ?? schema.allOf ?? schema.extends;
 
-  const combo = schema.oneOf ?? schema.allOf ?? schema.extends;
+    if (combo) {
+      return combo.some(childSchema => hasCycleHelper(childSchema, shapesSeen, shapeName, propName));
+    }
 
-  if (combo) {
-    return combo.some(childSchema => hasCycle(projectSchema, childSchema, shapesSeen));
-  }
+    if (schema.items) {
+      return hasCycleHelper(schema.items, shapesSeen, shapeName, propName);
+    }
 
-  if (schema.items) {
-    return hasCycle(projectSchema, schema.items, shapesSeen);
-  }
+    const {
+      properties
+    } = schema;
 
-  const {
-    properties
-  } = schema;
+    if (properties) {
+      return Object.keys(properties).some(name => {
+        const propSchema = properties[name];
+        return hasCycleHelper(propSchema, shapesSeen, shapeName, name);
+      });
+    }
 
-  if (properties) {
-    return Object.keys(properties).some(name => {
-      const propSchema = properties[name];
-      return hasCycle(projectSchema, propSchema, shapesSeen);
-    });
-  }
+    return false;
+  };
 
-  return false;
+  return hasCycleHelper(schema);
 }

package/es/util/form-config.js

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

package/es/util/index.js

@@ -1,3 +1,4 @@
 export * from './api-indexing';
 export * from './detect-cycles';
-export * from './merge';
+export * from './merge';
+export * from './form-config';

package/es/validate.js

@@ -1,4 +1,5 @@
 import { projectSchemaImportOptionalProps } from './types/types';
+import { JSONPath } from 'jsonpath-plus';
 import { createAjv } from '@takeshape/json-schema';
 import { SchemaValidationError } from '@takeshape/errors';
 import coerce from 'semver/functions/coerce';
@@ -11,7 +12,7 @@ import { CURRENT_SCHEMA_VERSION, LEGACY_SCHEMA_VERSION, LEGACY_API_VERSION } fro
 import { defaultWorkflow } from './workflows';
 import { allProjectSchemas } from './schemas';
 import authSchemas from './schemas/auth-schemas.json';
-import { getAllNamespaceShapes, visitShapeProperties, getAllRefsInShapes } from './schema-util';
+import { getAllNamespaceShapes, getAllRefsInShapes } from './schema-util';
 import { builtInShapes } from './builtin-schema';
 import { isValidTemplate } from './template-shapes';
 import { isBasicResolver, isComposeResolver } from './types/utils';
@@ -22,6 +23,7 @@ import { isEnumLikeSchema } from './enum';
 import metaSchemaV3_9_0 from './schemas/project-schema/meta-schema-v3.9.0.json';
 import { isIntegerLike } from '@takeshape/util';
 import forOwn from 'lodash/forOwn';
+import { getRelationship } from './relationships';
 
 function findDuplicates(items) {
   const seen = {};
@@ -172,6 +174,15 @@ function validateResolver(projectSchema, basePath, resolver) {
     return [takeshapeResolver, utilResolver, graphqlResolver, restResolver, awsLambdaResolver].flatMap(resolver => resolver.properties.name.enum).includes(resolverName);
   };
 
+  const isValidShapeName = shapeName => {
+    var _indexedShapes;
+
+    const modelShape = shapeName ? projectSchema.shapes[shapeName] : undefined;
+    return Boolean((modelShape === null || modelShape === void 0 ? void 0 : modelShape.model) || shapeName && ((_indexedShapes = projectSchema.indexedShapes) === null || _indexedShapes === void 0 ? void 0 : _indexedShapes[shapeName]));
+  };
+
+  const isLessThanV3_9_0 = lt(coerce(projectSchema.schemaVersion) ?? LEGACY_SCHEMA_VERSION, '3.9.0');
+
   const validateBasicResolver = resolver => {
     if (isBasicResolver(resolver)) {
       var _projectSchema$servic;
@@ -184,35 +195,23 @@ function validateResolver(projectSchema, basePath, resolver) {
         });
       }
 
-      if (lt(coerce(projectSchema.schemaVersion) ?? LEGACY_SCHEMA_VERSION, '3.9.0')) {
-        if (!isValidResolverNameV3_9_0(resolver.name)) {
-          errors.push({
-            type: 'notFound',
-            path: basePath.concat(['name']),
-            message: `Invalid resolver name "${resolver.name}"`
-          });
-        }
+      if (isLessThanV3_9_0 && !isValidResolverNameV3_9_0(resolver.name)) {
+        errors.push({
+          type: 'notFound',
+          path: basePath.concat(['name']),
+          message: `Invalid resolver name "${resolver.name}"`
+        });
       }
 
-      if (resolver.name.startsWith('takeshape')) {
+      if (isLessThanV3_9_0 && resolver.name.startsWith('takeshape')) {
         var _options;
 
-        let shapeName;
-
         if ((_options = resolver.options) !== null && _options !== void 0 && _options.model) {
           var _options2;
 
-          shapeName = (_options2 = resolver.options) === null || _options2 === void 0 ? void 0 : _options2.model;
-        } else if (resolver.shapeName) {
-          shapeName = resolver.shapeName;
-        }
-
-        if (shapeName) {
-          var _indexedShapes;
+          const shapeName = (_options2 = resolver.options) === null || _options2 === void 0 ? void 0 : _options2.model;
 
-          const modelShape = projectSchema.shapes[shapeName];
-
-          if (!(modelShape !== null && modelShape !== void 0 && modelShape.model) && !(shapeName && (_indexedShapes = projectSchema.indexedShapes) !== null && _indexedShapes !== void 0 && _indexedShapes[shapeName])) {
+          if (!isValidShapeName(shapeName)) {
             errors.push({
               type: 'notFound',
               path: basePath.concat(['options', 'model']),
@@ -221,6 +220,20 @@ function validateResolver(projectSchema, basePath, resolver) {
           }
         }
       }
+
+      if (resolver.shapeName) {
+        const {
+          shapeName
+        } = resolver;
+
+        if (!isValidShapeName(shapeName)) {
+          errors.push({
+            type: 'notFound',
+            path: basePath.concat(['shapeName']),
+            message: `Invalid Model Shape "${shapeName ?? ''}"`
+          });
+        }
+      }
     } else {
       errors.push({
         type: 'notFound',
@@ -366,29 +379,43 @@ function validateRefs(projectSchema, additionalShapeNames = builtInShapeNames) {
   return errors;
 }
 
+function visitShapePropertiesJson(projectSchema, callback) {
+  JSONPath('shapes.*.schema.properties.*', projectSchema, (property, _type, {
+    path: propertyPath
+  }) => {
+    callback(property, propertyPath.slice(3, -2).split(`']['`));
+  }, undefined);
+}
+
 function validateDirectives(projectSchema, additionalShapeIds = builtInModelShapeIds) {
   const errors = [];
   const projectShapeIds = new Set([...getModelShapeIds(projectSchema.shapes), ...additionalShapeIds]);
-  visitShapeProperties(projectSchema.shapes, (schema, path) => {
-    if (schema['@relationship']) {
-      var _schema$Relationship;
-
-      const shapeIds = (_schema$Relationship = schema['@relationship']) === null || _schema$Relationship === void 0 ? void 0 : _schema$Relationship.shapeIds;
-      shapeIds.forEach(shapeId => {
-        if (!projectShapeIds.has(shapeId)) {
-          const propPath = path.concat('@relationship');
-          errors.push({
-            type: 'notFound',
-            path: propPath,
-            message: `Invalid shapeId relationship "${shapeId}" for property "${propPath[4]}" in shape "${propPath[1]}"`
-          });
-        }
-      });
+  const isLessThanV3_18_0 = lt(coerce(projectSchema.schemaVersion) ?? LEGACY_SCHEMA_VERSION, '3.18.0');
+  visitShapePropertiesJson(projectSchema, (property, propertyPath) => {
+    if (isLessThanV3_18_0) {
+      const propSchema = property;
+
+      if (propSchema['@relationship']) {
+        var _propSchema$Relation;
+
+        const shapeIds = (_propSchema$Relation = propSchema['@relationship']) === null || _propSchema$Relation === void 0 ? void 0 : _propSchema$Relation.shapeIds;
+        shapeIds.forEach(shapeId => {
+          if (!projectShapeIds.has(shapeId)) {
+            const propPath = propertyPath.concat('@relationship');
+            errors.push({
+              type: 'notFound',
+              path: propPath,
+              message: `Invalid shapeId relationship "${shapeId}" for property "${propPath[4]}" in shape "${propPath[1]}"`
+            });
+          }
+        });
+      }
     }
 
-    if (schema['@resolver']) {
-      const resolver = schema['@resolver'];
-      const propPath = path.concat('@resolver');
+    const resolver = property['@resolver'];
+
+    if (resolver) {
+      const propPath = propertyPath.concat('@resolver');
       const resolverErrors = validateResolver(projectSchema, propPath, resolver);
 
       if (resolverErrors) {
@@ -401,11 +428,12 @@ function validateDirectives(projectSchema, additionalShapeIds = builtInModelShap
 
 function validateOneOfs(projectSchema) {
   const errors = [];
-  visitShapeProperties(projectSchema.shapes, (schema, path) => {
-    const oneOfPath = schema.items ? ['items', 'oneOf'] : ['oneOf'];
-    schema = schema.items ? schema.items : schema;
+  visitShapePropertiesJson(projectSchema, (property, propertyPath) => {
+    const oneOfPath = property.items ? ['items', 'oneOf'] : ['oneOf'];
+    const relationship = getRelationship(property);
+    const schema = property.items ? property.items : property;
 
-    if (schema.oneOf) {
+    if (schema.oneOf && !relationship) {
       if (isUnionSchema(schema)) {
         const modelsReferenced = enumerateOneOfKeys(projectSchema, schema.oneOf).map(child => child.shapeName).filter(shapeName => projectSchema.shapes[shapeName].model);
 
@@ -413,14 +441,14 @@ function validateOneOfs(projectSchema) {
           const shapeNames = modelsReferenced.join(', ');
           errors.push({
             type: 'json',
-            path: path.concat(oneOfPath),
+            path: propertyPath.concat(oneOfPath),
             message: `Invalid refs to ${shapeNames}. oneOf unions cannot reference model shapes. Use @relationship instead`
           });
         }
       } else if (!isEnumLikeSchema(schema)) {
         errors.push({
           type: 'json',
-          path: path.concat(oneOfPath),
+          path: propertyPath.concat(oneOfPath),
           message: `Invalid oneOf must contain only @ref or title + enum/const schemas`
         });
       }