@takeshape/schema 11.40.0 → 11.40.3

package/dist/esm/src/unions.js

@@ -0,0 +1,79 @@
+import { camelCase, isRecord } from "@takeshape/util";
+import omit from "lodash/omit.js";
+import { BadDataError } from "@takeshape/errors";
+import { getRef, refItemToNamespacedShapeName } from "./refs.js";
+import { isRefSchema } from "./types/utils.js";
+import { getShapeById } from "./util/shapes.js";
+import { getOutputShapeName } from "./template-shapes/names.js";
+export function enumerateOneOfKeys(projectSchema, oneOf) {
+    const result = [];
+    for (const child of oneOf) {
+        const refItem = getRef(projectSchema, child);
+        if (refItem) {
+            const shapeName = refItemToNamespacedShapeName(refItem);
+            if (projectSchema.shapes[shapeName]) {
+                const shapeId = projectSchema.shapes[shapeName].id;
+                result.push({
+                    propName: getOutputShapeName(camelCase(refItem.typeName)),
+                    propSchema: child,
+                    shapeName,
+                    shapeId
+                });
+            }
+        }
+    }
+    return result;
+}
+function getOneOf(schema) {
+    if (!schema.oneOf) {
+        throw new Error(`Expected ${JSON.stringify(schema)} to be a oneOf schema`);
+    }
+    return schema.oneOf;
+}
+export function isUnionSchema(schema) {
+    return Boolean(schema.oneOf?.every(isRefSchema));
+}
+export function oneOfToObject(projectSchema, schema) {
+    const properties = {};
+    for (const { propName, propSchema: child } of enumerateOneOfKeys(projectSchema, getOneOf(schema))) {
+        properties[propName] = child;
+    }
+    return { ...omit(schema, "oneOf"), type: "object", properties };
+}
+function formatKeys(keys) {
+    return keys.map(k => `"${k}"`).join(", ");
+}
+// eslint-disable-next-line max-params
+export const createUnwrapTransform = projectSchema => (obj, schema, name, shape, next) => {
+    if (isRecord(obj)) {
+        const oneOfKeys = enumerateOneOfKeys(projectSchema, getOneOf(schema));
+        const objectKeys = Object.keys(obj);
+        if (objectKeys.length !== 1) {
+            const propNames = oneOfKeys.map(k => k.propName);
+            throw new BadDataError(`Object should only specify one of the following keys: ${formatKeys(propNames)}, but found keys: ${formatKeys(objectKeys)}`);
+        }
+        for (const { propName, shapeId, propSchema } of oneOfKeys) {
+            const propValue = obj[propName];
+            if (isRecord(propValue)) {
+                const transformedPropValue = next(propValue, propSchema, name);
+                if (isRecord(transformedPropValue)) {
+                    return {
+                        ...transformedPropValue,
+                        _shapeId: shapeId
+                    };
+                }
+            }
+        }
+    }
+};
+// eslint-disable-next-line max-params
+export const createWrapTransform = projectSchema => (obj, schema, name, shape, next) => {
+    if (isRecord(obj) && typeof obj._shapeId === "string") {
+        const shape = getShapeById(projectSchema, obj._shapeId);
+        if (shape) {
+            return {
+                [camelCase(shape.name)]: next(omit(obj, "_shapeId"), shape.schema, name)
+            };
+        }
+    }
+};

package/dist/esm/src/user-schema.js

@@ -0,0 +1,7 @@
+/* tslint:disable */
+/**
+ * This file was automatically generated by json-schema-to-typescript.
+ * DO NOT MODIFY IT BY HAND. Instead, modify the source JSONSchema file,
+ * and run json-schema-to-typescript to regenerate this file.
+ */
+export {};

package/dist/esm/src/util/ai-tools.js

@@ -0,0 +1,6 @@
+export function getToolRef(tool) {
+    return typeof tool === 'string' ? tool : tool.ref;
+}
+export function normalizeToolConfig(tool) {
+    return typeof tool === 'string' ? { ref: tool } : tool;
+}

package/dist/esm/src/util/api-indexing.js

@@ -0,0 +1,57 @@
+import { ensureArray } from "@takeshape/util";
+import { isServiceResolver, isCachedShape } from "../types/index.js";
+import { getResolverServices } from "../services/util.js";
+import { getIdField } from "../schema-util.js";
+import { getQuery } from "../refs.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/esm/src/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/esm/src/util/find-shape-at-path.js

@@ -0,0 +1,53 @@
+import { isArraySchema, isObjectSchema, isRefSchema } from "../types/index.js";
+import { getRef, refItemToShape, refItemToShapeSchema } from "../refs.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/esm/src/util/form-config.js

@@ -0,0 +1,63 @@
+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
+            // 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 = 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/esm/src/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/esm/src/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/esm/src/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/esm/src/util/merge.js

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