@baseplate-dev/plugin-auth 0.1.2 → 1.0.0

package/dist/web/assets/{model-utils-CbQJy1wE.js → model-merger-BLh0ERqk.js}

@@ -1,4 +1,4 @@
-import { importShared } from './__federation_fn_import-BiwmVFwy.js';
+import { importShared } from './__federation_fn_import-Drn1CtCD.js';
 
 function createInitializedPluginSpec(spec, implementation) {
     return { spec, implementation };
@@ -19,10 +19,135 @@ function createPluginSpec(name, options) {
 
 function noop() { }
 
+function isPrimitive(value) {
+    return value == null || (typeof value !== 'object' && typeof value !== 'function');
+}
+
+function isTypedArray(x) {
+    return ArrayBuffer.isView(x) && !(x instanceof DataView);
+}
+
 function getSymbols(object) {
     return Object.getOwnPropertySymbols(object).filter(symbol => Object.prototype.propertyIsEnumerable.call(object, symbol));
 }
 
+function cloneDeepWithImpl(valueToClone, keyToClone, objectToClone, stack = new Map(), cloneValue = undefined) {
+    const cloned = cloneValue?.(valueToClone, keyToClone, objectToClone, stack);
+    if (cloned != null) {
+        return cloned;
+    }
+    if (isPrimitive(valueToClone)) {
+        return valueToClone;
+    }
+    if (stack.has(valueToClone)) {
+        return stack.get(valueToClone);
+    }
+    if (Array.isArray(valueToClone)) {
+        const result = new Array(valueToClone.length);
+        stack.set(valueToClone, result);
+        for (let i = 0; i < valueToClone.length; i++) {
+            result[i] = cloneDeepWithImpl(valueToClone[i], i, objectToClone, stack, cloneValue);
+        }
+        if (Object.hasOwn(valueToClone, 'index')) {
+            result.index = valueToClone.index;
+        }
+        if (Object.hasOwn(valueToClone, 'input')) {
+            result.input = valueToClone.input;
+        }
+        return result;
+    }
+    if (valueToClone instanceof Date) {
+        return new Date(valueToClone.getTime());
+    }
+    if (valueToClone instanceof RegExp) {
+        const result = new RegExp(valueToClone.source, valueToClone.flags);
+        result.lastIndex = valueToClone.lastIndex;
+        return result;
+    }
+    if (valueToClone instanceof Map) {
+        const result = new Map();
+        stack.set(valueToClone, result);
+        for (const [key, value] of valueToClone) {
+            result.set(key, cloneDeepWithImpl(value, key, objectToClone, stack, cloneValue));
+        }
+        return result;
+    }
+    if (valueToClone instanceof Set) {
+        const result = new Set();
+        stack.set(valueToClone, result);
+        for (const value of valueToClone) {
+            result.add(cloneDeepWithImpl(value, undefined, objectToClone, stack, cloneValue));
+        }
+        return result;
+    }
+    if (typeof Buffer !== 'undefined' && Buffer.isBuffer(valueToClone)) {
+        return valueToClone.subarray();
+    }
+    if (isTypedArray(valueToClone)) {
+        const result = new (Object.getPrototypeOf(valueToClone).constructor)(valueToClone.length);
+        stack.set(valueToClone, result);
+        for (let i = 0; i < valueToClone.length; i++) {
+            result[i] = cloneDeepWithImpl(valueToClone[i], i, objectToClone, stack, cloneValue);
+        }
+        return result;
+    }
+    if (valueToClone instanceof ArrayBuffer ||
+        (typeof SharedArrayBuffer !== 'undefined' && valueToClone instanceof SharedArrayBuffer)) {
+        return valueToClone.slice(0);
+    }
+    if (valueToClone instanceof DataView) {
+        const result = new DataView(valueToClone.buffer.slice(0), valueToClone.byteOffset, valueToClone.byteLength);
+        stack.set(valueToClone, result);
+        copyProperties(result, valueToClone, objectToClone, stack, cloneValue);
+        return result;
+    }
+    if (typeof File !== 'undefined' && valueToClone instanceof File) {
+        const result = new File([valueToClone], valueToClone.name, {
+            type: valueToClone.type,
+        });
+        stack.set(valueToClone, result);
+        copyProperties(result, valueToClone, objectToClone, stack, cloneValue);
+        return result;
+    }
+    if (valueToClone instanceof Blob) {
+        const result = new Blob([valueToClone], { type: valueToClone.type });
+        stack.set(valueToClone, result);
+        copyProperties(result, valueToClone, objectToClone, stack, cloneValue);
+        return result;
+    }
+    if (valueToClone instanceof Error) {
+        const result = new valueToClone.constructor();
+        stack.set(valueToClone, result);
+        result.message = valueToClone.message;
+        result.name = valueToClone.name;
+        result.stack = valueToClone.stack;
+        result.cause = valueToClone.cause;
+        copyProperties(result, valueToClone, objectToClone, stack, cloneValue);
+        return result;
+    }
+    if (typeof valueToClone === 'object' && valueToClone !== null) {
+        const result = Object.create(Object.getPrototypeOf(valueToClone));
+        stack.set(valueToClone, result);
+        copyProperties(result, valueToClone, objectToClone, stack, cloneValue);
+        return result;
+    }
+    return valueToClone;
+}
+function copyProperties(target, source, objectToClone = target, stack, cloneValue) {
+    const keys = [...Object.keys(source), ...getSymbols(source)];
+    for (let i = 0; i < keys.length; i++) {
+        const key = keys[i];
+        const descriptor = Object.getOwnPropertyDescriptor(target, key);
+        if (descriptor == null || descriptor.writable) {
+            target[key] = cloneDeepWithImpl(source[key], key, objectToClone, stack, cloneValue);
+        }
+    }
+}
+
+function cloneDeep(obj) {
+    return cloneDeepWithImpl(obj, undefined, obj, new Map(), undefined);
+}
+
 function isPlainObject(value) {
     if (!value || typeof value !== 'object') {
         return false;
@@ -37,6 +162,59 @@ function isPlainObject(value) {
     return Object.prototype.toString.call(value) === '[object Object]';
 }
 
+function mapValues(object, getNewValue) {
+    const result = {};
+    const keys = Object.keys(object);
+    for (let i = 0; i < keys.length; i++) {
+        const key = keys[i];
+        const value = object[key];
+        result[key] = getNewValue(value, key, object);
+    }
+    return result;
+}
+
+function merge(target, source) {
+    const sourceKeys = Object.keys(source);
+    for (let i = 0; i < sourceKeys.length; i++) {
+        const key = sourceKeys[i];
+        const sourceValue = source[key];
+        const targetValue = target[key];
+        if (Array.isArray(sourceValue)) {
+            if (Array.isArray(targetValue)) {
+                target[key] = merge(targetValue, sourceValue);
+            }
+            else {
+                target[key] = merge([], sourceValue);
+            }
+        }
+        else if (isPlainObject(sourceValue)) {
+            if (isPlainObject(targetValue)) {
+                target[key] = merge(targetValue, sourceValue);
+            }
+            else {
+                target[key] = merge({}, sourceValue);
+            }
+        }
+        else if (targetValue === undefined || sourceValue !== undefined) {
+            target[key] = sourceValue;
+        }
+    }
+    return target;
+}
+
+function omit(obj, keys) {
+    const result = { ...obj };
+    for (let i = 0; i < keys.length; i++) {
+        const key = keys[i];
+        delete result[key];
+    }
+    return result;
+}
+
+function toMerged(target, source) {
+    return merge(cloneDeep(target), source);
+}
+
 function getTag(value) {
     if (value == null) {
         return value === undefined ? '[object Undefined]' : '[object Null]';
@@ -284,10 +462,10 @@ const UPPERCASE = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';
  */
 const customNanoid = customAlphabet(`${NUMBERS}${LOWERCASE}${UPPERCASE}_`, 12);
 /**
- * Generate a random ID string made up of numbers, lowercase, and uppercase letters
- * @returns A random ID string
+ * Generate a random key string made up of numbers, lowercase, and uppercase letters
+ * @returns A random key string
  */
-function randomUid(length = 12) {
+function randomKey(length = 12) {
     return customNanoid(length);
 }
 
@@ -313,19 +491,27 @@ const CASE_VALIDATORS = {
     /**
      * Zod validator for validating kebab case, e.g. "my-project".
      */
-    KEBAB_CASE: z$2.string().regex(KEBAB_CASE_REGEX),
+    KEBAB_CASE: z$2.string().regex(KEBAB_CASE_REGEX, {
+        message: 'Must be kebab case (e.g. "my-project")',
+    }),
     /**
      * Zod validator for validating pascal case, e.g. "MyProject".
      */
-    PASCAL_CASE: z$2.string().regex(PASCAL_CASE_REGEX),
+    PASCAL_CASE: z$2.string().regex(PASCAL_CASE_REGEX, {
+        message: 'Must be pascal case (e.g. "MyProject")',
+    }),
     /**
      * Zod validator for validating camel case, e.g. "myProject".
      */
-    CAMEL_CASE: z$2.string().regex(CAMEL_CASE_REGEX),
+    CAMEL_CASE: z$2.string().regex(CAMEL_CASE_REGEX, {
+        message: 'Must be camel case (e.g. "myProject")',
+    }),
     /**
      * Zod validator for validating constant case, e.g. "MY_PROJECT".
      */
-    CONSTANT_CASE: z$2.string().regex(CONSTANT_CASE_REGEX),
+    CONSTANT_CASE: z$2.string().regex(CONSTANT_CASE_REGEX, {
+        message: 'Must be constant case (e.g. "MY_PROJECT")',
+    }),
 };
 
 /**
@@ -366,15 +552,15 @@ class DefinitionEntityType {
      * @returns The new ID.
      */
     generateNewId() {
-        return `${this.prefix}:${randomUid()}`;
+        return `${this.prefix}:${randomKey()}`;
     }
-    fromUid(uid) {
-        if (!uid) {
+    idFromKey(key) {
+        if (!key) {
             return undefined;
         }
-        return `${this.prefix}:${uid}`;
+        return `${this.prefix}:${key}`;
     }
-    toUid(id) {
+    keyFromId(id) {
         return id.split(':')[1];
     }
     isId(id) {
@@ -577,6 +763,107 @@ function getWithPath(object, path, defaultValue) {
     return current;
 }
 
+function isObject(value) {
+    return value !== null && (typeof value === 'object' || typeof value === 'function');
+}
+
+function isMatch(target, source) {
+    if (source === target) {
+        return true;
+    }
+    switch (typeof source) {
+        case 'object': {
+            if (source == null) {
+                return true;
+            }
+            const keys = Object.keys(source);
+            if (target == null) {
+                return keys.length === 0;
+            }
+            if (Array.isArray(source)) {
+                return isArrayMatch(target, source);
+            }
+            if (source instanceof Map) {
+                return isMapMatch(target, source);
+            }
+            if (source instanceof Set) {
+                return isSetMatch(target, source);
+            }
+            for (let i = 0; i < keys.length; i++) {
+                const key = keys[i];
+                if (!isPrimitive(target) && !(key in target)) {
+                    return false;
+                }
+                if (source[key] === undefined && target[key] !== undefined) {
+                    return false;
+                }
+                if (source[key] === null && target[key] !== null) {
+                    return false;
+                }
+                if (!isMatch(target[key], source[key])) {
+                    return false;
+                }
+            }
+            return true;
+        }
+        case 'function': {
+            if (Object.keys(source).length > 0) {
+                return isMatch(target, { ...source });
+            }
+            return false;
+        }
+        default: {
+            if (!isObject(target)) {
+                return eq(target, source);
+            }
+            return !source;
+        }
+    }
+}
+function isMapMatch(target, source) {
+    if (source.size === 0) {
+        return true;
+    }
+    if (!(target instanceof Map)) {
+        return false;
+    }
+    for (const [key, value] of source.entries()) {
+        if (!isMatch(target.get(key), value)) {
+            return false;
+        }
+    }
+    return true;
+}
+function isArrayMatch(target, source) {
+    if (source.length === 0) {
+        return true;
+    }
+    if (!Array.isArray(target)) {
+        return false;
+    }
+    const countedIndex = new Set();
+    for (let i = 0; i < source.length; i++) {
+        const sourceItem = source[i];
+        const index = target.findIndex((targetItem, index) => {
+            return isMatch(targetItem, sourceItem) && !countedIndex.has(index);
+        });
+        if (index === -1) {
+            return false;
+        }
+        countedIndex.add(index);
+    }
+    return true;
+}
+function isSetMatch(target, source) {
+    if (source.size === 0) {
+        return true;
+    }
+    if (!(target instanceof Set)) {
+        return false;
+    }
+    return isArrayMatch([...target], [...source]);
+}
+
 const IS_UNSIGNED_INTEGER = /^(?:0|[1-9]\d*)$/;
 function isIndex(value, length = Number.MAX_SAFE_INTEGER) {
     switch (typeof value) {
@@ -804,7 +1091,7 @@ class ZodRefBuilder {
         const idPath = entity.idPath
             ? this._constructPathWithoutPrefix(entity.idPath)
             : [...this._constructPathWithoutPrefix(entity.path), 'id'];
-        // TODO [>=0.9.16] Remove the fallback to generateNewId once a new version is released and manual setter
+        // TODO [>=0.2.0] Remove the fallback to generateNewId once we've released a new major verison.
         const id = get(this.data, idPath) ??
             entity.type.generateNewId();
         if (!get(this.data, idPath)) {
@@ -1102,10 +1389,14 @@ Object.defineProperty(ZodRefWrapper, "create", {
     })
 });
 
+function definitionSchema(creator) {
+    return (options) => creator(options);
+}
+
 const {z} = await importShared('zod');
 const featureEntityType = createEntityType('feature');
 const featureNameSchema = CASE_VALIDATORS.KEBAB_CASE;
-const featureSchema = zEnt(z.object({
+const createFeatureSchema = definitionSchema(() => zEnt(z.object({
     name: z
         .string()
         .min(1)
@@ -1118,8 +1409,21 @@ const featureSchema = zEnt(z.object({
         type: featureEntityType,
         onDelete: 'DELETE_PARENT',
     }),
-}), { type: featureEntityType });
-const featuresSchema = z.array(featureSchema).default([]);
+}), { type: featureEntityType }));
+const createFeaturesSchema = definitionSchema((ctx) => z.array(createFeatureSchema(ctx)).default([]));
+
+const modelEntityType = createEntityType('model');
+const modelScalarFieldEntityType = createEntityType('model-scalar-field', {
+    parentType: modelEntityType,
+});
+const modelLocalRelationEntityType = createEntityType('model-local-relation', { parentType: modelEntityType });
+const modelForeignRelationEntityType = createEntityType('model-foreign-relation', { parentType: modelEntityType });
+const modelUniqueConstraintEntityType = createEntityType('model-unique-constraint', { parentType: modelEntityType });
+const modelTransformerEntityType = createEntityType('model-transformer', { parentType: modelEntityType });
+const modelEnumEntityType = createEntityType('model-enum');
+const modelEnumValueEntityType = createEntityType('model-enum-value', {
+    parentType: modelEnumEntityType,
+});
 
 function getRootFeatures(projectDefinition) {
     return projectDefinition.features.filter((f) => !f.parentRef);
@@ -1259,5 +1563,489 @@ const ModelUtils = {
     getModelIdByNameOrDefault,
 };
 
-export { CASE_VALIDATORS as C, DefinitionEntityType as D, FeatureUtils as F, ModelUtils as M, ZodRefWrapper as Z, isEqual as a, createEntityType as b, createPluginSpec as c, get as d, eq as e, zRef as f, getSymbols as g, zEnt as h, isPlainObject as i, createDefinitionEntityNameResolver as j, ZodRef as k, featureEntityType as l, zRefBuilder as m, zRefId as n, featuresSchema as o, zPluginWrapper as p, ZodPluginWrapper as q, createInitializedPluginSpec as r, set as s, ZodRefBuilder as t, featureNameSchema as u, featureSchema as v, zodPluginSymbol as z };
-//# sourceMappingURL=model-utils-CbQJy1wE.js.map
+/**
+ * Allows diffing of arbitrary JSON objects.
+ */
+class DefinitionDiffField {
+    constructor(
+    /**
+     * The name of the field to be presented to the user.
+     */
+    name) {
+        Object.defineProperty(this, "name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: name
+        });
+    }
+}
+/**
+ * A field that is an array of objects with a unique key.
+ */
+class DefinitionDiffKeyedArrayField extends DefinitionDiffField {
+    constructor(name, getKey, options = {}) {
+        super(name);
+        Object.defineProperty(this, "getKey", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: getKey
+        });
+        Object.defineProperty(this, "options", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: options
+        });
+        this.getKey = getKey;
+    }
+    diff(current, desired) {
+        const currentValue = current ?? [];
+        const desiredValue = desired ?? [];
+        if (!Array.isArray(currentValue) || !Array.isArray(desiredValue)) {
+            throw new TypeError('Current and desired must be arrays');
+        }
+        const ops = [];
+        const { allowRemove, ignoreFields = ['id'] } = this.options;
+        const currentByKey = new Map(currentValue.map((item) => [this.getKey(item), item]));
+        const desiredByKey = new Map(desiredValue.map((item) => [this.getKey(item), item]));
+        for (const [key, desiredItem] of desiredByKey) {
+            const currentItem = currentByKey.get(key);
+            if (!currentItem) {
+                ops.push({ type: 'add', key, item: desiredItem });
+                continue;
+            }
+            if (!isMatch(omit(currentItem, ignoreFields), omit(desiredItem, ignoreFields))) {
+                ops.push({ type: 'update', key, item: desiredItem });
+            }
+        }
+        if (allowRemove) {
+            for (const [key, currentItem] of currentByKey) {
+                if (!desiredByKey.has(key)) {
+                    ops.push({ type: 'remove', key, item: currentItem });
+                }
+            }
+        }
+        return ops;
+    }
+    apply(current, diff) {
+        const patch = diff;
+        const currentValue = current ?? [];
+        if (!Array.isArray(currentValue)) {
+            throw new TypeError('Current must be array');
+        }
+        const items = [...currentValue];
+        for (const { type, key, item } of patch) {
+            const index = items.findIndex((i) => this.getKey(i) === key);
+            switch (type) {
+                case 'add': {
+                    items.push(item);
+                    break;
+                }
+                case 'update': {
+                    if (index === -1) {
+                        throw new Error(`Cannot apply patch. Item with key "${key}" not found.`);
+                    }
+                    // Preserve existing id if present.
+                    items[index] = toMerged(items[index], item);
+                    break;
+                }
+                case 'remove': {
+                    if (index !== -1) {
+                        items.splice(index, 1);
+                    }
+                    break;
+                }
+            }
+        }
+        return items;
+    }
+    getActionVerb(isNew) {
+        return isNew ? 'created' : 'added or updated';
+    }
+}
+/**
+ * A field that is a replacement for the entire object or array.
+ */
+class DefinitionDiffReplacementField extends DefinitionDiffField {
+    diff(current, desired) {
+        if (desired === undefined) {
+            return [];
+        }
+        if (!isMatch(current, desired)) {
+            return [{ type: 'update', key: '*', item: desired }];
+        }
+        return [];
+    }
+    apply(current, diff) {
+        if (diff.length === 0)
+            return current;
+        return diff[0].item;
+    }
+    getActionVerb(isNew) {
+        return isNew ? 'set' : 'replaced';
+    }
+}
+/**
+ * A field that ensures an array contains certain values.
+ * This field type only adds items, never removes them.
+ */
+class DefinitionDiffArrayIncludesField extends DefinitionDiffField {
+    constructor(name, getKey) {
+        super(name);
+        Object.defineProperty(this, "getKey", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: getKey
+        });
+    }
+    diff(current, desired) {
+        const currentValue = current ?? [];
+        const desiredValue = desired ?? [];
+        if (!Array.isArray(currentValue) || !Array.isArray(desiredValue)) {
+            throw new TypeError('Current and desired must be arrays');
+        }
+        const ops = [];
+        const currentSet = new Set(this.getKey ? currentValue.map(this.getKey) : currentValue);
+        for (const item of desiredValue) {
+            const key = this.getKey ? this.getKey(item) : String(item);
+            if (!currentSet.has(key)) {
+                ops.push({ type: 'add', key, item });
+            }
+        }
+        return ops;
+    }
+    apply(current, diff) {
+        const currentValue = (current ?? []);
+        if (!Array.isArray(currentValue)) {
+            throw new TypeError('Current must be array');
+        }
+        const items = [...currentValue];
+        for (const { type, item } of diff) {
+            if (type === 'add') {
+                items.push(item);
+            }
+        }
+        return items;
+    }
+    getActionVerb(isNew) {
+        return isNew ? 'created' : 'added';
+    }
+}
+function createDefinitionDiffConfig(config) {
+    return config;
+}
+/**
+ * Creates a diff between two objects.
+ */
+function createDefinitionDiff(current, desired, configuration) {
+    const ops = mapValues(configuration, (field, key) => {
+        if (!field)
+            return [];
+        return field.diff(get(current, key), get(desired, key));
+    });
+    if (Object.values(ops).every((ops) => ops.length === 0)) {
+        return undefined;
+    }
+    return ops;
+}
+/**
+ * Applies a diff to an object.
+ */
+function applyDefinitionDiff(current, diff, configuration) {
+    const clonedCurrent = cloneDeep(current);
+    for (const [key, ops] of Object.entries(diff)) {
+        if (!ops)
+            continue;
+        const field = configuration[key];
+        const currentValue = get(clonedCurrent, key);
+        set(clonedCurrent, key, field.apply(currentValue, ops));
+    }
+    return clonedCurrent;
+}
+
+/**
+ * Computes a unique key for a unique constraint by sorting its field refs.
+ *
+ * @param constraint - Unique constraint input.
+ * @returns A key string.
+ */
+function getUniqueConstraintKey(constraint) {
+    const fields = constraint.fields.map((f) => f.fieldRef).sort();
+    return fields.join('|');
+}
+const modelMergerDefinitionDiffConfig = createDefinitionDiffConfig({
+    'model.fields': new DefinitionDiffKeyedArrayField('fields', (f) => f.name),
+    'model.relations': new DefinitionDiffKeyedArrayField('relations', (r) => r.name),
+    'model.uniqueConstraints': new DefinitionDiffKeyedArrayField('unique constraints', (c) => getUniqueConstraintKey(c)),
+    'model.primaryKeyFieldRefs': new DefinitionDiffReplacementField('primary key fields'),
+    'graphql.objectType.enabled': new DefinitionDiffReplacementField('GraphQL object type enabled'),
+    'graphql.objectType.fields': new DefinitionDiffArrayIncludesField('GraphQL object type fields'),
+    'graphql.objectType.localRelations': new DefinitionDiffArrayIncludesField('GraphQL object type local relations'),
+    'graphql.objectType.foreignRelations': new DefinitionDiffArrayIncludesField('GraphQL object type foreign relations'),
+});
+/**
+ * Serializes a model merger model input such that all IDs are replaced with
+ * names.
+ *
+ * @param input - The model merger model input.
+ * @param definitionContainer - The definition container.
+ * @returns The serialized model merger model input.
+ */
+function serializeModelMergerModelInput(input, definitionContainer, siblingModels) {
+    const siblingModelFieldIdMap = new Map([
+        ...input.model.fields.map((f) => [f.id, f.name]),
+        ...siblingModels.flatMap((m) => m.model.fields.map((f) => [f.id, f.name])),
+    ]);
+    const siblingModelRelationIdMap = new Map([
+        ...(input.model.relations ?? []).map((r) => [r.id, r.name]),
+        ...siblingModels.flatMap((m) => (m.model.relations ?? []).map((r) => [r.id, r.name])),
+        ...(input.model.relations ?? []).map((r) => [r.foreignId, r.foreignRelationName]),
+        ...siblingModels.flatMap((m) => (m.model.relations ?? []).map((r) => [r.foreignId, r.foreignRelationName])),
+    ]);
+    const fieldNameFromId = (id) => siblingModelFieldIdMap.get(id) ?? definitionContainer.nameFromId(id);
+    const relationNameFromId = (id) => siblingModelRelationIdMap.get(id) ?? definitionContainer.nameFromId(id);
+    return {
+        ...input,
+        model: {
+            ...input.model,
+            relations: input.model.relations?.map((r) => ({
+                ...r,
+                references: r.references.map((reference) => ({
+                    ...reference,
+                    localRef: fieldNameFromId(reference.localRef),
+                    foreignRef: fieldNameFromId(reference.foreignRef),
+                })),
+            })),
+            uniqueConstraints: input.model.uniqueConstraints?.map((c) => ({
+                ...c,
+                fields: c.fields.map((f) => ({
+                    ...f,
+                    fieldRef: fieldNameFromId(f.fieldRef),
+                })),
+            })),
+            primaryKeyFieldRefs: input.model.primaryKeyFieldRefs.map(fieldNameFromId),
+        },
+        graphql: {
+            ...input.graphql,
+            objectType: {
+                ...input.graphql?.objectType,
+                fields: input.graphql?.objectType?.fields.map(fieldNameFromId) ?? [],
+                localRelations: input.graphql?.objectType?.localRelations?.map(relationNameFromId),
+                foreignRelations: input.graphql?.objectType?.foreignRelations?.map(relationNameFromId),
+            },
+        },
+    };
+}
+/**
+ * Attaches IDs to the model merger model input.
+ *
+ * @param input - The model merger model input.
+ * @returns The model merger model input with IDs attached.
+ */
+function attachIdsToModelMergerModelInput(input) {
+    return {
+        ...input,
+        model: {
+            ...input.model,
+            fields: input.model.fields.map((f) => ({
+                ...f,
+                id: f.id ?? modelScalarFieldEntityType.generateNewId(),
+            })),
+            relations: input.model.relations?.map((r) => ({
+                ...r,
+                id: r.id ?? modelLocalRelationEntityType.generateNewId(),
+                foreignId: r.foreignId ?? modelForeignRelationEntityType.generateNewId(),
+            })),
+            uniqueConstraints: input.model.uniqueConstraints?.map((c) => ({
+                ...c,
+                id: c.id ?? modelUniqueConstraintEntityType.generateNewId(),
+            })),
+        },
+    };
+}
+/**
+ * Deserializes a model merger model input converting all names to IDs.
+ *
+ * @param input - The model merger model input.
+ * @param resolveForeignFieldRef - A function that resolves the foreign field ref.
+ * @returns The deserialized model merger model input.
+ */
+function deserializeModelMergerModelInput(input, resolveForeignFieldRef, resolveForeignRelationRef) {
+    const inputWithIds = attachIdsToModelMergerModelInput(input);
+    const resolveLocalFieldName = (name) => {
+        const field = inputWithIds.model.fields.find((f) => f.name === name);
+        if (!field) {
+            throw new Error(`Field ${name} not found`);
+        }
+        return field.id;
+    };
+    const resolveLocalRelationName = (name) => {
+        const relation = inputWithIds.model.relations?.find((r) => r.name === name);
+        if (!relation) {
+            throw new Error(`Relation ${name} not found`);
+        }
+        return relation.id;
+    };
+    return {
+        ...inputWithIds,
+        model: {
+            ...inputWithIds.model,
+            relations: inputWithIds.model.relations?.map((relation) => ({
+                ...relation,
+                references: relation.references.map((reference) => ({
+                    ...reference,
+                    localRef: resolveLocalFieldName(reference.localRef),
+                    foreignRef: resolveForeignFieldRef(relation.modelRef, reference.foreignRef),
+                })),
+            })),
+            uniqueConstraints: inputWithIds.model.uniqueConstraints?.map((constraint) => ({
+                ...constraint,
+                fields: constraint.fields.map((field) => ({
+                    ...field,
+                    fieldRef: resolveLocalFieldName(field.fieldRef),
+                })),
+            })),
+            primaryKeyFieldRefs: inputWithIds.model.primaryKeyFieldRefs.map((fieldRef) => resolveLocalFieldName(fieldRef)),
+        },
+        graphql: {
+            ...inputWithIds.graphql,
+            objectType: {
+                ...inputWithIds.graphql?.objectType,
+                fields: inputWithIds.graphql?.objectType?.fields.map((fieldRef) => resolveLocalFieldName(fieldRef)) ?? [],
+                localRelations: inputWithIds.graphql?.objectType?.localRelations?.map((relationRef) => resolveLocalRelationName(relationRef)) ?? [],
+                foreignRelations: inputWithIds.graphql?.objectType?.foreignRelations?.map((relationRef) => resolveForeignRelationRef(relationRef)) ?? [],
+            },
+        },
+    };
+}
+/**
+ * Creates a new blank model config input from a name and feature ref.
+ *
+ * @param name - The name of the model.
+ * @param featureRef - The feature ref of the model.
+ * @returns The new model config input.
+ */
+function createNewModelConfigInput(name, featureRef) {
+    return {
+        id: modelEntityType.generateNewId(),
+        name,
+        featureRef,
+        model: {
+            fields: [],
+            primaryKeyFieldRefs: [],
+        },
+    };
+}
+/**
+ * Diff the model definition.
+ *
+ * @param current - The current model definition or a new model to be created.
+ * @param desired - The desired model definition.
+ * @param definitionContainer - Project definition container.
+ * @param options - Diff options.
+ * @returns A diff output or undefined if there are no differences.
+ */
+function createModelMergerResult(current, desired, definitionContainer, { siblingModels = [] } = {}) {
+    const currentModel = current ?? createNewModelConfigInput(desired.name, desired.featureRef);
+    // resolves all the names of the current model config input
+    const resolvedCurrent = serializeModelMergerModelInput(currentModel, definitionContainer, siblingModels);
+    const diff = createDefinitionDiff(resolvedCurrent, desired, modelMergerDefinitionDiffConfig);
+    if (!diff) {
+        return undefined;
+    }
+    return {
+        isNewModel: !current,
+        id: currentModel.id,
+        name: currentModel.name,
+        featureRef: currentModel.featureRef,
+        changes: diff,
+    };
+}
+/**
+ * Creates a model merger result for a set of models.
+ *
+ * @param current - A map of model IDs
+ * @param desired - The desired model definition.
+ * @param definitionContainer - Project definition container.
+ * @param options - Diff options.
+ * @returns A model merger result for a set of models.
+ */
+function createModelMergerResults(current, desired, definitionContainer, { siblingModels = [] } = {}) {
+    return mapValues(desired, (desired, key) => createModelMergerResult(current[key] && modelEntityType.isId(current[key])
+        ? ModelUtils.byIdOrThrow(definitionContainer.definition, current[key])
+        : undefined, desired, definitionContainer, {
+        siblingModels,
+    }));
+}
+function applyModelMergerDiff(model, diff, definitionContainer, siblingModels = []) {
+    const resolvedCurrent = serializeModelMergerModelInput(model, definitionContainer, siblingModels);
+    const patchedCurrent = applyDefinitionDiff(resolvedCurrent, diff, modelMergerDefinitionDiffConfig);
+    return {
+        ...model,
+        ...deserializeModelMergerModelInput(patchedCurrent, (modelId, fieldName) => {
+            const siblingModel = siblingModels.find((m) => m.id === modelId);
+            if (siblingModel) {
+                const field = siblingModel.model.fields.find((f) => f.name === fieldName);
+                if (!field) {
+                    throw new Error(`Field ${fieldName} not found in sibling model ${modelId}`);
+                }
+                return field.id;
+            }
+            const model = ModelUtils.byIdOrThrow(definitionContainer.definition, modelId);
+            const field = model.model.fields.find((f) => f.name === fieldName);
+            if (!field) {
+                throw new Error(`Field ${fieldName} not found in model ${model.name}`);
+            }
+            return field.id;
+        }, (relationName) => {
+            // Search sibling model first
+            let relationId;
+            for (const siblingModel of siblingModels) {
+                const relation = siblingModel.model.relations?.find((r) => r.foreignRelationName === relationName);
+                if (relation) {
+                    relationId = relation.foreignId;
+                    break;
+                }
+            }
+            if (relationId) {
+                return relationId;
+            }
+            const relations = ModelUtils.getRelationsToModel(definitionContainer.definition, model.id);
+            const relation = relations.find((r) => r.relation.foreignRelationName === relationName &&
+                r.relation.modelRef === model.id);
+            if (!relation) {
+                throw new Error(`Relation ${relationName} not found in model ${model.name}`);
+            }
+            return relation.relation.foreignId;
+        }),
+    };
+}
+function applyModelMergerResultInPlace(draftConfig, result, definitionContainer, { siblingModels = [] } = {}) {
+    const model = result.isNewModel
+        ? createNewModelConfigInput(result.name, result.featureRef)
+        : ModelUtils.byIdOrThrow(definitionContainer.definition, result.id);
+    const newModel = applyModelMergerDiff(model, result.changes, definitionContainer, siblingModels);
+    if (result.isNewModel) {
+        draftConfig.models.push(newModel);
+    }
+    else {
+        const index = draftConfig.models.findIndex((m) => m.id === result.id);
+        if (index === -1) {
+            throw new Error(`Model ${result.id} not found`);
+        }
+        draftConfig.models[index] = newModel;
+    }
+    return newModel.id;
+}
+function createAndApplyModelMergerResults(draftConfig, current, desired, definitionContainer, { siblingModels = [] } = {}) {
+    const results = createModelMergerResults(current, desired, definitionContainer, { siblingModels });
+    return mapValues(results, (result, key) => result
+        ? applyModelMergerResultInPlace(draftConfig, result, definitionContainer, { siblingModels })
+        : desired[key].name);
+}
+
+export { ZodPluginWrapper as A, createInitializedPluginSpec as B, CASE_VALIDATORS as C, ZodRefBuilder as D, ZodRef as E, FeatureUtils as F, DefinitionEntityType as G, featureNameSchema as H, createFeatureSchema as I, modelMergerDefinitionDiffConfig as J, createModelMergerResult as K, createModelMergerResults as L, ModelUtils as M, applyModelMergerDiff as N, applyModelMergerResultInPlace as O, createAndApplyModelMergerResults as P, DefinitionDiffKeyedArrayField as Q, DefinitionDiffReplacementField as R, DefinitionDiffArrayIncludesField as S, createDefinitionDiffConfig as T, createDefinitionDiff as U, applyDefinitionDiff as V, ZodRefWrapper as Z, createEntityType as a, zRef as b, createPluginSpec as c, definitionSchema as d, modelForeignRelationEntityType as e, modelLocalRelationEntityType as f, get as g, modelScalarFieldEntityType as h, isEqual as i, zEnt as j, modelTransformerEntityType as k, createDefinitionEntityNameResolver as l, mapValues as m, modelEntityType as n, modelEnumValueEntityType as o, featureEntityType as p, modelEnumEntityType as q, zRefBuilder as r, set as s, zRefId as t, modelUniqueConstraintEntityType as u, createFeaturesSchema as v, zPluginWrapper as w, omit as x, cloneDeep as y, zodPluginSymbol as z };
+//# sourceMappingURL=model-merger-BLh0ERqk.js.map