@takeshape/schema 11.89.0 → 11.92.0

package/dist/schema-util.d.ts

@@ -1,11 +1,11 @@
 import { type Maybe } from '@takeshape/util';
-import type { FieldMapping, ProjectSchemaJSON, PropertySchema, QueryJSON, ServiceConfig, ShapeJSON, ShapeMap, ShapeSchema } from './project-schema/index.ts';
+import type { ProjectSchemaJSON, PropertySchema, QueryJSON, ServiceConfig, ShapeJSON, ShapeMap, ShapeSchema } from './project-schema/index.ts';
 import { type RefItem, type RefItemWithPath, type ServicesContext, type ServicesShapesContext } from './refs.ts';
-import { type LatestProjectSchemaWithServices, type LayerSchema, type SchemaPath, type SchemaPropertyName, type SchemaPropertyNode, type SchemaWithArgs, type SchemaWithRef, type ServiceMap } from './types/index.ts';
+import { type LatestProjectSchemaWithServices, type LayerSchema, type SchemaPath, type SchemaPropertyName, type SchemaPropertyNode, type SchemaWithArgs, type ServiceMap } from './types/index.ts';
 export declare function isBuiltinShape(shapeName: string): boolean;
 export declare function isBuiltinQuery(name: string): boolean;
 export declare function isBuiltinMutation(name: string): boolean;
-export declare function isBuiltinType(projectSchema: ProjectSchemaJSON, refSchema: SchemaWithRef): boolean;
+export declare function isBuiltinType(projectSchema: ProjectSchemaJSON, refSchema: PropertySchema): boolean;
 export declare const schemaMetadataKeys: readonly ["$comment", "title", "description", "@l10n", "@deprecationReason", "@tag", "@tags", "@syncLocaleStructure", "@sensitive"];
 export declare const commonSchemaKeys: readonly ["type", "default", "readOnly", "$comment", "title", "description", "@l10n", "@deprecationReason", "@tag", "@tags", "@syncLocaleStructure", "@sensitive"];
 export declare const scalarSchemaKeys: readonly ["type", "default", "readOnly", "$comment", "title", "description", "@l10n", "@deprecationReason", "@tag", "@tags", "@syncLocaleStructure", "@sensitive", "format", "oneOf", "multipleOf", "maximum", "exclusiveMaximum", "minimum", "exclusiveMinimum", "maxLength", "minLength", "pattern"];
@@ -41,7 +41,6 @@ export declare function applyBuiltinPropertiesToShape(projectSchema: ProjectSche
  */
 export declare function getBuiltinsUsed(projectSchema: ProjectSchemaJSON): ShapeMap;
 export declare function applyDefaultsToSchema<T extends ProjectSchemaJSON>(projectSchema: T): T;
-export declare function getShapeByRef(projectSchema: ServicesShapesContext, shapeRef: string): ShapeJSON | undefined;
 export declare function getArgsReference(projectSchema: ServicesContext, argsSchema: SchemaWithArgs): Maybe<RefItem>;
 export declare function getArgsReferenceWithPath(context: ServicesContext, argsSchema: SchemaWithArgs, schemaPath?: SchemaPath): Maybe<RefItemWithPath>;
 export declare function getArgsShapeSchema(context: ServicesShapesContext, argsSchema: SchemaWithArgs): Maybe<ShapeSchema>;
@@ -99,7 +98,7 @@ export declare function shapeToJsonSchema(projectSchema: ProjectSchemaJSON, shap
     '@l10n'?: boolean;
     '@key'?: string;
     '@workflow'?: string;
-    '@mapping'?: FieldMapping;
+    '@mapping'?: import("./project-schema/latest.ts").FieldMapping;
     '@tag'?: string;
     '@tags'?: string[];
     '@deprecationReason'?: string;
@@ -147,30 +146,20 @@ export declare function getAllRefsInQueries(projectSchema: Pick<ProjectSchemaJSO
  * @param predicate return true to include the ref in
  */
 export declare function getAllRefs(projectSchema: Pick<ProjectSchemaJSON, 'queries' | 'mutations' | 'shapes' | 'services'>, predicate?: RefPredicate): RefItemWithPath[];
-export declare function isValidRefItem(refItem: RefItem): boolean;
 /**
  * Get all valid refs in a ProjectSchemaJSON
  * @param predicate return true to include the ref in
  */
 export declare function getAllValidRefs(projectSchema: Pick<ProjectSchemaJSON, 'queries' | 'mutations' | 'shapes' | 'services'>, predicate?: RefPredicate): RefItemWithPath[];
-export type Mapping = {
-    providerId: string;
-    serviceId: string;
-    shapeName: string;
-    key: string;
-};
-export declare function parseMapping(mapping: string): Mapping;
 export declare function splitMapping(mapping: string): string[];
 export declare function findMapping(schema: PropertySchema, predicate: (mappingStr: string) => boolean): string | undefined;
 export declare function getFirstMapping(schema: PropertySchema): string | undefined;
-export declare function getFullyQualifiedShapeName(schema: PropertySchema): string | undefined;
 /**
  * Find key for use storing data in ShapeDB or API Indexing this allows renaming of properties without db migration
  * Mapping must be using the shapedb service id
  * @param schema
  */
 export declare function getStorageKey(schema: PropertySchema): string | undefined;
-export declare function getPropertyService(schema: PropertySchema): string | undefined;
 export declare function emptySchema(projectId: string): ProjectSchemaJSON;
 export declare function createLayerSchema(partialSchema?: Partial<LayerSchema>): LayerSchema;
 export declare function getShapesById(projectSchema: ProjectSchemaJSON): ShapeMap;
@@ -264,7 +253,6 @@ export declare const getDefaultMutationName: (shapeName: string, resolver: Resol
 export declare function createShape(name: string, schema: ShapeSchema, rest?: Partial<ShapeJSON>): ShapeJSON;
 export declare function queryToPropertySchema(projectSchema: ProjectSchemaJSON, query: QueryJSON): PropertySchema;
 export declare function getQueriesShape(projectSchema: ProjectSchemaJSON, operation: 'query' | 'mutation'): ShapeJSON;
-export declare function fieldMappingContainsKey(fieldMapping: FieldMapping, key: string): boolean;
 /**
  * Return true if `schemaWithRef` is a ref to a shape named `shapeName`
  */

package/dist/schema-util.js

@@ -5,12 +5,11 @@ import isArray from 'lodash/isArray.js';
 import isString from 'lodash/isString.js';
 import keyBy from 'lodash/keyBy.js';
 import mapValues from 'lodash/mapValues.js';
-import some from 'lodash/some.js';
 import uniq from 'lodash/uniq.js';
 import { workflowsEnabled } from "./api-version.js";
 import { builtInForms, builtInShapes } from "./builtin-schema.js";
 import { SERVICE_OBJECT_PATTERN_NAME } from "./constants.js";
-import { atRefToRefItem, createTemplateShapeName, dereferenceObjectSchema, dereferenceSchema, getRef, getRefOrItemsRef, getRefShapeName, parseReturnShape, parseTemplateShape, refExpressionToRefItem, refItemToNamespacedShapeName, refItemToShape, refItemToShapeSchema, refToRefItem, returnShapeToSchema, serializePropertyRef } from "./refs.js";
+import { createTemplateShapeName, dereferenceObjectSchema, dereferenceSchema, getRef, getRefOrItemsRef, getRefShapeName, isValidRefItem, parseRef, parseReturnShape, refItemToNamespacedShapeName, refItemToShape, refItemToShapeSchema, refToRefItem, returnShapeToSchema, serializePropertyRef } from "./refs.js";
 import { getArgsType, isAllOfSchema, isArraySchema, isCachedShape, isExtendsSchema, isGraphqlResolver, isModelShape, isObjectSchema, isOneOfSchema, isReferenceableShape, isRefSchema } from "./types/index.js";
 import { isUnionSchema } from "./unions.js";
 import { getArgs } from "./util/has-arg.js";
@@ -384,7 +383,7 @@ const requiredBuiltinShapes = ['Asset', 'TSRelationship', 'TSStaticSite', 'TSUse
  */
 export function getBuiltinsUsed(projectSchema) {
     const builtinsUsed = {};
-    const shapeNames = uniq(requiredBuiltinShapes.concat(getAllRefs(projectSchema, (refItem) => refItem.serviceKey === 'local' && isBuiltinShape(refItem.typeName)).map(refItemToNamespacedShapeName)));
+    const shapeNames = uniq(requiredBuiltinShapes.concat(getAllRefs(projectSchema, (refItem) => refItem.layerId === 'local' && isBuiltinShape(refItem.shapeName)).map((ref) => refItemToNamespacedShapeName(projectSchema, ref))));
     const schemaWithAllBuiltins = {
         ...emptySchema('project-id'),
         shapes: builtInShapes
@@ -437,14 +436,11 @@ export function applyDefaultsToSchema(projectSchema) {
         })
     };
 }
-export function getShapeByRef(projectSchema, shapeRef) {
-    return refItemToShape(projectSchema, atRefToRefItem(projectSchema, shapeRef));
-}
 export function getArgsReference(projectSchema, argsSchema) {
     const args = getArgs(argsSchema);
     if (args && typeof args === 'string') {
         // @args: ShapeName OR Namespace_TypeName
-        return refExpressionToRefItem(projectSchema, args);
+        return parseRef(projectSchema, args);
     }
 }
 export function getArgsReferenceWithPath(context, argsSchema, schemaPath = []) {
@@ -500,7 +496,7 @@ const createShapeToPropertySchema = (projectSchema, definitions, definitionNames
             }
             const refItem = getRef(projectSchema, propSchema);
             if (refItem) {
-                const shapeName = refItemToNamespacedShapeName(refItem);
+                const shapeName = refItemToNamespacedShapeName(projectSchema, refItem);
                 const shape = refItemToShape(projectSchema, refItem);
                 if (shape) {
                     delete propSchema['@ref'];
@@ -689,7 +685,7 @@ export function getAllRefsInShapes(projectSchema, predicate) {
         if (propName === 'interfaces' && isArray(interfaces)) {
             interfaces.forEach((interfaceRefExpression, index) => {
                 addRef(items, {
-                    ...refExpressionToRefItem(projectSchema, interfaceRefExpression),
+                    ...parseRef(projectSchema, interfaceRefExpression),
                     path: [...path, index]
                 }, predicate);
             });
@@ -701,14 +697,13 @@ export function getAllRefsInShapes(projectSchema, predicate) {
             return;
         }
         if (propName === '@ref') {
-            const { shapeName, template } = parseTemplateShape(interfaces);
-            addRef(items, { ...atRefToRefItem(projectSchema, shapeName, template), path }, predicate);
+            addRef(items, { ...parseRef(projectSchema, interfaces), path }, predicate);
         }
         else if (propName === '$ref') {
             addRef(items, { ...refToRefItem(projectSchema, interfaces), path }, predicate);
         }
         else if (propName === '@args' || propName === 'args') {
-            addRef(items, { ...refExpressionToRefItem(projectSchema, interfaces), path }, predicate);
+            addRef(items, { ...parseRef(projectSchema, interfaces), path }, predicate);
         }
     });
     return items;
@@ -764,25 +759,12 @@ export function getAllRefs(projectSchema, predicate) {
         ...getAllRefsInQueries(projectSchema, 'mutations', predicate)
     ];
 }
-export function isValidRefItem(refItem) {
-    return refItem.isValidService;
-}
 /**
  * Get all valid refs in a ProjectSchemaJSON
  * @param predicate return true to include the ref in
  */
 export function getAllValidRefs(projectSchema, predicate) {
-    return getAllRefs(projectSchema, predicate).filter(isValidRefItem);
-}
-export function parseMapping(mapping) {
-    const [providerId, serviceId, coordinate] = mapping.split(':');
-    const [shapeName, key] = coordinate.split('.');
-    return {
-        providerId,
-        serviceId,
-        shapeName,
-        key
-    };
+    return getAllRefs(projectSchema, predicate).filter(isValidRefItem(projectSchema));
 }
 export function splitMapping(mapping) {
     const parts = mapping.split('.');
@@ -798,10 +780,6 @@ export function findMapping(schema, predicate) {
 export function getFirstMapping(schema) {
     return Array.isArray(schema['@mapping']) ? schema['@mapping'][0] : schema['@mapping'];
 }
-export function getFullyQualifiedShapeName(schema) {
-    const first = getFirstMapping(schema);
-    return first ? splitMapping(first)[0] : undefined;
-}
 /**
  * Find key for use storing data in ShapeDB or API Indexing this allows renaming of properties without db migration
  * Mapping must be using the shapedb service id
@@ -811,11 +789,6 @@ export function getStorageKey(schema) {
     const first = findMapping(schema, (mapping) => mapping.startsWith('shapedb:'));
     return first ? splitMapping(first)[1] : undefined;
 }
-export function getPropertyService(schema) {
-    const first = getFirstMapping(schema);
-    const split = first?.split(':');
-    return split ? `${split[0]}:${split[1]}` : undefined;
-}
 export function emptySchema(projectId) {
     return {
         projectId,
@@ -851,8 +824,8 @@ export function getShapesById(projectSchema) {
  * @returns A `string` array with all the shapes that are in namespaces.
  */
 export function getAllNamespaceShapes(projectSchema) {
-    const isServiceRef = (refItem) => Boolean(refItem.serviceNamespace);
-    return uniq(getAllValidRefs(projectSchema, isServiceRef).map(refItemToNamespacedShapeName));
+    const isServiceRef = (refItem) => refItem.layerId !== 'local';
+    return uniq(getAllValidRefs(projectSchema, isServiceRef).map((ref) => refItemToNamespacedShapeName(projectSchema, ref)));
 }
 /**
  * Returns a list of all shape names in a service namespace, excluding any
@@ -1052,7 +1025,7 @@ export function queryToPropertySchema(projectSchema, query) {
     let mapping;
     if (isGraphqlResolver(query.resolver)) {
         mapping = serializePropertyRef({
-            serviceId: query.resolver.service,
+            layerId: query.resolver.service,
             shapeName: 'Query',
             propertyName: query.resolver.fieldName
         });
@@ -1070,18 +1043,12 @@ export function getQueriesShape(projectSchema, operation) {
         properties: mapValues(projectSchema[operation === 'query' ? 'queries' : 'mutations'], (query) => queryToPropertySchema(projectSchema, query))
     });
 }
-export function fieldMappingContainsKey(fieldMapping, key) {
-    if (isArray(fieldMapping)) {
-        return some(fieldMapping, (mapping) => parseMapping(mapping).key === key);
-    }
-    return parseMapping(fieldMapping).key === key;
-}
 /**
  * Return true if `schemaWithRef` is a ref to a shape named `shapeName`
  */
 export function schemaMatchesShapeName(workingCopy, propertySchema, shapeName) {
     const arrayOfShapeRef = getRef(workingCopy, propertySchema);
-    return Boolean(arrayOfShapeRef && refItemToNamespacedShapeName(arrayOfShapeRef) === shapeName);
+    return Boolean(arrayOfShapeRef && refItemToNamespacedShapeName(workingCopy, arrayOfShapeRef) === shapeName);
 }
 /**
  * Return true if `shape` has a property that is an array of refs to `shapeName`

package/dist/schemas/project-schema/experimental.json

@@ -30,11 +30,115 @@
           "items": {
             "$ref": "#/definitions/agentGuard"
           }
+        },
+        "historyStrategies": {
+          "$ref": "#/definitions/historyStrategyMap"
         }
       },
       "required": ["start", "states", "api"],
       "additionalProperties": false
     },
+    "historyStrategyMap": {
+      "title": "History Strategy Map",
+      "type": "object",
+      "patternProperties": {
+        "^[0-9A-Za-z_]+$": {
+          "$ref": "#/definitions/historyStrategy"
+        }
+      },
+      "additionalProperties": false
+    },
+    "historyStrategy": {
+      "title": "History Strategy",
+      "type": "object",
+      "properties": {
+        "name": {
+          "type": "string"
+        },
+        "variables": {
+          "title": "Variables",
+          "type": "array",
+          "items": {
+            "$ref": "#/definitions/agentVariable"
+          }
+        },
+        "filter": {
+          "$ref": "#/definitions/historyStrategyFilter"
+        },
+        "execution": {
+          "$ref": "#/definitions/historyStrategyExecution"
+        }
+      },
+      "required": ["name", "execution"],
+      "additionalProperties": false
+    },
+    "historyStrategyFilter": {
+      "title": "History Strategy Filter",
+      "type": "object",
+      "properties": {
+        "toolCalls": {
+          "enum": ["retain", "clear"]
+        }
+      },
+      "additionalProperties": false
+    },
+    "historyStrategyExecution": {
+      "title": "History Strategy Execution",
+      "discriminator": {
+        "propertyName": "type"
+      },
+      "oneOf": [
+        {
+          "$ref": "#/definitions/historyStrategyExecutionReplace"
+        },
+        {
+          "$ref": "#/definitions/historyStrategyExecutionSummarize"
+        }
+      ]
+    },
+    "historyStrategyExecutionReplace": {
+      "title": "History Strategy Execution Replace",
+      "type": "object",
+      "properties": {
+        "type": {
+          "enum": ["replace"]
+        },
+        "template": {
+          "type": "string"
+        }
+      },
+      "required": ["type", "template"],
+      "additionalProperties": false
+    },
+    "historyStrategyExecutionSummarize": {
+      "title": "History Strategy Execution Summarize",
+      "type": "object",
+      "properties": {
+        "type": {
+          "enum": ["generate"]
+        },
+        "service": {
+          "type": "string"
+        },
+        "model": {
+          "type": "string"
+        },
+        "systemPrompt": {
+          "type": "string"
+        },
+        "tools": {
+          "type": "array",
+          "items": {
+            "$ref": "#/definitions/agentToolConfig"
+          }
+        },
+        "options": {
+          "$ref": "#/definitions/agentGenerateOptions"
+        }
+      },
+      "required": ["type", "service", "model", "systemPrompt"],
+      "additionalProperties": false
+    },
     "tool": {
       "title": "Tool JSON",
       "type": "object",
@@ -604,59 +708,6 @@
       "required": ["type", "argName", "variableName"],
       "additionalProperties": false
     },
-    "agentChatHistoryConfig": {
-      "title": "Agent Chat History Config",
-      "discriminator": {
-        "propertyName": "type"
-      },
-      "oneOf": [
-        {
-          "$ref": "#/definitions/agentChatHistoryRetain"
-        },
-        {
-          "$ref": "#/definitions/agentChatHistorySummarize"
-        },
-        {
-          "$ref": "#/definitions/agentChatHistoryClear"
-        }
-      ]
-    },
-    "agentChatHistoryRetain": {
-      "title": "Agent Chat History Retain",
-      "type": "object",
-      "properties": {
-        "type": {
-          "enum": ["retain"]
-        }
-      },
-      "required": ["type"],
-      "additionalProperties": false
-    },
-    "agentChatHistorySummarize": {
-      "title": "Agent Chat History Summarize",
-      "type": "object",
-      "properties": {
-        "type": {
-          "enum": ["summarize"]
-        },
-        "toolCalls": {
-          "enum": ["retain", "clear"]
-        }
-      },
-      "required": ["type", "toolCalls"],
-      "additionalProperties": false
-    },
-    "agentChatHistoryClear": {
-      "title": "Agent Chat History Clear",
-      "type": "object",
-      "properties": {
-        "type": {
-          "enum": ["clear"]
-        }
-      },
-      "required": ["type"],
-      "additionalProperties": false
-    },
     "agentExecutionGenerate": {
       "title": "Agent Execution Generate",
       "type": "object",
@@ -720,9 +771,6 @@
             "$ref": "#/definitions/agentToolConfig"
           }
         },
-        "history": {
-          "$ref": "#/definitions/agentChatHistoryConfig"
-        },
         "options": {
           "$ref": "#/definitions/agentGenerateOptions"
         }
@@ -747,6 +795,9 @@
         },
         "limit": {
           "type": "integer"
+        },
+        "historyStrategy": {
+          "type": "string"
         }
       },
       "additionalProperties": false,

package/dist/service-dependencies.js

@@ -4,8 +4,8 @@ import isObject from 'lodash/isObject.js';
 import pick from 'lodash/pick.js';
 import set from 'lodash/set.js';
 import { getImplementationShapeNameMap, isInterfaceShape, pruneUnusedInterfaces } from "./interfaces.js";
-import { createGetNamespace, dereferenceObjectSchema, getAllPropertyRefs, getRef, getRefShapeName, propertyRefItemToPath, refExpressionToRefItem, refItemToNamespacedShapeName } from "./refs.js";
-import { getAllNamespaceShapes, getAllRefsInQuery, getArgsReference, isValidRefItem, visitSchemaProperties } from "./schema-util.js";
+import { createGetNamespace, dereferenceObjectSchema, getAllPropertyRefs, getRef, getRefShapeName, isValidRefItem, propertyRefItemToPath, refExpressionToNamespacedName, refItemToNamespacedShapeName } from "./refs.js";
+import { getAllNamespaceShapes, getAllRefsInQuery, getArgsReference, visitSchemaProperties } from "./schema-util.js";
 import { isExtendsSchema, isObjectSchema, isProjectSchemaWithServices } from "./types/index.js";
 function getGraphQLServiceShapeMap(layers) {
     return Object.assign({}, ...Object.values(layers).map((layer) => layer.schema?.shapes ?? {}));
@@ -22,7 +22,7 @@ function getMissingPropertyRefs(projectSchema, getNamespace) {
     });
 }
 function refToQuery(serviceSchemas, ref) {
-    const serviceSchema = serviceSchemas[ref.serviceId]?.schema;
+    const serviceSchema = serviceSchemas[ref.layerId]?.schema;
     if (serviceSchema) {
         if (ref.shapeName === 'Query' || ref.shapeName === 'Mutation') {
             const operation = ref.shapeName === 'Query' ? 'queries' : 'mutations';
@@ -34,11 +34,11 @@ function getShapeRefs(services, serviceSchemas, propertyRefs) {
     const results = [];
     for (const ref of propertyRefs) {
         const query = refToQuery(serviceSchemas, ref);
-        const layerSchema = serviceSchemas[ref.serviceId]?.schema;
+        const layerSchema = serviceSchemas[ref.layerId]?.schema;
         if (query && layerSchema) {
             const layerWithService = {
                 ...layerSchema,
-                services: pick(services, [ref.serviceId]) // include own service so refs have isValidService: true
+                services: pick(services, [ref.layerId]) // include own service so refs have isValidService: true
             };
             results.push(...getAllRefsInQuery(layerWithService, [], query));
         }
@@ -46,14 +46,14 @@ function getShapeRefs(services, serviceSchemas, propertyRefs) {
     return results;
 }
 function interfacesToShapeNames(projectSchema, shapeRefArray) {
-    return shapeRefArray.map((shapeRef) => refItemToNamespacedShapeName(refExpressionToRefItem(projectSchema, shapeRef)));
+    return shapeRefArray.map((shapeRef) => refExpressionToNamespacedName(projectSchema, shapeRef));
 }
 /**
  * Add all referenced shape names to the refSet meant to be used as a callback to visitSchemaProperties
  */
 export function collectReferencedShapeNames(context, shapeNames) {
     const addRef = (refItem) => {
-        shapeNames.add(refItemToNamespacedShapeName(refItem));
+        shapeNames.add(refItemToNamespacedShapeName(context, refItem));
     };
     const collect = (schema) => {
         const args = schema['@args'];
@@ -87,8 +87,8 @@ export function resolveSchemaShapeDependencies(projectSchema, serviceLayers) {
             const remoteShapeMap = getGraphQLServiceShapeMap(serviceLayers);
             // Add shape references from queries
             addAll(requiredShapeNames, getShapeRefs(projectSchema.services, serviceLayers, missingPropertyRefs)
-                .filter(isValidRefItem)
-                .map(refItemToNamespacedShapeName));
+                .filter(isValidRefItem(projectSchema))
+                .map((item) => refItemToNamespacedShapeName(projectSchema, item)));
             // Add referenced queries and mutations
             for (const ref of missingPropertyRefs) {
                 const query = refToQuery(serviceLayers, ref);

package/dist/template-shapes/templates.d.ts

@@ -1,8 +1,8 @@
 import type { ObjectSchema, PropertySchema, ShapeJSON } from '../project-schema/index.ts';
 import type { ResolvedTemplate, TemplateContext } from './types.ts';
 import { TemplateVerbs } from './types.ts';
-export declare const TSGetArgs: (context: unknown, shape: ShapeJSON) => ResolvedTemplate;
-export declare const TSGetSingletonArgs: (context: unknown, shape: ShapeJSON) => ResolvedTemplate;
+export declare const TSGetArgs: (_context: unknown, shape: ShapeJSON) => ResolvedTemplate;
+export declare const TSGetSingletonArgs: (_context: unknown, shape: ShapeJSON) => ResolvedTemplate;
 export declare const TSListArgs: (context: TemplateContext, shape: ShapeJSON) => ResolvedTemplate;
 export declare const TSSearchArgs: (context: TemplateContext, shape: ShapeJSON) => ResolvedTemplate;
 export declare const CreateArgs: ({ projectSchema }: TemplateContext, shape: ShapeJSON) => ResolvedTemplate;
@@ -11,22 +11,22 @@ export declare const DuplicateArgs: ({ projectSchema }: TemplateContext, shape:
 export declare const DeleteArgs: ({ projectSchema }: TemplateContext, shape: ShapeJSON) => ResolvedTemplate;
 export declare const PaginatedList: typeof getPaginatedListShape;
 export declare const SearchResults: typeof getSearchResultsShape;
-export declare const CreateResult: (context: unknown, shape: ShapeJSON) => ResolvedTemplate;
-export declare const UpdateResult: (context: unknown, shape: ShapeJSON) => ResolvedTemplate;
-export declare const DuplicateResult: (context: unknown, shape: ShapeJSON) => ResolvedTemplate;
-export declare const DeleteResult: (context: unknown, shape: ShapeJSON) => ResolvedTemplate;
+export declare const CreateResult: (_context: unknown, shape: ShapeJSON) => ResolvedTemplate;
+export declare const UpdateResult: (_context: unknown, shape: ShapeJSON) => ResolvedTemplate;
+export declare const DuplicateResult: (_context: unknown, shape: ShapeJSON) => ResolvedTemplate;
+export declare const DeleteResult: (_context: unknown, shape: ShapeJSON) => ResolvedTemplate;
 export declare const TSSearchSortInput: ShapeJSON;
 export declare const commonSearchProps: Record<string, PropertySchema>;
 export declare const localeProps: ObjectSchema;
 export declare const termsProps: ObjectSchema;
 export declare const TSContentStructureInput: ShapeJSON;
-export declare function getPaginatedListShape(context: unknown, shape: ShapeJSON): ResolvedTemplate;
-export declare function getSearchResultsShape(context: unknown, shape: ShapeJSON): ResolvedTemplate;
-export declare function getIDQueryArgs(templateName: string): (context: unknown, shape: ShapeJSON) => ResolvedTemplate;
+export declare function getPaginatedListShape(_context: unknown, shape: ShapeJSON): ResolvedTemplate;
+export declare function getSearchResultsShape(_context: unknown, shape: ShapeJSON): ResolvedTemplate;
+export declare function getIDQueryArgs(templateName: string): (_context: unknown, shape: ShapeJSON) => ResolvedTemplate;
 /**
  * Construct shapes for a mutation inputs, given source shape info.
  */
 export declare function getMutationArgs(templateName: string, verb: TemplateVerbs): ({ projectSchema }: TemplateContext, shape: ShapeJSON) => ResolvedTemplate;
-export declare function getMutationResultType(verb: TemplateVerbs): (context: unknown, shape: ShapeJSON) => ResolvedTemplate;
+export declare function getMutationResultType(verb: TemplateVerbs): (_context: unknown, shape: ShapeJSON) => ResolvedTemplate;
 export declare const commonSearchArgs: ObjectSchema;
 export declare function getShapeListQueryArgs(templateName: string, legacyArgs: boolean): (context: TemplateContext, shape: ShapeJSON) => ResolvedTemplate;

package/dist/template-shapes/templates.js

@@ -3,7 +3,7 @@ import get from 'lodash/get.js';
 import keyBy from 'lodash/keyBy.js';
 import { createInputSchema } from "../create-input-schema.js";
 import { listTypePrefix } from "../migration/index.js";
-import { getFlattenedTemplateShapeName, getRef, getRefShapeName, refItemToAtRef, refItemToNamespacedShapeName } from "../refs.js";
+import { getFlattenedTemplateShapeName, getRef, getRefShapeName, serializeRef } from "../refs.js";
 import { createShape, getShapeDependencies } from "../schema-util.js";
 import { isCachedShape } from "../types/index.js";
 import { mergeObjectSchemas, mergeSchemaProperties } from "../util/merge.js";
@@ -88,7 +88,7 @@ export const TSContentStructureInput = createShape('TSContentStructureInput', {
     },
     required: ['path']
 }, { description: 'Describes a structural update to an array of data.' });
-export function getPaginatedListShape(context, shape) {
+export function getPaginatedListShape(_context, shape) {
     const shapeName = `${shape.name}${listTypePrefix}`;
     return {
         shapeName,
@@ -104,7 +104,7 @@ export function getPaginatedListShape(context, shape) {
         }
     };
 }
-export function getSearchResultsShape(context, shape) {
+export function getSearchResultsShape(_context, shape) {
     const shapeName = `${shape.name}SearchResults`;
     return {
         shapeName,
@@ -142,7 +142,7 @@ const idSchema = {
     required: ['_id']
 };
 export function getIDQueryArgs(templateName) {
-    return (context, shape) => {
+    return (_context, shape) => {
         const schema = shape.model?.type !== 'single' ? mergeSchemaProperties(idSchema, localeProps) : localeProps;
         const shapeName = getFlattenedTemplateShapeName(shape.name, templateName);
         return {
@@ -161,11 +161,8 @@ function rewriteRefs(context, shapeSchema, rewriteShapeName) {
         if ((value['@ref'] || value.$ref) && !parentPath.includes('@input') && !parentPath.includes('@output')) {
             const refItem = getRef(context, value);
             if (refItem) {
-                value['@ref'] = refItem.isForeign
-                    ? refItemToAtRef(refItem)
-                    : `local:${rewriteShapeName(refItemToNamespacedShapeName(refItem))}`;
+                value['@ref'] = serializeRef(refItem.layerId === 'local' ? { ...refItem, shapeName: rewriteShapeName(refItem.shapeName) } : refItem);
                 if (value.$ref) {
-                    // biome-ignore lint/performance/noDelete: Property presence may matter here
                     delete value.$ref;
                 }
             }
@@ -235,7 +232,7 @@ export function getMutationArgs(templateName, verb) {
     };
 }
 export function getMutationResultType(verb) {
-    return (context, shape) => {
+    return (_context, shape) => {
         const shapeName = formatShapeName([verb, shape.name, 'result'], {
             shapeNameIndex: 1
         });

package/dist/template-shapes/where.js

@@ -4,7 +4,7 @@ import isFunction from 'lodash/isFunction.js';
 import uniqBy from 'lodash/uniqBy.js';
 import unset from 'lodash/unset.js';
 import { workflowsEnabled } from "../api-version.js";
-import { followRef, getRef, getRefOrItemsRef, hasRefProperty, hasResolvableRef, refItemToNamespacedShapeName, refItemToShape } from "../refs.js";
+import { followRef, getRef, getRefOrItemsRef, hasRefProperty, hasResolvableRef, parseRef, refItemToNamespacedShapeName, refItemToShape } from "../refs.js";
 import { getRelationship, getRelationshipShapes, isEqualRelationship } from "../relationships.js";
 import { createSchemaPropertyList, createShape, getAllRefsInShapes } from "../schema-util.js";
 import { isCachedShape, isObjectSchema, isPropertySchemaWithRelationship } from "../types/utils.js";
@@ -144,12 +144,10 @@ function truncateNames(names) {
  * Get a formatted string of related shape names from a property schema with a
  * relationship resolver
  */
-function getRelationshipShapeName(refs) {
+function getRelationshipShapeName(context, refs) {
     return refs
-        .map((ref) => {
-        const shapeName = ref.split(':')[1];
-        return formatShapeName(shapeName);
-    })
+        .map((ref) => formatShapeName(parseRef(context, ref).shapeName))
+        .filter(isDefined)
         .sort()
         .join('');
 }
@@ -164,7 +162,7 @@ function getTypeName(name, prop, shapeName, context) {
     }
     const relationship = getRelationship(prop);
     if (relationship) {
-        const relationshipName = getRelationshipShapeName(relationship.refs);
+        const relationshipName = getRelationshipShapeName(context.projectSchema, relationship.refs);
         if (!relationshipName) {
             throw new Error(`Relationship property "${prop.title ?? ''}" is missing related shapes`);
         }
@@ -183,7 +181,7 @@ function getTypeName(name, prop, shapeName, context) {
         const prefix = `TS${relationshipDepth >= MAX_RELATIONSHIP_DEPTH ? 'Shallow' : ''}Where`;
         const fieldName = `${conflictingProperties?.has(name) ? '_' : ''}${formatShapeName(name)}`;
         const refItem = getRefOrItemsRef(projectSchema, prop);
-        const suffix = refItem ? refItemToNamespacedShapeName(refItem) : `${shapeName}${fieldName}`;
+        const suffix = refItem ? refItemToNamespacedShapeName(projectSchema, refItem) : `${shapeName}${fieldName}`;
         return `${prefix}${suffix}`;
     }
     return `TSWhere${pascalCase(type)}`;
@@ -323,11 +321,11 @@ function getRefSummary(shapes) {
     const result = {};
     for (const ref of getAllRefsInShapes({ shapes, services: {} })) {
         const path = ref.path.slice(1, ref.path.length - 1);
-        if (result[ref.typeName]) {
-            result[ref.typeName].push(path);
+        if (result[ref.shapeName]) {
+            result[ref.shapeName].push(path);
         }
         else {
-            result[ref.typeName] = [path];
+            result[ref.shapeName] = [path];
         }
     }
     return result;