@baseplate-dev/plugin-auth 0.1.2 → 1.0.0

package/dist/web/assets/__federation_shared_@baseplate-dev/{project-builder-lib-B62IPizQ.js → project-builder-lib-Tb9xtEo4.js}

@@ -1,6 +1,6 @@
-import { c as createPluginSpec, g as getSymbols, i as isPlainObject$2, a as isEqual, b as createEntityType, z as zodPluginSymbol, e as eq, Z as ZodRefWrapper, d as get$1, s as set$1, C as CASE_VALIDATORS, f as zRef, h as zEnt, j as createDefinitionEntityNameResolver, k as ZodRef, l as featureEntityType, m as zRefBuilder, n as zRefId, o as featuresSchema, M as ModelUtils, p as zPluginWrapper } from '../model-utils-CbQJy1wE.js';
-export { D as DefinitionEntityType, F as FeatureUtils, q as ZodPluginWrapper, t as ZodRefBuilder, r as createInitializedPluginSpec, u as featureNameSchema, v as featureSchema } from '../model-utils-CbQJy1wE.js';
-import { importShared } from '../__federation_fn_import-BiwmVFwy.js';
+import { c as createPluginSpec, i as isEqual, m as mapValues, a as createEntityType, z as zodPluginSymbol, Z as ZodRefWrapper, g as get$1, s as set$1, C as CASE_VALIDATORS, d as definitionSchema, b as zRef, e as modelForeignRelationEntityType, f as modelLocalRelationEntityType, h as modelScalarFieldEntityType, j as zEnt, k as modelTransformerEntityType, l as createDefinitionEntityNameResolver, n as modelEntityType, o as modelEnumValueEntityType, p as featureEntityType, q as modelEnumEntityType, r as zRefBuilder, t as zRefId, u as modelUniqueConstraintEntityType, v as createFeaturesSchema, M as ModelUtils, w as zPluginWrapper, x as omit, y as cloneDeep } from '../model-merger-BLh0ERqk.js';
+export { S as DefinitionDiffArrayIncludesField, Q as DefinitionDiffKeyedArrayField, R as DefinitionDiffReplacementField, G as DefinitionEntityType, F as FeatureUtils, A as ZodPluginWrapper, E as ZodRef, D as ZodRefBuilder, V as applyDefinitionDiff, N as applyModelMergerDiff, O as applyModelMergerResultInPlace, P as createAndApplyModelMergerResults, U as createDefinitionDiff, T as createDefinitionDiffConfig, I as createFeatureSchema, B as createInitializedPluginSpec, K as createModelMergerResult, L as createModelMergerResults, H as featureNameSchema, J as modelMergerDefinitionDiffConfig } from '../model-merger-BLh0ERqk.js';
+import { importShared } from '../__federation_fn_import-Drn1CtCD.js';
 
 function createAdminCrudInputCompilerImplementation() {
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -99,171 +99,6 @@ function flow(...funcs) {
     };
 }
 
-function isPrimitive(value) {
-    return value == null || (typeof value !== 'object' && typeof value !== 'function');
-}
-
-function isTypedArray(x) {
-    return ArrayBuffer.isView(x) && !(x instanceof DataView);
-}
-
-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 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$2(sourceValue)) {
-            if (isPlainObject$2(targetValue)) {
-                target[key] = merge(targetValue, sourceValue);
-            }
-            else {
-                target[key] = merge({}, sourceValue);
-            }
-        }
-        else if (targetValue === undefined || sourceValue !== undefined) {
-            target[key] = sourceValue;
-        }
-    }
-    return target;
-}
-
 function isObjectLike(value) {
     return typeof value === 'object' && value !== null;
 }
@@ -291,15 +126,6 @@ function mergeWith(target, source, merge) {
     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 pickBy(obj, shouldPick) {
     const result = {};
     const keys = Object.keys(obj);
@@ -313,13 +139,9 @@ function pickBy(obj, shouldPick) {
     return result;
 }
 
-function toMerged(target, source) {
-    return merge(cloneDeep(target), source);
-}
-
 // adapted from https://github.com/AitoDotAI/json-stringify-pretty-compact
 // allows { } to be presented as {} to better mirror prettier formatting
-function isObject$1(obj) {
+function isObject(obj) {
     return typeof obj === 'object' && obj !== null;
 }
 function forEach(obj, cb) {
@@ -327,7 +149,7 @@ function forEach(obj, cb) {
         // eslint-disable-next-line unicorn/no-array-for-each
         obj.forEach(cb);
     }
-    else if (isObject$1(obj)) {
+    else if (isObject(obj)) {
         for (const key of Object.keys(obj)) {
             const val = obj[key];
             cb(val, key);
@@ -336,9 +158,9 @@ function forEach(obj, cb) {
 }
 function getTreeDepth(obj) {
     let depth = 0;
-    if (Array.isArray(obj) || isObject$1(obj)) {
+    if (Array.isArray(obj) || isObject(obj)) {
         forEach(obj, (val) => {
-            if (Array.isArray(val) || isObject$1(val)) {
+            if (Array.isArray(val) || isObject(val)) {
                 const tmpDepth = getTreeDepth(val);
                 if (tmpDepth > depth) {
                     depth = tmpDepth;
@@ -409,7 +231,7 @@ function stringifyPrettyCompact(rootObj, options = {}) {
                 return prettified;
             }
         }
-        if (isObject$1(obj)) {
+        if (isObject(obj)) {
             const nextIndent = currentIndent + indent;
             const items = [];
             let delimiters;
@@ -1651,27 +1473,27 @@ function createPluginConfigImplementation() {
     const schemas = new Map();
     const migrationsMap = new Map();
     return {
-        registerSchema(pluginId, schema) {
-            if (schemas.has(pluginId)) {
-                throw new Error(`Schema for plugin ${pluginId} is already registered`);
+        registerSchema(pluginKey, schema) {
+            if (schemas.has(pluginKey)) {
+                throw new Error(`Schema for plugin ${pluginKey} is already registered`);
             }
-            schemas.set(pluginId, schema);
+            schemas.set(pluginKey, schema);
         },
-        registerMigrations(pluginId, migrations) {
-            if (migrationsMap.has(pluginId)) {
-                throw new Error(`Migrations for plugin ${pluginId} are already registered`);
+        registerMigrations(pluginKey, migrations) {
+            if (migrationsMap.has(pluginKey)) {
+                throw new Error(`Migrations for plugin ${pluginKey} are already registered`);
             }
             const sortedMigrations = sortAndValidateMigrations(migrations);
-            migrationsMap.set(pluginId, sortedMigrations);
+            migrationsMap.set(pluginKey, sortedMigrations);
         },
-        getSchema(pluginId) {
-            return schemas.get(pluginId);
+        getSchema(pluginKey) {
+            return schemas.get(pluginKey);
         },
-        getMigrations(pluginId) {
-            return migrationsMap.get(pluginId);
+        getMigrations(pluginKey) {
+            return migrationsMap.get(pluginKey);
         },
-        getLastMigrationVersion(pluginId) {
-            const migrations = migrationsMap.get(pluginId);
+        getLastMigrationVersion(pluginKey) {
+            const migrations = migrationsMap.get(pluginKey);
             return migrations?.[migrations.length - 1]?.version;
         },
     };
@@ -1696,7 +1518,7 @@ function runPluginMigrations(projectDefinition, pluginImplementationStore) {
     setAutoFreeze(false);
     return produce(projectDefinition, (draft) => {
         for (const pluginDefinition of draft.plugins ?? []) {
-            const pluginMigrations = pluginConfigService.getMigrations(pluginEntityType.toUid(pluginDefinition.id));
+            const pluginMigrations = pluginConfigService.getMigrations(pluginEntityType.keyFromId(pluginDefinition.id));
             const currentSchemaVersion = pluginDefinition.configSchemaVersion ?? -1;
             if (!pluginMigrations)
                 continue;
@@ -2448,107 +2270,6 @@ const AppUtils = {
     getBackendRelativePath,
 };
 
-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]);
-}
-
 /**
  * Resolves entity names in a ZodRefPayload.
  *
@@ -2847,7 +2568,7 @@ const palettesSchema = z$i.object({
     base: paletteSchema,
     primary: paletteSchema,
 });
-const themeSchema = z$i.object({
+const createThemeSchema = definitionSchema(() => z$i.object({
     palettes: z$i.object({
         base: paletteSchema,
         primary: paletteSchema,
@@ -2856,7 +2577,7 @@ const themeSchema = z$i.object({
         light: themeColorSchema,
         dark: themeColorSchema,
     }),
-});
+}));
 
 const {z: z$h} = await importShared('zod');
 
@@ -2877,19 +2598,6 @@ const VALIDATORS = {
         .optional(),
 };
 
-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,
-});
-
 const {z: z$g} = await importShared('zod');
 const roleArray = z$g
     .array(zRef(z$g.string(), {
@@ -2897,7 +2605,7 @@ const roleArray = z$g
     onDelete: 'DELETE',
 }))
     .optional();
-const modelGraphqlSchema = z$g.object({
+const createModelGraphqlSchema = definitionSchema(() => z$g.object({
     objectType: z$g
         .object({
         enabled: z$g.boolean().default(false),
@@ -2981,7 +2689,7 @@ const modelGraphqlSchema = z$g.object({
         }),
     })
         .default({}),
-});
+}));
 
 const {z: z$f} = await importShared('zod');
 
@@ -2997,15 +2705,15 @@ function createModelTransformerType(payload) {
 }
 
 const {z: z$e} = await importShared('zod');
-const passwordTransformerSchema = zEnt(z$e.object({
+const createPasswordTransformerSchema = definitionSchema(() => zEnt(z$e.object({
     ...baseTransformerFields,
     type: z$e.literal('password'),
 }), {
     type: modelTransformerEntityType,
     parentPath: { context: 'model' },
     getNameResolver: () => 'password',
-});
-const embeddedRelationTransformerSchema = zEnt(z$e.object({
+}));
+const createEmbeddedRelationTransformerSchema = definitionSchema(() => zEnt(z$e.object({
     ...baseTransformerFields,
     foreignRelationRef: zRef(z$e.string().min(1), {
         type: modelForeignRelationEntityType,
@@ -3038,16 +2746,16 @@ const embeddedRelationTransformerSchema = zEnt(z$e.object({
     }),
 }).refBuilder((builder) => {
     builder.addPathToContext('modelRef', modelEntityType, 'embeddedModel');
-});
+}));
 const BUILT_IN_TRANSFORMERS = [
     createModelTransformerType({
         name: 'password',
-        schema: passwordTransformerSchema,
+        schema: createPasswordTransformerSchema,
         getName: () => 'Password',
     }),
     createModelTransformerType({
         name: 'embeddedRelation',
-        schema: embeddedRelationTransformerSchema,
+        schema: createEmbeddedRelationTransformerSchema,
         getName: (definitionContainer, definition) => definitionContainer.nameFromId(definition.foreignRelationRef),
     }),
 ];
@@ -3063,10 +2771,6 @@ function createModelTransformerImplementation() {
             if (transformers[transformer.name]) {
                 throw new Error(`Model transformer with name ${transformer.name} is already registered`);
             }
-            // check transformer schema is a zEnt
-            if (!(transformer.schema instanceof ZodRef)) {
-                throw new TypeError(`Model transformer schema for ${transformer.name} is not a zEnt`);
-            }
             transformers[transformer.name] =
                 transformer;
         },
@@ -3089,38 +2793,38 @@ const modelTransformerSpec = createPluginSpec('core/model-transformer', {
     defaultInitializer: createModelTransformerImplementation,
 });
 
-const transformerSchema = zWithPlugins((plugins, data) => {
+const createTransformerSchema = definitionSchema((ctx) => zWithPlugins((plugins, data) => {
     const { type } = baseTransformerSchema.parse(data);
     const transformer = plugins
         .getPluginSpec(modelTransformerSpec)
         .getModelTransformer(type);
-    return transformer.schema;
-});
+    return transformer.schema(ctx);
+}));
 
 const {z: z$d} = await importShared('zod');
-const enumValueSchema = zEnt(z$d.object({
+const createEnumValueSchema = definitionSchema(() => zEnt(z$d.object({
     name: z$d.string().min(1),
     friendlyName: z$d.string().min(1),
 }), {
     type: modelEnumValueEntityType,
     parentPath: { context: 'enum' },
-});
-const enumBaseSchema = z$d.object({
+}));
+const createEnumBaseSchema = definitionSchema((ctx) => z$d.object({
     name: z$d.string().min(1),
     featureRef: zRef(z$d.string().min(1), {
         type: featureEntityType,
         onDelete: 'RESTRICT',
     }),
-    values: z$d.array(enumValueSchema),
+    values: z$d.array(createEnumValueSchema(ctx)),
     isExposed: z$d.boolean(),
-});
-const enumSchema = zEnt(enumBaseSchema, {
+}));
+const createEnumSchema = definitionSchema((ctx) => zEnt(createEnumBaseSchema(ctx), {
     type: modelEnumEntityType,
     addContext: 'enum',
-});
+}));
 
 const {z: z$c} = await importShared('zod');
-const modelScalarFieldSchema = zEnt(z$c.object({
+const createModelScalarFieldSchema = definitionSchema(() => zEnt(z$c.object({
     name: VALIDATORS.CAMEL_CASE_STRING,
     type: z$c.enum(SCALAR_FIELD_TYPES),
     isOptional: z$c.boolean().default(false),
@@ -3182,7 +2886,7 @@ const modelScalarFieldSchema = zEnt(z$c.object({
         };
     }
     return value;
-});
+}));
 const REFERENTIAL_ACTIONS = [
     'Cascade',
     'Restrict',
@@ -3190,7 +2894,7 @@ const REFERENTIAL_ACTIONS = [
     'SetNull',
     'SetDefault',
 ];
-const modelRelationFieldSchema = zRefBuilder(z$c.object({
+const createModelRelationFieldSchema = definitionSchema(() => zRefBuilder(z$c.object({
     id: zRefId,
     foreignId: z$c
         .string()
@@ -3229,8 +2933,8 @@ const modelRelationFieldSchema = zRefBuilder(z$c.object({
         getNameResolver: (entity) => entity.foreignRelationName,
         parentPath: 'modelRef',
     });
-});
-const modelUniqueConstraintSchema = zEnt(z$c.object({
+}));
+const createModelUniqueConstraintSchema = definitionSchema(() => zEnt(z$c.object({
     fields: z$c.array(z$c.object({
         fieldRef: zRef(z$c.string().min(1), {
             type: modelScalarFieldEntityType,
@@ -3247,8 +2951,8 @@ const modelUniqueConstraintSchema = zEnt(z$c.object({
             resolveName: (entityNames) => entityNames.fields.join('_'),
         });
     },
-});
-const modelServiceSchema = z$c.object({
+}));
+const createModelServiceSchema = definitionSchema((ctx) => z$c.object({
     create: z$c
         .object({
         enabled: z$c.boolean().default(false),
@@ -3294,9 +2998,9 @@ const modelServiceSchema = z$c.object({
         .default({
         enabled: false,
     }),
-    transformers: z$c.array(transformerSchema).default([]),
-});
-const modelBaseSchema = z$c.object({
+    transformers: z$c.array(createTransformerSchema(ctx)).default([]),
+}));
+const createModelBaseSchema = definitionSchema((ctx) => z$c.object({
     id: zRefId,
     name: VALIDATORS.PASCAL_CASE_STRING,
     featureRef: zRef(z$c.string().min(1), {
@@ -3304,8 +3008,8 @@ const modelBaseSchema = z$c.object({
         onDelete: 'RESTRICT',
     }),
     model: z$c.object({
-        fields: z$c.array(modelScalarFieldSchema),
-        relations: z$c.array(modelRelationFieldSchema).optional(),
+        fields: z$c.array(createModelScalarFieldSchema(ctx)),
+        relations: z$c.array(createModelRelationFieldSchema(ctx)).optional(),
         primaryKeyFieldRefs: z$c
             .array(zRef(z$c.string(), {
             type: modelScalarFieldEntityType,
@@ -3313,20 +3017,22 @@ const modelBaseSchema = z$c.object({
             parentPath: { context: 'model' },
         }))
             .min(1),
-        uniqueConstraints: z$c.array(modelUniqueConstraintSchema).optional(),
+        uniqueConstraints: z$c
+            .array(createModelUniqueConstraintSchema(ctx))
+            .optional(),
     }),
-    service: modelServiceSchema.default({
+    service: createModelServiceSchema(ctx).default({
         create: { enabled: false },
         update: { enabled: false },
         delete: { enabled: false },
         transformers: [],
     }),
-    graphql: modelGraphqlSchema.optional(),
-});
-const modelSchema = zEnt(modelBaseSchema, {
+    graphql: createModelGraphqlSchema(ctx).optional(),
+}));
+const createModelSchema = definitionSchema((ctx) => zEnt(createModelBaseSchema(ctx), {
     type: modelEntityType,
     addContext: 'model',
-});
+}));
 
 const adminSectionEntityType = createEntityType('admin-section', {
     parentType: appEntityType,
@@ -3357,7 +3063,7 @@ const adminCrudEmbeddedFormEntityType = createEntityType('admin-crud-embedded-fo
 });
 
 const {z: z$9} = await importShared('zod');
-const adminCrudTextInputSchema = z$9.object({
+const createAdminCrudTextInputSchema = definitionSchema(() => z$9.object({
     type: z$9.literal('text'),
     label: z$9.string().min(1),
     modelFieldRef: zRef(z$9.string(), {
@@ -3366,12 +3072,12 @@ const adminCrudTextInputSchema = z$9.object({
         parentPath: { context: 'model' },
     }),
     validation: z$9.string().optional(),
-});
+}));
 const adminCrudTextInputType = createAdminCrudInputType({
     name: 'text',
-    schema: adminCrudTextInputSchema,
+    schema: createAdminCrudTextInputSchema,
 });
-const adminCrudForeignInputSchema = z$9.object({
+const createAdminCrudForeignInputSchema = definitionSchema(() => z$9.object({
     type: z$9.literal('foreign'),
     label: z$9.string().min(1),
     localRelationRef: zRef(z$9.string(), {
@@ -3383,12 +3089,12 @@ const adminCrudForeignInputSchema = z$9.object({
     valueExpression: z$9.string().min(1),
     defaultLabel: z$9.string().optional(),
     nullLabel: z$9.string().optional(),
-});
+}));
 const adminCrudForeignInputType = createAdminCrudInputType({
     name: 'foreign',
-    schema: adminCrudForeignInputSchema,
+    schema: createAdminCrudForeignInputSchema,
 });
-const adminCrudEnumInputSchema = z$9.object({
+const createAdminCrudEnumInputSchema = definitionSchema(() => z$9.object({
     type: z$9.literal('enum'),
     label: z$9.string().min(1),
     modelFieldRef: zRef(z$9.string(), {
@@ -3396,12 +3102,12 @@ const adminCrudEnumInputSchema = z$9.object({
         onDelete: 'RESTRICT',
         parentPath: { context: 'model' },
     }),
-});
+}));
 const adminCrudEnumInputType = createAdminCrudInputType({
     name: 'enum',
-    schema: adminCrudEnumInputSchema,
+    schema: createAdminCrudEnumInputSchema,
 });
-const adminCrudEmbeddedInputSchema = z$9.object({
+const createAdminCrudEmbeddedInputSchema = definitionSchema(() => z$9.object({
     type: z$9.literal('embedded'),
     label: z$9.string().min(1),
     modelRelationRef: zRef(z$9.string(), {
@@ -3414,12 +3120,12 @@ const adminCrudEmbeddedInputSchema = z$9.object({
         parentPath: { context: 'admin-section' },
         onDelete: 'RESTRICT',
     }),
-});
+}));
 const adminCrudEmbeddedInputType = createAdminCrudInputType({
     name: 'embedded',
-    schema: adminCrudEmbeddedInputSchema,
+    schema: createAdminCrudEmbeddedInputSchema,
 });
-const adminCrudEmbeddedLocalInputSchema = z$9.object({
+const createAdminCrudEmbeddedLocalInputSchema = definitionSchema(() => z$9.object({
     type: z$9.literal('embeddedLocal'),
     label: z$9.string().min(1),
     localRelationRef: zRef(z$9.string(), {
@@ -3432,18 +3138,18 @@ const adminCrudEmbeddedLocalInputSchema = z$9.object({
         parentPath: { context: 'admin-section' },
         onDelete: 'RESTRICT',
     }),
-});
+}));
 const adminCrudEmbeddedLocalInputType = createAdminCrudInputType({
     name: 'embeddedLocal',
-    schema: adminCrudEmbeddedLocalInputSchema,
+    schema: createAdminCrudEmbeddedLocalInputSchema,
 });
-const adminCrudPasswordInputSchema = z$9.object({
+const createAdminCrudPasswordInputSchema = definitionSchema(() => z$9.object({
     type: z$9.literal('password'),
     label: z$9.string().min(1),
-});
+}));
 const adminCrudPasswordInputType = createAdminCrudInputType({
     name: 'password',
-    schema: adminCrudPasswordInputSchema,
+    schema: createAdminCrudPasswordInputSchema,
 });
 const BUILT_IN_ADMIN_CRUD_INPUTS = [
     adminCrudTextInputType,
@@ -3482,17 +3188,17 @@ const adminCrudInputSpec = createPluginSpec('core/admin-crud-input', {
     defaultInitializer: createAdminCrudInputImplementation,
 });
 
-const adminCrudInputSchema = zWithPlugins((plugins, data) => {
+const createAdminCrudInputSchema = definitionSchema((ctx) => zWithPlugins((plugins, data) => {
     const { type } = baseAdminCrudInputSchema.parse(data);
     const input = plugins
         .getPluginSpec(adminCrudInputSpec)
         .getAdminCrudInput(type);
-    return input.schema;
-});
+    return input.schema(ctx);
+}));
 
 const {z: z$8} = await importShared('zod');
 // Table Columns
-const adminCrudForeignDisplaySchema = z$8.object({
+const createAdminCrudForeignDisplaySchema = definitionSchema(() => z$8.object({
     type: z$8.literal('foreign'),
     localRelationRef: zRef(z$8.string(), {
         type: modelLocalRelationEntityType,
@@ -3501,31 +3207,27 @@ const adminCrudForeignDisplaySchema = z$8.object({
     }),
     labelExpression: z$8.string().min(1),
     valueExpression: z$8.string().min(1),
-});
-const adminCrudTextDisplaySchema = z$8.object({
+}));
+const createAdminCrudTextDisplaySchema = definitionSchema(() => z$8.object({
     type: z$8.literal('text'),
     modelFieldRef: zRef(z$8.string(), {
         type: modelScalarFieldEntityType,
         onDelete: 'RESTRICT',
         parentPath: { context: 'model' },
     }),
-});
-const adminCrudDisplaySchema = z$8.discriminatedUnion('type', [
-    adminCrudTextDisplaySchema,
-    adminCrudForeignDisplaySchema,
-]);
-function primitiveMapToKeys(map) {
-    return [...map.keys()]
-        .map((m) => m?.valueOf())
-        .filter((x) => x !== undefined);
-}
-const adminCrudDisplayTypes = primitiveMapToKeys(adminCrudDisplaySchema.optionsMap);
-const adminCrudTableColumnSchema = z$8.object({
+}));
+const createAdminCrudDisplaySchema = definitionSchema((ctx) => z$8.discriminatedUnion('type', [
+    createAdminCrudTextDisplaySchema(ctx),
+    createAdminCrudForeignDisplaySchema(ctx),
+]));
+// TODO: Improve this to be more dynamic in the future
+const adminCrudDisplayTypes = ['text', 'foreign'];
+const createAdminCrudTableColumnSchema = definitionSchema((ctx) => z$8.object({
     label: z$8.string().min(1),
-    display: adminCrudDisplaySchema,
-});
+    display: createAdminCrudDisplaySchema(ctx),
+}));
 // Embedded Crud
-const adminCrudEmbeddedObjectSchema = z$8.object({
+const createAdminCrudEmbeddedObjectSchema = definitionSchema((ctx) => z$8.object({
     id: z$8.string().min(1),
     name: z$8.string().min(1),
     modelRef: zRef(z$8.string().min(1), {
@@ -3535,10 +3237,10 @@ const adminCrudEmbeddedObjectSchema = z$8.object({
     includeIdField: z$8.boolean().optional(),
     type: z$8.literal('object'),
     form: z$8.object({
-        fields: z$8.array(adminCrudInputSchema),
+        fields: z$8.array(createAdminCrudInputSchema(ctx)),
     }),
-});
-const adminCrudEmbeddedListSchema = z$8.object({
+}));
+const createAdminCrudEmbeddedListSchema = definitionSchema((ctx) => z$8.object({
     id: z$8.string().min(1),
     name: z$8.string().min(1),
     modelRef: zRef(z$8.string().min(1), {
@@ -3550,24 +3252,24 @@ const adminCrudEmbeddedListSchema = z$8.object({
     // NOTE: These two fields need to be synced with crud section schema
     // because the web app expects that (TODO)
     table: z$8.object({
-        columns: z$8.array(adminCrudTableColumnSchema),
+        columns: z$8.array(createAdminCrudTableColumnSchema(ctx)),
     }),
     form: z$8.object({
-        fields: z$8.array(adminCrudInputSchema),
+        fields: z$8.array(createAdminCrudInputSchema(ctx)),
     }),
-});
-const adminCrudEmbeddedFormSchema = zRefBuilder(z$8.discriminatedUnion('type', [
-    adminCrudEmbeddedObjectSchema,
-    adminCrudEmbeddedListSchema,
+}));
+const createAdminCrudEmbeddedFormSchema = definitionSchema((ctx) => zRefBuilder(z$8.discriminatedUnion('type', [
+    createAdminCrudEmbeddedObjectSchema(ctx),
+    createAdminCrudEmbeddedListSchema(ctx),
 ]), (builder) => {
     builder.addEntity({
         type: adminCrudEmbeddedFormEntityType,
         parentPath: { context: 'admin-section' },
     });
     builder.addPathToContext('modelRef', modelEntityType, 'model');
-});
+}));
 // Admin Section
-const adminCrudSectionSchema = zRefBuilder(z$8.object({
+const createAdminCrudSectionSchema = definitionSchema((ctx) => zRefBuilder(z$8.object({
     ...baseAdminSectionValidators,
     type: z$8.literal('crud'),
     modelRef: zRef(z$8.string().min(1), {
@@ -3576,25 +3278,25 @@ const adminCrudSectionSchema = zRefBuilder(z$8.object({
     }),
     disableCreate: z$8.boolean().optional(),
     table: z$8.object({
-        columns: z$8.array(adminCrudTableColumnSchema),
+        columns: z$8.array(createAdminCrudTableColumnSchema(ctx)),
     }),
     form: z$8.object({
-        fields: z$8.array(adminCrudInputSchema),
+        fields: z$8.array(createAdminCrudInputSchema(ctx)),
     }),
-    embeddedForms: z$8.array(adminCrudEmbeddedFormSchema).optional(),
+    embeddedForms: z$8.array(createAdminCrudEmbeddedFormSchema(ctx)).optional(),
 }), (builder) => {
     builder.addPathToContext('modelRef', modelEntityType, 'model');
-});
+}));
 
 const {z: z$7} = await importShared('zod');
-const adminSectionSchema = zRefBuilder(adminCrudSectionSchema, (builder) => {
+const createAdminSectionSchema = definitionSchema((ctx) => zRefBuilder(createAdminCrudSectionSchema(ctx), (builder) => {
     builder.addEntity({
         type: adminSectionEntityType,
         parentPath: { context: 'app' },
         addContext: 'admin-section',
     });
-});
-const adminAppSchema = z$7.object({
+}));
+const createAdminAppSchema = definitionSchema((ctx) => z$7.object({
     ...baseAppValidators,
     type: z$7.literal('admin'),
     allowedRoles: z$7
@@ -3603,12 +3305,12 @@ const adminAppSchema = z$7.object({
         onDelete: 'DELETE',
     }))
         .optional(),
-    sections: z$7.array(adminSectionSchema).optional(),
-});
+    sections: z$7.array(createAdminSectionSchema(ctx)).optional(),
+}));
 const adminAppEntryType = createAppEntryType('admin');
 
 const {z: z$6} = await importShared('zod');
-const backendAppSchema = z$6.object({
+const createBackendAppSchema = definitionSchema(() => z$6.object({
     ...baseAppValidators,
     type: z$6.literal('backend'),
     enableStripe: z$6.boolean().optional(),
@@ -3617,11 +3319,11 @@ const backendAppSchema = z$6.object({
     enablePostmark: z$6.boolean().optional(),
     enableSubscriptions: z$6.boolean().optional(),
     enableAxios: z$6.boolean().optional(),
-});
+}));
 const backendAppEntryType = createAppEntryType('backend');
 
 const {z: z$5} = await importShared('zod');
-const webAppSchema = z$5.object({
+const createWebAppSchema = definitionSchema(() => z$5.object({
     ...baseAppValidators,
     type: z$5.literal('web'),
     includeAuth: z$5.boolean().optional(),
@@ -3635,41 +3337,38 @@ const webAppSchema = z$5.object({
         .optional(),
     includeUploadComponents: z$5.boolean().optional(),
     enableSubscriptions: z$5.boolean().optional(),
-});
+}));
 const webAppEntryType = createAppEntryType('web');
 
-function definitionSchema(creator) {
-    return (options) => creator(options);
-}
-
 const {z: z$4} = await importShared('zod');
-const basePluginDefinitionSchema = zEnt(z$4.object({
+const basePluginDefinitionSchema = z$4.object({
+    id: z$4.string().min(1),
     packageName: z$4.string(),
     name: z$4.string(),
     version: z$4.string(),
     config: z$4.unknown(),
     configSchemaVersion: z$4.number().optional(),
-}), {
-    type: pluginEntityType,
 });
-const pluginWithConfigSchema = zWithPlugins((plugins, data) => {
-    const parsedBasePluginSchema = basePluginDefinitionSchema.parse(data);
-    const pluginId = pluginEntityType.toUid(parsedBasePluginSchema.id);
+const createPluginWithConfigSchema = definitionSchema(() => zWithPlugins((plugins, data) => {
+    const parsedBasePlugin = basePluginDefinitionSchema.parse(data);
+    const pluginKey = pluginEntityType.keyFromId(parsedBasePlugin.id);
     const configSchema = plugins
         .getPluginSpec(pluginConfigSpec)
-        .getSchema(pluginId);
+        .getSchema(pluginKey);
+    const pluginDefinitionWithEnt = zEnt(basePluginDefinitionSchema, {
+        type: pluginEntityType,
+    });
     if (!configSchema) {
-        return basePluginDefinitionSchema;
+        return pluginDefinitionWithEnt;
     }
-    return basePluginDefinitionSchema.and(z$4.object({
+    return pluginDefinitionWithEnt.and(z$4.object({
         config: configSchema,
     }));
-});
-const pluginsSchema = z$4.array(pluginWithConfigSchema);
+}));
+const createPluginsSchema = definitionSchema((ctx) => z$4.array(createPluginWithConfigSchema(ctx)));
 
 const {z: z$3} = await importShared('zod');
-
-const templateExtractorSchema = z$3.object({
+const createTemplateExtractorSchema = definitionSchema(() => z$3.object({
     /**
      * Whether to write template extractor metadata when writing files to the project.
      *
@@ -3684,7 +3383,7 @@ const templateExtractorSchema = z$3.object({
      * The list is delimited by a newline and can include a * to match any number of characters.
      */
     fileIdRegexWhitelist: z$3.string().default(''),
-});
+}));
 
 const {z: z$2} = await importShared('zod');
 const generalSettingsSchema = z$2.object({
@@ -3708,32 +3407,32 @@ const generalSettingsSchema = z$2.object({
         .int()
         .refine((portOffset) => portOffset % 1000 === 0, 'Port offset must be a multiple of 1000, e.g. 1000, 2000, 3000, etc.'),
 });
-const createSettingsSchema = definitionSchema(() => z$2.object({
+const createSettingsSchema = definitionSchema((ctx) => z$2.object({
     general: generalSettingsSchema,
-    templateExtractor: templateExtractorSchema.optional(),
-    theme: themeSchema.optional(),
+    templateExtractor: createTemplateExtractorSchema(ctx).optional(),
+    theme: createThemeSchema(ctx).optional(),
 }));
 
 const {z: z$1} = await importShared('zod');
-const appSchema = zRefBuilder(z$1.discriminatedUnion('type', [
-    backendAppSchema,
-    webAppSchema,
-    adminAppSchema,
+const createAppSchema = definitionSchema((ctx) => zRefBuilder(z$1.discriminatedUnion('type', [
+    createBackendAppSchema(ctx),
+    createWebAppSchema(ctx),
+    createAdminAppSchema(ctx),
 ]), (builder) => {
     builder.addEntity({
         type: appEntityType,
         addContext: 'app',
     });
-});
+}));
 const createProjectDefinitionSchema = definitionSchema((ctx) => z$1.object({
     cliVersion: z$1.string().nullish(),
-    apps: z$1.array(appSchema).default([]),
-    features: featuresSchema,
-    models: z$1.array(modelSchema).default([]),
-    enums: z$1.array(enumSchema).optional(),
+    apps: z$1.array(createAppSchema(ctx)).default([]),
+    features: createFeaturesSchema(ctx),
+    models: z$1.array(createModelSchema(ctx)).default([]),
+    enums: z$1.array(createEnumSchema(ctx)).optional(),
     isInitialized: z$1.boolean().default(false),
     schemaVersion: z$1.number(),
-    plugins: pluginsSchema.optional(),
+    plugins: createPluginsSchema(ctx).optional(),
     settings: createSettingsSchema(ctx),
 }));
 
@@ -3848,7 +3547,7 @@ function getTransformName(definitionContainer, transformer, pluginStore) {
 const ModelTransformerUtils = { getTransformer, getTransformName };
 
 function byId(projectDefinition, id) {
-    const pluginEntityId = pluginEntityType.fromUid(id);
+    const pluginEntityId = pluginEntityType.idFromKey(id);
     const plugin = projectDefinition.plugins?.find((m) => m.id === pluginEntityId);
     return plugin ?? null;
 }
@@ -3865,7 +3564,7 @@ function configByIdOrThrow(projectDefinition, id) {
 }
 function setPluginConfig(projectDefinition, plugin, pluginConfig, pluginImplementationStore) {
     const plugins = projectDefinition.plugins ?? [];
-    const pluginEntityId = pluginEntityType.fromUid(plugin.id);
+    const pluginEntityId = pluginEntityType.idFromKey(plugin.id);
     const pluginConfigService = pluginImplementationStore.getPluginSpec(pluginConfigSpec);
     const lastMigrationVersion = pluginConfigService.getLastMigrationVersion(plugin.id);
     projectDefinition.plugins = plugins.some((p) => p.id === pluginEntityId)
@@ -8934,7 +8633,7 @@ const migration011PluginId = createSchemaMigration({
     version: 11,
     name: 'pluginId',
     description: 'Convert plugin ids to use the plugin entity type',
-    migrate: (config) => transformJsonPath(config, 'plugins.*.id', (id) => pluginEntityType.fromUid(id)),
+    migrate: (config) => transformJsonPath(config, 'plugins.*.id', (id) => pluginEntityType.idFromKey(id)),
 });
 
 const migration012MigrateAuthConfig = createSchemaMigration({
@@ -9112,6 +8811,12 @@ function createTestProjectDefinition(input = {}) {
         ...input,
     };
 }
+function createTestProjectDefinitionInput(input = {}) {
+    return {
+        ...createTestProjectDefinition(),
+        ...input,
+    };
+}
 function createTestProjectDefinitionContainer(input = {}) {
     const pluginStore = {
         availablePlugins: [],
@@ -9121,384 +8826,12 @@ function createTestProjectDefinitionContainer(input = {}) {
         plugins: pluginImplementationStore,
     });
     const schemaWithPlugins = zPluginWrapper(projectDefinitionSchema, pluginImplementationStore);
-    const resolvedRefPayload = deserializeSchemaWithReferences(schemaWithPlugins, createTestProjectDefinition(input));
+    const resolvedRefPayload = deserializeSchemaWithReferences(schemaWithPlugins, createTestProjectDefinitionInput(input));
     return new ProjectDefinitionContainer(resolvedRefPayload, { pluginStore }, pluginImplementationStore);
 }
 
 const AVAILABLE_FLAGS = ['TEMPLATE_EXTRACTOR'];
 
-/**
- * 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;
-    }
-}
-/**
- * A field that is a replacement for the entire object or array.
- */
-class DefinitionDiffReplacementField extends DefinitionDiffField {
-    diff(current, desired) {
-        if (!isMatch(current, desired)) {
-            return [{ type: 'update', key: '*', item: desired }];
-        }
-        return [];
-    }
-    apply(current, diff) {
-        if (diff.length === 0)
-            return current;
-        return diff[0].item;
-    }
-}
-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$1(current, key), get$1(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$1(clonedCurrent, key);
-        set$1(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('uniqueConstraints', (c) => getUniqueConstraintKey(c)),
-    'model.primaryKeyFieldRefs': new DefinitionDiffReplacementField('primaryKeyFieldRefs'),
-});
-/**
- * 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 nameFromId = (id) => siblingModelFieldIdMap.get(id) ?? definitionContainer.nameFromId(id);
-    return {
-        ...input,
-        model: {
-            ...input.model,
-            relations: input.model.relations?.map((r) => ({
-                ...r,
-                references: r.references.map((reference) => ({
-                    ...reference,
-                    localRef: nameFromId(reference.localRef),
-                    foreignRef: nameFromId(reference.foreignRef),
-                })),
-            })),
-            uniqueConstraints: input.model.uniqueConstraints?.map((c) => ({
-                ...c,
-                fields: c.fields.map((f) => ({
-                    ...f,
-                    fieldRef: nameFromId(f.fieldRef),
-                })),
-            })),
-            primaryKeyFieldRefs: input.model.primaryKeyFieldRefs.map(nameFromId),
-        },
-    };
-}
-/**
- * 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) {
-    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;
-    };
-    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)),
-        },
-    };
-}
-/**
- * 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;
-        }),
-    };
-}
-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);
-}
-
 /**
  * Convert a color name to a hex color. Can be one of the following:
  * - A fixed color name (e.g. 'white', 'black').
@@ -10555,5 +9888,5 @@ function generateDefaultTheme() {
     };
 }
 
-export { AVAILABLE_FLAGS, AppUtils, BUILT_IN_ADMIN_CRUD_INPUTS, BUILT_IN_TRANSFORMERS, COLOR_PALETTES, DefinitionDiffKeyedArrayField, DefinitionDiffReplacementField, EnumUtils, FIXED_COLOR_MAPPINGS, ModelFieldUtils, ModelTransformerUtils, ModelUtils, PALETTE_SHADES, PluginImplementationStore, PluginUtils, ProjectDefinitionContainer, REFERENTIAL_ACTIONS, SCALAR_FIELD_TYPES, SCHEMA_MIGRATIONS, SchemaMigrationError, THEME_COLORS, THEME_COLOR_KEYS, VALIDATORS, ZodRef, ZodRefWrapper, ZodWithPlugins, adminAppEntryType, adminAppSchema, adminCrudDisplaySchema, adminCrudDisplayTypes, adminCrudEmbeddedFormEntityType, adminCrudEmbeddedFormSchema, adminCrudEmbeddedInputSchema, adminCrudEmbeddedInputType, adminCrudEmbeddedListSchema, adminCrudEmbeddedLocalInputSchema, adminCrudEmbeddedLocalInputType, adminCrudEmbeddedObjectSchema, adminCrudEnumInputSchema, adminCrudForeignDisplaySchema, adminCrudForeignInputSchema, adminCrudInputCompilerSpec, adminCrudInputSchema, adminCrudInputSpec, adminCrudPasswordInputSchema, adminCrudSectionSchema, adminCrudTableColumnSchema, adminCrudTextDisplaySchema, adminCrudTextInputSchema, adminSectionEntityType, adminSectionSchema, appCompilerSpec, appEntityType, appSchema, applyDefinitionDiff, applyModelMergerDiff, applyModelMergerResultInPlace, authConfigSpec, authRoleEntityType, backendAppEntryType, backendAppSchema, baseAdminCrudInputSchema, baseAdminSectionValidators, baseAppSchema, baseAppValidators, basePluginDefinitionSchema, baseTransformerFields, baseTransformerSchema, convertColorNameToOklch, convertHexToOklch, convertOklchToColorName, convertOklchToHex, createAdminCrudInputCompilerImplementation, createAdminCrudInputImplementation, createAdminCrudInputType, createAndApplyModelMergerResults, createAppCompiler, createAppCompilerPlugin, createAppEntryType, createDefinitionDiff, createDefinitionDiffConfig, createDefinitionEntityNameResolver, createEntityType, createModelMergerResult, createModelMergerResults, createModelTransformerCompilerImplementation, createModelTransformerImplementation, createModelTransformerType, createPlatformPluginExport, createPluginConfigImplementation, createPluginImplementationStore, createPluginSpec, createProjectDefinitionSchema, createProjectDefinitionSchemaWithContext, createSettingsSchema, createTestProjectDefinition, createTestProjectDefinitionContainer, createWebConfigImplementation, definitionSchema, deserializeSchemaWithReferences, embeddedRelationTransformerSchema, enumBaseSchema, enumSchema, enumValueSchema, featureEntityType, featuresSchema, fixRefDeletions, generalSettingsSchema, generateCssFromThemeConfig, generateDefaultTheme, generateThemeColorsFromShade, getBackendRelativePath, getDefaultThemeColorFromShade, getLatestMigrationVersion, initializePlugins, isMigrateableProjectDefinition, modelBaseSchema, modelEntityType, modelEnumEntityType, modelEnumValueEntityType, modelForeignRelationEntityType, modelGraphqlSchema, modelLocalRelationEntityType, modelMergerDefinitionDiffConfig, modelRelationFieldSchema, modelScalarFieldEntityType, modelScalarFieldSchema, modelSchema, modelServiceSchema, modelTransformerCompilerSpec, modelTransformerEntityType, modelTransformerSpec, modelUniqueConstraintEntityType, modelUniqueConstraintSchema, oklchColor, paletteSchema, palettesSchema, parseOklch, parseProjectDefinitionWithContext, parseProjectDefinitionWithReferences, passwordTransformerSchema, pluginConfigSpec, pluginEntityType, pluginManifestJsonSchema, pluginMetadataSchema, pluginSpecDependencySchema, pluginSpecSupportSchema, pluginWithConfigSchema, pluginsSchema, runPluginMigrations, runSchemaMigrations, serializeSchema, serializeSchemaFromRefPayload, stripEmptyGeneratorChildren, stripUndefinedValues, templateExtractorSchema, themeColorSchema, themeSchema, transformerSchema, undefinedIfEmpty, undefinedIfFalsy, webAppEntryType, webAppSchema, webConfigSpec, zEnt, zPluginWrapper, zRef, zRefBuilder, zRefId, zWithPlugins };
-//# sourceMappingURL=project-builder-lib-B62IPizQ.js.map
+export { AVAILABLE_FLAGS, AppUtils, BUILT_IN_ADMIN_CRUD_INPUTS, BUILT_IN_TRANSFORMERS, COLOR_PALETTES, EnumUtils, FIXED_COLOR_MAPPINGS, ModelFieldUtils, ModelTransformerUtils, ModelUtils, PALETTE_SHADES, PluginImplementationStore, PluginUtils, ProjectDefinitionContainer, REFERENTIAL_ACTIONS, SCALAR_FIELD_TYPES, SCHEMA_MIGRATIONS, SchemaMigrationError, THEME_COLORS, THEME_COLOR_KEYS, VALIDATORS, ZodRefWrapper, ZodWithPlugins, adminAppEntryType, adminCrudDisplayTypes, adminCrudEmbeddedFormEntityType, adminCrudEmbeddedInputType, adminCrudEmbeddedLocalInputType, adminCrudInputCompilerSpec, adminCrudInputSpec, adminSectionEntityType, appCompilerSpec, appEntityType, authConfigSpec, authRoleEntityType, backendAppEntryType, baseAdminCrudInputSchema, baseAdminSectionValidators, baseAppSchema, baseAppValidators, basePluginDefinitionSchema, baseTransformerFields, baseTransformerSchema, convertColorNameToOklch, convertHexToOklch, convertOklchToColorName, convertOklchToHex, createAdminAppSchema, createAdminCrudDisplaySchema, createAdminCrudEmbeddedFormSchema, createAdminCrudEmbeddedInputSchema, createAdminCrudEmbeddedListSchema, createAdminCrudEmbeddedLocalInputSchema, createAdminCrudEmbeddedObjectSchema, createAdminCrudEnumInputSchema, createAdminCrudForeignDisplaySchema, createAdminCrudForeignInputSchema, createAdminCrudInputCompilerImplementation, createAdminCrudInputImplementation, createAdminCrudInputSchema, createAdminCrudInputType, createAdminCrudPasswordInputSchema, createAdminCrudSectionSchema, createAdminCrudTableColumnSchema, createAdminCrudTextDisplaySchema, createAdminCrudTextInputSchema, createAdminSectionSchema, createAppCompiler, createAppCompilerPlugin, createAppEntryType, createAppSchema, createBackendAppSchema, createDefinitionEntityNameResolver, createEmbeddedRelationTransformerSchema, createEntityType, createEnumBaseSchema, createEnumSchema, createEnumValueSchema, createFeaturesSchema, createModelBaseSchema, createModelGraphqlSchema, createModelRelationFieldSchema, createModelScalarFieldSchema, createModelSchema, createModelServiceSchema, createModelTransformerCompilerImplementation, createModelTransformerImplementation, createModelTransformerType, createModelUniqueConstraintSchema, createPasswordTransformerSchema, createPlatformPluginExport, createPluginConfigImplementation, createPluginImplementationStore, createPluginSpec, createPluginWithConfigSchema, createPluginsSchema, createProjectDefinitionSchema, createProjectDefinitionSchemaWithContext, createSettingsSchema, createTemplateExtractorSchema, createTestProjectDefinition, createTestProjectDefinitionContainer, createTestProjectDefinitionInput, createThemeSchema, createTransformerSchema, createWebAppSchema, createWebConfigImplementation, definitionSchema, deserializeSchemaWithReferences, featureEntityType, fixRefDeletions, generalSettingsSchema, generateCssFromThemeConfig, generateDefaultTheme, generateThemeColorsFromShade, getBackendRelativePath, getDefaultThemeColorFromShade, getLatestMigrationVersion, initializePlugins, isMigrateableProjectDefinition, modelEntityType, modelEnumEntityType, modelEnumValueEntityType, modelForeignRelationEntityType, modelLocalRelationEntityType, modelScalarFieldEntityType, modelTransformerCompilerSpec, modelTransformerEntityType, modelTransformerSpec, modelUniqueConstraintEntityType, oklchColor, paletteSchema, palettesSchema, parseOklch, parseProjectDefinitionWithContext, parseProjectDefinitionWithReferences, pluginConfigSpec, pluginEntityType, pluginManifestJsonSchema, pluginMetadataSchema, pluginSpecDependencySchema, pluginSpecSupportSchema, runPluginMigrations, runSchemaMigrations, serializeSchema, serializeSchemaFromRefPayload, stripEmptyGeneratorChildren, stripUndefinedValues, themeColorSchema, undefinedIfEmpty, undefinedIfFalsy, webAppEntryType, webConfigSpec, zEnt, zPluginWrapper, zRef, zRefBuilder, zRefId, zWithPlugins };
+//# sourceMappingURL=project-builder-lib-Tb9xtEo4.js.map