@takeshape/schema 11.89.0 → 11.92.0

package/dist/types/types.d.ts

@@ -105,20 +105,6 @@ export type ServiceConfigUpdate = SetRequired<PartialDeep<ServiceConfigWithNullS
 export type LatestProjectSchemaWithServices = {
     services: ServiceMapJSON;
 } & ProjectSchemaJSON;
-/**
- * Types of refs
- */
-export declare enum RefType {
-    '@ref' = "@ref",
-    $ref = "$ref"
-}
-/**
- * Stub of a PropertySchema that may contain a `$ref` or `@ref`.
- */
-export type RefSchemaStub = {
-    items?: RefSchemaStub;
-} & Pick<PropertySchema, RefType>;
-export type SchemaWithRef = PropertySchema | RefSchemaStub;
 /**
  * Types of args
  */

package/dist/types/types.js

@@ -1,13 +1,5 @@
 export const projectSchemaImportOptionalProps = ['projectId', 'locales', 'defaultLocale', 'author'];
 export const legacyProjectSchemaImportOptionalProps = ['created', 'updated', 'version', 'dataKey'];
-/**
- * Types of refs
- */
-export var RefType;
-(function (RefType) {
-    RefType["@ref"] = "@ref";
-    RefType["$ref"] = "$ref";
-})(RefType || (RefType = {}));
 /**
  * Types of args
  */

package/dist/types/utils.d.ts

@@ -1,7 +1,7 @@
 import type { Maybe } from '@takeshape/util';
 import type { AgentExecution, AgentExecutionChat, AgentExecutionGenerate, AIGenerateTextResolver, AIResolverName, AllOfSchema, AnyServiceConfig, AwsLambdaResolver, BasicAuthentication, BasicResolver, BearerAuthentication, ComposeResolver, CustomAuthentication, DirectiveConfig, DirectiveMappingArray, DirectiveMappingMap, ExtendsSchema, GoogleAuthentication, GraphqlResolver, OAuth2Authentication, OAuth2BearerAuthentication, ObjectSchema, OneOfSchema, ParameterOp, ParameterOpMapping, ParameterOpNested, ParameterOpOp, ParameterOpValue, ParameterSerializeContentOptions, ParameterSerializeOptions, ParameterSerializeStyleOptions, ParameterSerializeStyleOptionsForPathParams, ParameterSerializeStyleOptionsForSearchParams, ProjectSchemaJSON, PropertySchema, RefSchema, RefSchemaLegacy, Resolver, RestResolver, ReturnShape, ReturnShapeArraySchema, SearchParamsAuthentication, ServiceAuthentication, ServiceResolver, ShapedbResolver, ShapeJSON, ShapeMap, ShapeSchemaEnum, TakeshapeResolver, UtilResolver } from '../project-schema/index.ts';
-import type { CachedShape, EncryptedServiceConfig, GraphQLServiceConfig, LatestProjectSchemaWithServices, MeshShape, OpenAPIServiceConfig, PropertySchemaWithRelationship, RESTServiceConfig, ReferenceableShape, SchemaWithArgs, SchemaWithRef, ServiceConfigWithCustomAuthentication, ServiceConfigWithOAuth2Authentication, ShopifyServiceConfig } from './types.ts';
-import { ArgsType, RefType } from './types.ts';
+import type { CachedShape, EncryptedServiceConfig, GraphQLServiceConfig, LatestProjectSchemaWithServices, MeshShape, OpenAPIServiceConfig, PropertySchemaWithRelationship, RESTServiceConfig, ReferenceableShape, SchemaWithArgs, ServiceConfigWithCustomAuthentication, ServiceConfigWithOAuth2Authentication, ShopifyServiceConfig } from './types.ts';
+import { ArgsType } from './types.ts';
 /** Resolver Type Utils **/
 /**
  * Only tests that the shape is right, not that the name is correct. That's a job for the validator.
@@ -103,12 +103,6 @@ export declare function isCustomAuthentication(authentication: ServiceAuthentica
  * @param argsSchema Any schema that may have an `args` property.
  */
 export declare const getArgsType: (argsSchema: SchemaWithArgs) => Maybe<ArgsType>;
-/**
- * A utility to return the type of ref present on a schema.
- *
- * @param refSchema Any schema that may have a `ref` property.
- */
-export declare const getRefType: (refSchema: SchemaWithRef) => Maybe<RefType>;
 export declare function isPropertySchemaWithRelationship(schema: PropertySchema): schema is PropertySchemaWithRelationship;
 export declare function isModelShape(shape: ShapeJSON): boolean;
 export declare function isCachedShape(shape: ShapeJSON): shape is CachedShape;

package/dist/types/utils.js

@@ -5,7 +5,7 @@ import isPlainObject from 'lodash/isPlainObject.js';
 import isString from 'lodash/isString.js';
 import isUndefined from 'lodash/isUndefined.js';
 import { latestSchemaJson } from "../schemas/index.js";
-import { ArgsType, RefType } from "./types.js";
+import { ArgsType } from "./types.js";
 /** Resolver Type Utils **/
 /**
  * Only tests that the shape is right, not that the name is correct. That's a job for the validator.
@@ -240,19 +240,6 @@ export const getArgsType = (argsSchema) => {
         return ArgsType.args;
     }
 };
-/**
- * A utility to return the type of ref present on a schema.
- *
- * @param refSchema Any schema that may have a `ref` property.
- */
-export const getRefType = (refSchema) => {
-    if (has(refSchema, '@ref')) {
-        return RefType['@ref'];
-    }
-    if (has(refSchema, '$ref')) {
-        return RefType.$ref;
-    }
-};
 export function isPropertySchemaWithRelationship(schema) {
     return schema['@resolver']?.name === 'shapedb:getRelated';
 }

package/dist/unions.js

@@ -10,11 +10,11 @@ export function enumerateOneOfKeys(projectSchema, oneOf) {
     for (const child of oneOf) {
         const refItem = getRef(projectSchema, child);
         if (refItem) {
-            const shapeName = refItemToNamespacedShapeName(refItem);
+            const shapeName = refItemToNamespacedShapeName(projectSchema, refItem);
             if (projectSchema.shapes[shapeName]) {
                 const shapeId = projectSchema.shapes[shapeName].id;
                 result.push({
-                    propName: getOutputShapeName(camelCase(refItem.typeName)),
+                    propName: getOutputShapeName(camelCase(refItem.shapeName)),
                     propSchema: child,
                     shapeName,
                     shapeId

package/dist/util/expressions.d.ts

@@ -1,5 +1,16 @@
-import jsep from 'jsep';
-type AnyExpression = jsep.ArrayExpression | jsep.BinaryExpression | jsep.MemberExpression | jsep.CallExpression | jsep.ConditionalExpression | jsep.Identifier | jsep.Literal | jsep.ThisExpression | jsep.UnaryExpression;
+import jsep, { type Expression } from 'jsep';
+export interface ObjectExpression extends Expression {
+    type: 'ObjectExpression';
+    properties: PropertyExpression[];
+}
+export interface PropertyExpression extends Expression {
+    type: 'Property';
+    computed: boolean;
+    key: AnyExpression;
+    value: AnyExpression;
+    shorthand: boolean;
+}
+type AnyExpression = jsep.ArrayExpression | jsep.BinaryExpression | jsep.MemberExpression | jsep.CallExpression | jsep.ConditionalExpression | jsep.Identifier | jsep.Literal | jsep.ThisExpression | jsep.UnaryExpression | ObjectExpression | PropertyExpression;
 export declare const METHODS_NOT_SUPPORTED = "Methods are not supported in expressions";
 export declare const THIS_NOT_SUPPORTED = "This is not supported in expressions";
 export declare function parseExpression(expression: string): AnyExpression;

package/dist/util/expressions.js

@@ -1,4 +1,6 @@
+import object from '@jsep-plugin/object';
 import jsep from 'jsep';
+jsep.plugins.register(object);
 // Default operator precedence from https://github.com/EricSmekens/jsep/blob/master/src/jsep.js#L55
 const DEFAULT_PRECEDENCE = {
     '||': 1,
@@ -106,6 +108,14 @@ const unops = {
 function evaluateArray(list, context) {
     return list.map((v) => (v ? evaluate(v, context) : undefined));
 }
+function evaluateObject(properties, context) {
+    const obj = {};
+    for (const node of properties) {
+        const key = !node.computed && node.key.type === 'Identifier' ? node.key.name : evaluate(node.key, context);
+        obj[key] = evaluate(node.value, context);
+    }
+    return obj;
+}
 function isObject(x) {
     return Boolean(x) && typeof x === 'object';
 }
@@ -132,6 +142,8 @@ function evaluate(_node, context) {
     switch (node.type) {
         case 'ArrayExpression':
             return evaluateArray(node.elements, context);
+        case 'ObjectExpression':
+            return evaluateObject(node.properties, context);
         case 'CallExpression': {
             if (node.callee.type === 'MemberExpression') {
                 throw Error(METHODS_NOT_SUPPORTED);
@@ -187,6 +199,15 @@ function validateAST(options, rootNode) {
         switch (node.type) {
             case 'ArrayExpression':
                 return node.elements.flatMap((v) => (v ? validate(v, node, 'elements') : []));
+            case 'ObjectExpression':
+                return node.properties.flatMap((v) => validate(v, node, 'properties'));
+            case 'Property': {
+                {
+                    const keyErrors = !node.computed && node.key.type === 'Identifier' ? undefined : validate(node.key, node, 'key');
+                    const valueErrors = validate(node.value, node, 'value');
+                    return keyErrors ? [...keyErrors, ...valueErrors] : valueErrors;
+                }
+            }
             case 'CallExpression': {
                 if (node.callee.type === 'MemberExpression') {
                     return [{ message: METHODS_NOT_SUPPORTED }];
@@ -307,6 +328,17 @@ export function expressionToString(_node, parent) {
         const arr = node.elements.map((element) => expressionToString(element, node)).join(',');
         return `[${arr}]`;
     }
+    if (node.type === 'Property') {
+        const keyStr = expressionToString(node.key, node);
+        if (node.shorthand) {
+            return keyStr;
+        }
+        return `${node.computed ? `[${keyStr}]` : keyStr}: ${expressionToString(node.value, node)}`;
+    }
+    if (node.type === 'ObjectExpression') {
+        const props = node.properties.map((element) => expressionToString(element, node)).join(',');
+        return `{ ${props} }`;
+    }
     if (node.type === 'Literal') {
         return node.raw;
     }

package/dist/util/form-config.js

@@ -28,7 +28,7 @@ export function normalizeForms(projectSchema) {
             if (propSchema) {
                 const ref = getRefOrItemsRef(projectSchema, propSchema);
                 if (ref && propConfig.properties) {
-                    const nestedShapeName = refItemToNamespacedShapeName(ref);
+                    const nestedShapeName = refItemToNamespacedShapeName(projectSchema, ref);
                     normalizedForms[nestedShapeName] = { default: deepClone(propConfig) };
                     storeSourceForm(shapeName, formConfig, propName);
                     normalizeNested(nestedShapeName, propConfig);

package/dist/util/get-conflicting-properties.js

@@ -1,5 +1,5 @@
 import { isDefined, setIsEqual } from '@takeshape/util';
-import { dereferenceSchema, getRef, refItemToAtRef } from "../refs.js";
+import { dereferenceSchema, getRef, serializeRef } from "../refs.js";
 import { isObjectSchema } from "../types/index.js";
 /**
  * Normalize ref, oneOf and array schemas and get a list of @ref expressions
@@ -10,7 +10,7 @@ function getRefStrings(context, propertySchema) {
     return schemas
         .map((propertySchema) => {
         const ref = getRef(context, propertySchema);
-        return ref ? refItemToAtRef(ref) : undefined;
+        return ref ? serializeRef(ref) : undefined;
     })
         .filter(isDefined);
 }

package/dist/util/has-arg.js

@@ -1,4 +1,4 @@
-import { refExpressionToRefItem, refItemToShape } from "../refs.js";
+import { parseRef, refItemToShape } from "../refs.js";
 import { isObjectSchema } from "../types/index.js";
 import { findSchemaAtPath } from "./find-shape-at-path.js";
 export function getArgs(prop) {
@@ -8,7 +8,7 @@ export function getArgsSchema(projectSchema, args) {
     if (typeof args === 'object') {
         return args;
     }
-    const ref = refExpressionToRefItem(projectSchema, args);
+    const ref = parseRef(projectSchema, args);
     const shapeSchema = refItemToShape(projectSchema, ref)?.schema;
     if (shapeSchema && isObjectSchema(shapeSchema)) {
         return shapeSchema;

package/dist/util/is-asset-property.d.ts

@@ -0,0 +1,3 @@
+import type { PropertySchema } from '../project-schema/index.ts';
+export declare function isAssetProperty(prop: PropertySchema): boolean;
+export declare function isAssetRef(str: string): boolean;

package/dist/util/is-asset-property.js

@@ -0,0 +1,11 @@
+import { getRef, parseRef } from "../refs.js";
+export function isAssetProperty(prop) {
+    const ref = getRef({}, prop.oneOf?.[0] ?? prop);
+    return Boolean(ref && isAssetRefItem(ref));
+}
+export function isAssetRef(str) {
+    return isAssetRefItem(parseRef({}, str));
+}
+function isAssetRefItem(ref) {
+    return ref.layerId === 'local' && ref.shapeName === 'Asset';
+}

package/dist/util/merge.js

@@ -1,5 +1,5 @@
 import { assert, deepClone, isDefined, rebaseArray, rebaseObject } from '@takeshape/util';
-import { assignWith } from 'lodash';
+import assignWith from 'lodash/assignWith.js';
 import difference from 'lodash/difference.js';
 import isEqual from 'lodash/isEqual.js';
 import last from 'lodash/last.js';

package/dist/validate/validate.js

@@ -2,7 +2,7 @@ import { SchemaValidationError } from '@takeshape/errors';
 import { createAjv } from '@takeshape/json-schema';
 import { DEFAULT_MIN_SCHEDULE_TRIGGER_INTERVAL, ensureArray, isIntegerLike, isRecord, value } from '@takeshape/util';
 import { JSONPath } from 'jsonpath-plus';
-import { flatten } from 'lodash';
+import flatten from 'lodash/flatten.js';
 import get from 'lodash/get.js';
 import initial from 'lodash/initial.js';
 import isEqual from 'lodash/isEqual.js';
@@ -19,7 +19,7 @@ import neq from 'semver/functions/neq.js';
 import { builtInShapes } from "../builtin-schema.js";
 import { isEnumLikeSchema } from "../enum.js";
 import { isLatestProjectSchemaJSON } from "../project-schema/index.js";
-import { atRefToRefItem, createGetNamespace, getRefShapeName, getToolRef, parsePropertyRef, propertyRefItemToPath, propertyRefItemToResolverPath, refItemToAtRef, refItemToNamespacedShapeName, refItemToShape } from "../refs.js";
+import { createGetNamespace, getRefShapeName, getToolRef, isValidServiceId, parsePropertyRef, parseRef, propertyRefItemToPath, propertyRefItemToResolverPath, refItemToNamespacedShapeName, refItemToShape, serializeRef } from "../refs.js";
 import { getRelationship } from "../relationships.js";
 import { scalars } from "../scalars.js";
 import { getAllRefs, isBuiltinMutation, isBuiltinQuery } from "../schema-util.js";
@@ -168,7 +168,7 @@ const validateAIToolConfig = (projectSchema, getNamespace, tool, basePath) => {
             message: `Unable to parse property ref "${toolRef}"`
         };
     }
-    if (parsed.serviceId !== 'local') {
+    if (parsed.layerId !== 'local') {
         return;
     }
     if ((parsed.shapeName === 'Query' && isBuiltinQuery(parsed.propertyName)) ||
@@ -216,7 +216,7 @@ function validateResolver(projectSchema, basePath, baseResolver) {
                 message: `Unable to parse property ref "${resolver.to}"`
             };
         }
-        if (parsed.serviceId !== 'local') {
+        if (parsed.layerId !== 'local') {
             return;
         }
         const targetResolver = get(projectSchema, propertyRefItemToResolverPath(getNamespace, parsed));
@@ -363,10 +363,10 @@ async function validateResolverReferences(context, projectSchema, basePath, base
     const isInvalidPropertyRef = async (refStr) => {
         const ref = parsePropertyRef(refStr);
         // ref string format and local refs are validated in validateResolver()
-        if (!ref || ref.serviceId === 'local') {
+        if (!ref || ref.layerId === 'local') {
             return false;
         }
-        const layerState = await context.resolveLayer(ref.serviceId);
+        const layerState = await context.resolveLayer(ref.layerId);
         return layerState.status === 'ok'
             ? !get(layerState.schema, propertyRefItemToPath(value(''), ref))
             : !allowDisconnected(context, layerState.status);
@@ -453,8 +453,8 @@ function listShapeJoins(projectSchema) {
     return joins;
 }
 function validateLocalShapeJoinRef(projectSchema, item) {
-    const refItem = atRefToRefItem(projectSchema, item.ref);
-    if (refItem.serviceKey === 'local') {
+    const refItem = parseRef(projectSchema, item.ref);
+    if (refItem.layerId === 'local') {
         const shape = refItemToShape(projectSchema, refItem);
         if (!shape) {
             return [
@@ -472,9 +472,9 @@ function validateLocalShapeJoins(projectSchema) {
     return listShapeJoins(projectSchema).flatMap((item) => validateLocalShapeJoinRef(projectSchema, item).concat(validateResolver(projectSchema, item.path.concat('resolver'), item.join.resolver)));
 }
 async function validateShapeJoinRef(context, projectSchema, item) {
-    const refItem = atRefToRefItem(projectSchema, item.ref);
+    const refItem = parseRef(projectSchema, item.ref);
     if (refItem) {
-        const layer = await context.resolveLayer(refItem.serviceKey);
+        const layer = await context.resolveLayer(refItem.layerId);
         const valid = isValidRef(context, projectSchema, layer, refItem);
         if (!valid) {
             return [
@@ -587,10 +587,13 @@ function isAllOfPath(path) {
     const index = path.indexOf('allOf');
     return index !== -1 && isIntegerLike(path[index + 1]);
 }
+function isLocalRef(refItem) {
+    return refItem.layerId === 'local';
+}
 function validateLocalRefs(projectSchema) {
     const errors = [];
     const shapeNames = new Set([...builtInShapeNames, ...Object.keys(projectSchema.shapes)]);
-    const refs = getAllRefs(projectSchema).filter((item) => !item.isForeign);
+    const refs = getAllRefs(projectSchema).filter(isLocalRef);
     for (const item of refs) {
         if (item.template && !isValidTemplate(item.template)) {
             errors.push({
@@ -599,7 +602,7 @@ function validateLocalRefs(projectSchema) {
                 message: `Invalid template "${item.template}"`
             });
         }
-        const shapeName = refItemToNamespacedShapeName(item);
+        const shapeName = refItemToNamespacedShapeName(projectSchema, item);
         if (!shapeNames.has(shapeName)) {
             const invalidRef = get(projectSchema, item.path);
             const path = invalidRef.items ? [...item.path, 'items', '@ref'] : item.path;
@@ -632,10 +635,10 @@ function validateLocalRefs(projectSchema) {
     return errors;
 }
 function isValidRef(context, projectSchema, layer, item) {
-    const { serviceKey: layerId } = item;
-    const shapeName = refItemToNamespacedShapeName(item);
+    const { layerId } = item;
+    const shapeName = refItemToNamespacedShapeName(projectSchema, item);
     const localShapeExists = Boolean(projectSchema.shapes[shapeName]) || builtInShapeNames.has(shapeName);
-    return (item.isValidService &&
+    return (isValidServiceId(projectSchema, layerId) &&
         (layerId === 'local' ? localShapeExists : localShapeExists || isValidShapeReference(context, layer, shapeName)));
 }
 function mustBeInterface({ path }) {
@@ -647,8 +650,8 @@ async function validateRefs(context, projectSchema) {
     const refs = getAllRefs(projectSchema);
     const layerIds = new Set();
     for (const item of refs) {
-        if (item.serviceKey !== 'local') {
-            layerIds.add(item.serviceKey);
+        if (item.layerId !== 'local') {
+            layerIds.add(item.layerId);
         }
     }
     const layersById = Object.fromEntries(await pMap(layerIds, async (layerId) => [layerId, await resolveLayer(layerId)]));
@@ -660,7 +663,7 @@ async function validateRefs(context, projectSchema) {
                 message: `Invalid template "${item.path}"`
             });
         }
-        const { serviceKey: layerId } = item;
+        const { layerId } = item;
         const layer = layersById[layerId];
         const valid = isValidRef(context, projectSchema, layer, item);
         if (!valid) {
@@ -674,7 +677,8 @@ async function validateRefs(context, projectSchema) {
             // only validate interfaces with connected layers isValidRef above handles when allowDisconnectedLayers false
             const context = layer?.schema ?? projectSchema;
             const shape = get(context, item.path.slice(0, 2));
-            errors.push(...validateShapeImplementsInterface(context, shape, item, item.path));
+            const layerWithServices = { ...context, services: projectSchema.services };
+            errors.push(...validateShapeImplementsInterface(layerWithServices, shape, item, item.path));
         }
     }
     return errors;
@@ -781,7 +785,7 @@ function validateShapeImplementsInterface(projectSchema, shape, interfaceRefItem
         errors.push({
             type: 'notFound',
             path,
-            message: `Invalid interface "${refItemToAtRef(interfaceRefItem)}" not found`
+            message: `Invalid interface "${serializeRef(interfaceRefItem)}" not found`
         });
     }
     else if (interfaceShape.type !== 'interface') {
@@ -912,6 +916,21 @@ function validateAgents(projectSchema) {
                 })));
             }
         }
+        if (agent.historyStrategies) {
+            const seenStrategyNames = new Set();
+            for (const [historyStrategyId, historyStrategy] of Object.entries(agent.historyStrategies)) {
+                if (seenStrategyNames.has(historyStrategy.name)) {
+                    errors.push({
+                        path: [...agentPath, 'historyStrategies', historyStrategyId, 'name'],
+                        type: 'conflict',
+                        message: `Duplicate history strategy name "${historyStrategy.name}"`
+                    });
+                }
+                else {
+                    seenStrategyNames.add(historyStrategy.name);
+                }
+            }
+        }
     }
     return errors;
 }

package/examples/latest/agent-schema.json

@@ -323,7 +323,8 @@
             },
             "transition": []
           }
-        }
+        },
+        "historyStrategies": {}
       },
       "chat": {
         "api": {
@@ -360,7 +361,8 @@
               }
             ]
           }
-        }
+        },
+        "historyStrategies": {}
       }
     }
   }

package/examples/source/agent-schema.json

@@ -305,7 +305,8 @@
             },
             "transition": []
           }
-        }
+        },
+        "historyStrategies": {}
       },
       "chat": {
         "api": {
@@ -342,7 +343,8 @@
               }
             ]
           }
-        }
+        },
+        "historyStrategies": {}
       }
     }
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@takeshape/schema",
-  "version": "11.89.0",
+  "version": "11.92.0",
   "description": "TakeShape Schema",
   "homepage": "https://www.takeshape.io",
   "repository": {
@@ -46,6 +46,7 @@
     "examples"
   ],
   "dependencies": {
+    "@jsep-plugin/object": "^1.2.2",
     "ajv": "8.13.0",
     "ajv-formats": "3.0.1",
     "blueimp-md5": "^2.10.0",
@@ -57,9 +58,9 @@
     "p-reduce": "^2.1.0",
     "semver": "^7.3.2",
     "tiny-invariant": "^1.2.0",
-    "@takeshape/errors": "11.89.0",
-    "@takeshape/json-schema": "11.89.0",
-    "@takeshape/util": "11.89.0"
+    "@takeshape/errors": "11.92.0",
+    "@takeshape/util": "11.92.0",
+    "@takeshape/json-schema": "11.92.0"
   },
   "devDependencies": {
     "@takeshape/json-schema-to-typescript": "^11.0.0",
@@ -76,7 +77,7 @@
     "json-schema-to-ts": "^3.1.1",
     "meow": "^9.0.0",
     "shortid": "^2.2.15",
-    "@takeshape/infra": "11.89.0"
+    "@takeshape/infra": "11.92.0"
   },
   "engines": {
     "node": ">=20"