@takeshape/schema 12.1.0 → 12.1.4

package/dist/util/expressions.d.ts

@@ -0,0 +1,34 @@
+import jsep, { type Expression } from 'jsep';
+export interface ObjectExpression extends Expression {
+    type: 'ObjectExpression';
+    properties: PropertyExpression[];
+}
+export interface PropertyExpression extends Expression {
+    type: 'Property';
+    computed: boolean;
+    key: AnyExpression;
+    value: AnyExpression;
+    shorthand: boolean;
+}
+type AnyExpression = jsep.ArrayExpression | jsep.BinaryExpression | jsep.MemberExpression | jsep.CallExpression | jsep.ConditionalExpression | jsep.Identifier | jsep.Literal | jsep.ThisExpression | jsep.UnaryExpression | ObjectExpression | PropertyExpression;
+export declare const METHODS_NOT_SUPPORTED = "Methods are not supported in expressions";
+export declare const THIS_NOT_SUPPORTED = "This is not supported in expressions";
+export declare function parseExpression(expression: string): AnyExpression;
+export type ExpressionContext = {
+    currentStateId: string;
+    previousStateId?: string;
+    currentStateOutput?: unknown;
+    sessionMemory: Record<string, unknown>;
+    claims: Record<string, unknown>;
+    args: Record<string, unknown>;
+    vars: Record<string, unknown>;
+};
+export declare function validateExpression(expression: string): {
+    valid: true;
+} | {
+    valid: false;
+    errors: string[];
+};
+export declare function compileExpression(expression: string): (context: Record<string, unknown>) => unknown;
+export declare function expressionToString(_node: jsep.Expression | null, parent?: AnyExpression): string;
+export {};

package/dist/util/expressions.js

@@ -0,0 +1,350 @@
+import object from '@jsep-plugin/object';
+import jsep from 'jsep';
+jsep.plugins.register(object);
+// Default operator precedence from https://github.com/EricSmekens/jsep/blob/master/src/jsep.js#L55
+const DEFAULT_PRECEDENCE = {
+    '||': 1,
+    '&&': 2,
+    '|': 3,
+    '^': 4,
+    '&': 5,
+    '==': 6,
+    '!=': 6,
+    '===': 6,
+    '!==': 6,
+    '<': 7,
+    '>': 7,
+    '<=': 7,
+    '>=': 7,
+    '<<': 8,
+    '>>': 8,
+    '>>>': 8,
+    '+': 9,
+    '-': 9,
+    '*': 10,
+    '/': 10,
+    '%': 10
+};
+/**
+ * Evaluation code from JSEP project, under MIT License.
+ * Copyright (c) 2013 Stephen Oney, http://jsep.from.so/
+ */
+const binops = {
+    // '|'(a, b) {
+    //   return a | b;
+    // },
+    // '^'(a, b) {
+    //   return a ^ b;
+    // },
+    // '&'(a, b) {
+    //   return a & b;
+    // },
+    '=='(a, b) {
+        // biome-ignore lint/suspicious/noDoubleEquals: ignore
+        return a == b;
+    },
+    '!='(a, b) {
+        // biome-ignore lint/suspicious/noDoubleEquals: ignore
+        return a != b;
+    },
+    '==='(a, b) {
+        return a === b;
+    },
+    '!=='(a, b) {
+        return a !== b;
+    },
+    '<'(a, b) {
+        return a < b;
+    },
+    '>'(a, b) {
+        return a > b;
+    },
+    '<='(a, b) {
+        return a <= b;
+    },
+    '>='(a, b) {
+        return a >= b;
+    },
+    // '<<'(a, b) {
+    //   return a << b;
+    // },
+    // '>>'(a, b) {
+    //   return a >> b;
+    // },
+    // '>>>'(a, b) {
+    //   return a >>> b;
+    // },
+    '+'(a, b) {
+        return a + b;
+    },
+    '-'(a, b) {
+        return a - b;
+    },
+    '*'(a, b) {
+        return a * b;
+    },
+    '/'(a, b) {
+        return a / b;
+    },
+    '%'(a, b) {
+        return a % b;
+    }
+};
+const unops = {
+    '-'(a) {
+        return -a;
+    },
+    '+'(a) {
+        return Number(a);
+    },
+    // '~'(a) {
+    //   return ~a;
+    // },
+    '!'(a) {
+        return !a;
+    }
+};
+function evaluateArray(list, context) {
+    return list.map((v) => (v ? evaluate(v, context) : undefined));
+}
+function evaluateObject(properties, context) {
+    const obj = {};
+    for (const node of properties) {
+        const key = !node.computed && node.key.type === 'Identifier' ? node.key.name : evaluate(node.key, context);
+        obj[key] = evaluate(node.value, context);
+    }
+    return obj;
+}
+function isObject(x) {
+    return Boolean(x) && typeof x === 'object';
+}
+export const METHODS_NOT_SUPPORTED = 'Methods are not supported in expressions';
+export const THIS_NOT_SUPPORTED = 'This is not supported in expressions';
+function evaluateMember(node, context) {
+    const object = evaluate(node.object, context);
+    let key;
+    if (node.computed) {
+        key = evaluate(node.property, context);
+    }
+    else {
+        key = node.property.name;
+    }
+    if (typeof key === 'string' && /^__proto__|prototype|constructor$/.test(key)) {
+        throw Error(`Access to member "${key}" disallowed.`);
+    }
+    if (isObject(object) && Object.hasOwn(object, key)) {
+        return [object, object[key]];
+    }
+}
+function evaluate(_node, context) {
+    const node = _node;
+    switch (node.type) {
+        case 'ArrayExpression':
+            return evaluateArray(node.elements, context);
+        case 'ObjectExpression':
+            return evaluateObject(node.properties, context);
+        case 'CallExpression': {
+            if (node.callee.type === 'MemberExpression') {
+                throw Error(METHODS_NOT_SUPPORTED);
+            }
+            const fn = evaluate(node.callee, context);
+            if (typeof fn !== 'function') {
+                return undefined;
+            }
+            return fn.apply(null, evaluateArray(node.arguments, context));
+        }
+        case 'ConditionalExpression':
+            return evaluate(node.test, context) ? evaluate(node.consequent, context) : evaluate(node.alternate, context);
+        case 'Identifier':
+            return context[node.name];
+        case 'Literal':
+            return node.value;
+        case 'BinaryExpression': {
+            if (node.operator === '||') {
+                return evaluate(node.left, context) || evaluate(node.right, context);
+            }
+            if (node.operator === '&&') {
+                return evaluate(node.left, context) && evaluate(node.right, context);
+            }
+            const op = binops[node.operator];
+            if (!op) {
+                throw new Error(`Unsupported operator ${node.operator}`);
+            }
+            return op(evaluate(node.left, context), evaluate(node.right, context));
+        }
+        case 'UnaryExpression': {
+            const op = unops[node.operator];
+            if (!op) {
+                throw new Error(`Unsupported operator ${node.operator}`);
+            }
+            return op(evaluate(node.argument, context));
+        }
+        case 'MemberExpression':
+            return evaluateMember(node, context)?.[1];
+        case 'ThisExpression':
+            return context;
+        default:
+            return undefined;
+    }
+}
+export function parseExpression(expression) {
+    return jsep(expression);
+}
+function validateAST(options, rootNode) {
+    const validate = (_node, parent, parentKey) => {
+        const node = _node;
+        switch (node.type) {
+            case 'ArrayExpression':
+                return node.elements.flatMap((v) => (v ? validate(v, node, 'elements') : []));
+            case 'ObjectExpression':
+                return node.properties.flatMap((v) => validate(v, node, 'properties'));
+            case 'Property': {
+                {
+                    const keyErrors = !node.computed && node.key.type === 'Identifier' ? undefined : validate(node.key, node, 'key');
+                    const valueErrors = validate(node.value, node, 'value');
+                    return keyErrors ? [...keyErrors, ...valueErrors] : valueErrors;
+                }
+            }
+            case 'CallExpression': {
+                if (node.callee.type === 'MemberExpression') {
+                    return [{ message: METHODS_NOT_SUPPORTED }];
+                }
+                return [
+                    ...validate(node.callee, node, 'callee'),
+                    ...node.arguments.flatMap((v) => (v ? validate(v, node, 'arguments') : []))
+                ];
+            }
+            case 'ConditionalExpression':
+                return [
+                    ...validate(node.test, node, 'test'),
+                    ...validate(node.consequent, node, 'consequent'),
+                    ...validate(node.alternate, node, 'alternate')
+                ];
+            case 'Identifier': {
+                const errors = [];
+                if (parent?.type === 'CallExpression' && parentKey === 'callee' && options.allowedFunctions) {
+                    if (!options.allowedFunctions.includes(node.name)) {
+                        errors.push({ message: `Unknown function "${node.name}"` });
+                    }
+                }
+                else {
+                    if (parent?.type === 'MemberExpression' && !parent.computed && parentKey === 'property') {
+                        return errors;
+                    }
+                    if (options.allowedVars && !options.allowedVars.includes(node.name)) {
+                        errors.push({ message: `Unknown variable "${node.name}"` });
+                    }
+                }
+                return errors;
+            }
+            case 'Literal':
+                return [];
+            case 'BinaryExpression': {
+                const op = binops[node.operator];
+                if (!op) {
+                    throw new Error(`Unsupported operator ${node.operator}`);
+                }
+                return [...validate(node.left, node, 'left'), ...validate(node.right, node, 'right')];
+            }
+            case 'UnaryExpression': {
+                const op = unops[node.operator];
+                if (!op) {
+                    return [{ message: `Unsupported operator ${node.operator}` }];
+                }
+                return validate(node.argument, node, 'argument');
+            }
+            case 'MemberExpression':
+                return [
+                    ...validate(node.object, node, 'object'),
+                    ...(node.computed ? validate(node.property, node, 'property') : [])
+                ];
+            case 'ThisExpression':
+                return [{ message: THIS_NOT_SUPPORTED }];
+        }
+    };
+    return validate(rootNode, undefined, undefined);
+}
+const contextKeys = [
+    'currentStateId',
+    'previousStateId',
+    'currentStateOutput',
+    'sessionMemory',
+    'claims',
+    'args',
+    'vars'
+];
+export function validateExpression(expression) {
+    try {
+        const ast = parseExpression(expression);
+        const errors = validateAST({
+            allowedVars: contextKeys,
+            allowedFunctions: ['contains']
+        }, ast);
+        if (errors.length) {
+            return {
+                valid: false,
+                errors: errors.map((e) => e.message)
+            };
+        }
+        return { valid: true };
+    }
+    catch (e) {
+        return { valid: false, errors: [e.message] };
+    }
+}
+export function compileExpression(expression) {
+    const ast = parseExpression(expression);
+    return (context) => evaluate(ast, context);
+}
+export function expressionToString(_node, parent) {
+    if (!_node) {
+        return '';
+    }
+    const node = _node;
+    if (node.type === 'BinaryExpression') {
+        const wrap = parent?.type === 'BinaryExpression' && DEFAULT_PRECEDENCE[parent.operator] > DEFAULT_PRECEDENCE[node.operator];
+        const str = `${expressionToString(node.left, node)} ${node.operator} ${expressionToString(node.right, node)}`;
+        return wrap ? `(${str})` : str;
+    }
+    if (node.type === 'CallExpression') {
+        const args = node.arguments.map((arg) => expressionToString(arg, node));
+        return `${expressionToString(node.callee, node)}(${args.join(', ')})`;
+    }
+    if (node.type === 'UnaryExpression') {
+        return node.operator + expressionToString(node.argument, node);
+    }
+    if (node.type === 'MemberExpression') {
+        if (node.computed) {
+            return `${expressionToString(node.object, node)}[${expressionToString(node.property, node)}]`;
+        }
+        return `${expressionToString(node.object, node)}.${expressionToString(node.property, node)}`;
+    }
+    if (node.type === 'ArrayExpression') {
+        const arr = node.elements.map((element) => expressionToString(element, node)).join(',');
+        return `[${arr}]`;
+    }
+    if (node.type === 'Property') {
+        const keyStr = expressionToString(node.key, node);
+        if (node.shorthand) {
+            return keyStr;
+        }
+        return `${node.computed ? `[${keyStr}]` : keyStr}: ${expressionToString(node.value, node)}`;
+    }
+    if (node.type === 'ObjectExpression') {
+        const props = node.properties.map((element) => expressionToString(element, node)).join(',');
+        return `{ ${props} }`;
+    }
+    if (node.type === 'Literal') {
+        return node.raw;
+    }
+    if (node.type === 'Identifier') {
+        return node.name;
+    }
+    if (node.type === 'ConditionalExpression') {
+        return `${expressionToString(node.test, node)} ? ${expressionToString(node.consequent, node)} : ${expressionToString(node.alternate, node)}`;
+    }
+    if (node.type === 'ThisExpression') {
+        return 'this';
+    }
+    return '';
+}

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: Pick<ProjectSchemaJSON, 'services' | 'shapes'>, 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: Pick<ProjectSchemaJSON, 'services' | 'shapes'>, propSchema: PropertySchema, queryPath: string[]): ShapeJSON | undefined;

package/dist/util/find-shape-at-path.js

@@ -0,0 +1,53 @@
+import { getRef, refItemToShape, refItemToShapeSchema } from "../refs.js";
+import { isArraySchema, isObjectSchema, isRefSchema } from "../types/index.js";
+/**
+ *
+ * @param projectSchema
+ * @param schema
+ * @param queryPath
+ *
+ * @example
+ * findShapeAtPath(projectSchema, projectSchema.shapes.Shopify_ProductConnection.shape, ['edges', 'node']) // finds {'@ref': Shopify_Product}
+ */
+export function findSchemaAtPath(projectSchema, schema, queryPath) {
+    if (queryPath.length === 0) {
+        return schema;
+    }
+    const [prop, ...rest] = queryPath;
+    if (isRefSchema(schema)) {
+        const ref = getRef(projectSchema, schema);
+        if (ref) {
+            const shapeSchema = refItemToShapeSchema(projectSchema, ref);
+            if (shapeSchema) {
+                return findSchemaAtPath(projectSchema, shapeSchema, queryPath);
+            }
+        }
+        return undefined;
+    }
+    if (isArraySchema(schema)) {
+        return findSchemaAtPath(projectSchema, schema.items, queryPath);
+    }
+    if (isObjectSchema(schema)) {
+        const propSchema = schema.properties[prop];
+        if (propSchema) {
+            return findSchemaAtPath(projectSchema, propSchema, rest);
+        }
+    }
+    return undefined;
+}
+/**
+ *
+ * @param projectSchema
+ * @param propSchema
+ * @param queryPath
+ *
+ * @example
+ * findShapeAtPath(projectSchema, projectSchema.shapes.Shopify_ProductConnection.shape, ['edges', 'node']) // finds Shopify_Product
+ */
+export function findShapeAtPath(projectSchema, propSchema, queryPath) {
+    const result = findSchemaAtPath(projectSchema, propSchema, queryPath);
+    if (result) {
+        const refItem = getRef(projectSchema, result.items ?? result);
+        return refItem && refItemToShape(projectSchema, refItem);
+    }
+}

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(projectSchema, 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, serializeRef } 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 ? serializeRef(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: Pick<ProjectSchemaJSON, 'services' | 'shapes'>, 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/graphql-string.d.ts

@@ -0,0 +1,6 @@
+import type { ProjectSchema } from '../models/types.ts';
+import type { ObjectSchema } from '../project-schema/index.ts';
+export declare function getVariablesSchema(runtimeSchema: ProjectSchema, queryStr: string): {
+    argsSchema: ObjectSchema;
+    argsAreFromShape: boolean;
+} | undefined;