@takeshape/schema 11.89.0 → 11.91.0

package/dist/refs.js

@@ -1,5 +1,5 @@
 import { NotFoundError } from '@takeshape/errors';
-import { isDefined, isIntegerLike, isRecord, visit } from '@takeshape/util';
+import { deepCloneWith, isDefined, isIntegerLike, isIterableObject, isRecord, visit } from '@takeshape/util';
 import compact from 'lodash/compact.js';
 import assign from 'lodash/fp/assign.js';
 import omit from 'lodash/fp/omit.js';
@@ -7,15 +7,10 @@ import get from 'lodash/get.js';
 import isString from 'lodash/isString.js';
 import { isScalar } from "./scalars.js";
 import { getServiceNamespaces } from "./services/util.js";
-import { getRefType, isAllOfSchema, isExtendsSchema, isObjectSchema, isOneOfSchema, isRefSchema, isRefSchemaLegacy } from "./types/index.js";
+import { isAllOfSchema, isExtendsSchema, isObjectSchema, isOneOfSchema, isRefSchema, isRefSchemaLegacy } from "./types/index.js";
 import { mergeDeepObjectSchemas, mergeObjectSchemas } from "./util/merge.js";
 import { getShape } from "./util/shapes.js";
-/**
- * Guard for RefItemWithPath. Tests for presence of all required props.
- */
-export function isRefItemWithPath(ref) {
-    return Boolean(ref.typeName && ref.serviceKey && ref.path && isDefined(ref.isForeign));
-}
+export const LOCAL_LAYER_ID = 'local';
 const templateShapeRegex = /^(\w+)<([\w:-]+)>$/;
 /**
  * Parse a template like `PaginatedList<Post>` and return both the template and the shape name.
@@ -27,17 +22,17 @@ export function parseTemplateShape(shapeExpression) {
     }
     return { shapeName: shapeExpression, template: undefined };
 }
-export function parseReturnShape(projectSchema, shape) {
+export function parseReturnShape(context, shape) {
     if (typeof shape === 'object') {
         if (isRefSchema(shape.items)) {
-            const ref = getRef(projectSchema, shape.items);
+            const ref = getRef(context, shape.items);
             if (!ref) {
                 throw new Error(`Could not parse ${JSON.stringify(shape.items)}: invalid ref`);
             }
             return {
                 isArray: true,
                 ref,
-                shapeName: refItemToNamespacedShapeName(ref)
+                shapeName: refItemToNamespacedShapeName(context, ref)
             };
         }
         if (typeof shape.items.type !== 'string') {
@@ -45,8 +40,8 @@ export function parseReturnShape(projectSchema, shape) {
         }
         return { isArray: true, shapeName: shape.items.type };
     }
-    const ref = refExpressionToRefItem(projectSchema, shape);
-    const shapeName = refItemToNamespacedShapeName(ref);
+    const ref = parseRef(context, shape);
+    const shapeName = refItemToNamespacedShapeName(context, ref);
     return { isArray: false, shapeName, ref, template: ref.template };
 }
 /**
@@ -58,7 +53,7 @@ export function returnShapeToSchema(projectSchema, returnShape) {
             return { type: returnShape };
         }
         return {
-            '@ref': refItemToAtRef(refExpressionToRefItem(projectSchema, returnShape))
+            '@ref': serializeRef(parseRef(projectSchema, returnShape))
         };
     }
     return returnShape;
@@ -85,19 +80,12 @@ function $refToPath(ref) {
 function $refToShapeName(ref) {
     return $refToPath(ref)[1];
 }
-export function $refToAtRef($ref, service, namespace) {
-    const shapeName = $refToShapeName($ref);
-    if (service === 'local') {
-        return `local:${shapeName}`;
-    }
-    return `${service}:${namespace === undefined ? shapeName : shapeName.replace(`${namespace}_`, '')}`;
-}
 export function refSchemaToPath(context, refSchema) {
     const refItem = getRef(context, refSchema);
     if (refItem === undefined) {
         throw new Error('Invalid ref in refSchemaToPath');
     }
-    return refItemToShapePath(refItem);
+    return refItemToShapePath(context, refItem);
 }
 /**
  * Safely turn a "template" shape reference (`@args`, `args`, `shape`) into a `RefItem`
@@ -107,18 +95,25 @@ export function refSchemaToPath(context, refSchema) {
  * A ref expression might include "template" name and refer to a local or remote
  * shape, `Foo` or `CreateArgs<Foo>` or `CreateArgs<remote:Foo>`.*
  */
-export function refExpressionToRefItem(context, refExpression) {
+export function parseRef(context, refExpression) {
     const { shapeName, template } = parseTemplateShape(refExpression);
     if (shapeName.includes(':')) {
-        return atRefToRefItem(context, shapeName, template);
+        return refExpressionToRefItem(shapeName, template);
     }
     return shapeNameToRefItem(context, shapeName, template);
 }
+export function isRefEqual(context, a, b) {
+    const parsedA = typeof a === 'string' ? parseRef(context, a) : a;
+    const parsedB = typeof b === 'string' ? parseRef(context, b) : b;
+    return (parsedA.shapeName === parsedB.shapeName &&
+        parsedA.layerId === parsedB.layerId &&
+        parsedA.template === parsedB.template);
+}
 /**
  * Converts a list of ref expressions into a list of ref items.
  */
 export function refExpressionListToRefItemList(context, refExpressionList) {
-    return refExpressionList.map((ref) => refExpressionToRefItem(context, ref));
+    return refExpressionList.map((ref) => parseRef(context, ref));
 }
 /**
  * Sugar for converting a `refExpression` directly into a shape, without the
@@ -129,8 +124,8 @@ export function refExpressionListToRefItemList(context, refExpressionList) {
  * A ref expression might include "template" name and refer to a local or remote
  * shape, `Foo` or `CreateArgs<Foo>` or `CreateArgs<remote:Foo>`.
  */
-export function refExpressionToShape(context, refExpression) {
-    return refItemToShape(context, refExpressionToRefItem(context, refExpression));
+export function getShapeByRef(context, refExpression) {
+    return refItemToShape(context, parseRef(context, refExpression));
 }
 /**
  * Provided a service name and a referenced type. Supports 2 or 3 part
@@ -139,32 +134,30 @@ export function refExpressionToShape(context, refExpression) {
  * @returns
  * A 2 member array, where 0 is the service name, 1 is the referenced type.
  */
-export function splitAtRef(atRef) {
-    const index = atRef.lastIndexOf(':');
-    const serviceKey = index === -1 ? 'local' : atRef.substring(0, index);
-    const referencedType = index === -1 ? atRef : atRef.substring(index + 1);
+function splitRefExpression(ref) {
+    const index = ref.lastIndexOf(':');
+    const serviceKey = index === -1 ? LOCAL_LAYER_ID : ref.substring(0, index);
+    const referencedType = index === -1 ? ref : ref.substring(index + 1);
     return [serviceKey, referencedType];
 }
-function isValidServiceId(context, serviceId) {
-    return serviceId === 'local' || Boolean(context.services?.[serviceId]);
+export function isValidServiceId(context, serviceId) {
+    return serviceId === LOCAL_LAYER_ID || Boolean(context.services?.[serviceId]);
+}
+export function isValidRefItem(context) {
+    return (refItem) => {
+        return isValidServiceId(context, refItem.layerId);
+    };
 }
 /**
  * Parses and returns a typeName, serviceKey, and potentially a namespace for
  * the type.
  */
-export function atRefToRefItem(context, atRef, template) {
-    const [serviceKey, typeName] = splitAtRef(atRef);
-    // It's possible the service doesn't have a namespace, or is local and has
-    // no service config.
-    const serviceConfig = context.services?.[serviceKey];
-    const serviceNamespace = serviceConfig?.namespace;
+function refExpressionToRefItem(ref, template) {
+    const [serviceKey, typeName] = splitRefExpression(ref);
     return {
-        typeName,
-        serviceKey,
-        serviceNamespace,
-        template,
-        isForeign: Boolean(serviceConfig),
-        isValidService: isValidServiceId(context, serviceKey)
+        shapeName: typeName,
+        layerId: serviceKey,
+        template
     };
 }
 export function refToRefItem(context, $ref, template) {
@@ -175,39 +168,33 @@ export function refToRefItem(context, $ref, template) {
  */
 export function parseName(context, name) {
     const shapeNameParts = name.split('_');
-    let serviceId;
-    let namespace;
+    let layerId;
     if (shapeNameParts.length > 1) {
         const namespaces = getServiceNamespaces(context);
         const maybeNamespace = shapeNameParts[0];
-        serviceId = namespaces.get(maybeNamespace);
-        if (serviceId) {
+        layerId = namespaces.get(maybeNamespace);
+        if (layerId) {
             name = shapeNameParts.slice(1).join('_');
-            namespace = maybeNamespace;
         }
     }
     return {
         name,
-        serviceId: serviceId ?? 'local',
-        namespace
+        layerId: layerId ?? LOCAL_LAYER_ID
     };
 }
 function shapeNameToRefItem(context, shapeName, template) {
     const parsed = parseName(context, shapeName);
     return {
-        typeName: parsed.name,
-        serviceKey: parsed.serviceId,
-        serviceNamespace: parsed.namespace,
-        template,
-        isForeign: parsed.serviceId !== 'local',
-        isValidService: isValidServiceId(context, parsed.serviceId)
+        shapeName: parsed.name,
+        layerId: parsed.layerId,
+        template
     };
 }
 export function shapeToRefItem(context, shape) {
     return shapeNameToRefItem(context, shape.name);
 }
 export function shapeToRefString(context, shape) {
-    return refItemToAtRef(shapeNameToRefItem(context, shape.name));
+    return serializeRef(shapeNameToRefItem(context, shape.name));
 }
 /**
  * Given a property schema and project schema, finds a `@ref` or `$ref` and
@@ -217,21 +204,20 @@ export function getRef(context, refSchema) {
     if (refSchema['@ref']) {
         // @ref: my-service:ShapeName
         const { shapeName, template } = parseTemplateShape(refSchema['@ref']);
-        return atRefToRefItem(context, shapeName, template);
+        return refExpressionToRefItem(shapeName, template);
     }
     if (refSchema.$ref) {
         // $ref: #/shapes/[ShapeName OR Namespace_TypeName]/schema
         return refToRefItem(context, refSchema.$ref);
     }
 }
-export function getRefWithPath(context, refSchema, schemaPath = [], isInterfaceRef = false) {
+export function getRefWithPath(context, refSchema, schemaPath = []) {
     const refItem = getRef(context, refSchema);
     if (refItem) {
-        const refType = getRefType(refSchema);
+        const refType = refSchema['@ref'] ? '@ref' : '$ref';
         return {
             ...refItem,
-            path: schemaPath.concat([refType]),
-            isInterfaceRef
+            path: schemaPath.concat([refType])
         };
     }
 }
@@ -272,28 +258,32 @@ export function getRefOrItemsRef(context, refSchema, schemaPath = []) {
 /**
  * Turns a `RefItem` into an `@ref`.
  */
-export function refItemToAtRef(refItem) {
-    const shapeRef = `${refItem.serviceKey}:${refItem.typeName}`;
+export function serializeRef(refItem) {
+    const shapeRef = formatShapeRef(refItem.layerId, refItem.shapeName);
     return refItem.template ? createTemplateShapeName(refItem.template, shapeRef) : shapeRef;
 }
 /**
  * Turns a `RefItem` into a standard shape name, namespacing if present.
  */
-export function refItemToNamespacedShapeName(refItem) {
-    const { serviceNamespace, typeName } = refItem;
-    return serviceNamespace ? `${serviceNamespace}_${typeName}` : typeName;
+export function refItemToNamespacedShapeName(context, refItem) {
+    const { shapeName, layerId } = refItem;
+    const namespace = getNamespace(context, layerId);
+    return namespace ? `${namespace}_${shapeName}` : shapeName;
+}
+export function refExpressionToNamespacedName(context, refExpression) {
+    return refItemToNamespacedShapeName(context, parseRef(context, refExpression));
 }
 /**
  * Turns a `RefItem` into a path suitable for `lodash.get`.
  */
-export function refItemToShapePath(refItem) {
-    return ['shapes', refItemToNamespacedShapeName(refItem)];
+export function refItemToShapePath(context, refItem) {
+    return ['shapes', refItemToNamespacedShapeName(context, refItem)];
 }
 /**
  * Get a Shape referenced by a `RefItem`.
  */
 export function refItemToShape(context, refItem) {
-    const shapePath = refItemToShapePath(refItem);
+    const shapePath = refItemToShapePath(context, refItem);
     return get(context, shapePath);
 }
 /**
@@ -306,7 +296,7 @@ export function refItemListToShapeList(context, refItems) {
  * Get a shape referenced by a `RefItem`, also returning the path to the new shape.
  */
 export function refItemToShapeWithPath(context, refItem) {
-    const shapePath = refItemToShapePath(refItem);
+    const shapePath = refItemToShapePath(context, refItem);
     const shape = get(context, shapePath);
     return shape ? { shape, path: shapePath } : undefined;
 }
@@ -314,7 +304,7 @@ export function refItemToShapeWithPath(context, refItem) {
  * Get a Shape schema referenced by a `RefItem`.
  */
 export function refItemToShapeSchema(context, refItem) {
-    const shapePath = refItemToShapePath(refItem);
+    const shapePath = refItemToShapePath(context, refItem);
     return get(context, [...shapePath, 'schema']);
 }
 /**
@@ -322,14 +312,14 @@ export function refItemToShapeSchema(context, refItem) {
  */
 export function getRefShapeName(context, refSchema) {
     const refItem = getRef(context, refSchema);
-    return refItem ? refItemToNamespacedShapeName(refItem) : undefined;
+    return refItem ? refItemToNamespacedShapeName(context, refItem) : undefined;
 }
 /**
  * Sugar, for when you really just need a path...
  */
-export function anyRefToShapeSchemaPath(context, refSchema) {
+export function refSchemaToShapeSchemaPath(context, refSchema) {
     const refItem = getRef(context, refSchema);
-    return refItem ? [...refItemToShapePath(refItem), 'schema'] : undefined;
+    return refItem ? [...refItemToShapePath(context, refItem), 'schema'] : undefined;
 }
 /**
  * Helper fn to omit `ref` props from the target schema, and then extend it with the source schema.
@@ -369,7 +359,8 @@ export function hasRef(schema) {
  */
 export function hasResolvableRef(context, schema) {
     if (isRefSchema(schema) || isRefSchemaLegacy(schema)) {
-        return Boolean(refItemToShapeSchema(context, getRef(context, schema)));
+        const ref = getRef(context, schema);
+        return Boolean(ref && refItemToShapeSchema(context, ref));
     }
     if (isAllOfSchema(schema)) {
         return Boolean(schema.allOf.find((s) => hasResolvableRef(context, s)));
@@ -440,29 +431,28 @@ export function dereferenceObjectSchema(context, shapeOrFieldSchema, schemaPath
     }
     return schema;
 }
-function getNamespace(context, serviceId) {
-    return context.services?.[serviceId]?.namespace;
+function getNamespace(context, layerId) {
+    return context.services?.[layerId]?.namespace;
 }
 export function createGetNamespace(context) {
-    return (serviceId) => getNamespace(context, serviceId);
+    return (layerId) => getNamespace(context, layerId);
 }
 export function parsePropertyRef(refStr) {
-    const [serviceId, coordinate] = splitAtRef(refStr);
+    const [layerId, coordinate] = splitRefExpression(refStr);
     const coordinateParts = coordinate.split('.');
     if (coordinateParts.length === 1) {
-        return { serviceId, shapeName: 'Query', propertyName: coordinateParts[0] };
+        return { layerId, shapeName: 'Query', propertyName: coordinateParts[0] };
     }
     if (coordinateParts.length === 2) {
         return {
-            serviceId,
+            layerId,
             shapeName: coordinateParts[0],
             propertyName: coordinateParts[1]
         };
     }
 }
-export function serializePropertyRef({ shapeName, propertyName, serviceId }) {
-    const coordinate = `${shapeName}.${propertyName}`;
-    return serviceId === 'local' ? coordinate : `${serviceId}:${coordinate}`;
+export function serializePropertyRef({ shapeName, propertyName, layerId }) {
+    return formatShapeRef(layerId, `${shapeName}.${propertyName}`);
 }
 export function normalizePropertyRef(refStr) {
     const parsed = parsePropertyRef(refStr);
@@ -473,10 +463,10 @@ export function propertyRefToShapeRef(propertyRef) {
     if (!parsed) {
         throw new Error(`Invalid property ref "${propertyRef}`);
     }
-    return formatShapeRef(parsed.serviceId, parsed.shapeName);
+    return formatShapeRef(parsed.layerId, parsed.shapeName);
 }
-export function formatShapeRef(serviceId, shapeName) {
-    return `${serviceId}:${shapeName}`;
+export function formatShapeRef(layerId, shapeName) {
+    return layerId === LOCAL_LAYER_ID ? shapeName : `${layerId}:${shapeName}`;
 }
 export function applyNamespace(namespace, name) {
     return namespace ? `${namespace}_${name}` : name;
@@ -489,25 +479,9 @@ export function propertyRefItemToArgsPath(getNamespace, item) {
     const path = propertyRefItemToPath(getNamespace, item);
     return path.concat(path[0] === 'shapes' ? '@args' : 'args');
 }
-export function propertyRefItemToLocalName(getNamespace, item) {
-    const { shapeName, serviceId, propertyName } = item;
-    if (shapeName === 'Query' || shapeName === 'Mutation') {
-        const namespaced = applyNamespace(getNamespace(serviceId), propertyName);
-        return `${shapeName}.${namespaced}`;
-    }
-    return propertyName;
-}
-export function queryRefToLocalName(context, queryRef) {
-    const parsedQueryRef = parsePropertyRef(queryRef);
-    if (parsedQueryRef) {
-        return parsedQueryRef.serviceId === 'local'
-            ? parsedQueryRef.propertyName
-            : propertyRefItemToLocalName(createGetNamespace(context), parsedQueryRef);
-    }
-}
 export function propertyRefItemToPath(getNamespace, item) {
-    const { shapeName, serviceId, propertyName } = item;
-    const namespace = getNamespace(serviceId);
+    const { shapeName, layerId, propertyName } = item;
+    const namespace = getNamespace(layerId);
     if (shapeName === 'Query' || shapeName === 'Mutation') {
         return [shapeName === 'Query' ? 'queries' : 'mutations', applyNamespace(namespace, propertyName)];
     }
@@ -524,7 +498,7 @@ export function propertyRefToArgs(projectSchema, ref) {
  * Get a ref to the given shape.
  */
 export function normalizeRefExpression(context, refExpression) {
-    return refItemToAtRef(refExpressionToRefItem(context, refExpression));
+    return serializeRef(parseRef(context, refExpression));
 }
 export function normalizeLocalRefString(ref) {
     return ref.startsWith('local:') ? ref.substring(6) : ref;
@@ -588,38 +562,28 @@ export function ensureQuery(projectSchema, queryRef) {
     return query;
 }
 export function normalizeRefs(projectSchema, property) {
-    let updatedProperty = {
-        ...property
-    };
-    // Array items
-    if (property.items) {
-        return {
-            ...updatedProperty,
-            items: normalizeRefs(projectSchema, property.items)
-        };
-    }
-    // Unions
-    if (property.oneOf) {
-        return {
-            ...updatedProperty,
-            oneOf: property.oneOf.map((item) => normalizeRefs(projectSchema, item))
-        };
-    }
-    // Convert $ref to @ref
-    const refItem = getRef(projectSchema, updatedProperty);
-    if (refItem && updatedProperty.$ref) {
-        updatedProperty = {
-            ...omit(['$ref'], updatedProperty),
-            '@ref': refItemToAtRef(refItem)
-        };
-    }
-    return updatedProperty;
+    return deepCloneWith(property ?? projectSchema, (value, _key, _parent, clone) => {
+        if (isIterableObject(value)) {
+            const ref = getRef(projectSchema, value);
+            if (ref) {
+                const { $ref, '@output': output, '@input': input, ...newRefSchema } = value;
+                newRefSchema['@ref'] = serializeRef(ref);
+                if (output) {
+                    newRefSchema['@output'] = clone(output, '@output', value);
+                }
+                if (input) {
+                    newRefSchema['@input'] = clone(input, '@input', value);
+                }
+                return newRefSchema;
+            }
+        }
+    });
 }
 /**
  * Get a ShapeJSON from a RefItem, with the schema dereferenced.
  */
 export function getReferencedShape(projectSchema, refItem, namespace) {
-    const shape = getShape(projectSchema, applyNamespace(namespace ?? getNamespace(projectSchema, refItem.serviceId), refItem.shapeName));
+    const shape = getShape(projectSchema, applyNamespace(namespace ?? getNamespace(projectSchema, refItem.layerId), refItem.shapeName));
     if (shape) {
         return {
             ...shape,
@@ -631,7 +595,7 @@ export function getReferencedShape(projectSchema, refItem, namespace) {
  * Get a PropertySchema from a RefItem.
  */
 export function getReferencedShapeProperty(projectSchema, refItem, namespace) {
-    const shape = getReferencedShape(projectSchema, refItem, namespace ?? getNamespace(projectSchema, refItem.serviceId));
+    const shape = getReferencedShape(projectSchema, refItem, namespace ?? getNamespace(projectSchema, refItem.layerId));
     if (shape && isObjectSchema(shape.schema)) {
         return shape.schema.properties[refItem.propertyName];
     }

package/dist/relationships.d.ts

@@ -27,7 +27,7 @@ export declare function getLegacyRelationship(projectSchema: ProjectSchemaJSON,
 export declare function getRelationship(propertySchema: PropertySchema): Maybe<Relationship>;
 export declare function findExistingRelationships(projectSchema: ProjectSchemaJSON, shapes: ShapeMap): Record<string, RelationshipEnv[]>;
 /**
- * Test whether two PropertySchemas have equal realtionships
+ * Test whether two PropertySchemas have equal relationships
  */
 export declare function isEqualRelationship(a: PropertySchema, b: PropertySchema): boolean;
 /**

package/dist/relationships.js

@@ -3,7 +3,7 @@ import camelCase from 'lodash/camelCase.js';
 import find from 'lodash/find.js';
 import uniq from 'lodash/uniq.js';
 import { builtInShapes } from "./builtin-schema.js";
-import { followRef, getRefShapeName } from "./refs.js";
+import { followRef, getRefShapeName, getShapeByRef, shapeToRefString } from "./refs.js";
 import { isModelShape, isObjectSchema, isPropertySchemaWithRelationship } from "./types/index.js";
 import { isUnionSchema } from "./unions.js";
 import { getShapeById } from "./util/shapes.js";
@@ -28,7 +28,7 @@ export function getRelationshipSchema(projectSchema, relationship) {
             .map((shapeId) => {
             const shape = getShapeById(projectSchema, shapeId) ?? find(builtInShapes, (shape) => shape.id === shapeId);
             return (shape && {
-                '@ref': `local:${shape.name}`
+                '@ref': shapeToRefString(projectSchema, shape)
             });
         })
             .filter(isDefined);
@@ -50,7 +50,7 @@ export function getRelationshipSchema(projectSchema, relationship) {
             '@input': {
                 type: 'array',
                 items: {
-                    '@ref': 'local:TSRelationship'
+                    '@ref': 'TSRelationship'
                 }
             }
         };
@@ -59,7 +59,7 @@ export function getRelationshipSchema(projectSchema, relationship) {
         ...propertySchema,
         ...shapeRefsSchema,
         '@input': {
-            '@ref': 'local:TSRelationship'
+            '@ref': 'TSRelationship'
         }
     };
 }
@@ -81,25 +81,15 @@ export function getRelationshipShapeRefs(propertySchema) {
  * Get a list of shapes given a property schema with a relationship resolver.
  */
 export function getRelationshipShapes(shapes, refs) {
-    return refs
-        .map((ref) => {
-        const shapeName = ref.split(':')[1];
-        const shape = shapes[shapeName];
-        return shape ? shape : undefined;
-    })
-        .filter(isDefined);
+    const context = { shapes };
+    return refs.map((ref) => getShapeByRef(context, ref)).filter(isDefined);
 }
 /**
  * Get a list of shape ids given a property schema with a relationship resolver.
  */
 export function getRelationshipShapeIds(shapes, refs) {
-    return refs
-        .map((ref) => {
-        const shapeName = ref.split(':')[1];
-        const shape = shapes[shapeName];
-        return shape ? shape.id : undefined;
-    })
-        .filter(isDefined);
+    const context = { shapes };
+    return refs.map((ref) => getShapeByRef(context, ref)?.id).filter(isDefined);
 }
 /**
  * Turn a Relationship into a LegacyRelationship object.
@@ -193,7 +183,7 @@ export function findExistingRelationships(projectSchema, shapes) {
     return relationships;
 }
 /**
- * Test whether two PropertySchemas have equal realtionships
+ * Test whether two PropertySchemas have equal relationships
  */
 export function isEqualRelationship(a, b) {
     const relationshipA = getRelationship(a);
@@ -236,23 +226,24 @@ export function addRelatedFields(projectSchema, allRelationships) {
         const shape = getShapeById(projectSchema, shapeId);
         if (shape && isObjectSchema(shape.schema)) {
             const relatedShapeIds = getRelatedShapeIds(shapeRelationships);
-            const relatedShapeNames = getShapes(projectSchema, relatedShapeIds).map((shape) => shape.name);
-            if (relatedShapeNames.length) {
-                let shapeName;
-                if (relatedShapeNames.length === 1) {
+            const relatedShapeRefs = getShapes(projectSchema, relatedShapeIds).map((shape) => shapeToRefString(projectSchema, shape));
+            if (relatedShapeRefs.length) {
+                let shapeRef;
+                if (relatedShapeRefs.length === 1) {
                     // If only one back reference exists, _references is a regular shape
-                    shapeName = relatedShapeNames[0];
+                    shapeRef = relatedShapeRefs[0];
                 }
                 else {
                     // If many back references exist, _references will be a union of referring shapes
-                    shapeName = `${shape.name}Reference`;
+                    const shapeName = `${shape.name}Reference`;
+                    shapeRef = shapeName;
                     projectSchema.shapes[shapeName] = {
                         id: shapeName,
                         name: shapeName,
                         title: shapeName,
                         schema: {
-                            oneOf: relatedShapeNames.map((name) => ({
-                                '@ref': `local:${name}`
+                            oneOf: relatedShapeRefs.map((name) => ({
+                                '@ref': name
                             }))
                         }
                     };
@@ -262,8 +253,8 @@ export function addRelatedFields(projectSchema, allRelationships) {
                 // It is for convenience.
                 if (shapeRelationships.some((rel) => rel.hasBackreference)) {
                     shape.schema.properties._references = {
-                        '@args': `TSListArgs<local:${shapeName}>`,
-                        '@ref': `PaginatedList<local:${shapeName}>`,
+                        '@args': `TSListArgs<${shapeRef}>`,
+                        '@ref': `PaginatedList<${shapeRef}>`,
                         '@resolver': {
                             name: 'shapedb:list',
                             service: 'shapedb',
@@ -286,8 +277,8 @@ export function addRelatedFields(projectSchema, allRelationships) {
                     const relatedFieldName = relatedName ? relatedName : `${camelCase(relatedShape.name)}Set`;
                     const filterField = relatedName ? relationship.path.concat('_id').join('.') : '_references';
                     shape.schema.properties[relatedFieldName] = {
-                        '@args': `TSListArgs<local:${relatedShape.name}>`,
-                        '@ref': `PaginatedList<local:${relatedShape.name}>`,
+                        '@args': `TSListArgs<${relatedShape.name}>`,
+                        '@ref': `PaginatedList<${relatedShape.name}>`,
                         '@resolver': {
                             name: 'shapedb:list',
                             service: 'shapedb',