@takeshape/schema 11.40.0 → 11.41.0

package/dist/cjs/src/util/form-config.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findShapeFormConfig = exports.normalizeForms = void 0;
+const util_1 = require("@takeshape/util");
+const refs_1 = require("../refs");
+const schema_util_1 = require("../schema-util");
+/**
+ * If there any non-normal (nested) forms in the schema, create forms for referenced shapes.
+ * The original forms are left intact.
+ */
+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: (0, util_1.deepClone)(formConfig) };
+            // Remove prop now that it has been normalized
+            // eslint-disable-next-line @typescript-eslint/no-dynamic-delete
+            delete normalizedForms[shapeName].default.properties[propName];
+        }
+    };
+    const normalizeNested = (shapeName, formConfig) => {
+        const shape = projectSchema.shapes[shapeName];
+        if (!shape || !formConfig.properties) {
+            return;
+        }
+        const propertyAccessor = (0, schema_util_1.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 = (0, refs_1.getRefOrItemsRef)(projectSchema, propSchema);
+                if (ref && propConfig.properties) {
+                    const nestedShapeName = (0, refs_1.refItemToNamespacedShapeName)(ref);
+                    normalizedForms[nestedShapeName] = { default: (0, util_1.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;
+}
+exports.normalizeForms = normalizeForms;
+const cache = new WeakMap();
+/**
+ * Find the form config for a given shape name and the form key.
+ */
+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];
+}
+exports.findShapeFormConfig = findShapeFormConfig;

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

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getConflictingProperties = void 0;
+const util_1 = require("@takeshape/util");
+const refs_1 = require("../refs");
+const types_1 = require("../types");
+/**
+ * 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 = (0, refs_1.getRef)(context, propertySchema);
+        return ref ? (0, refs_1.refItemToAtRef)(ref) : undefined;
+    })
+        .filter(util_1.isDefined);
+}
+function isRefEqual(context, a, b) {
+    return (0, util_1.setIsEqual)(getRefStrings(context, a), getRefStrings(context, b));
+}
+/**
+ * Given a list of shapes find the conflicting props
+ */
+function getConflictingProperties(context, shapes) {
+    const conflicts = new Set();
+    const allProps = {};
+    for (const shape of Object.values(shapes)) {
+        const schema = (0, refs_1.dereferenceSchema)(context, shape.schema, ['shapes', shape.name]);
+        if (!(0, types_1.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;
+}
+exports.getConflictingProperties = getConflictingProperties;

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

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getReturnShape = exports.getReturnShapeRef = void 0;
+const refs_1 = require("../refs");
+function isQuery(propOrQuery) {
+    return 'shape' in propOrQuery && 'resolver' in propOrQuery;
+}
+function getReturnShapeHelper(projectSchema, propOrQuery) {
+    let shape;
+    if (isQuery(propOrQuery)) {
+        const { shapeName } = (0, refs_1.parseReturnShape)(projectSchema, propOrQuery.shape);
+        shape = projectSchema.shapes[shapeName];
+    }
+    else {
+        const ref = (0, refs_1.getRef)(projectSchema, propOrQuery);
+        if (ref) {
+            shape = (0, refs_1.refItemToShape)(projectSchema, ref);
+        }
+    }
+    return shape;
+}
+function getReturnShapeRef(context, propOrQuery) {
+    return isQuery(propOrQuery) ? (0, refs_1.parseReturnShape)(context, propOrQuery.shape).ref : (0, refs_1.getRef)(context, propOrQuery);
+}
+exports.getReturnShapeRef = getReturnShapeRef;
+const cache = new WeakMap();
+function getReturnShape(projectSchema, propOrQuery) {
+    let result = cache.get(propOrQuery);
+    if (result === undefined) {
+        result = getReturnShapeHelper(projectSchema, propOrQuery);
+        cache.set(propOrQuery, result ?? null);
+    }
+    return result ?? undefined;
+}
+exports.getReturnShape = getReturnShape;

package/dist/cjs/src/util/has-arg.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasArg = exports.getArgs = void 0;
+const find_shape_at_path_1 = require("./find-shape-at-path");
+function getArgs(prop) {
+    return '@args' in prop ? prop['@args'] : 'args' in prop ? prop.args : undefined;
+}
+exports.getArgs = getArgs;
+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((0, find_shape_at_path_1.findSchemaAtPath)(projectSchema, schema, pathArray));
+}
+exports.hasArg = hasArg;

package/dist/cjs/src/util/merge.js

@@ -0,0 +1,261 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mergeProjectSchemas = exports.mergeFormConfigs = exports.rebaseFormProperties = exports.mergeFormProperties = exports.rebaseSchemaProperties = exports.mergeSchemaProperties = exports.mergeDeepObjectSchemas = exports.mergeObjectSchemas = void 0;
+const util_1 = require("@takeshape/util");
+const union_js_1 = __importDefault(require("lodash/union.js"));
+const difference_js_1 = __importDefault(require("lodash/difference.js"));
+const isEqual_js_1 = __importDefault(require("lodash/isEqual.js"));
+const unset_js_1 = __importDefault(require("lodash/unset.js"));
+const set_js_1 = __importDefault(require("lodash/set.js"));
+const last_js_1 = __importDefault(require("lodash/last.js"));
+const omit_js_1 = __importDefault(require("lodash/omit.js"));
+const pickBy_js_1 = __importDefault(require("lodash/pickBy.js"));
+const lodash_1 = require("lodash");
+const types_1 = require("../types");
+function mergeObjectSchemas(...args) {
+    return args
+        .filter(util_1.isDefined)
+        .reduce((parent, schemas) => mergeSchemaProperties(parent, schemas), { type: 'object', properties: {} });
+}
+exports.mergeObjectSchemas = mergeObjectSchemas;
+function mergeDeepObjectSchemas(...args) {
+    return args
+        .filter(util_1.isDefined)
+        .reduce((parent, schemas) => mergeSchemaProperties(parent, schemas, true), { type: 'object', properties: {} });
+}
+exports.mergeDeepObjectSchemas = mergeDeepObjectSchemas;
+function mergeSchemaProperties(parent, overrides, deep = false) {
+    const result = {
+        ...parent,
+        properties: deep
+            ? (0, lodash_1.assignWith)({}, parent.properties, overrides.properties, (objValue, srcValue) => {
+                // merge objects if possible
+                if (objValue !== undefined && srcValue !== undefined) {
+                    if ((0, types_1.isObjectSchema)(objValue) && (0, types_1.isObjectSchema)(srcValue)) {
+                        return mergeObjectSchemas(objValue, srcValue);
+                    }
+                    if (((0, types_1.isObjectSchema)(objValue) || (0, types_1.isRefSchema)(objValue)) &&
+                        ((0, types_1.isObjectSchema)(srcValue) || (0, types_1.isRefSchema)(srcValue))) {
+                        return { allOf: [objValue, srcValue] };
+                    }
+                }
+            })
+            : { ...parent.properties, ...overrides.properties }
+    };
+    const required = (0, union_js_1.default)(parent.required, overrides.required);
+    if (required.length) {
+        result.required = required;
+    }
+    return result;
+}
+exports.mergeSchemaProperties = mergeSchemaProperties;
+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 = {
+        ...(0, util_1.rebaseObject)(toOther, baseOther, fromOther),
+        type: 'object',
+        properties: (0, util_1.rebaseObject)(toProperties, baseProperties, fromProperties)
+    };
+    const required = (0, util_1.rebaseArray)(toRequired ?? [], baseRequired ?? [], fromRequired ?? []);
+    if (required.length) {
+        newSchema.required = required;
+    }
+    return newSchema;
+}
+exports.rebaseSchemaProperties = rebaseSchemaProperties;
+function mergeFormProperties(parent, overrides) {
+    const result = {
+        ...parent,
+        properties: {
+            ...parent.properties,
+            ...overrides.properties
+        }
+    };
+    const order = (0, union_js_1.default)(parent.order, overrides.order);
+    if (order.length) {
+        result.order = order;
+    }
+    return result;
+}
+exports.mergeFormProperties = mergeFormProperties;
+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 = {
+        ...(0, util_1.rebaseObject)(toOther, baseOther, fromOther),
+        properties: (0, util_1.rebaseObject)(toProperties, baseProperties, fromProperties)
+    };
+    const order = (0, util_1.rebaseArray)(toOrder ?? [], baseOrder ?? [], fromOrder ?? []);
+    if (order.length) {
+        newForm.order = order;
+    }
+    return newForm;
+}
+exports.rebaseFormProperties = rebaseFormProperties;
+function mergeFormConfigs(...configs) {
+    return configs.reduce(mergeFormProperties, { properties: {}, order: [] });
+}
+exports.mergeFormConfigs = mergeFormConfigs;
+const mergeableSections = ['shapes', 'mutations', 'queries', 'forms', 'services'];
+const isMergeableSection = (str) => {
+    return mergeableSections.includes(str);
+};
+const pickUnmergeable = (projectSchema) => {
+    return (0, pickBy_js_1.default)(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 (0, difference_js_1.default)(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 (!(0, isEqual_js_1.default)(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);
+    (0, util_1.assert)(shape, 'Expected shape not found');
+    return shape;
+}
+function rebaseShapeProperties(toShape, fromShape, baseShape) {
+    return baseShape
+        ? (0, util_1.rebaseObject)((0, omit_js_1.default)(toShape, 'schema'), (0, omit_js_1.default)(baseShape, 'schema'), (0, omit_js_1.default)(fromShape, 'schema'))
+        : { ...toShape, ...fromShape };
+}
+// eslint-disable-next-line complexity
+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 ((0, isEqual_js_1.default)(toSchema, fromSchema)) {
+        const baseShape = findChangedShape(parent, change);
+        return {
+            ...rebaseShapeProperties(toShape, fromShape, baseShape),
+            schema: toSchema
+        };
+    }
+    if ((0, types_1.isObjectSchema)(toSchema) && (0, types_1.isObjectSchema)(fromSchema)) {
+        const baseShape = findChangedShape(parent, change);
+        const baseSchema = baseShape?.schema;
+        return {
+            ...rebaseShapeProperties(toShape, fromShape, baseShape),
+            schema: change.op === 'update' && baseSchema && (0, types_1.isObjectSchema)(baseSchema)
+                ? rebaseSchemaProperties(toSchema, baseSchema, fromSchema)
+                : mergeSchemaProperties(toSchema, fromSchema)
+        };
+    }
+    if ((0, types_1.isExtendsSchema)(toSchema) &&
+        (0, types_1.isExtendsSchema)(fromSchema) &&
+        toSchema.extends.length === fromSchema.extends.length) {
+        const fromExtends = fromSchema.extends;
+        const toObj = (0, last_js_1.default)(toSchema.extends);
+        const fromObj = (0, last_js_1.default)(fromSchema.extends);
+        if (toObj &&
+            (0, types_1.isObjectSchema)(toObj) &&
+            fromObj &&
+            (0, types_1.isObjectSchema)(fromObj) &&
+            toSchema.extends.slice(0, toSchema.extends.length - 1).every((item, i) => (0, isEqual_js_1.default)(item, fromExtends[i]))) {
+            let mergedObjSchema;
+            const baseShape = findChangedShape(parent, change);
+            const baseSchema = baseShape?.schema;
+            if (change.op === 'update' && baseSchema && (0, types_1.isExtendsSchema)(baseSchema)) {
+                const baseObj = (0, last_js_1.default)(baseSchema.extends);
+                if (baseObj && (0, types_1.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') {
+        (0, unset_js_1.default)(base, change.path);
+    }
+    else if (change.op === 'add') {
+        (0, set_js_1.default)(base, change.path, change.value);
+    }
+    else if (change.op === 'update') {
+        if (change.section === 'shapes') {
+            const mergedShape = attemptToMerge(base, parent, head, change);
+            if (mergedShape) {
+                (0, set_js_1.default)(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;
+                (0, set_js_1.default)(base, change.path, {
+                    default: baseForm ? rebaseFormProperties(toForm, baseForm, fromForm) : mergeFormConfigs(toForm, fromForm)
+                });
+                return;
+            }
+        }
+        (0, set_js_1.default)(base, change.path, change.value);
+    }
+}
+function mergeProjectSchemas(base, parent, head) {
+    const changesTo = compareSections(parent, base);
+    const changesFrom = compareSections(parent, head);
+    const mergedSchema = (0, util_1.deepClone)(base);
+    for (let change of changesFrom) {
+        const potentialConflict = changesTo.find(changeTo => (0, isEqual_js_1.default)(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);
+                    // eslint-disable-next-line max-depth
+                    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, (0, util_1.rebaseObject)(pickUnmergeable(base), pickUnmergeable(parent), pickUnmergeable(head)));
+    return { error: undefined, mergedSchema };
+}
+exports.mergeProjectSchemas = mergeProjectSchemas;

package/dist/cjs/src/util/patch-schema.js

@@ -0,0 +1,50 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.patchSchema = exports.shallowMerge = void 0;
+const forIn_js_1 = __importDefault(require("lodash/forIn.js"));
+const omit_js_1 = __importDefault(require("lodash/omit.js"));
+const schemaUpdateMergedKeys = ['queries', 'mutations', 'shapes', 'workflows', 'forms', 'services'];
+function shallowMerge(original, update) {
+    const result = { ...original };
+    if (update) {
+        (0, forIn_js_1.default)(update, (obj, key) => {
+            // Null is a sentinel value to indicate delete
+            if (obj === null) {
+                // eslint-disable-next-line @typescript-eslint/no-dynamic-delete
+                delete result[key];
+            }
+            else {
+                result[key] = obj;
+            }
+        });
+    }
+    return result;
+}
+exports.shallowMerge = shallowMerge;
+/**
+ * Apply a schema update to a schema.
+ * Resulting schema is not assumed to be valid and should be validated if appropriate.
+ */
+function patchSchema(projectSchema, update) {
+    // Patch old schema with update
+    const updatedSchema = {
+        ...projectSchema,
+        ...(0, omit_js_1.default)(update, [...schemaUpdateMergedKeys, 'ai-experimental'])
+    };
+    for (const key of schemaUpdateMergedKeys) {
+        if (update[key]) {
+            updatedSchema[key] = shallowMerge(projectSchema[key], update[key]);
+        }
+    }
+    if (update['ai-experimental']?.agents) {
+        const ai = {
+            agents: shallowMerge(projectSchema['ai-experimental']?.agents, update['ai-experimental'].agents)
+        };
+        updatedSchema['ai-experimental'] = ai;
+    }
+    return updatedSchema;
+}
+exports.patchSchema = patchSchema;

package/dist/cjs/src/util/shapes.js

@@ -0,0 +1,32 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ensureShapeById = exports.ensureShape = exports.getShape = exports.getShapeById = void 0;
+const find_js_1 = __importDefault(require("lodash/find.js"));
+const errors_1 = require("@takeshape/errors");
+function getShapeById(projectSchema, shapeId) {
+    return (0, find_js_1.default)(projectSchema.shapes, shape => shape.id === shapeId);
+}
+exports.getShapeById = getShapeById;
+function getShape(context, name) {
+    return context.shapes[name];
+}
+exports.getShape = getShape;
+function ensureShape(projectSchema, name) {
+    const shape = getShape(projectSchema, name);
+    if (!shape) {
+        throw new errors_1.NotFoundError(`Shape "${name}" Not found`);
+    }
+    return shape;
+}
+exports.ensureShape = ensureShape;
+function ensureShapeById(projectSchema, shapeId) {
+    const shape = getShapeById(projectSchema, shapeId);
+    if (!shape) {
+        throw new errors_1.NotFoundError(`Shape with id "${shapeId}" Not found`);
+    }
+    return shape;
+}
+exports.ensureShapeById = ensureShapeById;