@takeshape/schema 12.1.1 → 12.1.5

package/dist/migration/to/v3.9.0.js

@@ -0,0 +1,79 @@
+import { visit } from '@takeshape/util';
+import isEmpty from 'lodash/isEmpty.js';
+import omit from 'lodash/omit.js';
+function omitOptions(resolver, names) {
+    if (resolver.options) {
+        const newOptions = omit(resolver.options, names);
+        if (isEmpty(newOptions)) {
+            resolver.options = undefined;
+        }
+        else {
+            resolver.options = newOptions;
+        }
+    }
+}
+const migrate = async (_, projectSchema) => {
+    /**
+     * Resolver props that are guaranteed in this version, and dependent on the
+     * resolver type. Ensure they exist.
+     */
+    const ensureResolverOptions = (resolver) => {
+        if (resolver.name.startsWith('takeshape')) {
+            if (!resolver.shapeName) {
+                resolver.shapeName =
+                    resolver.options?.model ?? resolver.options?.indexedShape ?? '';
+                omitOptions(resolver, ['model', 'indexedShape']);
+            }
+        }
+        if (resolver.name.startsWith('graphql')) {
+            if (!resolver.fieldName) {
+                resolver.fieldName = resolver.options?.fieldName ?? '';
+                omitOptions(resolver, ['fieldName']);
+            }
+        }
+        if (resolver.name.startsWith('awsLambda')) {
+            if (!resolver.functionName) {
+                resolver.functionName = resolver.options?.functionName ?? '';
+                omitOptions(resolver, ['functionName']);
+            }
+        }
+        if (resolver.name.startsWith('rest')) {
+            if (!resolver.path) {
+                if (resolver.pathParams) {
+                    resolver.path = {
+                        ...resolver.pathParams,
+                        serialize: {
+                            ...resolver.pathParams.serialize,
+                            template: resolver.options?.path
+                        }
+                    };
+                }
+                else {
+                    resolver.path = resolver.options?.path ?? '';
+                }
+                omitOptions(resolver, ['path']);
+            }
+        }
+        /**
+         * `resolver.name` was previously validated with app code and v3.9.0
+         * enumerates the previous validation, making this assertion safe.
+         */
+        return resolver;
+    };
+    /**
+     * Function will visit each resolver in the schema and mutate them.
+     */
+    visit(projectSchema, ['resolver', '@resolver'], (resolver) => {
+        if (resolver.compose) {
+            resolver.compose.forEach(ensureResolverOptions);
+        }
+        else {
+            ensureResolverOptions(resolver);
+        }
+    });
+    return {
+        ...projectSchema,
+        schemaVersion: '3.9.0'
+    };
+};
+export default migrate;

package/dist/migration/types.d.ts

@@ -0,0 +1,26 @@
+import type { Logger } from '@takeshape/logger';
+import type { AgentJSON, FormConfig, GuardJSON, ProjectSchemaJSON, QueryJSON, ServiceConfigJSON, ShapeJSON, ToolJSON, Workflow } from '../project-schema/index.ts';
+import type { EncryptFn, SafeDecryptFn } from '../services/types.ts';
+export type ProjectSchemaMigrationContext = {
+    label: string;
+    generateDataKeyFn: () => Promise<string>;
+    encryptFn: EncryptFn;
+    decryptFn: SafeDecryptFn;
+    logger: Logger;
+};
+export declare const AGENTS_UPDATE_KEY = "agents";
+export declare const GUARDS_UPDATE_KEY = "guards";
+export declare const TOOLS_UPDATE_KEY = "tools";
+export type ProjectSchemaUpdate = {
+    queries?: Record<string, QueryJSON | null>;
+    mutations?: Record<string, QueryJSON | null>;
+    shapes?: Record<string, ShapeJSON | null>;
+    [AGENTS_UPDATE_KEY]?: Record<string, AgentJSON | null>;
+    [GUARDS_UPDATE_KEY]?: Record<string, GuardJSON | null>;
+    [TOOLS_UPDATE_KEY]?: Record<string, ToolJSON | null>;
+    forms?: Record<string, FormConfig | null>;
+    workflows?: Record<string, Workflow | null>;
+    services?: Record<string, ServiceConfigJSON | null>;
+    deactivated?: number;
+} & Omit<Partial<ProjectSchemaJSON>, 'queries' | 'mutations' | 'shapes' | 'agents' | 'guards' | 'tools' | 'forms' | 'workflows' | 'services'>;
+export type MigrateFunction<FromSchema, ToSchema> = (context: ProjectSchemaMigrationContext, fromSchema: FromSchema) => Promise<ToSchema>;

package/dist/migration/types.js

@@ -0,0 +1,3 @@
+export const AGENTS_UPDATE_KEY = 'agents';
+export const GUARDS_UPDATE_KEY = 'guards';
+export const TOOLS_UPDATE_KEY = 'tools';

package/dist/migration/utils.d.ts

@@ -0,0 +1,2 @@
+export declare function formatDate(timestamp?: number): string;
+export declare function normalizeSchemaVersion(version?: string): string;

package/dist/migration/utils.js

@@ -0,0 +1,6 @@
+export function formatDate(timestamp) {
+    return (timestamp ? new Date(timestamp) : new Date()).toISOString();
+}
+export function normalizeSchemaVersion(version) {
+    return version ?? '1';
+}

package/dist/mocks.d.ts

@@ -0,0 +1,14 @@
+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';
+/**
+ * Like emptySchema, but for tests.
+ */
+export declare function createMockSchema(projectId: string, schema?: Partial<ProjectSchemaJSON>): ProjectSchemaJSON;
+/**
+ * Capturing a common pattern used in tests. Creates an empty schema, with defaults.
+ */
+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

@@ -0,0 +1,58 @@
+import { pascalCase } from '@takeshape/util';
+import { applyDefaultsToSchema, emptySchema } from "./schema-util.js";
+/**
+ * Like emptySchema, but for tests.
+ */
+export function createMockSchema(projectId, schema = {}) {
+    return {
+        ...emptySchema(projectId),
+        ...schema,
+        projectId
+    };
+}
+/**
+ * Capturing a common pattern used in tests. Creates an empty schema, with defaults.
+ */
+export function createMockSchemaWithDefaults(projectId, schema = {}, options) {
+    return applyDefaultsToSchema({
+        ...emptySchema(projectId),
+        ...schema,
+        projectId
+    }, options);
+}
+export function createMockServiceConfig(serviceKey, serviceConfig) {
+    return {
+        id: serviceKey,
+        title: pascalCase(serviceKey),
+        provider: 'graphql',
+        serviceType: 'graphql',
+        namespace: pascalCase(serviceKey),
+        authenticationType: 'bearer',
+        authentication: {
+            type: 'bearer',
+            token: 'abc123'
+        },
+        options: {
+            endpoint: 'https://example.test/graphql'
+        },
+        ...serviceConfig
+    };
+}
+export function createMockStoredServiceConfig(serviceKey, serviceConfig) {
+    return {
+        ...createMockServiceConfig(serviceKey),
+        authentication: 'encrypted-abc123',
+        ...serviceConfig
+    };
+}
+export function addMockIndexingConfig(shape) {
+    return {
+        ...shape,
+        loaders: {
+            list: {
+                query: `Query.get${shape.name}List`
+            }
+        },
+        cache: { enabled: true }
+    };
+}

package/dist/models/agent.d.ts

@@ -0,0 +1,3 @@
+import type { AgentJSON } from '../project-schema/latest.ts';
+import type { Agent, ProjectSchema } from './types.ts';
+export declare function createAgent(parent: ProjectSchema, name: string, agent: AgentJSON): Agent;

package/dist/models/agent.js

@@ -0,0 +1,73 @@
+import { isAgentQuery } from "../util/agent-utils.js";
+function queryPredicate(agentName) {
+    return (query) => isAgentQuery(query.json, agentName);
+}
+class AgentImpl {
+    #schema;
+    #agentName;
+    #agent;
+    constructor(parent, name, agent) {
+        this.#schema = parent;
+        this.#agentName = name;
+        this.#agent = agent;
+    }
+    get name() {
+        return this.#agentName;
+    }
+    get title() {
+        return this.#agent.title;
+    }
+    get description() {
+        return this.#agent.description;
+    }
+    get disabled() {
+        return this.#agent.disabled;
+    }
+    get systemPrompt() {
+        return this.#agent.systemPrompt;
+    }
+    get sessionMemoryShape() {
+        const ref = this.#agent.memory?.sessionMemory.shape;
+        if (ref) {
+            return this.#schema.getShape(ref);
+        }
+        return undefined;
+    }
+    get historyStrategies() {
+        return this.#agent.historyStrategies;
+    }
+    get isProtectionEnabled() {
+        return this.#agent.protection?.enabled ?? false;
+    }
+    get apiInputs() {
+        return this.#agent.api.inputs;
+    }
+    get startState() {
+        return this.#agent.start;
+    }
+    getState(stateId) {
+        return this.#agent.states[stateId];
+    }
+    ensureState(stateId) {
+        const state = this.getState(stateId);
+        if (!state) {
+            throw new Error(`State "${stateId}" not found in agent "${this.#agentName}"`);
+        }
+        return state;
+    }
+    getMutations() {
+        return this.#schema.getLocalMutations().filter(queryPredicate(this.name));
+    }
+    getQueries() {
+        return this.#schema.getLocalQueries().filter(queryPredicate(this.name));
+    }
+    getInputConfig(inputName) {
+        return this.#agent.api.inputs.find((input) => input.name === inputName);
+    }
+    get json() {
+        return this.#agent;
+    }
+}
+export function createAgent(parent, name, agent) {
+    return new AgentImpl(parent, name, agent);
+}

package/dist/models/project-schema.d.ts

@@ -0,0 +1,28 @@
+import type { ProjectSchemaJSON, PropertySchema } from '../project-schema/index.ts';
+import type { ServiceLayers } from '../types/types.ts';
+import type { Agent, GetShapeOptions, ProjectSchema, Query, Shape, Tool } from './types.ts';
+export declare class ProjectSchemaImpl implements ProjectSchema {
+    #private;
+    constructor(projectSchemaJson: ProjectSchemaJSON, layers: ServiceLayers);
+    getShape(rawShapeRef: string, options?: GetShapeOptions): Shape | undefined;
+    ensureShape(rawShapeRef: string, options?: GetShapeOptions): Shape;
+    getQuery(rawQueryRef: string): Query | undefined;
+    getTool(rawToolRef: string): Tool | undefined;
+    ensureTool(ref: string): Tool;
+    getTools(): Tool[];
+    ensureQuery(ref: string): Query;
+    getLocalQueries(): Query[];
+    getLocalMutations(): Query[];
+    getAgents(): Agent[];
+    ensureAgent(name: string): Agent;
+    getAgent(name: string): Agent | undefined;
+    dereferenceSchema(propertySchema: PropertySchema): PropertySchema;
+    dereferenceObjectSchema(propertySchema: PropertySchema): import("../project-schema/latest.ts").ObjectSchema;
+    /**
+     * Get context variables configuration for a shape by name.
+     * Returns undefined if the shape has no context variables configured.
+     * Results are cached for efficient repeated lookups.
+     */
+    getShapeContextVariables(shapeName: string): Record<string, string> | undefined;
+    get json(): ProjectSchemaJSON;
+}

package/dist/models/project-schema.js

@@ -0,0 +1,186 @@
+import { NotFoundError } from '@takeshape/errors';
+import { getAgent, getAgentMap } from "../agents.js";
+import { allBuiltInShapes } from '../builtin-schema.js';
+import { dereferenceObjectSchema, dereferenceSchema, getQuery, normalizePropertyRef, normalizeRefExpression, parsePropertyRef, parseRef, refItemToNamespacedShapeName } from "../refs.js";
+import { getShape } from "../util/shapes.js";
+import { getTool, getToolNames } from "../util/tools.js";
+import { createAgent } from "./agent.js";
+import { createQuery } from './query.js';
+import { createShape } from './shape.js';
+import { createTool } from "./tool.js";
+export class ProjectSchemaImpl {
+    #projectSchemaJson;
+    #layers;
+    #shapeCache;
+    #queryCache;
+    #agentCache;
+    #toolCache;
+    #shapeContextCache;
+    constructor(projectSchemaJson, layers) {
+        this.#projectSchemaJson = projectSchemaJson;
+        this.#layers = layers;
+        this.#shapeCache = new Map();
+        this.#queryCache = new Map();
+        this.#agentCache = new Map();
+        this.#toolCache = new Map();
+        this.#shapeContextCache = new Map();
+    }
+    getShape(rawShapeRef, options) {
+        const shapeRef = normalizeRefExpression(this.#projectSchemaJson, rawShapeRef);
+        let shape = this.#shapeCache.get(shapeRef);
+        if (!shape) {
+            const refItem = parseRef(this.#projectSchemaJson, rawShapeRef);
+            if (refItem) {
+                const namespacedName = refItemToNamespacedShapeName(this.#projectSchemaJson, refItem);
+                let shapeJson = getShape(this.#projectSchemaJson, namespacedName);
+                if (!shapeJson && options?.includeAllBuiltIns) {
+                    shapeJson = getShape({ shapes: allBuiltInShapes }, namespacedName);
+                }
+                if (shapeJson) {
+                    shape = createShape(this, refItem, shapeJson);
+                    this.#shapeCache.set(shapeRef, shape);
+                }
+                else if (refItem.layerId !== 'local') {
+                    const layerSchema = this.#layers[refItem.layerId]?.schema;
+                    if (layerSchema) {
+                        shapeJson = getShape(layerSchema, namespacedName);
+                        if (shapeJson) {
+                            shape = createShape(this, refItem, shapeJson);
+                            this.#shapeCache.set(shapeRef, shape);
+                        }
+                    }
+                }
+            }
+        }
+        return shape;
+    }
+    ensureShape(rawShapeRef, options) {
+        const shape = this.getShape(rawShapeRef, options);
+        if (!shape) {
+            throw new NotFoundError(`Shape "${rawShapeRef}" not found`);
+        }
+        return shape;
+    }
+    getQuery(rawQueryRef) {
+        const queryRef = normalizePropertyRef(rawQueryRef, 'Query');
+        let query = this.#queryCache.get(queryRef);
+        if (!query) {
+            const queryEntry = getQuery(this.#projectSchemaJson, queryRef);
+            if (queryEntry) {
+                query = createQuery(this, queryEntry);
+                this.#queryCache.set(queryRef, query);
+            }
+            else {
+                const parsedRef = parsePropertyRef(queryRef);
+                if (parsedRef && parsedRef.layerId !== 'local') {
+                    const layerSchema = this.#layers[parsedRef.layerId]?.schema;
+                    if (layerSchema) {
+                        const queryEntry = getQuery(layerSchema, parsedRef.propertyName);
+                        if (queryEntry) {
+                            query = createQuery(this, { ...queryEntry, ref: parsedRef });
+                            this.#queryCache.set(queryRef, query);
+                        }
+                    }
+                }
+            }
+        }
+        return query;
+    }
+    getTool(rawToolRef) {
+        const toolRef = normalizePropertyRef(rawToolRef, 'Tool');
+        let tool = this.#toolCache.get(toolRef);
+        if (!tool) {
+            const parsedRef = parsePropertyRef(toolRef);
+            if (parsedRef) {
+                const toolJson = getTool(this.#projectSchemaJson, toolRef);
+                if (toolJson) {
+                    tool = createTool(this, parsedRef, toolJson);
+                    this.#toolCache.set(toolRef, tool);
+                }
+                else if (parsedRef.layerId !== 'local') {
+                    const layerSchema = this.#layers[parsedRef.layerId]?.schema;
+                    if (layerSchema) {
+                        const toolJson = getTool(layerSchema, parsedRef.propertyName);
+                        if (toolJson) {
+                            tool = createTool(this, parsedRef, toolJson);
+                            this.#toolCache.set(toolRef, tool);
+                        }
+                    }
+                }
+            }
+        }
+        return tool;
+    }
+    ensureTool(ref) {
+        const tool = this.getTool(ref);
+        if (!tool) {
+            throw new NotFoundError(`Tool "${ref}" not found`);
+        }
+        return tool;
+    }
+    getTools() {
+        return getToolNames(this.#projectSchemaJson).map((name) => this.ensureTool(`Tool.${name}`));
+    }
+    ensureQuery(ref) {
+        const query = this.getQuery(ref);
+        if (!query) {
+            throw new NotFoundError(`Query "${ref}" not found`);
+        }
+        return query;
+    }
+    getLocalQueries() {
+        return Object.keys(this.#projectSchemaJson.queries).map((queryName) => this.ensureQuery(`Query.${queryName}`));
+    }
+    getLocalMutations() {
+        return Object.keys(this.#projectSchemaJson.mutations).map((queryName) => this.ensureQuery(`Mutation.${queryName}`));
+    }
+    getAgents() {
+        const agents = getAgentMap(this.#projectSchemaJson);
+        return agents ? Object.keys(agents).map((name) => this.ensureAgent(name)) : [];
+    }
+    ensureAgent(name) {
+        const agent = this.getAgent(name);
+        if (!agent) {
+            throw new NotFoundError(`Agent "${name}" not found`);
+        }
+        return agent;
+    }
+    getAgent(name) {
+        let agent = this.#agentCache.get(name);
+        if (!agent) {
+            const agentJson = getAgent(this.#projectSchemaJson, name);
+            if (agentJson) {
+                agent = createAgent(this, name, agentJson);
+                this.#agentCache.set(name, agent);
+            }
+        }
+        return agent;
+    }
+    dereferenceSchema(propertySchema) {
+        return dereferenceSchema(this.#projectSchemaJson, propertySchema);
+    }
+    dereferenceObjectSchema(propertySchema) {
+        return dereferenceObjectSchema(this.#projectSchemaJson, propertySchema);
+    }
+    /**
+     * Get context variables configuration for a shape by name.
+     * Returns undefined if the shape has no context variables configured.
+     * Results are cached for efficient repeated lookups.
+     */
+    getShapeContextVariables(shapeName) {
+        // Check cache first - includes null entries for shapes without context
+        const cached = this.#shapeContextCache.get(shapeName);
+        if (cached !== undefined) {
+            return cached ?? undefined;
+        }
+        // Look up shape context config
+        const shape = this.#projectSchemaJson.shapes?.[shapeName];
+        const contextVariables = shape?.context?.variables;
+        // Cache the result (null for shapes without context variables)
+        this.#shapeContextCache.set(shapeName, contextVariables ?? null);
+        return contextVariables;
+    }
+    get json() {
+        return this.#projectSchemaJson;
+    }
+}

package/dist/models/query.d.ts

@@ -0,0 +1,3 @@
+import { type QueryEntry } from '../refs.ts';
+import type { ProjectSchema, Query } from './types.ts';
+export declare function createQuery(parent: ProjectSchema, entry: QueryEntry): Query;

package/dist/models/query.js

@@ -0,0 +1,46 @@
+import { parseReturnShape, serializePropertyRef } from "../refs.js";
+class QueryImpl {
+    #schema;
+    #name;
+    #query;
+    #ref;
+    constructor(parent, entry) {
+        this.#schema = parent;
+        this.#name = entry.name;
+        this.#query = entry.query;
+        this.#ref = entry.ref;
+    }
+    get ref() {
+        return serializePropertyRef(this.#ref);
+    }
+    get argsSchema() {
+        const args = this.#query.args;
+        if (args) {
+            if (typeof args === 'object') {
+                return this.#schema.dereferenceObjectSchema(args);
+            }
+            return this.#schema.getShape(args)?.getObjectSchema();
+        }
+        return undefined;
+    }
+    get argsAreFromShape() {
+        const args = this.#query.args;
+        return Boolean(args && typeof args === 'string');
+    }
+    get type() {
+        return this.#ref.shapeName === 'Mutation' ? 'mutation' : 'query';
+    }
+    get name() {
+        return this.#name;
+    }
+    get json() {
+        return this.#query;
+    }
+    get returnShape() {
+        const { shapeName } = parseReturnShape(this.#schema.json, this.#query.shape);
+        return this.#schema.getShape(shapeName);
+    }
+}
+export function createQuery(parent, entry) {
+    return new QueryImpl(parent, entry);
+}

package/dist/models/runtime-schema.d.ts

@@ -0,0 +1,9 @@
+import type { ProjectSchemaJSON } from '../project-schema/index.ts';
+import type { ServiceLayers } from '../types/types.ts';
+import { ProjectSchemaImpl } from './project-schema.ts';
+export declare class RuntimeSchema extends ProjectSchemaImpl {
+    private constructor();
+    static buildSchema(userSchema: ProjectSchemaJSON, layers: ServiceLayers): RuntimeSchema;
+    static safeBuildSchema(userSchema: ProjectSchemaJSON, layers: ServiceLayers): RuntimeSchema | undefined;
+    static fromJson(runtimeSchema: ProjectSchemaJSON, layers: ServiceLayers): RuntimeSchema;
+}

package/dist/models/runtime-schema.js

@@ -0,0 +1,20 @@
+import { buildRuntimeSchema } from "../runtime-schema.js";
+import { ProjectSchemaImpl } from "./project-schema.js";
+export class RuntimeSchema extends ProjectSchemaImpl {
+    constructor(runtimeSchema, layers) {
+        super(runtimeSchema, layers);
+    }
+    static buildSchema(userSchema, layers) {
+        const runtimeSchema = buildRuntimeSchema(userSchema, layers);
+        return new RuntimeSchema(runtimeSchema, layers);
+    }
+    static safeBuildSchema(userSchema, layers) {
+        try {
+            return RuntimeSchema.buildSchema(userSchema, layers);
+        }
+        catch { }
+    }
+    static fromJson(runtimeSchema, layers) {
+        return new RuntimeSchema(runtimeSchema, layers);
+    }
+}

package/dist/models/shape.d.ts

@@ -0,0 +1,4 @@
+import type { ShapeJSON } from '../project-schema/latest.ts';
+import { type RefItem } from '../refs.ts';
+import type { ProjectSchema, Shape } from './types.ts';
+export declare function createShape(parent: ProjectSchema, ref: RefItem, shape: ShapeJSON): Shape;

package/dist/models/shape.js

@@ -0,0 +1,36 @@
+import { serializeRef } from "../refs.js";
+import { isObjectSchema } from "../types/utils.js";
+class ShapeImpl {
+    #schema;
+    #ref;
+    #shape;
+    #dereferencedSchema;
+    constructor(parent, ref, shape) {
+        this.#schema = parent;
+        this.#ref = ref;
+        this.#shape = shape;
+    }
+    get name() {
+        return this.#shape.name;
+    }
+    get ref() {
+        return serializeRef(this.#ref);
+    }
+    get refItem() {
+        return this.#ref;
+    }
+    get json() {
+        return this.#shape;
+    }
+    getObjectSchema() {
+        if (!this.#dereferencedSchema) {
+            this.#dereferencedSchema = this.#schema.dereferenceSchema(this.#shape.schema);
+        }
+        if (isObjectSchema(this.#dereferencedSchema)) {
+            return this.#dereferencedSchema;
+        }
+    }
+}
+export function createShape(parent, ref, shape) {
+    return new ShapeImpl(parent, ref, shape);
+}

package/dist/models/tool.d.ts

@@ -0,0 +1,4 @@
+import { type PropertyRefItem } from '../refs.ts';
+import type { NamedToolJSON } from '../types/index.ts';
+import type { ProjectSchema, Tool } from './types.ts';
+export declare function createTool(parent: ProjectSchema, ref: PropertyRefItem, entry: NamedToolJSON): Tool;