@takeshape/schema 12.1.1 → 12.1.5

package/dist/util/graphql-string.js

@@ -0,0 +1,75 @@
+import { Kind, parse } from '@0no-co/graphql.web';
+// TODO consider moving this to @takeshape/graphql
+export function getVariablesSchema(runtimeSchema, queryStr) {
+    const doc = parse(queryStr);
+    const op = doc.definitions.find((def) => def.kind === 'OperationDefinition');
+    return op?.variableDefinitions && variablesToPropertySchema(runtimeSchema, op.variableDefinitions);
+}
+function variablesToPropertySchema(runtimeSchema, nodes) {
+    const properties = {};
+    const required = [];
+    let argsAreFromShape = false;
+    for (const node of nodes) {
+        let typeNode = node.type;
+        let isRequired = false;
+        if (typeNode.kind === Kind.NON_NULL_TYPE) {
+            isRequired = true;
+            typeNode = typeNode.type;
+        }
+        const { propertySchema, isFromShape } = graphqlTypeNodeToPropertySchemaWithShapeInfo(runtimeSchema, typeNode);
+        if (propertySchema) {
+            const name = node.variable.name.value;
+            properties[name] = propertySchema;
+            if (isRequired) {
+                required.push(name);
+            }
+            if (isFromShape) {
+                argsAreFromShape = true;
+            }
+        }
+    }
+    return { argsSchema: { type: 'object', properties, required }, argsAreFromShape };
+}
+const scalarTypeMap = {
+    String: 'string',
+    Int: 'integer',
+    Float: 'number',
+    Boolean: 'boolean',
+    ID: 'string',
+    JSON: 'object',
+    JSONObject: 'object'
+};
+function graphqlTypeNodeToPropertySchema(runtimeSchema, node) {
+    const { propertySchema } = graphqlTypeNodeToPropertySchemaWithShapeInfo(runtimeSchema, node);
+    return propertySchema;
+}
+function graphqlTypeNodeToPropertySchemaWithShapeInfo(runtimeSchema, node) {
+    // Handle NonNullType (e.g., String!)
+    if (node.kind === Kind.NON_NULL_TYPE) {
+        return graphqlTypeNodeToPropertySchemaWithShapeInfo(runtimeSchema, node.type);
+    }
+    // Handle ListType (e.g., [String])
+    if (node.kind === Kind.LIST_TYPE) {
+        const { propertySchema, isFromShape } = graphqlTypeNodeToPropertySchemaWithShapeInfo(runtimeSchema, node.type);
+        return {
+            propertySchema: propertySchema
+                ? {
+                    type: 'array',
+                    items: propertySchema
+                }
+                : undefined,
+            isFromShape
+        };
+    }
+    const typeName = node.name.value;
+    const jsonType = scalarTypeMap[typeName];
+    if (jsonType) {
+        return { propertySchema: { type: jsonType }, isFromShape: false };
+    }
+    // TODO this lookup needs to account for Input suffixes and inline object shapes
+    const shape = runtimeSchema.getShape(typeName);
+    if (shape) {
+        return { propertySchema: { '@ref': shape.ref }, isFromShape: true };
+    }
+    return { propertySchema: undefined, isFromShape: false };
+}

package/dist/util/has-arg.d.ts

@@ -0,0 +1,6 @@
+import type { Args, ObjectSchema, ProjectSchemaJSON } from '../project-schema/index.ts';
+import { type ServicesShapesContext } from '../refs.ts';
+import { type SchemaWithArgs } from '../types/index.ts';
+export declare function getArgs(prop: SchemaWithArgs): Args | undefined;
+export declare function getArgsSchema(projectSchema: ServicesShapesContext, args: Args): ObjectSchema | undefined;
+export declare function hasArg(projectSchema: ProjectSchemaJSON, prop: SchemaWithArgs, argPath: string | string[]): boolean;

package/dist/util/has-arg.js

@@ -0,0 +1,25 @@
+import { dereferenceObjectSchema, parseRef, refItemToShape } from "../refs.js";
+import { isObjectSchema } from "../types/index.js";
+import { findSchemaAtPath } from "./find-shape-at-path.js";
+export function getArgs(prop) {
+    return '@args' in prop ? prop['@args'] : 'args' in prop ? prop.args : undefined;
+}
+export function getArgsSchema(projectSchema, args) {
+    if (typeof args === 'object') {
+        return dereferenceObjectSchema(projectSchema, args);
+    }
+    const ref = parseRef(projectSchema, args);
+    const shapeSchema = refItemToShape(projectSchema, ref)?.schema;
+    if (shapeSchema && isObjectSchema(shapeSchema)) {
+        return shapeSchema;
+    }
+}
+export function hasArg(projectSchema, prop, argPath) {
+    const args = getArgs(prop);
+    if (!args) {
+        return false;
+    }
+    const schema = getArgsSchema(projectSchema, args);
+    const pathArray = Array.isArray(argPath) ? argPath : argPath.split('.');
+    return Boolean(schema && findSchemaAtPath(projectSchema, schema, pathArray));
+}

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.d.ts

@@ -0,0 +1,17 @@
+import type { FormConfig, ObjectSchema, ProjectSchemaJSON } from '../project-schema/index.ts';
+export declare function omitObjectSchema(schema: ObjectSchema, names: string[]): ObjectSchema;
+export declare function pickObjectSchema(schema: ObjectSchema, names: string[]): ObjectSchema;
+export declare function mergeObjectSchemas(...args: Array<ObjectSchema | undefined>): ObjectSchema;
+export declare function mergeDeepObjectSchemas(...args: Array<ObjectSchema | undefined>): ObjectSchema;
+export declare function mergeSchemaProperties(parent: ObjectSchema, overrides: ObjectSchema, deep?: boolean): ObjectSchema;
+export declare function rebaseSchemaProperties(base: ObjectSchema, parent: ObjectSchema, head: ObjectSchema): ObjectSchema;
+export declare function mergeFormProperties(parent: FormConfig, overrides: FormConfig): FormConfig;
+export declare function rebaseFormProperties(base: FormConfig, parent: FormConfig, head: FormConfig): FormConfig;
+export declare function mergeFormConfigs(...configs: FormConfig[]): FormConfig;
+export declare function mergeProjectSchemas(base: ProjectSchemaJSON, parent: ProjectSchemaJSON, head: ProjectSchemaJSON): {
+    error: string;
+    mergedSchema: undefined;
+} | {
+    error: undefined;
+    mergedSchema: ProjectSchemaJSON;
+};

package/dist/util/merge.js

@@ -0,0 +1,278 @@
+import { assert, deepClone, isDefined, rebaseArray, rebaseObject } from '@takeshape/util';
+import assignWith from 'lodash/assignWith.js';
+import difference from 'lodash/difference.js';
+import intersection from 'lodash/intersection.js';
+import isEqual from 'lodash/isEqual.js';
+import last from 'lodash/last.js';
+import omit from 'lodash/omit.js';
+import pick from 'lodash/pick.js';
+import pickBy from 'lodash/pickBy.js';
+import set from 'lodash/set.js';
+import union from 'lodash/union.js';
+import unset from 'lodash/unset.js';
+import { isExtendsSchema, isObjectSchema, isRefSchema } from "../types/index.js";
+export function omitObjectSchema(schema, names) {
+    const { properties, required, ...rest } = schema;
+    const filteredSchema = {
+        ...rest,
+        properties: omit(properties, names)
+    };
+    if (required) {
+        filteredSchema.required = difference(required, names);
+    }
+    return filteredSchema;
+}
+export function pickObjectSchema(schema, names) {
+    const { properties, required, ...rest } = schema;
+    const filteredSchema = {
+        ...rest,
+        properties: pick(properties, names)
+    };
+    if (required) {
+        filteredSchema.required = intersection(required, names);
+    }
+    return filteredSchema;
+}
+export function mergeObjectSchemas(...args) {
+    return args.filter(isDefined).reduce((parent, schemas) => mergeSchemaProperties(parent, schemas), {
+        type: 'object',
+        properties: {}
+    });
+}
+export function mergeDeepObjectSchemas(...args) {
+    return args.filter(isDefined).reduce((parent, schemas) => mergeSchemaProperties(parent, schemas, true), {
+        type: 'object',
+        properties: {}
+    });
+}
+export function mergeSchemaProperties(parent, overrides, deep = false) {
+    const result = {
+        ...parent,
+        properties: deep
+            ? assignWith({}, parent.properties, overrides.properties, (objValue, srcValue) => {
+                // merge objects if possible
+                if (objValue !== undefined && srcValue !== undefined) {
+                    // skip merging if they are equal this avoids allOf with duplicate refs
+                    if (isEqual(objValue, srcValue)) {
+                        return objValue;
+                    }
+                    if (isObjectSchema(objValue) && isObjectSchema(srcValue)) {
+                        return mergeObjectSchemas(objValue, srcValue);
+                    }
+                    if ((isObjectSchema(objValue) || isRefSchema(objValue)) &&
+                        (isObjectSchema(srcValue) || isRefSchema(srcValue))) {
+                        return { allOf: [objValue, srcValue] };
+                    }
+                }
+            })
+            : { ...parent.properties, ...overrides.properties }
+    };
+    const required = union(parent.required, overrides.required);
+    if (required.length) {
+        result.required = required;
+    }
+    return result;
+}
+export function rebaseSchemaProperties(base, parent, head) {
+    const { properties: toProperties, required: toRequired, ...toOther } = base;
+    const { properties: baseProperties, required: baseRequired, ...baseOther } = parent;
+    const { properties: fromProperties, required: fromRequired, ...fromOther } = head;
+    const newSchema = {
+        ...rebaseObject(toOther, baseOther, fromOther),
+        type: 'object',
+        properties: rebaseObject(toProperties, baseProperties, fromProperties)
+    };
+    const required = rebaseArray(toRequired ?? [], baseRequired ?? [], fromRequired ?? []);
+    if (required.length) {
+        newSchema.required = required;
+    }
+    return newSchema;
+}
+export function mergeFormProperties(parent, overrides) {
+    const result = {
+        ...parent,
+        properties: {
+            ...parent.properties,
+            ...overrides.properties
+        }
+    };
+    const order = union(parent.order, overrides.order);
+    if (order.length) {
+        result.order = order;
+    }
+    return result;
+}
+export function rebaseFormProperties(base, parent, head) {
+    const { properties: toProperties, order: toOrder, ...toOther } = base;
+    const { properties: baseProperties, order: baseOrder, ...baseOther } = parent;
+    const { properties: fromProperties, order: fromOrder, ...fromOther } = head;
+    const newForm = {
+        ...rebaseObject(toOther, baseOther, fromOther),
+        properties: rebaseObject(toProperties, baseProperties, fromProperties)
+    };
+    const order = rebaseArray(toOrder ?? [], baseOrder ?? [], fromOrder ?? []);
+    if (order.length) {
+        newForm.order = order;
+    }
+    return newForm;
+}
+export function mergeFormConfigs(...configs) {
+    return configs.reduce(mergeFormProperties, { properties: {}, order: [] });
+}
+const mergeableSections = ['shapes', 'mutations', 'queries', 'forms', 'services'];
+const isMergeableSection = (str) => {
+    return mergeableSections.includes(str);
+};
+const pickUnmergeable = (projectSchema) => {
+    return pickBy(projectSchema, (_value, key) => !isMergeableSection(key));
+};
+function compareSection(section, original, updated) {
+    const changes = [];
+    const originalKeys = Object.keys(original);
+    const updatedKeys = Object.keys(updated);
+    for (const removedKey of difference(originalKeys, updatedKeys)) {
+        changes.push({ path: [section, removedKey], section, op: 'remove' });
+    }
+    for (const [key, value] of Object.entries(updated)) {
+        if (!original[key]) {
+            changes.push({ path: [section, key], section, op: 'add', value });
+        }
+        else if (!isEqual(original[key], updated[key])) {
+            changes.push({ path: [section, key], section, op: 'update', value });
+        }
+    }
+    return changes;
+}
+function compareSections(parent, branch) {
+    return mergeableSections.flatMap((section) => (parent[section] ?? branch[section]) ? compareSection(section, parent[section] ?? {}, branch[section] ?? {}) : []);
+}
+function findChangedShape(schema, change) {
+    return schema.shapes[change.path[1]];
+}
+function getChangedShape(schema, change) {
+    const shape = findChangedShape(schema, change);
+    assert(shape, 'Expected shape not found');
+    return shape;
+}
+function rebaseShapeProperties(toShape, fromShape, baseShape) {
+    return baseShape
+        ? rebaseObject(omit(toShape, 'schema'), omit(baseShape, 'schema'), omit(fromShape, 'schema'))
+        : { ...toShape, ...fromShape };
+}
+function attemptToMerge(base, parent, head, change) {
+    const toShape = getChangedShape(base, change);
+    const fromShape = getChangedShape(head, change);
+    const toSchema = toShape.schema;
+    const fromSchema = fromShape.schema;
+    if (isEqual(toSchema, fromSchema)) {
+        const baseShape = findChangedShape(parent, change);
+        return {
+            ...rebaseShapeProperties(toShape, fromShape, baseShape),
+            schema: toSchema
+        };
+    }
+    if (isObjectSchema(toSchema) && isObjectSchema(fromSchema)) {
+        const baseShape = findChangedShape(parent, change);
+        const baseSchema = baseShape?.schema;
+        return {
+            ...rebaseShapeProperties(toShape, fromShape, baseShape),
+            schema: change.op === 'update' && baseSchema && isObjectSchema(baseSchema)
+                ? rebaseSchemaProperties(toSchema, baseSchema, fromSchema)
+                : mergeSchemaProperties(toSchema, fromSchema)
+        };
+    }
+    if (isExtendsSchema(toSchema) &&
+        isExtendsSchema(fromSchema) &&
+        toSchema.extends.length === fromSchema.extends.length) {
+        const fromExtends = fromSchema.extends;
+        const toObj = last(toSchema.extends);
+        const fromObj = last(fromSchema.extends);
+        if (toObj &&
+            isObjectSchema(toObj) &&
+            fromObj &&
+            isObjectSchema(fromObj) &&
+            toSchema.extends.slice(0, toSchema.extends.length - 1).every((item, i) => isEqual(item, fromExtends[i]))) {
+            let mergedObjSchema;
+            const baseShape = findChangedShape(parent, change);
+            const baseSchema = baseShape?.schema;
+            if (change.op === 'update' && baseSchema && isExtendsSchema(baseSchema)) {
+                const baseObj = last(baseSchema.extends);
+                if (baseObj && isObjectSchema(baseObj)) {
+                    mergedObjSchema = rebaseSchemaProperties(toObj, baseObj, fromObj);
+                }
+            }
+            mergedObjSchema ||= mergeSchemaProperties(toObj, fromObj);
+            return {
+                ...rebaseShapeProperties(toShape, fromShape, baseShape),
+                schema: {
+                    extends: [...toSchema.extends.slice(0, toSchema.extends.length - 1), mergedObjSchema]
+                }
+            };
+        }
+    }
+}
+function applyChange(base, parent, head, change) {
+    if (change.op === 'remove') {
+        unset(base, change.path);
+    }
+    else if (change.op === 'add') {
+        set(base, change.path, change.value);
+    }
+    else if (change.op === 'update') {
+        if (change.section === 'shapes') {
+            const mergedShape = attemptToMerge(base, parent, head, change);
+            if (mergedShape) {
+                set(base, change.path, mergedShape);
+                return;
+            }
+        }
+        else if (change.section === 'forms') {
+            const shapeName = change.path[1];
+            const toForm = base.forms?.[shapeName]?.default;
+            const fromForm = head.forms?.[shapeName]?.default;
+            if (toForm && fromForm) {
+                const baseForm = parent.forms?.[shapeName]?.default;
+                set(base, change.path, {
+                    default: baseForm ? rebaseFormProperties(toForm, baseForm, fromForm) : mergeFormConfigs(toForm, fromForm)
+                });
+                return;
+            }
+        }
+        set(base, change.path, change.value);
+    }
+}
+export function mergeProjectSchemas(base, parent, head) {
+    const changesTo = compareSections(parent, base);
+    const changesFrom = compareSections(parent, head);
+    const mergedSchema = deepClone(base);
+    for (let change of changesFrom) {
+        const potentialConflict = changesTo.find((changeTo) => isEqual(changeTo.path, change.path));
+        if (potentialConflict) {
+            if (potentialConflict.op === 'remove' && change.op !== 'remove') {
+                return {
+                    error: `Attempting to ${change.op} ${change.path.join('.')} which has already been removed`,
+                    mergedSchema: undefined
+                };
+            }
+            if ((potentialConflict.op === 'add' && change.op === 'add') ||
+                (potentialConflict.op === 'update' && change.op === 'update')) {
+                if (change.section === 'shapes') {
+                    const mergedValue = attemptToMerge(base, parent, head, change);
+                    if (!mergedValue) {
+                        return {
+                            error: `Unable to merge ${change.path.join('.')} schemas conflict`,
+                            mergedSchema: undefined
+                        };
+                    }
+                    change = { ...change, op: 'add', value: mergedValue };
+                }
+                else if (change.section === 'forms') {
+                    change = { ...change, op: 'update' };
+                }
+            }
+        }
+        applyChange(mergedSchema, parent, head, change);
+    }
+    Object.assign(mergedSchema, rebaseObject(pickUnmergeable(base), pickUnmergeable(parent), pickUnmergeable(head)));
+    return { error: undefined, mergedSchema };
+}

package/dist/util/patch-schema.d.ts

@@ -0,0 +1,13 @@
+import { type ProjectSchemaUpdate } from '../migration/types.ts';
+import type { ProjectSchemaJSON } from '../project-schema/index.ts';
+/**
+ * Apply a schema update to a schema. This can operate on a schema with frozen properties,
+ * such as one produced by immer. Resulting schema is not assumed to be valid and should
+ * be validated if appropriate.
+ */
+export declare function patchSchema<T extends ProjectSchemaJSON>(projectSchema: T, schemaUpdate: ProjectSchemaUpdate): T;
+export type ApplyToProjectSchemaOptions = {
+    mode?: 'replace' | 'preserve' | 'fail';
+    servicesMode?: 'replace' | 'preserve' | 'fail';
+};
+export declare function getSchemaUpdateFromPattern(currentSchema: ProjectSchemaJSON, patternSchema: ProjectSchemaJSON, options: ApplyToProjectSchemaOptions): ProjectSchemaUpdate | undefined;

package/dist/util/patch-schema.js

@@ -0,0 +1,89 @@
+import set from 'lodash/fp/set.js';
+import get from 'lodash/get.js';
+import intersection from 'lodash/intersection.js';
+import isEmpty from 'lodash/isEmpty.js';
+import isEqual from 'lodash/isEqual.js';
+import omit from 'lodash/omit.js';
+import omitBy from 'lodash/omitBy.js';
+import unset from 'lodash/unset.js';
+import { AGENTS_UPDATE_KEY, GUARDS_UPDATE_KEY, TOOLS_UPDATE_KEY } from "../migration/types.js";
+/**
+ * Array of lodash.get paths to keys that are merged when applying a schema update.
+ */
+const MERGED_KEYS = [
+    'queries',
+    'mutations',
+    'shapes',
+    'workflows',
+    'forms',
+    'services',
+    AGENTS_UPDATE_KEY,
+    GUARDS_UPDATE_KEY,
+    TOOLS_UPDATE_KEY
+];
+function shallowMerge(original, update) {
+    const result = { ...original };
+    for (const [key, obj] of Object.entries(update)) {
+        // Null is a sentinel value to indicate delete
+        if (obj === null) {
+            unset(result, key);
+        }
+        else {
+            result[key] = obj;
+        }
+    }
+    return result;
+}
+/**
+ * Apply a schema update to a schema. This can operate on a schema with frozen properties,
+ * such as one produced by immer. Resulting schema is not assumed to be valid and should
+ * be validated if appropriate.
+ */
+export function patchSchema(projectSchema, schemaUpdate) {
+    // Patch old schema with update
+    let updatedSchema = {
+        ...projectSchema,
+        ...omit(schemaUpdate, MERGED_KEYS)
+    };
+    for (const key of MERGED_KEYS) {
+        const update = get(schemaUpdate, key);
+        if (update) {
+            updatedSchema = set(key, shallowMerge(get(projectSchema, key) ?? {}, update), updatedSchema);
+        }
+    }
+    return updatedSchema;
+}
+const DEFAULT_OPTIONS = {
+    mode: 'preserve',
+    servicesMode: 'preserve'
+};
+function setSectionUpdate(update, patternKey, currentValues, patternValues, options) {
+    const { mode, servicesMode } = { ...DEFAULT_OPTIONS, ...options };
+    const keyMode = patternKey === 'services' ? servicesMode : mode;
+    // Check for conflict in "fail" mode
+    if (keyMode === 'fail' && currentValues && patternValues) {
+        const wouldBeOverwritten = intersection(Object.keys(currentValues), Object.keys(patternValues));
+        if (wouldBeOverwritten.length > 0) {
+            throw new Error(`The following ${patternKey} would be overwritten: ${wouldBeOverwritten.join(', ')}`);
+        }
+    }
+    // Add values to update
+    if (patternValues) {
+        const updateValues = keyMode === 'preserve' && currentValues
+            ? omit(patternValues, Object.keys(currentValues))
+            : omitBy(patternValues, (value, key) => isEqual(currentValues?.[key], value));
+        if (!isEmpty(updateValues)) {
+            update[patternKey] = updateValues;
+        }
+    }
+}
+function isEmptyUpdate(update) {
+    return MERGED_KEYS.every((key) => isEmpty(update[key]));
+}
+export function getSchemaUpdateFromPattern(currentSchema, patternSchema, options) {
+    const update = {};
+    for (const path of MERGED_KEYS) {
+        setSectionUpdate(update, path, get(currentSchema, path), get(patternSchema, path), options);
+    }
+    return isEmptyUpdate(update) ? undefined : update;
+}

package/dist/util/query-field-path.d.ts

@@ -0,0 +1,9 @@
+import type { ProjectSchemaJSON } from '../project-schema/index.ts';
+export declare function getQueryFieldPath(operation: 'query' | 'mutation', fieldName: string): ['queries' | 'mutations', ...string[]];
+/**
+ * Get a query or property schema
+ * @param schema
+ * @param queryFieldPath
+ * @returns
+ */
+export declare function findSchemaAtQueryFieldPath(schema: Pick<ProjectSchemaJSON, 'queries' | 'mutations' | 'services' | 'shapes'>, queryFieldPath: ReturnType<typeof getQueryFieldPath>): import("../project-schema/latest.ts").PropertySchema | undefined;

package/dist/util/query-field-path.js

@@ -0,0 +1,23 @@
+import { findSchemaAtPath } from "./find-shape-at-path.js";
+import { getReturnShape } from "./get-return-shape.js";
+function parseFieldName(fieldName) {
+    return fieldName.split('.');
+}
+export function getQueryFieldPath(operation, fieldName) {
+    return [operation === 'query' ? 'queries' : 'mutations', ...parseFieldName(fieldName)];
+}
+/**
+ * Get a query or property schema
+ * @param schema
+ * @param queryFieldPath
+ * @returns
+ */
+export function findSchemaAtQueryFieldPath(schema, queryFieldPath) {
+    const [operationName, queryName, ...fieldPath] = queryFieldPath;
+    const queryOrMutation = schema[operationName]?.[queryName];
+    if (!queryOrMutation) {
+        return undefined;
+    }
+    const shape = getReturnShape(schema, queryOrMutation);
+    return shape ? findSchemaAtPath(schema, shape.schema, fieldPath) : undefined;
+}

package/dist/util/shapes.d.ts

@@ -0,0 +1,5 @@
+import type { ProjectSchemaJSON, ShapeJSON } from '../project-schema/index.ts';
+export declare function getShapeById(projectSchema: Pick<ProjectSchemaJSON, 'shapes'>, shapeId: string): ShapeJSON | undefined;
+export declare function getShape(context: Pick<ProjectSchemaJSON, 'shapes'>, name: string): ShapeJSON | undefined;
+export declare function ensureShape(projectSchema: Pick<ProjectSchemaJSON, 'shapes'>, name: string): ShapeJSON;
+export declare function ensureShapeById(projectSchema: Pick<ProjectSchemaJSON, 'shapes'>, shapeId: string): ShapeJSON;

package/dist/util/shapes.js

@@ -0,0 +1,22 @@
+import { NotFoundError } from '@takeshape/errors';
+import find from 'lodash/find.js';
+export function getShapeById(projectSchema, shapeId) {
+    return find(projectSchema.shapes, (shape) => shape.id === shapeId);
+}
+export function getShape(context, name) {
+    return context.shapes[name];
+}
+export function ensureShape(projectSchema, name) {
+    const shape = getShape(projectSchema, name);
+    if (!shape) {
+        throw new NotFoundError(`Shape "${name}" Not found`);
+    }
+    return shape;
+}
+export function ensureShapeById(projectSchema, shapeId) {
+    const shape = getShapeById(projectSchema, shapeId);
+    if (!shape) {
+        throw new NotFoundError(`Shape with id "${shapeId}" Not found`);
+    }
+    return shape;
+}

package/dist/util/tools.d.ts

@@ -0,0 +1,10 @@
+import type { ToolMap } from '../project-schema/index.ts';
+import type { LayerSchema, NamedToolJSON } from '../types/index.ts';
+export declare const TOOL_SCHEMA_PATH: readonly ["tools"];
+export declare function getToolMap(projectSchema: LayerSchema): ToolMap | undefined;
+export declare function getTools(projectSchema: LayerSchema): NamedToolJSON[];
+export declare function getToolNames(projectSchema: LayerSchema): string[];
+export declare function getTool(layer: LayerSchema, toolRef: string): NamedToolJSON | undefined;
+export declare function setTools<S extends Partial<LayerSchema>>(layer: S, tools: NamedToolJSON[]): S;
+export declare function setTool<S extends Partial<LayerSchema>>(layer: S, namedTool: NamedToolJSON): S;
+export declare function removeTools<S extends Partial<LayerSchema>>(layer: S, toolNames: string[]): S;

package/dist/util/tools.js

@@ -0,0 +1,39 @@
+import omit from 'lodash/omit.js';
+import { parsePropertyRef } from "../refs.js";
+export const TOOL_SCHEMA_PATH = ['tools'];
+export function getToolMap(projectSchema) {
+    return projectSchema.tools;
+}
+export function getTools(projectSchema) {
+    const { tools } = projectSchema;
+    return tools ? Object.keys(tools).map((name) => ({ name, ...tools[name] })) : [];
+}
+export function getToolNames(projectSchema) {
+    return projectSchema.tools ? Object.keys(projectSchema.tools) : [];
+}
+export function getTool(layer, toolRef) {
+    const parsed = parsePropertyRef(toolRef, 'Tool');
+    if (!parsed) {
+        throw new Error(`Invalid tool ref "${toolRef}"`);
+    }
+    const toolName = parsed.propertyName;
+    const tool = layer.tools?.[toolName];
+    return tool ? { ...tool, name: toolName } : undefined;
+}
+export function setTools(layer, tools) {
+    return {
+        ...layer,
+        tools: tools.reduce((acc, { name, ...tool }) => {
+            acc[name] = tool;
+            return acc;
+        }, {})
+    };
+}
+export function setTool(layer, namedTool) {
+    const { name, ...tool } = namedTool;
+    return { ...layer, tools: { ...(layer.tools ?? {}), [name]: tool } };
+}
+export function removeTools(layer, toolNames) {
+    const newTools = omit(layer.tools ?? {}, toolNames);
+    return { ...layer, tools: newTools };
+}

package/dist/validate/ai.d.ts

@@ -0,0 +1,6 @@
+import type { SchemaValidationErrorItem } from '@takeshape/errors';
+import type { AgentToolConfig, ProjectSchemaJSON, ToolJSON } from '../project-schema/latest.ts';
+import type { Path, ValidateReferencesContext } from './types.ts';
+export declare function validateAIToolConfig(projectSchema: ProjectSchemaJSON, toolConfig: AgentToolConfig, basePath: Path): SchemaValidationErrorItem | undefined;
+export declare function validateToolQuery(context: ValidateReferencesContext, tool: ToolJSON, basePath: Path): Promise<SchemaValidationErrorItem | undefined>;
+export declare function validateAgents(projectSchema: ProjectSchemaJSON): SchemaValidationErrorItem[];