@takeshape/schema 11.52.0 → 11.56.1

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

@@ -0,0 +1 @@
+export {};

package/dist/util/__tests__/patch-schema.test.js

@@ -0,0 +1,82 @@
+import shopifyStoreJson from '@/examples/latest/shopify-store-with-widget.json';
+import omit from 'lodash/omit.js';
+import set from 'lodash/set.js';
+import { describe, expect, test } from 'vitest';
+import { applyDefaultsToSchema } from "../../schema-util.js";
+import { patchSchema } from "../patch-schema.js";
+const shopifyStoreSchema = applyDefaultsToSchema(shopifyStoreJson);
+describe('patchSchema', () => {
+    test('delete shape', () => {
+        expect(patchSchema(shopifyStoreSchema, {
+            shapes: {
+                Product: null
+            }
+        })).toEqual({
+            ...shopifyStoreSchema,
+            shapes: {
+                ...omit(shopifyStoreSchema.shapes, ['Product'])
+            }
+        });
+    });
+    test('add shape', () => {
+        const Dog = {
+            name: 'Dog',
+            id: 'Dog',
+            title: 'Dog',
+            schema: {
+                type: 'object',
+                properties: {}
+            }
+        };
+        expect(patchSchema(shopifyStoreSchema, {
+            shapes: {
+                Dog
+            }
+        })).toEqual({
+            ...shopifyStoreSchema,
+            shapes: {
+                ...shopifyStoreSchema.shapes,
+                Dog
+            }
+        });
+    });
+    test('nested paths', () => {
+        const agentJson = { api: { type: 'chat' } };
+        const aiExperimentalSchema = set(shopifyStoreSchema, 'ai-experimental.agents', { foo: agentJson });
+        expect(patchSchema(aiExperimentalSchema, {
+            'ai-experimental.agents': {
+                foo: null,
+                bar: agentJson
+            }
+        })).toEqual({
+            ...aiExperimentalSchema,
+            'ai-experimental': {
+                agents: {
+                    bar: agentJson
+                }
+            }
+        });
+    });
+    test('preserving unpatched props', () => {
+        const agentJson = { api: { type: 'chat' } };
+        const aiExperimental = {
+            agents: { foo: agentJson },
+            someOtherPropertyThatIsNotTouched: 'foo'
+        };
+        const aiExperimentalSchema = set(shopifyStoreSchema, 'ai-experimental', aiExperimental);
+        expect(patchSchema(aiExperimentalSchema, {
+            'ai-experimental.agents': {
+                foo: null,
+                bar: agentJson
+            }
+        })).toEqual({
+            ...aiExperimentalSchema,
+            'ai-experimental': {
+                ...aiExperimental,
+                agents: {
+                    bar: agentJson
+                }
+            }
+        });
+    });
+});

package/dist/util/__tests__/shapes.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/util/__tests__/shapes.test.js

@@ -0,0 +1,30 @@
+import postSchemaJson from '@/examples/latest/post-schema.json';
+import { deepClone } from '@takeshape/util';
+import { describe, expect, test } from 'vitest';
+import { ensureShape, ensureShapeById } from "../shapes.js";
+function getPostSchema() {
+    return deepClone(postSchemaJson);
+}
+describe('ensureShape', () => {
+    test('success', () => {
+        const postSchema = getPostSchema();
+        const shape = postSchema.shapes.Post;
+        expect(ensureShape(postSchema, shape.name)).toEqual(shape);
+    });
+    test('missing', () => {
+        const postSchema = getPostSchema();
+        expect(() => ensureShape(postSchema, 'Bogus')).toThrowErrorMatchingInlineSnapshot(`[NotFoundError: Shape "Bogus" Not found]`);
+    });
+});
+describe('ensureShapeById', () => {
+    test('success', () => {
+        const postSchema = getPostSchema();
+        const shape = postSchema.shapes.Post;
+        const shapeId = shape.id;
+        expect(ensureShapeById(postSchema, shapeId)).toEqual(shape);
+    });
+    test('missing', () => {
+        const postSchema = getPostSchema();
+        expect(() => ensureShapeById(postSchema, 'bogus')).toThrowErrorMatchingInlineSnapshot(`[NotFoundError: Shape with id "bogus" Not found]`);
+    });
+});

package/dist/util/ai-tools.d.ts

@@ -0,0 +1,3 @@
+import type { AIToolConfig, AgentToolConfig } from '../project-schema/latest.ts';
+export declare function getToolRef(tool: Pick<AIToolConfig, 'ref'> | string): string;
+export declare function normalizeToolConfig(tool: AIToolConfig | AgentToolConfig | string): AIToolConfig | AgentToolConfig;

package/dist/util/api-indexing.d.ts

@@ -0,0 +1,9 @@
+import { type Maybe } from '@takeshape/util';
+import type { ProjectSchemaJSON, ShapeLoaders } from '../project-schema/index.ts';
+import type { GetQueryIndexingConfig, ListQueryIndexingConfig } from '../types/index.ts';
+export declare function serviceHasIndexedShapes(schema: ProjectSchemaJSON, serviceId: string): boolean;
+export declare function getIndexedServices(projectSchema: ProjectSchemaJSON, configs: ShapeLoaders[keyof ShapeLoaders]): string[];
+type Getter<T> = (context: Pick<ProjectSchemaJSON, 'shapes'>, shapeName: string) => T;
+export declare const getListQueryIndexConfigs: Getter<ListQueryIndexingConfig[]>;
+export declare const getGetQueryIndexConfig: Getter<Maybe<GetQueryIndexingConfig>>;
+export {};

package/dist/util/api-indexing.js

@@ -0,0 +1,57 @@
+import { ensureArray } from '@takeshape/util';
+import { getQuery } from "../refs.js";
+import { getIdField } from "../schema-util.js";
+import { getResolverServices } from "../services/util.js";
+import { isCachedShape, isServiceResolver } from "../types/index.js";
+export function serviceHasIndexedShapes(schema, serviceId) {
+    for (const shape of Object.values(schema.shapes ?? {})) {
+        const indexingEnabled = isCachedShape(shape);
+        const listConfigs = shape.loaders?.list;
+        if (indexingEnabled && listConfigs) {
+            for (const { query: queryRef } of ensureArray(listConfigs)) {
+                const resolved = getQuery(schema, queryRef);
+                if (resolved && isServiceResolver(resolved.query.resolver) && resolved.query.resolver.service === serviceId) {
+                    return true;
+                }
+            }
+        }
+    }
+    return false;
+}
+export function getIndexedServices(projectSchema, configs) {
+    return ensureArray(configs).reduce((services, queryConfig) => {
+        const resolved = queryConfig?.query ? getQuery(projectSchema, queryConfig.query) : undefined;
+        return resolved?.query ? [...services, ...getResolverServices(resolved.query.resolver)] : services;
+    }, []);
+}
+function flattenListQueryConfigs(base, queryConfig, maybeConfigArray) {
+    return (maybeConfigArray &&
+        ensureArray(maybeConfigArray).flatMap((config) => ensureArray(config.args).map((args) => ({
+            ...base,
+            ...queryConfig,
+            ...config,
+            args
+        }))));
+}
+function getQueryIndexConfigHelper(op) {
+    return ({ shapes }, shapeName) => {
+        const { cache, loaders } = shapes[shapeName] ?? {};
+        if (cache && loaders) {
+            const idField = getIdField(cache);
+            if (op === 'list') {
+                return flattenListQueryConfigs({ shapeName, idField }, cache.fragment, loaders.list);
+            }
+            const queryConfig = loaders.get;
+            if (queryConfig) {
+                return {
+                    idField,
+                    shapeName,
+                    ...cache.fragment,
+                    ...queryConfig
+                };
+            }
+        }
+    };
+}
+export const getListQueryIndexConfigs = getQueryIndexConfigHelper('list');
+export const getGetQueryIndexConfig = getQueryIndexConfigHelper('get');

package/dist/util/detect-cycles.d.ts

@@ -0,0 +1,7 @@
+import type { ProjectSchemaJSON, PropertySchema } from '../project-schema/index.ts';
+type SchemaPredicate = (projectSchema: ProjectSchemaJSON, propSchema: PropertySchema, shapeName?: string, propName?: string) => boolean;
+/**
+ * Use a basic depth-first search to determine whether a schema contains a cycle
+ */
+export declare function hasCycle(projectSchema: ProjectSchemaJSON, schema: PropertySchema, predicate?: SchemaPredicate): boolean;
+export {};

package/dist/util/detect-cycles.js

@@ -0,0 +1,45 @@
+import { value } from '@takeshape/util';
+import { getRef, refItemToShape } from "../refs.js";
+function immutableSetAdd(set, str) {
+    const result = new Set(set);
+    result.add(str);
+    return result;
+}
+/**
+ * Use a basic depth-first search to determine whether a schema contains a cycle
+ */
+export function hasCycle(projectSchema, schema, predicate = value(true)) {
+    const hasCycleHelper = (schema, shapesSeen = new Set(), shapeName, propName) => {
+        if (!predicate(projectSchema, schema, shapeName, propName)) {
+            return false;
+        }
+        const refItem = getRef(projectSchema, schema);
+        if (refItem) {
+            const refShape = refItemToShape(projectSchema, refItem);
+            // If we have a refItem, but no shape, this is a dangling ref and has no cycles
+            if (!refShape) {
+                return false;
+            }
+            if (shapesSeen.has(refShape.name)) {
+                return true;
+            }
+            return hasCycleHelper(refShape.schema, immutableSetAdd(shapesSeen, refShape.name), refShape.name);
+        }
+        const combo = schema.oneOf ?? schema.allOf ?? schema.extends;
+        if (combo) {
+            return combo.some((childSchema) => hasCycleHelper(childSchema, shapesSeen, shapeName, propName));
+        }
+        if (schema.items) {
+            return hasCycleHelper(schema.items, shapesSeen, shapeName, propName);
+        }
+        const { properties } = schema;
+        if (properties) {
+            return Object.keys(properties).some((name) => {
+                const propSchema = properties[name];
+                return hasCycleHelper(propSchema, shapesSeen, shapeName, name);
+            });
+        }
+        return false;
+    };
+    return hasCycleHelper(schema);
+}

package/dist/util/find-shape-at-path.d.ts

@@ -0,0 +1,21 @@
+import type { ProjectSchemaJSON, PropertySchema, ShapeJSON } from '../project-schema/index.ts';
+/**
+ *
+ * @param projectSchema
+ * @param schema
+ * @param queryPath
+ *
+ * @example
+ * findShapeAtPath(projectSchema, projectSchema.shapes.Shopify_ProductConnection.shape, ['edges', 'node']) // finds {'@ref': Shopify_Product}
+ */
+export declare function findSchemaAtPath(projectSchema: ProjectSchemaJSON, schema: PropertySchema, queryPath: string[]): PropertySchema | undefined;
+/**
+ *
+ * @param projectSchema
+ * @param propSchema
+ * @param queryPath
+ *
+ * @example
+ * findShapeAtPath(projectSchema, projectSchema.shapes.Shopify_ProductConnection.shape, ['edges', 'node']) // finds Shopify_Product
+ */
+export declare function findShapeAtPath(projectSchema: ProjectSchemaJSON, propSchema: PropertySchema, queryPath: string[]): ShapeJSON | undefined;

package/dist/util/form-config.d.ts

@@ -0,0 +1,11 @@
+import { type Maybe } from '@takeshape/util';
+import type { FormConfig, FormMap, ProjectSchemaJSON } from '../project-schema/index.ts';
+/**
+ * If there any non-normal (nested) forms in the schema, create forms for referenced shapes.
+ * The original forms are left intact.
+ */
+export declare function normalizeForms(projectSchema: ProjectSchemaJSON): FormMap;
+/**
+ * Find the form config for a given shape name and the form key.
+ */
+export declare function findShapeFormConfig(projectSchema: ProjectSchemaJSON, shapeName: string, formName: string): Maybe<FormConfig>;

package/dist/util/form-config.js

@@ -0,0 +1,62 @@
+import { deepClone } from '@takeshape/util';
+import { getRefOrItemsRef, refItemToNamespacedShapeName } from "../refs.js";
+import { createSchemaPropertyAccessor } from "../schema-util.js";
+/**
+ * If there any non-normal (nested) forms in the schema, create forms for referenced shapes.
+ * The original forms are left intact.
+ */
+export function normalizeForms(projectSchema) {
+    const normalizedForms = {};
+    const { forms = {} } = projectSchema;
+    const storeSourceForm = (shapeName, formConfig, propName) => {
+        // Leave original forms intact for backwards compatibility
+        if (!forms[shapeName]) {
+            normalizedForms[shapeName] ||= { default: deepClone(formConfig) };
+            // Remove prop now that it has been normalized
+            delete normalizedForms[shapeName].default.properties[propName];
+        }
+    };
+    const normalizeNested = (shapeName, formConfig) => {
+        const shape = projectSchema.shapes[shapeName];
+        if (!shape || !formConfig.properties) {
+            return;
+        }
+        const propertyAccessor = createSchemaPropertyAccessor(projectSchema, shape);
+        for (const propName of Object.keys(formConfig.properties)) {
+            const propConfig = formConfig.properties[propName];
+            const propSchema = propertyAccessor.getValue(propName);
+            if (propSchema) {
+                const ref = getRefOrItemsRef(projectSchema, propSchema);
+                if (ref && propConfig.properties) {
+                    const nestedShapeName = refItemToNamespacedShapeName(ref);
+                    normalizedForms[nestedShapeName] = { default: deepClone(propConfig) };
+                    storeSourceForm(shapeName, formConfig, propName);
+                    normalizeNested(nestedShapeName, propConfig);
+                }
+            }
+        }
+    };
+    if (forms) {
+        for (const shapeName of Object.keys(forms)) {
+            normalizeNested(shapeName, forms[shapeName].default);
+            // copy forms with no changes
+            normalizedForms[shapeName] ||= forms[shapeName];
+        }
+    }
+    return normalizedForms;
+}
+const cache = new WeakMap();
+/**
+ * Find the form config for a given shape name and the form key.
+ */
+export function findShapeFormConfig(projectSchema, shapeName, formName) {
+    if (!projectSchema.forms) {
+        return;
+    }
+    let normalizedForms = cache.get(projectSchema);
+    if (!normalizedForms) {
+        normalizedForms = normalizeForms(projectSchema);
+        cache.set(projectSchema, normalizedForms);
+    }
+    return normalizedForms[shapeName]?.[formName];
+}

package/dist/util/get-conflicting-properties.d.ts

@@ -0,0 +1,6 @@
+import type { ShapeJSON } from '../project-schema/index.ts';
+import { type ServicesShapesContext } from '../refs.ts';
+/**
+ * Given a list of shapes find the conflicting props
+ */
+export declare function getConflictingProperties(context: ServicesShapesContext, shapes: ShapeJSON[]): Set<string>;

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

@@ -0,0 +1,55 @@
+import { isDefined, setIsEqual } from '@takeshape/util';
+import { dereferenceSchema, getRef, refItemToAtRef } from "../refs.js";
+import { isObjectSchema } from "../types/index.js";
+/**
+ * Normalize ref, oneOf and array schemas and get a list of @ref expressions
+ */
+function getRefStrings(context, propertySchema) {
+    const schema = propertySchema.items ?? propertySchema;
+    const schemas = schema.oneOf ? schema.oneOf : [schema];
+    return schemas
+        .map((propertySchema) => {
+        const ref = getRef(context, propertySchema);
+        return ref ? refItemToAtRef(ref) : undefined;
+    })
+        .filter(isDefined);
+}
+function isRefEqual(context, a, b) {
+    return setIsEqual(getRefStrings(context, a), getRefStrings(context, b));
+}
+/**
+ * Given a list of shapes find the conflicting props
+ */
+export function getConflictingProperties(context, shapes) {
+    const conflicts = new Set();
+    const allProps = {};
+    for (const shape of Object.values(shapes)) {
+        const schema = dereferenceSchema(context, shape.schema, ['shapes', shape.name]);
+        if (!isObjectSchema(schema)) {
+            continue;
+        }
+        const required = new Set(schema.required ?? []);
+        for (const [name, prop] of Object.entries(schema.properties)) {
+            // skip props that we know already have  conflict
+            if (conflicts.has(name)) {
+                continue;
+            }
+            const isRequired = required.has(name);
+            if (allProps[name]) {
+                if (
+                // same type
+                allProps[name][0].type !== prop.type ||
+                    // same refs
+                    !isRefEqual(context, allProps[name][0], prop) ||
+                    // same nullability
+                    isRequired !== allProps[name][1]) {
+                    conflicts.add(name);
+                }
+            }
+            else {
+                allProps[name] = [prop, isRequired];
+            }
+        }
+    }
+    return conflicts;
+}

package/dist/util/get-return-shape.d.ts

@@ -0,0 +1,4 @@
+import type { ProjectSchemaJSON, PropertySchema, QueryJSON, ShapeJSON } from '../project-schema/index.ts';
+import { type ServicesShapesContext } from '../refs.ts';
+export declare function getReturnShapeRef(context: ServicesShapesContext, propOrQuery: PropertySchema | QueryJSON): import("@takeshape/util").Maybe<import("../refs.ts").RefItem>;
+export declare function getReturnShape(projectSchema: ProjectSchemaJSON, propOrQuery: PropertySchema | QueryJSON): ShapeJSON | undefined;

package/dist/util/get-return-shape.js

@@ -0,0 +1,30 @@
+import { getRef, parseReturnShape, refItemToShape } from "../refs.js";
+function isQuery(propOrQuery) {
+    return 'shape' in propOrQuery && 'resolver' in propOrQuery;
+}
+function getReturnShapeHelper(projectSchema, propOrQuery) {
+    let shape;
+    if (isQuery(propOrQuery)) {
+        const { shapeName } = parseReturnShape(projectSchema, propOrQuery.shape);
+        shape = projectSchema.shapes[shapeName];
+    }
+    else {
+        const ref = getRef(projectSchema, propOrQuery);
+        if (ref) {
+            shape = refItemToShape(projectSchema, ref);
+        }
+    }
+    return shape;
+}
+export function getReturnShapeRef(context, propOrQuery) {
+    return isQuery(propOrQuery) ? parseReturnShape(context, propOrQuery.shape).ref : getRef(context, propOrQuery);
+}
+const cache = new WeakMap();
+export function getReturnShape(projectSchema, propOrQuery) {
+    let result = cache.get(propOrQuery);
+    if (result === undefined) {
+        result = getReturnShapeHelper(projectSchema, propOrQuery);
+        cache.set(propOrQuery, result ?? null);
+    }
+    return result ?? undefined;
+}

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

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

package/dist/util/has-arg.js

@@ -0,0 +1,13 @@
+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 hasArg(projectSchema, prop, argPath) {
+    const args = getArgs(prop);
+    if (!args) {
+        return false;
+    }
+    const schema = typeof args === 'string' ? projectSchema.shapes[args]?.schema : args;
+    const pathArray = Array.isArray(argPath) ? argPath : argPath.split('.');
+    return Boolean(findSchemaAtPath(projectSchema, schema, pathArray));
+}

package/dist/util/merge.d.ts

@@ -0,0 +1,15 @@
+import type { FormConfig, ObjectSchema, ProjectSchemaJSON } from '../project-schema/index.ts';
+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;
+};