@takeshape/schema 12.1.1 → 12.1.5

package/dist/constants.d.ts

@@ -0,0 +1 @@
+export declare const SERVICE_OBJECT_PATTERN_NAME = "pattern:service-object";

package/dist/constants.js

@@ -0,0 +1 @@
+export const SERVICE_OBJECT_PATTERN_NAME = 'pattern:service-object';

package/dist/content-schema-transform.d.ts

@@ -0,0 +1,35 @@
+import type { ProjectSchemaJSON, PropertySchema, ShapeJSON } from './project-schema/index.ts';
+import type { ContentTransform, KeyTransform, PropertyTransform, PropertyTransformMap, SchemaType, SourceKeyTransform } from './types/index.ts';
+export declare function getType(schema: Pick<PropertySchema, 'type'>): SchemaType;
+export declare function preferKey(name: string, schema: PropertySchema): string;
+/**
+ * A key transform to select the field name
+ */
+export declare const preferName: KeyTransform;
+export declare function preferSourceKey(name: string, schema: PropertySchema): string[];
+export declare function findTransforms(pluginMap: PropertyTransformMap | undefined, schema: PropertySchema, name: string, shape?: ShapeJSON): PropertyTransform | undefined;
+export type Accumulator<T = unknown> = {
+    accumulate(value: unknown, schema: PropertySchema, name: string): void;
+    getResults(): T;
+};
+export type ContentTransformParams = {
+    transforms?: PropertyTransformMap;
+    accumulators?: Accumulator[];
+    projectSchema: ProjectSchemaJSON;
+    keyTransform?: KeyTransform;
+    sourceKeyTransform?: SourceKeyTransform;
+    passThrough?: boolean;
+    allowNullObjects?: boolean;
+};
+export declare function getContentTransform({ transforms, accumulators, keyTransform, sourceKeyTransform, passThrough, allowNullObjects, projectSchema }: ContentTransformParams): ContentTransform;
+export type PropertyInfo = {
+    schema: PropertySchema;
+    key: string;
+    isRequired: boolean;
+};
+export type GetPropertyInfoContext = {
+    projectSchema: ProjectSchemaJSON;
+    transforms?: PropertyTransformMap;
+    keyTransform?: KeyTransform;
+};
+export declare function getPropertyInfo(context: GetPropertyInfoContext, schema: PropertySchema, path: string): PropertyInfo[];

package/dist/content-schema-transform.js

@@ -0,0 +1,162 @@
+import difference from 'lodash/difference.js';
+import forEach from 'lodash/forEach.js';
+import get from 'lodash/get.js';
+import pick from 'lodash/pick.js';
+import { dereferenceSchema, getRefShapeName } from "./refs.js";
+import { getStorageKey } from "./schema-util.js";
+import { isArraySchema, isObjectSchema } from "./types/utils.js";
+import { enumerateOneOfKeys, isUnionSchema } from "./unions.js";
+const typeCache = new WeakMap();
+export function getType(schema) {
+    let type = typeCache.get(schema);
+    if (type) {
+        return type;
+    }
+    type = schema.type;
+    // Handle nullable types for example: ['object', 'null']
+    if (Array.isArray(type)) {
+        const filtered = type.filter((name) => name !== 'null');
+        if (!filtered.length) {
+            throw new Error('Invalid schema');
+        }
+        type = filtered[0];
+    }
+    typeCache.set(schema, type);
+    return type;
+}
+function ensureArray(value) {
+    return Array.isArray(value) ? value : [value];
+}
+export function preferKey(name, schema) {
+    return getStorageKey(schema) ?? name;
+}
+/**
+ * A key transform to select the field name
+ */
+export const preferName = (name) => name;
+function getLocalizedKey(key, locale) {
+    return locale ? `${key}:${locale}` : key;
+}
+function getNonDefaultLocales(projectSchema) {
+    return projectSchema.locales.filter((locale) => locale !== projectSchema.defaultLocale);
+}
+function getLocalizedSourceKeys(keys, locales) {
+    return keys.flatMap((key) => [{ key }, ...locales.map((locale) => ({ key: `${key}:${locale}`, locale }))]);
+}
+export function preferSourceKey(name, schema) {
+    const key = getStorageKey(schema);
+    return key ? [key, name] : [name];
+}
+export function findTransforms(pluginMap, schema, name, shape) {
+    const type = getType(schema);
+    if (pluginMap && (pluginMap[type] ?? pluginMap['*'])) {
+        const plugins = (pluginMap[type] ?? []).concat(pluginMap['*'] ?? []);
+        return plugins.find((plugin) => plugin.filter(schema, name, shape));
+    }
+    return undefined;
+}
+export function getContentTransform({ transforms, accumulators, keyTransform = preferKey, sourceKeyTransform = preferSourceKey, passThrough = true, allowNullObjects = false, projectSchema }) {
+    const nonDefaultLocales = getNonDefaultLocales(projectSchema);
+    const prepare = (schema, obj, name = '', parent) => {
+        const shapeName = getRefShapeName(projectSchema, schema);
+        schema = dereferenceSchema(projectSchema, schema);
+        if (accumulators) {
+            for (const accumulator of accumulators) {
+                accumulator.accumulate(obj, schema, name);
+            }
+        }
+        const shape = shapeName ? projectSchema.shapes[shapeName] : undefined;
+        const transform = findTransforms(transforms, schema, name, shape);
+        if (transform) {
+            const next = (value, schema, name, parent) => prepare(schema, value, name, parent);
+            return transform.process(obj, { ...schema, $parent: parent }, name, shape, next);
+        }
+        if (obj && isUnionSchema(schema)) {
+            for (const { shapeId, propSchema } of enumerateOneOfKeys(projectSchema, schema.oneOf)) {
+                if (obj._shapeId === shapeId) {
+                    return prepare(propSchema, obj, name, schema);
+                }
+            }
+        }
+        if (obj && isObjectSchema(schema)) {
+            const result = {};
+            const assigned = new Set();
+            forEach(schema.properties, (fieldSchema, name) => {
+                const sourceKeys = ensureArray(sourceKeyTransform(name, fieldSchema, obj));
+                const localizedSourceKeys = getLocalizedSourceKeys(sourceKeys, nonDefaultLocales);
+                for (const { key: sourceKey, locale } of localizedSourceKeys) {
+                    const value = prepare(fieldSchema, get(obj, sourceKey), name, schema);
+                    if (value !== undefined) {
+                        assigned.add(sourceKey);
+                        const transform = findTransforms(transforms, dereferenceSchema(projectSchema, fieldSchema), name);
+                        const getKey = transform?.keyTransform ? transform.keyTransform : keyTransform;
+                        const key = getLocalizedKey(getKey(name, fieldSchema, sourceKey), locale);
+                        result[key] = value;
+                    }
+                }
+            });
+            if (passThrough && obj) {
+                const keys = difference(Object.keys(obj), [...assigned]);
+                if (keys.length) {
+                    Object.assign(result, pick(obj, keys));
+                }
+            }
+            return result;
+        }
+        if (isArraySchema(schema)) {
+            const itemSchema = schema.items;
+            if (Array.isArray(obj)) {
+                return obj.map((item) => prepare(itemSchema, item, name, schema));
+            }
+            if (obj === undefined) {
+                prepare(itemSchema, obj, name, parent);
+            }
+        }
+        if (allowNullObjects && isObjectSchema(schema) && obj === null) {
+            return null;
+        }
+        // Allow properties that have not been transformed
+        return passThrough ? obj : undefined;
+    };
+    return prepare;
+}
+function transformKey(transforms, propSchema, name, transform = preferKey) {
+    const schemaTransform = findTransforms(transforms, propSchema, name);
+    if (schemaTransform?.keyTransform) {
+        transform = schemaTransform.keyTransform;
+    }
+    return transform(name, propSchema);
+}
+export function getPropertyInfo(context, schema, path) {
+    const { projectSchema, transforms, keyTransform } = context;
+    const result = [];
+    const findProperty = (currentSchema, name, rest, path) => {
+        if (isObjectSchema(currentSchema)) {
+            const propSchema = currentSchema.properties[name];
+            const isRequired = currentSchema.required?.includes(name) ?? false;
+            if (!propSchema) {
+                return;
+            }
+            const refSchema = dereferenceSchema(projectSchema, propSchema);
+            const nextPath = path.concat(transformKey(transforms, refSchema, name, keyTransform));
+            if (rest.length) {
+                const [nextName, ...nextRest] = rest;
+                findProperty(refSchema, nextName, nextRest, nextPath);
+            }
+            else {
+                result.push({ schema: refSchema, key: nextPath.join('.'), isRequired });
+            }
+        }
+        else if (isUnionSchema(currentSchema)) {
+            for (const optionSchema of currentSchema.oneOf) {
+                findProperty(dereferenceSchema(projectSchema, optionSchema), name, rest, path);
+            }
+        }
+        else if (isArraySchema(currentSchema)) {
+            findProperty(dereferenceSchema(projectSchema, currentSchema.items), name, rest, path);
+        }
+    };
+    const [first, ...rest] = path.split('.');
+    findProperty(dereferenceSchema(projectSchema, schema), first, rest, []);
+    return result;
+}

package/dist/create-input-schema.d.ts

@@ -0,0 +1,9 @@
+import type { ProjectSchemaJSON, PropertySchema, ShapeSchema } from './project-schema/index.ts';
+export type CreateInputSchemaOptions = {
+    isUpdate?: boolean;
+};
+/**
+ * Convert all output properties in the schema to be input properties,
+ * For an update, remove `required` and `default` fields as well.
+ */
+export declare function createInputSchema<T extends ProjectSchemaJSON | ShapeSchema | PropertySchema>(schema: T, options?: CreateInputSchemaOptions): T;

package/dist/create-input-schema.js

@@ -0,0 +1,68 @@
+import { deepCloneWith, isIterableObject, REMOVE } from '@takeshape/util';
+import defaults from 'lodash/fp/defaults.js';
+const inputSchemaCache = new Map();
+function getInputSchemaCache(options) {
+    // Ensure key order does not invalidate the cache
+    const key = JSON.stringify(options, Object.keys(options).sort());
+    let cache = inputSchemaCache.get(key);
+    if (!cache) {
+        cache = new WeakMap();
+        inputSchemaCache.set(key, cache);
+    }
+    return cache;
+}
+/**
+ * Convert all output properties in the schema to be input properties,
+ * For an update, remove `required` and `default` fields as well.
+ */
+export function createInputSchema(schema, options = {}) {
+    const inputSchemaCache = getInputSchemaCache(defaults({ isUpdate: false }, options));
+    let rewrittenSchema = inputSchemaCache.get(schema);
+    if (rewrittenSchema) {
+        return rewrittenSchema;
+    }
+    rewrittenSchema = deepCloneWith(schema, (value, key, parent, clone) => {
+        // Remove required
+        if (options.isUpdate && key === 'required' && Array.isArray(value) && value.length) {
+            return REMOVE;
+        }
+        // Remove default
+        if (options.isUpdate &&
+            key === 'default' &&
+            value !== undefined &&
+            isIterableObject(parent) &&
+            parent.type !== undefined) {
+            return REMOVE;
+        }
+        if (isIterableObject(value) && value.type === 'object' && isIterableObject(value.properties)) {
+            const properties = {};
+            for (const [key, prop] of Object.entries(value.properties)) {
+                if (isIterableObject(prop) && (!prop['@resolver'] || prop['@input'])) {
+                    properties[key] = clone(prop, key, value);
+                }
+            }
+            let required;
+            if (!options.isUpdate && Array.isArray(value.required)) {
+                required = value.required.filter((key) => Boolean(properties[key]));
+            }
+            return {
+                ...value,
+                properties,
+                required
+            };
+        }
+        if (isIterableObject(value) && isIterableObject(value['@input'])) {
+            const { '@input': input, '@l10n': l10n, '@syncLocaleStructure': syncLocaleStructure, '@mapping': mapping, title, ...output } = value;
+            return {
+                ...clone(input, '@input', value),
+                title,
+                '@l10n': l10n,
+                '@syncLocaleStructure': syncLocaleStructure,
+                '@mapping': mapping,
+                '@output': output
+            };
+        }
+    });
+    inputSchemaCache.set(schema, rewrittenSchema);
+    return rewrittenSchema;
+}

package/dist/enum.d.ts

@@ -0,0 +1,2 @@
+import type { PropertySchema } from './project-schema/index.ts';
+export declare function isEnumLikeSchema(schema: PropertySchema): boolean;

package/dist/enum.js

@@ -0,0 +1,9 @@
+export function isEnumLikeSchema(schema) {
+    if (schema.enum) {
+        return true;
+    }
+    if (schema.oneOf) {
+        return schema.oneOf.every((optionSchema) => optionSchema.title !== undefined && (optionSchema.enum ?? optionSchema.const));
+    }
+    return false;
+}

package/dist/flatten-templates.d.ts

@@ -0,0 +1,2 @@
+import type { ProjectSchemaJSON } from './project-schema/index.ts';
+export declare function flattenTemplates<T extends ProjectSchemaJSON>(projectSchema: T): T;

package/dist/flatten-templates.js

@@ -0,0 +1,20 @@
+import { deepClone } from '@takeshape/util';
+import set from 'lodash/set.js';
+import { refItemToNamespacedShapeName } from "./refs.js";
+import { getAllRefs } from "./schema-util.js";
+import { isValidTemplate, resolveTemplate } from "./template-shapes/index.js";
+export function flattenTemplates(projectSchema) {
+    const templateRefs = getAllRefs(projectSchema, (ref) => Boolean(ref.template));
+    if (!templateRefs.length) {
+        return projectSchema;
+    }
+    const newSchema = deepClone(projectSchema);
+    for (const ref of templateRefs) {
+        if (ref.template && isValidTemplate(ref.template)) {
+            const { shapeName, dependencies } = resolveTemplate(newSchema, ref.template, refItemToNamespacedShapeName(newSchema, ref));
+            set(newSchema, ref.path, ref.path[ref.path.length - 1] === '@ref' ? `local:${shapeName}` : shapeName);
+            Object.assign(newSchema.shapes, dependencies);
+        }
+    }
+    return newSchema;
+}

package/dist/get-is-leaf.d.ts

@@ -0,0 +1,3 @@
+import type { ProjectSchemaJSON, PropertySchema } from './project-schema/index.ts';
+export type IsLeaf = (key?: string) => boolean;
+export declare function getIsLeaf(projectSchema: ProjectSchemaJSON, shapeSchema: PropertySchema): IsLeaf;

package/dist/get-is-leaf.js

@@ -0,0 +1,56 @@
+import { getType } from "./content-schema-transform.js";
+import { followRef, getRefShapeName } from "./refs.js";
+import { getStorageKey, isBuiltinType } from "./schema-util.js";
+import { isPropertySchemaWithRelationship } from "./types/index.js";
+const scalarTags = new Set(['draftjs']);
+function isLeafTypeV3(projectSchema, propertySchema) {
+    const type = getType(propertySchema);
+    return Boolean(
+    // Must have key
+    getStorageKey(propertySchema) &&
+        // If is not a structure, then is a leaf
+        (!['object', 'array'].includes(type) ||
+            // If is relationship, then is a leaf
+            isPropertySchemaWithRelationship(propertySchema['@output'] ?? propertySchema) ||
+            Boolean(propertySchema['@tag'] && scalarTags.has(propertySchema['@tag'])) ||
+            // If is array, then should not be a synchronized structure
+            (type === 'array' && !propertySchema['@syncLocaleStructure']) ||
+            isBuiltinType(projectSchema, propertySchema)));
+}
+export function getIsLeaf(projectSchema, shapeSchema) {
+    const leafMap = new Set();
+    const shapesSeen = new Set();
+    const collectLeaves = (schema) => {
+        const shapeName = getRefShapeName(projectSchema, schema);
+        schema = shapeName ? followRef(projectSchema, schema) : schema;
+        const key = getStorageKey(schema);
+        if (key && isLeafTypeV3(projectSchema, schema)) {
+            leafMap.add(key);
+        }
+        if (shapeName) {
+            // Skip shapes we have already seen to avoid cycles
+            if (shapesSeen.has(shapeName)) {
+                return;
+            }
+            shapesSeen.add(shapeName);
+        }
+        const combo = schema.oneOf ?? schema.allOf;
+        if (combo) {
+            combo.map(collectLeaves);
+        }
+        else if (schema.properties) {
+            for (const name of Object.keys(schema.properties)) {
+                collectLeaves(schema.properties[name]);
+            }
+        }
+        else if (schema.items) {
+            collectLeaves(schema.items);
+        }
+    };
+    collectLeaves(shapeSchema);
+    return (key) => {
+        // Remove locale suffix
+        key = key ? key.split(':')[0] : key;
+        return Boolean(key && leafMap.has(key));
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1,64 @@
+export * from './agents.ts';
+export * from './api-version.ts';
+export type { AccessPolicyDocument, ApiKey, Condition, Role, RoleImport, RoleInput, Statement, User, UserPermission } from './auth-schemas.ts';
+export * from './auth-utils.ts';
+export * from './builtin-schema.ts';
+export * from './constants.ts';
+export * from './content-schema-transform.ts';
+export * from './create-input-schema.ts';
+export * from './enum.ts';
+export * from './flatten-templates.ts';
+export * from './get-is-leaf.ts';
+export * from './interfaces.ts';
+export * from './migration/index.ts';
+export type { ProjectSchemaUpdate } from './migration/types.ts';
+export { AGENTS_UPDATE_KEY, GUARDS_UPDATE_KEY, TOOLS_UPDATE_KEY } from './migration/types.ts';
+export * from './mocks.ts';
+export * from './models/agent.ts';
+export * from './models/runtime-schema.ts';
+export * from './models/types.ts';
+export * from './models/user-schema.ts';
+export * from './patterns.ts';
+export * from './project-schema/index.ts';
+export * from './project-schema/migrate.ts';
+export * from './refs.ts';
+export * from './relationships.ts';
+export * from './resolvers/ai/agent-message-payload.ts';
+export type { AgentSessionPayload } from './resolvers/ai/agent-session-payload.ts';
+export * from './resolvers/ai/types.ts';
+export * from './resolvers/takeshape/assets/constants.ts';
+export * from './runtime-schema.ts';
+export * from './scalars.ts';
+export * from './schema-transform.ts';
+export * from './schema-util.ts';
+export * from './service-dependencies.ts';
+export * from './services/services.ts';
+export * from './services/types.ts';
+export * from './services/util.ts';
+export * from './shape-paths.ts';
+export * from './taxonomies.ts';
+export * from './template-shapes/index.ts';
+export * from './types/transforms.ts';
+export * from './types/types.ts';
+export * from './types/utils.ts';
+export * from './unions.ts';
+export * from './util/api-indexing.ts';
+export * from './util/coerce-value.ts';
+export * from './util/detect-cycles.ts';
+export * from './util/expressions.ts';
+export * from './util/find-shape-at-path.ts';
+export * from './util/form-config.ts';
+export * from './util/get-conflicting-properties.ts';
+export * from './util/get-return-shape.ts';
+export * from './util/has-arg.ts';
+export * from './util/is-asset-property.ts';
+export * from './util/merge.ts';
+export * from './util/patch-schema.ts';
+export * from './util/query-field-path.ts';
+export * from './util/shapes.ts';
+export * from './util/tools.ts';
+export * from './validate/errors.ts';
+export * from './validate/types.ts';
+export * from './validate/validate.ts';
+export * from './versions.ts';
+export * from './workflows.ts';

package/dist/index.js

@@ -0,0 +1,61 @@
+export * from "./agents.js";
+export * from "./api-version.js";
+export * from "./auth-utils.js";
+export * from "./builtin-schema.js";
+export * from "./constants.js";
+export * from "./content-schema-transform.js";
+export * from "./create-input-schema.js";
+export * from "./enum.js";
+export * from "./flatten-templates.js";
+export * from "./get-is-leaf.js";
+export * from "./interfaces.js";
+export * from "./migration/index.js";
+export { AGENTS_UPDATE_KEY, GUARDS_UPDATE_KEY, TOOLS_UPDATE_KEY } from "./migration/types.js";
+export * from "./mocks.js";
+export * from "./models/agent.js";
+export * from "./models/runtime-schema.js";
+export * from "./models/types.js";
+export * from "./models/user-schema.js";
+export * from "./patterns.js";
+export * from "./project-schema/index.js";
+export * from "./project-schema/migrate.js";
+export * from "./refs.js";
+export * from "./relationships.js";
+export * from "./resolvers/ai/agent-message-payload.js";
+export * from "./resolvers/ai/types.js";
+export * from "./resolvers/takeshape/assets/constants.js";
+export * from "./runtime-schema.js";
+export * from "./scalars.js";
+export * from "./schema-transform.js";
+export * from "./schema-util.js";
+export * from "./service-dependencies.js";
+export * from "./services/services.js";
+export * from "./services/types.js";
+export * from "./services/util.js";
+export * from "./shape-paths.js";
+export * from "./taxonomies.js";
+export * from "./template-shapes/index.js";
+export * from "./types/transforms.js";
+export * from "./types/types.js";
+export * from "./types/utils.js";
+export * from "./unions.js";
+export * from "./util/api-indexing.js";
+export * from "./util/coerce-value.js";
+export * from "./util/detect-cycles.js";
+export * from "./util/expressions.js";
+export * from "./util/find-shape-at-path.js";
+export * from "./util/form-config.js";
+export * from "./util/get-conflicting-properties.js";
+export * from "./util/get-return-shape.js";
+export * from "./util/has-arg.js";
+export * from "./util/is-asset-property.js";
+export * from "./util/merge.js";
+export * from "./util/patch-schema.js";
+export * from "./util/query-field-path.js";
+export * from "./util/shapes.js";
+export * from "./util/tools.js";
+export * from "./validate/errors.js";
+export * from "./validate/types.js";
+export * from "./validate/validate.js";
+export * from "./versions.js";
+export * from "./workflows.js";

package/dist/interfaces.d.ts

@@ -0,0 +1,14 @@
+import type { OneOfSchema, ProjectSchemaJSON, PropertySchema, ShapeJSON, ShapeMap } from './project-schema/index.ts';
+import { type RefItem, type ServicesShapesContext } from './refs.ts';
+export declare function isInterfaceShape(shape?: ShapeJSON): shape is ShapeJSON & {
+    type: 'interface';
+};
+export type ImplementationShapeMap = Record<string, Set<ShapeJSON>>;
+export type ImplementationShapeNameMap = Record<string, Set<string>>;
+export declare function isInterfaceRef(context: ServicesShapesContext, propertySchema: PropertySchema): boolean;
+export declare function getImplementationShapeMap(shapeMap: ShapeMap): ImplementationShapeMap;
+export declare function getImplementationShapeNameMap(shapeMap: ShapeMap): ImplementationShapeNameMap;
+export declare function pruneUnusedInterfaces(projectSchema: ProjectSchemaJSON, shapeMap: ShapeMap): ShapeMap;
+export declare function getImplementingShapes(context: Pick<ProjectSchemaJSON, 'services' | 'shapes'>, interfaceRef: RefItem): ShapeJSON[];
+export declare function interfaceToUnion(context: Pick<ProjectSchemaJSON, 'shapes' | 'services'>, interfaceRef: RefItem): OneOfSchema;
+export declare function getPossibleShapeNames(projectSchema: ProjectSchemaJSON, shape: ShapeJSON): string[];

package/dist/interfaces.js

@@ -0,0 +1,86 @@
+import { isDefined } from '@takeshape/util';
+import mapValues from 'lodash/mapValues.js';
+import { getRef, getShapeByRef, normalizeRefExpression, parseRef, refItemToNamespacedShapeName, refItemToShape, shapeToRefItem } from "./refs.js";
+import { isUnionSchema } from "./unions.js";
+export function isInterfaceShape(shape) {
+    return shape?.type === 'interface';
+}
+export function isInterfaceRef(context, propertySchema) {
+    const ref = getRef(context, propertySchema);
+    return Boolean(ref && isInterfaceShape(refItemToShape(context, ref)));
+}
+function add(record, key, value) {
+    if (!record[key]) {
+        record[key] = new Set([value]);
+    }
+    else {
+        record[key].add(value);
+    }
+}
+function getImplementationsHelper(shapeMap, mapFn) {
+    const result = {};
+    for (const shape of Object.values(shapeMap)) {
+        for (const interfaceName of shape.interfaces ?? []) {
+            add(result, interfaceName, mapFn(shape));
+        }
+    }
+    return result;
+}
+export function getImplementationShapeMap(shapeMap) {
+    return getImplementationsHelper(shapeMap, (x) => x);
+}
+export function getImplementationShapeNameMap(shapeMap) {
+    return getImplementationsHelper(shapeMap, (shape) => shape.name);
+}
+export function pruneUnusedInterfaces(projectSchema, shapeMap) {
+    return mapValues(shapeMap, (shape) => {
+        const { interfaces } = shape;
+        if (interfaces?.length) {
+            const context = { ...projectSchema, shapes: shapeMap };
+            const filteredInterfaces = interfaces.filter((refExpression) => getShapeByRef(context, refExpression));
+            if (interfaces.length !== filteredInterfaces.length) {
+                return { ...shape, interfaces: filteredInterfaces };
+            }
+        }
+        return shape;
+    });
+}
+function compareRefItems(refItem1, refItem2) {
+    return refItem1.shapeName === refItem2.shapeName && refItem1.layerId === refItem2.layerId;
+}
+export function getImplementingShapes(context, interfaceRef) {
+    const shapeMap = context.shapes;
+    const implementingShapes = [];
+    for (const shape of Object.values(shapeMap)) {
+        if (shape.interfaces?.find((interfaceRefExpression) => compareRefItems(parseRef(context, interfaceRefExpression), interfaceRef))) {
+            implementingShapes.push(shape);
+        }
+    }
+    return implementingShapes;
+}
+export function interfaceToUnion(context, interfaceRef) {
+    const shapes = getImplementingShapes(context, interfaceRef);
+    return {
+        oneOf: shapes.map((shape) => ({
+            '@ref': normalizeRefExpression(context, shape.name)
+        }))
+    };
+}
+export function getPossibleShapeNames(projectSchema, shape) {
+    let names;
+    if (isInterfaceShape(shape)) {
+        names = getImplementingShapes(projectSchema, shapeToRefItem(projectSchema, shape)).map((shape) => shape.name);
+    }
+    else if (isUnionSchema(shape.schema)) {
+        names = shape.schema.oneOf
+            .map((member) => {
+            const ref = getRef(projectSchema, member);
+            return ref && refItemToNamespacedShapeName(projectSchema, ref);
+        })
+            .filter(isDefined);
+    }
+    else {
+        names = [shape.name];
+    }
+    return names;
+}

package/dist/layers/layers.d.ts

@@ -0,0 +1,26 @@
+import type { FlattenedSchemaV4_0_0, LayerSchemaV4_0_0, ObjectSchemaV4_0_0, ProjectSchemaJSONV4_0_0, PropertySchemaV4_0_0, QueryJSONV4_0_0, ShapeMapV4_0_0 } from '../project-schema/index.ts';
+import { type RefItemWithPath } from './refs.ts';
+export type GetLayer = (layerId: string) => LayerSchemaV4_0_0 | undefined;
+export declare function isObjectSchemaV4_0_0(maybeObjectSchema: PropertySchemaV4_0_0): maybeObjectSchema is ObjectSchemaV4_0_0;
+export type RefPredicate = (ref: RefItemWithPath) => boolean;
+/**
+ * Walk through a `ProjectSchema` and collect all the `ref`s.
+ */
+export declare function getAllRefsInShapes(shapes: ShapeMapV4_0_0, predicate?: RefPredicate): RefItemWithPath[];
+/**
+ * Get all refs
+ */
+export declare function getAllRefsInQuery(shapes: ShapeMapV4_0_0, queryPath: string[], query: QueryJSONV4_0_0, predicate?: (ref: RefItemWithPath) => boolean): RefItemWithPath[];
+type SchemaContext = Pick<FlattenedSchemaV4_0_0, 'shapes' | 'queries' | 'mutations'>;
+/**
+ * Collect refs from `queries` or `mutations`.
+ */
+export declare function getAllRefsInQueries(context: SchemaContext, rootPropertyName: 'queries' | 'mutations', predicate?: RefPredicate): RefItemWithPath[];
+/**
+ * Get all refs in a ProjectSchema
+ * @param predicate return true to include the ref in
+ */
+export declare function getAllRefs(projectSchema: SchemaContext, predicate?: RefPredicate): RefItemWithPath[];
+export declare function collectReferencedShapeNames(layerId: string, refSet: Set<string>): (schema: PropertySchemaV4_0_0) => void;
+export declare function flattenSchema(projectSchema: ProjectSchemaJSONV4_0_0, getLayer: GetLayer): FlattenedSchemaV4_0_0;
+export {};