@takeshape/schema 11.132.0 → 11.133.0

package/dist/builtin-schema.d.ts

@@ -1,8 +1,18 @@
+import type { Entitlements } from '@takeshape/util';
 import type { FormMap, ShapeJSON, ShapeMap } from './project-schema/index.ts';
 import type { Content } from './types/index.ts';
+export type SchemaDefaultsOptions = {
+    entitlements: Pick<Entitlements, 'staticSites'>;
+};
 export declare function isAsset(content: Content): boolean;
 export declare function getAssetS3Path(content: Content): string | undefined;
 export declare function setAssetS3Path(content: Content, path: string): void;
 export declare const jsonShape: ShapeJSON;
-export declare const builtInShapes: ShapeMap;
-export declare const builtInForms: FormMap;
+export declare function getBuiltInShapes(options: SchemaDefaultsOptions): ShapeMap;
+export declare function getBuiltInForms(options: SchemaDefaultsOptions): FormMap;
+export declare const allBuiltInShapes: {
+    [x: string]: ShapeJSON;
+};
+export declare const allBuiltInForms: {
+    [x: string]: import("./project-schema/latest.ts").FormsConfig;
+};

package/dist/builtin-schema.js

@@ -29,7 +29,7 @@ export const jsonShape = {
     title: JSON_SHAPE_NAME,
     schema: {}
 };
-export const builtInShapes = {
+const builtInShapes = {
     [JSON_SHAPE_NAME]: jsonShape,
     TSRelationship: {
         id: 'TSRelationship',
@@ -169,6 +169,93 @@ export const builtInShapes = {
         title: 'Asset Image Meta',
         schema: assetImageMeta.schema
     },
+    TSReference: {
+        id: 'TSReference',
+        name: 'TSReference',
+        title: 'TakeShape Reference',
+        schema: {
+            type: 'object',
+            properties: {
+                _tid: {
+                    type: 'string'
+                },
+                data: {
+                    '@ref': 'TSSearchable',
+                    '@resolver': {
+                        name: 'takeshape:get',
+                        service: 'takeshape',
+                        args: {
+                            ops: [{ path: 'tid', mapping: '$source._tid' }]
+                        }
+                    }
+                }
+            },
+            required: ['_tid']
+        }
+    },
+    TSEmbeddingSearchArgs: {
+        id: 'TSEmbeddingSearchArgs',
+        name: 'TSEmbeddingSearchArgs',
+        title: 'Embedding Search Args',
+        schema: embeddingSearchArgs.schema
+    },
+    [agentRunMode.shapeName]: {
+        title: 'Agent Run Mode',
+        id: agentRunMode.shapeName,
+        name: agentRunMode.shapeName,
+        schema: agentRunMode.schema
+    },
+    [agentGenerateArgs.shapeName]: {
+        title: 'Generate Args',
+        id: agentGenerateArgs.shapeName,
+        name: agentGenerateArgs.shapeName,
+        schema: agentGenerateArgs.schema
+    },
+    [agentChatArgs.shapeName]: {
+        title: 'Chat Args',
+        id: agentChatArgs.shapeName,
+        name: agentChatArgs.shapeName,
+        schema: agentChatArgs.schema
+    },
+    // Preserved for backward compatibility
+    [agentChatResponse.shapeName]: {
+        title: 'Chat Agent Response',
+        id: agentChatResponse.shapeName,
+        name: agentChatResponse.shapeName,
+        schema: agentChatResponse.schema
+    },
+    [agentChatPayload.shapeName]: {
+        title: 'Chat Agent Payload',
+        id: agentChatPayload.shapeName,
+        name: agentChatPayload.shapeName,
+        schema: agentChatPayload.schema
+    },
+    [inspectAgentResponse.shapeName]: {
+        title: 'Inspect Agent Response',
+        id: inspectAgentResponse.shapeName,
+        name: inspectAgentResponse.shapeName,
+        schema: inspectAgentResponse.schema
+    },
+    [createAgentSessionResponse.shapeName]: {
+        title: 'Create Agent Session Response',
+        id: createAgentSessionResponse.shapeName,
+        name: createAgentSessionResponse.shapeName,
+        schema: createAgentSessionResponse.schema
+    },
+    [abortAgentMessageResponse.shapeName]: {
+        title: 'Abort Agent Message Response',
+        id: abortAgentMessageResponse.shapeName,
+        name: abortAgentMessageResponse.shapeName,
+        schema: abortAgentMessageResponse.schema
+    },
+    [sendAgentFeedbackArgs.shapeName]: {
+        title: 'Send Agent Feedback Args',
+        id: sendAgentFeedbackArgs.shapeName,
+        name: sendAgentFeedbackArgs.shapeName,
+        schema: sendAgentFeedbackArgs.schema
+    }
+};
+const staticSiteShapes = {
     TSStaticSite: {
         id: 'SITE',
         name: 'TSStaticSite',
@@ -318,94 +405,9 @@ export const builtInShapes = {
                 }
             }
         }
-    },
-    TSReference: {
-        id: 'TSReference',
-        name: 'TSReference',
-        title: 'TakeShape Reference',
-        schema: {
-            type: 'object',
-            properties: {
-                _tid: {
-                    type: 'string'
-                },
-                data: {
-                    '@ref': 'TSSearchable',
-                    '@resolver': {
-                        name: 'takeshape:get',
-                        service: 'takeshape',
-                        args: {
-                            ops: [{ path: 'tid', mapping: '$source._tid' }]
-                        }
-                    }
-                }
-            },
-            required: ['_tid']
-        }
-    },
-    TSEmbeddingSearchArgs: {
-        id: 'TSEmbeddingSearchArgs',
-        name: 'TSEmbeddingSearchArgs',
-        title: 'Embedding Search Args',
-        schema: embeddingSearchArgs.schema
-    },
-    [agentRunMode.shapeName]: {
-        title: 'Agent Run Mode',
-        id: agentRunMode.shapeName,
-        name: agentRunMode.shapeName,
-        schema: agentRunMode.schema
-    },
-    [agentGenerateArgs.shapeName]: {
-        title: 'Generate Args',
-        id: agentGenerateArgs.shapeName,
-        name: agentGenerateArgs.shapeName,
-        schema: agentGenerateArgs.schema
-    },
-    [agentChatArgs.shapeName]: {
-        title: 'Chat Args',
-        id: agentChatArgs.shapeName,
-        name: agentChatArgs.shapeName,
-        schema: agentChatArgs.schema
-    },
-    // Preserved for backward compatibility
-    [agentChatResponse.shapeName]: {
-        title: 'Chat Agent Response',
-        id: agentChatResponse.shapeName,
-        name: agentChatResponse.shapeName,
-        schema: agentChatResponse.schema
-    },
-    [agentChatPayload.shapeName]: {
-        title: 'Chat Agent Payload',
-        id: agentChatPayload.shapeName,
-        name: agentChatPayload.shapeName,
-        schema: agentChatPayload.schema
-    },
-    [inspectAgentResponse.shapeName]: {
-        title: 'Inspect Agent Response',
-        id: inspectAgentResponse.shapeName,
-        name: inspectAgentResponse.shapeName,
-        schema: inspectAgentResponse.schema
-    },
-    [createAgentSessionResponse.shapeName]: {
-        title: 'Create Agent Session Response',
-        id: createAgentSessionResponse.shapeName,
-        name: createAgentSessionResponse.shapeName,
-        schema: createAgentSessionResponse.schema
-    },
-    [abortAgentMessageResponse.shapeName]: {
-        title: 'Abort Agent Message Response',
-        id: abortAgentMessageResponse.shapeName,
-        name: abortAgentMessageResponse.shapeName,
-        schema: abortAgentMessageResponse.schema
-    },
-    [sendAgentFeedbackArgs.shapeName]: {
-        title: 'Send Agent Feedback Args',
-        id: sendAgentFeedbackArgs.shapeName,
-        name: sendAgentFeedbackArgs.shapeName,
-        schema: sendAgentFeedbackArgs.schema
     }
 };
-export const builtInForms = {
+const builtInForms = {
     Asset: {
         default: {
             order: ['title', 'description', 'caption', 'credit', 'filename', 'path', 'mimeType', 'sourceUrl', 'uploadStatus'],
@@ -439,7 +441,9 @@ export const builtInForms = {
                 }
             }
         }
-    },
+    }
+};
+const staticSiteForms = {
     TSStaticSite: {
         default: {
             order: ['title', 'provider', 'destination', 'idKey', 'secretKey', 'environmentVariables'],
@@ -619,3 +623,11 @@ export const builtInForms = {
         }
     }
 };
+export function getBuiltInShapes(options) {
+    return options?.entitlements.staticSites ? { ...builtInShapes, ...staticSiteShapes } : builtInShapes;
+}
+export function getBuiltInForms(options) {
+    return options.entitlements.staticSites ? { ...builtInForms, ...staticSiteForms } : builtInForms;
+}
+export const allBuiltInShapes = { ...builtInShapes, ...staticSiteShapes };
+export const allBuiltInForms = { ...builtInForms, ...staticSiteForms };

package/dist/mocks.d.ts

@@ -1,3 +1,4 @@
+import type { SchemaDefaultsOptions } from './builtin-schema.js';
 import type { ProjectSchemaJSON, ServiceConfig, ServiceConfigJSON, ShapeJSON } from './project-schema/index.ts';
 import type { CachedShape, ServiceKey } from './types/types.ts';
 /**
@@ -7,7 +8,7 @@ export declare function createMockSchema(projectId: string, schema?: Partial<Pro
 /**
  * Capturing a common pattern used in tests. Creates an empty schema, with defaults.
  */
-export declare function createMockSchemaWithDefaults(projectId: string, schema?: Partial<ProjectSchemaJSON>): ProjectSchemaJSON;
+export declare function createMockSchemaWithDefaults(projectId: string, schema?: Partial<ProjectSchemaJSON>, options?: SchemaDefaultsOptions): ProjectSchemaJSON;
 export declare function createMockServiceConfig(serviceKey: ServiceKey, serviceConfig?: Partial<ServiceConfig>): ServiceConfig;
 export declare function createMockStoredServiceConfig(serviceKey: ServiceKey, serviceConfig?: Partial<ServiceConfigJSON>): ServiceConfigJSON;
 export declare function addMockIndexingConfig(shape: ShapeJSON): CachedShape;

package/dist/mocks.js

@@ -13,12 +13,12 @@ export function createMockSchema(projectId, schema = {}) {
 /**
  * Capturing a common pattern used in tests. Creates an empty schema, with defaults.
  */
-export function createMockSchemaWithDefaults(projectId, schema = {}) {
+export function createMockSchemaWithDefaults(projectId, schema = {}, options) {
     return applyDefaultsToSchema({
         ...emptySchema(projectId),
         ...schema,
         projectId
-    });
+    }, options);
 }
 export function createMockServiceConfig(serviceKey, serviceConfig) {
     return {

package/dist/models/runtime-schema.js

@@ -5,8 +5,7 @@ export class RuntimeSchema extends ProjectSchemaImpl {
         super(runtimeSchema, layers);
     }
     static buildSchema(userSchema, layers) {
-        // biome-ignore lint/suspicious/noConsole: ignore
-        const runtimeSchema = buildRuntimeSchema(userSchema, layers, console.log);
+        const runtimeSchema = buildRuntimeSchema(userSchema, layers);
         return new RuntimeSchema(runtimeSchema, layers);
     }
     static safeBuildSchema(userSchema, layers) {

package/dist/relationships.js

@@ -2,7 +2,7 @@ import { isDefined } from '@takeshape/util';
 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 { allBuiltInShapes } from "./builtin-schema.js";
 import { followRef, getRefShapeName, getShapeByRef, shapeToRefString } from "./refs.js";
 import { isModelShape, isObjectSchema, isPropertySchemaWithRelationship } from "./types/index.js";
 import { isUnionSchema } from "./unions.js";
@@ -26,7 +26,7 @@ export function getRelationshipSchema(projectSchema, relationship) {
     if ('shapeIds' in relationship) {
         shapeRefs = relationship.shapeIds
             .map((shapeId) => {
-            const shape = getShapeById(projectSchema, shapeId) ?? find(builtInShapes, (shape) => shape.id === shapeId);
+            const shape = getShapeById(projectSchema, shapeId) ?? find(allBuiltInShapes, (shape) => shape.id === shapeId);
             return (shape && {
                 '@ref': shapeToRefString(projectSchema, shape)
             });

package/dist/runtime-schema.d.ts

@@ -1,5 +1,6 @@
+import type { SchemaDefaultsOptions } from './builtin-schema.js';
 import type { ProjectSchemaJSON } from './project-schema/index.ts';
 import { type ServiceLayers } from './types/index.ts';
 export declare function applyLegacyCompatibilityTweaks(projectSchema: ProjectSchemaJSON): ProjectSchemaJSON;
-export declare const applyDefaultsAndFlatten: (projectSchema: ProjectSchemaJSON) => ProjectSchemaJSON;
-export declare function buildRuntimeSchema(projectSchema: ProjectSchemaJSON, serviceLayers: ServiceLayers, log: (messsage: string, error: Error) => void): ProjectSchemaJSON;
+export declare function applyDefaultsAndFlatten(projectSchema: ProjectSchemaJSON, options?: SchemaDefaultsOptions): ProjectSchemaJSON;
+export declare function buildRuntimeSchema(projectSchema: ProjectSchemaJSON, serviceLayers: ServiceLayers, options?: SchemaDefaultsOptions): ProjectSchemaJSON;

package/dist/runtime-schema.js

@@ -1,6 +1,5 @@
 import { SchemaBuildError } from '@takeshape/errors';
 import { deepClone } from '@takeshape/util';
-import compose from 'lodash/fp/compose.js';
 import isError from 'lodash/isError.js';
 import set from 'lodash/set.js';
 import { addAiQueries } from "./agents.js";
@@ -64,18 +63,23 @@ export function applyLegacyCompatibilityTweaks(projectSchema) {
     addRelatedFields(newSchema, findExistingRelationships(projectSchema, projectSchema.shapes));
     return newSchema;
 }
-export const applyDefaultsAndFlatten = compose(flattenTemplates, applyLegacyCompatibilityTweaks, applyDefaultsToSchema, addAiQueries);
-export function buildRuntimeSchema(projectSchema, serviceLayers, log) {
+export function applyDefaultsAndFlatten(projectSchema, options) {
+    let newSchema = projectSchema;
+    newSchema = addAiQueries(newSchema);
+    newSchema = applyDefaultsToSchema(newSchema, options);
+    newSchema = applyLegacyCompatibilityTweaks(newSchema);
+    newSchema = flattenTemplates(newSchema);
+    return newSchema;
+}
+export function buildRuntimeSchema(projectSchema, serviceLayers, options) {
     try {
         const projectSchemaWithDependencies = resolveSchemaShapeDependencies(projectSchema, serviceLayers);
-        return applyDefaultsAndFlatten(projectSchemaWithDependencies);
+        return applyDefaultsAndFlatten(projectSchemaWithDependencies, options);
     }
     catch (err) {
-        const error = new SchemaBuildError('An error occurred while building the schema', {
+        throw new SchemaBuildError('An error occurred while building the schema', {
             cause: isError(err) ? err : undefined,
             schema: projectSchema
         });
-        log('build runtime error', error);
-        throw error;
     }
 }

package/dist/schema-util.d.ts

@@ -1,4 +1,5 @@
 import { type Maybe } from '@takeshape/util';
+import { type SchemaDefaultsOptions } from './builtin-schema.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 ServiceMap } from './types/index.ts';
@@ -39,8 +40,8 @@ export declare function applyBuiltinPropertiesToShape(projectSchema: ProjectSche
  * Get all built-in shapes that are depended on by the given project schema.
  * Required built-in shapes are always included.
  */
-export declare function getBuiltinsUsed(projectSchema: ProjectSchemaJSON): ShapeMap;
-export declare function applyDefaultsToSchema<T extends ProjectSchemaJSON>(projectSchema: T): T;
+export declare function getBuiltinsUsed(builtInShapes: ShapeMap, projectSchema: ProjectSchemaJSON): ShapeMap;
+export declare function applyDefaultsToSchema<T extends ProjectSchemaJSON>(projectSchema: T, options?: SchemaDefaultsOptions): T;
 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>;

package/dist/schema-util.js

@@ -1,4 +1,4 @@
-import { deepClone, ensureArray, pascalCase, visit } from '@takeshape/util';
+import { DEFAULT_ENTITLEMENTS, deepClone, ensureArray, pascalCase, visit } from '@takeshape/util';
 import curry from 'lodash/fp/curry.js';
 import orderBy from 'lodash/fp/orderBy.js';
 import isArray from 'lodash/isArray.js';
@@ -8,7 +8,7 @@ import mapValues from 'lodash/mapValues.js';
 import uniq from 'lodash/uniq.js';
 import { AGENTS_SCHEMA_PATH, getAgentMap } from './agents.js';
 import { workflowsEnabled } from "./api-version.js";
-import { builtInForms, builtInShapes } from "./builtin-schema.js";
+import { allBuiltInShapes, getBuiltInForms, getBuiltInShapes } from "./builtin-schema.js";
 import { SERVICE_OBJECT_PATTERN_NAME } from "./constants.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";
@@ -19,9 +19,9 @@ import { CURRENT_API_VERSION, CURRENT_SCHEMA_VERSION } from "./versions.js";
 import { defaultWorkflow, getStatusField } from "./workflows.js";
 export function isBuiltinShape(ref) {
     const parsed = parseRef({}, ref);
-    return Boolean(parsed.layerId === 'local' && builtInShapes[parsed.shapeName]);
+    return Boolean(parsed.layerId === 'local' && allBuiltInShapes[parsed.shapeName]);
 }
-const builtInQueriesAndMutations = getShapeQueriesAndMutations(Object.values(builtInShapes));
+const builtInQueriesAndMutations = getShapeQueriesAndMutations(Object.values(allBuiltInShapes));
 export function isBuiltinQuery(name) {
     return builtInQueriesAndMutations.queries[name] !== undefined;
 }
@@ -383,7 +383,7 @@ const requiredBuiltinShapes = ['Asset', 'TSRelationship', 'TSStaticSite', 'TSUse
  * Get all built-in shapes that are depended on by the given project schema.
  * Required built-in shapes are always included.
  */
-export function getBuiltinsUsed(projectSchema) {
+export function getBuiltinsUsed(builtInShapes, projectSchema) {
     const builtinsUsed = {};
     const shapeNames = uniq(requiredBuiltinShapes.concat(getAllRefs(projectSchema, (refItem) => refItem.layerId === 'local' && isBuiltinShape(refItem.shapeName)).map((ref) => refItemToNamespacedShapeName(projectSchema, ref))));
     const schemaWithAllBuiltins = {
@@ -391,15 +391,24 @@ export function getBuiltinsUsed(projectSchema) {
         shapes: builtInShapes
     };
     for (const builtinShapeName of shapeNames) {
-        builtinsUsed[builtinShapeName] = builtInShapes[builtinShapeName];
-        for (const depShapeName of getShapeDependencies(schemaWithAllBuiltins, builtInShapes[builtinShapeName])) {
-            builtinsUsed[depShapeName] = builtInShapes[depShapeName];
+        if (builtInShapes[builtinShapeName]) {
+            builtinsUsed[builtinShapeName] = builtInShapes[builtinShapeName];
+            for (const depShapeName of getShapeDependencies(schemaWithAllBuiltins, builtInShapes[builtinShapeName])) {
+                builtinsUsed[depShapeName] = builtInShapes[depShapeName];
+            }
         }
     }
     return builtinsUsed;
 }
-export function applyDefaultsToSchema(projectSchema) {
-    const builtinsUsed = getBuiltinsUsed(projectSchema);
+export function applyDefaultsToSchema(projectSchema, options) {
+    const optionsWithDefaults = {
+        entitlements: DEFAULT_ENTITLEMENTS,
+        ...options
+    };
+    const builtInShapes = getBuiltInShapes(optionsWithDefaults);
+    const builtinsUsed = getBuiltinsUsed(builtInShapes, projectSchema);
+    const builtInQueriesAndMutations = getShapeQueriesAndMutations(Object.values(builtInShapes));
+    const builtInForms = getBuiltInForms(optionsWithDefaults);
     return {
         ...projectSchema,
         workflows: {

package/dist/validate/validate.d.ts

@@ -2,9 +2,8 @@ import { type SchemaValidationErrorItem } from '@takeshape/errors';
 import { type Entitlements } from '@takeshape/util';
 import type { SetRequired } from 'type-fest';
 import type { RoleImport, RoleInput } from '../auth-schemas.ts';
-import type { AnyProjectSchemaJSON, ProjectSchemaJSON } from '../project-schema/index.ts';
+import type { AnyProjectSchemaJSON, ProjectSchemaJSON, ShapeMap } from '../project-schema/index.ts';
 import type { LayerState, ProjectSchemaImport } from '../types/types.ts';
-export declare const builtInShapeNames: Set<string>;
 export type SchemaValidationResult = {
     valid: true;
     schema: AnyProjectSchemaJSON;
@@ -33,8 +32,11 @@ export type EntitlementsOptions = {
     entitlements: Entitlements;
 };
 export type ValidateContext = {
+    builtInShapes: ShapeMap;
+    builtInShapeNames: Set<string>;
+} & ValidateOptions;
+export type ValidateOptions = {
     allowDisconnectedLayers?: boolean;
-    generatedApi?: Pick<ProjectSchemaJSON, 'queries' | 'mutations'>;
     structureOnly?: boolean;
 } & EntitlementsOptions & ValidateSyntaxOptions;
 export type ValidateReferencesContext = SetRequired<ValidateContext, 'resolveLayer'> & {
@@ -44,7 +46,7 @@ export declare function validateSchemaSyntax(obj: unknown, options?: ValidateSyn
 /**
  * Validates a schema using a matching validation based on the `schemaVersion` property.
  */
-export declare function validateSchema(context: ValidateContext, obj: unknown): Promise<SchemaValidationResult>;
+export declare function validateSchema(options: ValidateOptions, obj: unknown): Promise<SchemaValidationResult>;
 export declare function ensureValidLatestSchemaSyntax(obj: unknown): ProjectSchemaJSON;
 /**
  * Validates and returns a `RoleInput`, which is a subset of the `Role`

package/dist/validate/validate.js

@@ -1,6 +1,6 @@
 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 { DEFAULT_ENTITLEMENTS, DEFAULT_MIN_SCHEDULE_TRIGGER_INTERVAL, ensureArray, isIntegerLike, isRecord, value } from '@takeshape/util';
 import { JSONPath } from 'jsonpath-plus';
 import flatten from 'lodash/flatten.js';
 import get from 'lodash/get.js';
@@ -17,7 +17,7 @@ import gte from 'semver/functions/gte.js';
 import lt from 'semver/functions/lt.js';
 import neq from 'semver/functions/neq.js';
 import { GUARDS_SCHEMA_PATH, getGuards, isGuardEnabled } from "../agents.js";
-import { builtInShapes } from "../builtin-schema.js";
+import { getBuiltInShapes } from "../builtin-schema.js";
 import { isEnumLikeSchema } from "../enum.js";
 import { isLatestProjectSchemaJSON } from "../project-schema/index.js";
 import { createGetNamespace, getRefShapeName, getToolRef, isValidServiceId, parsePropertyRef, parseRef, propertyRefItemToPath, propertyRefItemToResolverPath, refItemToNamespacedShapeName, refItemToShape, serializeRef } from "../refs.js";
@@ -38,7 +38,6 @@ import { defaultWorkflow } from "../workflows.js";
 import { validateAgents, validateAIToolConfig } from "./ai.js";
 import { formatError } from "./errors.js";
 import { pushErrors } from './util.js';
-export const builtInShapeNames = new Set([...Object.keys(builtInShapes), ...scalars, 'object']);
 function findDuplicates(items) {
     const seen = {};
     for (const item of items) {
@@ -153,13 +152,13 @@ function enumerateBasicResolvers(resolver, path) {
     visit(resolver, path);
     return results;
 }
-function validateResolver(projectSchema, basePath, baseResolver) {
+function validateResolver(context, projectSchema, basePath, baseResolver) {
     const errors = [];
     const isValidShapeName = (shapeName) => {
         if (!shapeName) {
             return false;
         }
-        const shape = getShape(projectSchema, shapeName) ?? getShape({ shapes: builtInShapes }, shapeName);
+        const shape = getShape(projectSchema, shapeName) ?? getShape({ shapes: context.builtInShapes }, shapeName);
         if (shape?.model) {
             return true;
         }
@@ -293,16 +292,16 @@ function validateResolver(projectSchema, basePath, baseResolver) {
     }
     return errors;
 }
-function validateLocalQueryConfig(projectSchema, query, operation, name) {
+function validateLocalQueryConfig(context, projectSchema, query, operation, name) {
     const location = operation === 'query' ? 'queries' : 'mutations';
-    return validateResolver(projectSchema, [location, name, 'resolver'], query.resolver);
+    return validateResolver(context, projectSchema, [location, name, 'resolver'], query.resolver);
 }
 const operationProps = [['query', 'queries'], ['mutation', 'mutations']];
-function validateLocalQueryConfigs(projectSchema) {
+function validateLocalQueryConfigs(context, projectSchema) {
     const errors = [];
     for (const [operation, prop] of operationProps) {
         for (const name of Object.keys(projectSchema[prop])) {
-            errors.push(...validateLocalQueryConfig(projectSchema, projectSchema[prop][name], operation, name));
+            errors.push(...validateLocalQueryConfig(context, projectSchema, projectSchema[prop][name], operation, name));
         }
     }
     return errors;
@@ -427,8 +426,8 @@ function validateLocalShapeJoinRef(projectSchema, item) {
     }
     return [];
 }
-function validateLocalShapeJoins(projectSchema) {
-    return listShapeJoins(projectSchema).flatMap((item) => validateLocalShapeJoinRef(projectSchema, item).concat(validateResolver(projectSchema, item.path.concat('resolver'), item.join.resolver)));
+function validateLocalShapeJoins(context, projectSchema) {
+    return listShapeJoins(projectSchema).flatMap((item) => validateLocalShapeJoinRef(projectSchema, item).concat(validateResolver(context, projectSchema, item.path.concat('resolver'), item.join.resolver)));
 }
 async function validateShapeJoinRef(context, projectSchema, item) {
     const refItem = parseRef(projectSchema, item.ref);
@@ -549,9 +548,9 @@ function isAllOfPath(path) {
 function isLocalRef(refItem) {
     return refItem.layerId === 'local';
 }
-function validateLocalRefs(projectSchema) {
+function validateLocalRefs(context, projectSchema) {
     const errors = [];
-    const shapeNames = new Set([...builtInShapeNames, ...Object.keys(projectSchema.shapes)]);
+    const shapeNames = new Set([...context.builtInShapeNames, ...Object.keys(projectSchema.shapes)]);
     const refs = getAllRefs(projectSchema).filter(isLocalRef);
     for (const item of refs) {
         if (item.template && !isValidTemplate(item.template)) {
@@ -596,7 +595,7 @@ function validateLocalRefs(projectSchema) {
 function isValidRef(context, projectSchema, layer, item) {
     const { layerId } = item;
     const shapeName = refItemToNamespacedShapeName(projectSchema, item);
-    const localShapeExists = Boolean(projectSchema.shapes[shapeName]) || builtInShapeNames.has(shapeName);
+    const localShapeExists = Boolean(projectSchema.shapes[shapeName]) || context.builtInShapeNames.has(shapeName);
     return (isValidServiceId(projectSchema, layerId) &&
         (layerId === 'local' ? localShapeExists : localShapeExists || isValidShapeReference(context, layer, shapeName)));
 }
@@ -647,13 +646,13 @@ function visitShapePropertiesJson(projectSchema, callback) {
         callback(property, propertyPath.slice(3, -2).split(`']['`));
     }, undefined);
 }
-function validateDirectives(projectSchema) {
+function validateDirectives(context, projectSchema) {
     const errors = [];
     visitShapePropertiesJson(projectSchema, (property, propertyPath) => {
         const resolver = property['@resolver'];
         if (resolver) {
             const propPath = propertyPath.concat('@resolver');
-            const resolverErrors = validateResolver(projectSchema, propPath, resolver);
+            const resolverErrors = validateResolver(context, projectSchema, propPath, resolver);
             if (resolverErrors) {
                 errors.push(...resolverErrors);
             }
@@ -882,10 +881,10 @@ function validateSyntax(context, schema) {
         .concat(checkShapeNames(schema.shapes))
         .concat(checkShapeIds(schema.shapes))
         .concat(validateWorkflows(schema))
-        .concat(validateLocalQueryConfigs(schema))
-        .concat(validateLocalRefs(schema))
-        .concat(validateLocalShapeJoins(schema))
-        .concat(validateDirectives(schema))
+        .concat(validateLocalQueryConfigs(context, schema))
+        .concat(validateLocalRefs(context, schema))
+        .concat(validateLocalShapeJoins(context, schema))
+        .concat(validateDirectives(context, schema))
         .concat(validateLocales(schema))
         .concat(checkWorkflowStepNames(schema.workflows))
         .concat(checkWorkflowStepKeys(schema.workflows))
@@ -937,19 +936,23 @@ export function validateSchemaSyntax(obj, options = {}) {
 /**
  * Validates a schema using a matching validation based on the `schemaVersion` property.
  */
-export async function validateSchema(context, obj) {
+export async function validateSchema(options, obj) {
     if (isUndefined(obj)) {
         return schemaUndefinedResult;
     }
-    const contextWithDefaults = {
+    const builtInShapes = getBuiltInShapes({ entitlements: options.entitlements ?? DEFAULT_ENTITLEMENTS });
+    const builtInShapeNames = new Set([...Object.keys(builtInShapes), ...scalars, 'object']);
+    const context = {
         allowDisconnectedLayers: true,
-        ...context
+        builtInShapes,
+        builtInShapeNames,
+        ...options
     };
     const schemaVersion = normalizeSchemaVersion(obj);
     if (!schemaVersion) {
         return invalidVersionResult;
     }
-    const structuralValidation = validateStructure(schemaVersion, contextWithDefaults, obj);
+    const structuralValidation = validateStructure(schemaVersion, context, obj);
     if (!structuralValidation.valid || context.structureOnly) {
         return structuralValidation;
     }
@@ -957,9 +960,9 @@ export async function validateSchema(context, obj) {
     if (!isLatestProjectSchemaJSON(schema)) {
         return invalidVersionResult;
     }
-    const syntaxValidation = validateSyntax(contextWithDefaults, schema);
+    const syntaxValidation = validateSyntax(context, schema);
     const validateReferencesContext = {
-        ...contextWithDefaults,
+        ...context,
         projectSchema: schema
     };
     if (!syntaxValidation.valid || !isValidateReferencesContext(validateReferencesContext)) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@takeshape/schema",
-  "version": "11.132.0",
+  "version": "11.133.0",
   "description": "TakeShape Schema",
   "homepage": "https://www.takeshape.io",
   "repository": {
@@ -56,9 +56,9 @@
     "p-reduce": "2.1.0",
     "semver": "7.7.2",
     "tiny-invariant": "1.3.3",
-    "@takeshape/json-schema": "11.132.0",
-    "@takeshape/errors": "11.132.0",
-    "@takeshape/util": "11.132.0"
+    "@takeshape/errors": "11.133.0",
+    "@takeshape/json-schema": "11.133.0",
+    "@takeshape/util": "11.133.0"
   },
   "devDependencies": {
     "@takeshape/json-schema-to-typescript": "11.0.0",
@@ -75,8 +75,8 @@
     "glob": "7.2.3",
     "json-schema-to-ts": "3.1.1",
     "shortid": "2.2.16",
-    "@takeshape/infra": "11.132.0",
-    "@takeshape/logger": "11.132.0"
+    "@takeshape/infra": "11.133.0",
+    "@takeshape/logger": "11.133.0"
   },
   "engines": {
     "node": ">=22"