@baseplate-dev/plugin-auth 1.0.1 → 1.0.3

package/dist/web/assets/{model-merger-gxuB007n.js → model-merger-DYdmgijL.js}

@@ -1,4 +1,4 @@
-import { importShared } from './__federation_fn_import-CxP86CUK.js';
+import { importShared } from './__federation_fn_import-CktB8mRs.js';
 
 function createInitializedPluginSpec(spec, implementation) {
     return { spec, implementation };
@@ -469,7 +469,7 @@ function randomKey(length = 12) {
     return customNanoid(length);
 }
 
-const {z: z$2} = await importShared('zod');
+const {z: z$3} = await importShared('zod');
 
 /**
  * Regex for validating kebab case, e.g. "my-project".
@@ -491,25 +491,25 @@ 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$3.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$3.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$3.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$3.string().regex(CONSTANT_CASE_REGEX, {
         message: 'Must be constant case (e.g. "MY_PROJECT")',
     }),
 };
@@ -572,46 +572,170 @@ function createEntityType(name, options) {
     return new DefinitionEntityType(name, prefix, parentType);
 }
 
-const zodPluginSymbol = Symbol('zod-plugin');
+class DefinitionReferenceMarker {
+    constructor(value, reference) {
+        Object.defineProperty(this, "value", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: value
+        });
+        Object.defineProperty(this, "reference", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: reference
+        });
+    }
+    toString() {
+        return this.value ?? '';
+    }
+}
+const REF_ANNOTATIONS_MARKER_SYMBOL = Symbol('refAnnotationsMarker');
 
-/**
- * Zod Plugin Wrapper
- *
- * Used for initializing the zod parsing with plugins
- */
-const {ZodType: ZodType$1} = await importShared('zod');
-class ZodPluginWrapper extends ZodType$1 {
-    _parse(input) {
-        // run builder
-        const pluginContext = {
-            pluginStore: this._def.pluginStore,
-        };
-        return this._def.innerType._parse({
-            ...input,
-            parent: {
-                ...input.parent,
-                common: {
-                    ...input.parent.common,
-                    [zodPluginSymbol]: pluginContext,
+const {z: z$2} = await importShared('zod');
+function extendParserContextWithRefs({ transformReferences, }) {
+    function withRef(reference) {
+        return z$2.string().transform((value) => {
+            if (transformReferences && value) {
+                return new DefinitionReferenceMarker(value, reference);
+            }
+            return value;
+        });
+    }
+    function withEnt(schema, entity) {
+        if (!('id' in schema.shape)) {
+            throw new Error(`Entity must have an id field. Entity type: ${entity.type.name}. Schema keys: ${Object.keys(schema.shape).join(', ')}`);
+        }
+        return schema.transform((value) => {
+            // Check if the id is valid
+            if (!('id' in value) || !entity.type.isId(value.id)) {
+                throw new Error(`Invalid id for entity ${entity.type.name}. Id: ${value.id}`);
+            }
+            if (transformReferences) {
+                const existingAnnotations = REF_ANNOTATIONS_MARKER_SYMBOL in value
+                    ? value[REF_ANNOTATIONS_MARKER_SYMBOL]
+                    : undefined;
+                return {
+                    ...value,
+                    [REF_ANNOTATIONS_MARKER_SYMBOL]: {
+                        entities: [...(existingAnnotations?.entities ?? []), entity],
+                        references: existingAnnotations?.references ?? [],
+                        contextPaths: existingAnnotations?.contextPaths ?? [],
+                    },
+                };
+            }
+            return value;
+        });
+    }
+    function withRefBuilder(schema, builder) {
+        return schema.transform((value) => {
+            if (!value) {
+                return value;
+            }
+            if (typeof value !== 'object') {
+                throw new TypeError(`refBuilder requires an object, but got ${typeof value}`);
+            }
+            const existingAnnotations = REF_ANNOTATIONS_MARKER_SYMBOL in value
+                ? value[REF_ANNOTATIONS_MARKER_SYMBOL]
+                : undefined;
+            const entities = existingAnnotations?.entities ?? [];
+            const references = existingAnnotations?.references ?? [];
+            const contextPaths = existingAnnotations?.contextPaths ?? [];
+            const refBuilder = {
+                addReference: (reference) => {
+                    references.push(reference);
                 },
-            },
+                addEntity: (entity) => {
+                    entities.push(entity);
+                },
+                addPathToContext: (path, type, context) => {
+                    contextPaths.push({ path, type, context });
+                },
+            };
+            builder?.(refBuilder, value);
+            if (transformReferences) {
+                return {
+                    ...value,
+                    [REF_ANNOTATIONS_MARKER_SYMBOL]: {
+                        entities,
+                        references,
+                        contextPaths,
+                    },
+                };
+            }
+            return value;
         });
     }
-    get pluginStore() {
-        return this._def.pluginStore;
+    return {
+        withRef,
+        withEnt,
+        withRefBuilder,
+    };
+}
+
+const {z: z$1} = await importShared('zod');
+
+function isEmpty(value) {
+    if (Array.isArray(value)) {
+        return value.length === 0;
+    }
+    if (typeof value === 'object' && value !== null) {
+        return Object.values(value).every((val) => val === undefined);
     }
+    return value === false || value === '';
 }
-Object.defineProperty(ZodPluginWrapper, "create", {
-    enumerable: true,
-    configurable: true,
-    writable: true,
-    value: (type, pluginStore) => new ZodPluginWrapper({
-        innerType: type,
-        pluginStore,
-    })
-});
-function zPluginWrapper(type, pluginStore) {
-    return ZodPluginWrapper.create(type, pluginStore);
+/**
+ * Extends the parser context with default value handling functionality.
+ *
+ * @param options - The schema creator options containing the defaultMode
+ * @returns An object containing the withDefault method
+ */
+function extendParserContextWithDefaults(options) {
+    const mode = options.defaultMode ?? 'populate';
+    return {
+        withDefault: function withDefault(schema, defaultValue) {
+            // Auto-add .optional() to the schema
+            const optionalSchema = schema.optional();
+            switch (mode) {
+                case 'populate': {
+                    // Use preprocess to inject defaults before validation
+                    return z$1.preprocess((value) => {
+                        if (value === undefined) {
+                            return defaultValue;
+                        }
+                        return value;
+                    }, optionalSchema);
+                }
+                case 'strip': {
+                    // Use transform to remove values matching defaults after validation
+                    return optionalSchema.transform((value) => {
+                        if (isEmpty(value)) {
+                            return undefined;
+                        }
+                        // eslint-disable-next-line @typescript-eslint/no-unsafe-return -- it's typed to a generic
+                        return value;
+                    });
+                }
+                case 'preserve': {
+                    // Return schema with .optional() added
+                    // eslint-disable-next-line @typescript-eslint/no-unsafe-return -- it's typed to a generic
+                    return optionalSchema.transform((x) => x);
+                }
+            }
+        },
+    };
+}
+
+function createDefinitionSchemaParserContext(options) {
+    return {
+        ...options,
+        ...extendParserContextWithRefs(options),
+        ...extendParserContextWithDefaults(options),
+    };
+}
+function definitionSchema(creator) {
+    return (context) => creator(context);
 }
 
 function isDeepKey(key) {
@@ -895,506 +1019,11 @@ function set(obj, path, value) {
     return obj;
 }
 
-const {z: z$1,ZodType} = await importShared('zod');
-
-/**
- * Zod reference ID schema: a string with a minimum length of 1.
- */
-const zRefId = z$1.string().min(1);
-/**
- * Determines whether the given object is a Promise.
- * @param object - The value to test.
- * @returns True if the value is a Promise, false otherwise.
- */
-function isPromise(object) {
-    return object instanceof Promise;
-}
-/**
- * Creates a definition entity name resolver.
- * @param entityNameResolver - The entity name resolver.
- * @returns The definition entity name resolver.
- */
-function createDefinitionEntityNameResolver(entityNameResolver) {
-    return entityNameResolver;
-}
-/**
- * ZodRefBuilder is responsible for constructing reference paths, and registering
- * references and entities as defined in a Zod schema.
- *
- * The builder uses a prefix (usually the current parsing path) and context (a
- * shared map for resolving relative references) to build complete reference paths.
- *
- * @template TInput - The type of the input data being parsed.
- */
-class ZodRefBuilder {
-    /**
-     * Creates a new builder instance.
-     * @param pathPrefix - The starting path for all references.
-     * @param context - Shared context including a path map and deserialize flag.
-     * @param data - The data being parsed.
-     */
-    constructor(pathPrefix, context, data) {
-        Object.defineProperty(this, "references", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "entitiesWithNameResolver", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "pathPrefix", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "context", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "pathMap", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "data", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        this.references = [];
-        this.entitiesWithNameResolver = [];
-        this.pathPrefix = pathPrefix;
-        this.context = context;
-        this.pathMap = new Map();
-        this.data = data;
-    }
-    /**
-     * Converts a dot-separated string path into an array of keys.
-     * @param path - A string (e.g. "a.b.0.c") representing the path.
-     * @returns An array of keys (numbers for numeric strings, otherwise strings).
-     */
-    _constructPathWithoutPrefix(path) {
-        if (!path)
-            return [];
-        const pathComponents = path
-            .split('.')
-            .map((key) => (/^[0-9]+$/.test(key) ? Number.parseInt(key, 10) : key));
-        return pathComponents;
-    }
-    /**
-     * Prepends the builder's path prefix to the provided path.
-     * @param path - The dot-separated path string.
-     * @returns The complete reference path as an array.
-     */
-    _constructPath(path) {
-        if (!path)
-            return this.pathPrefix;
-        return [...this.pathPrefix, ...this._constructPathWithoutPrefix(path)];
-    }
-    /**
-     * Constructs a reference path that may be defined directly as a string or indirectly
-     * via a context object. If a context object is provided, the function looks up the
-     * actual path from the builder's context.
-     *
-     * @param path - Either a dot-separated string path or an object with a context key.
-     * @param expectedEntityType - The entity type expected for this context.
-     * @returns The resolved reference path.
-     * @throws If the context cannot be found or its type does not match.
-     */
-    _constructPathWithContext(path, expectedEntityType) {
-        if (typeof path === 'string') {
-            return this._constructPath(path);
-        }
-        // Lookup the context for the given key.
-        const pathContext = this.context.pathMap.get(path.context);
-        if (!pathContext) {
-            throw new Error(`Could not find context for ${path.context} from ${this.pathPrefix.join('.')}`);
-        }
-        if (pathContext.type !== expectedEntityType) {
-            throw new Error(`Attempted to retrieve context for ${path.context} from ${this.pathPrefix.join('.')} expecting ${expectedEntityType.name}, but found ${pathContext.type.name}`);
-        }
-        return pathContext.path;
-    }
-    /**
-     * Registers a reference based on the provided input definition.
-     *
-     * Flow:
-     * 1. Validate that the parent path is provided if required (and vice versa).
-     * 2. Compute the reference path; if the path is empty, use the entire data.
-     * 3. If the referenced value is null or undefined, skip adding the reference.
-     * 4. Otherwise, add the reference and, if requested, register its context.
-     *
-     * @param reference - The reference definition.
-     * @throws If parent path usage is incorrect.
-     */
-    addReference(reference) {
-        if (!reference.type.parentType && reference.parentPath) {
-            throw new Error(`Parent path does nothing since reference does not have parent`);
-        }
-        if (reference.type.parentType && !reference.parentPath) {
-            throw new Error(`Parent path required if reference type has parent type`);
-        }
-        // Compute the path without prefix once.
-        const refPathWithoutPrefix = this._constructPathWithoutPrefix(reference.path);
-        // If the path is empty, use the entire data; otherwise, retrieve the value.
-        const refValue = refPathWithoutPrefix.length === 0
-            ? this.data
-            : get(this.data, refPathWithoutPrefix);
-        if (refValue === undefined || refValue === null)
-            return;
-        const fullPath = this._constructPath(reference.path);
-        this.references.push({
-            type: reference.type,
-            path: fullPath,
-            parentPath: reference.parentPath &&
-                reference.type.parentType &&
-                this._constructPathWithContext(reference.parentPath, reference.type.parentType),
-            onDelete: reference.onDelete,
-        });
-        // Optionally, add this path to the shared context.
-        if (reference.addContext) {
-            this._addPathToContext(fullPath, reference.type, reference.addContext);
-        }
-    }
-    /**
-     * Registers an entity based on the provided definition.
-     *
-     * Flow:
-     * 1. Validate that not both a name and a name reference path are provided.
-     * 2. Compute the full entity path.
-     * 3. Resolve the entity ID:
-     *    - Use the provided idPath if available; otherwise, default to appending 'id'
-     *      to the entity path.
-     *    - If no id is found, generate a new one.
-     * 4. Resolve the entity name:
-     *    - Use the provided resolveName if available; otherwise, default to using the
-     *      name path.
-     * 5. Register the entity in either the direct entities list or the name-ref list.
-     * 6. Optionally, add the entity’s id path to the shared context.
-     *
-     * @param entity - The entity definition.
-     * @throws If both name and nameRefPath are provided or if no name is resolved.
-     */
-    addEntity(entity) {
-        // Build the full path for the entity.
-        const path = this._constructPath(entity.path);
-        // Resolve the id path: if provided use it; otherwise, assume the id is at "entity.path.id"
-        const idPath = entity.idPath
-            ? this._constructPathWithoutPrefix(entity.idPath)
-            : [...this._constructPathWithoutPrefix(entity.path), 'id'];
-        const id = get(this.data, idPath);
-        if (!id) {
-            throw new Error(`No id found for entity ${entity.type.name}`);
-        }
-        if (!entity.type.isId(id)) {
-            throw new Error(`Invalid id: ${id} for entity ${entity.type.name}`);
-        }
-        // Resolve the name: if getNameResolver is provided, use it to build the name resolver; otherwise,
-        // use the default name resolver.
-        const getNameResolver = entity.getNameResolver ?? ((value) => get(value, 'name'));
-        const nameResolver = getNameResolver(this.data);
-        // Base entity definition shared between regular entities and those with a name reference.
-        const entityBase = {
-            id,
-            type: entity.type,
-            path,
-            idPath: [...this.pathPrefix, ...idPath],
-            parentPath: entity.parentPath &&
-                entity.type.parentType &&
-                this._constructPathWithContext(entity.parentPath, entity.type.parentType),
-        };
-        this.entitiesWithNameResolver.push({
-            ...entityBase,
-            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment -- needed to allow more specific generic typed to be put in here
-            nameResolver: typeof nameResolver === 'string'
-                ? { resolveName: () => nameResolver }
-                : nameResolver,
-        });
-        // Optionally add the id path to the context.
-        if (entity.addContext) {
-            this._addPathToContext([...this.pathPrefix, ...idPath], entity.type, entity.addContext);
-        }
-    }
-    /**
-     * Registers a given path into the builder's context map.
-     * @param path - The full reference path.
-     * @param type - The entity type associated with the path.
-     * @param context - A unique key to identify this context.
-     * @throws If the context key is already registered.
-     */
-    _addPathToContext(path, type, context) {
-        if (this.pathMap.has(context)) {
-            throw new Error(`Context path already defined for ${context} at ${this.pathPrefix.join('.')}`);
-        }
-        this.pathMap.set(context, { path, type });
-    }
-    /**
-     * Convenience method that builds a full path from a dot-separated string and
-     * adds it to the context.
-     * @param path - The dot-separated string path.
-     * @param type - The entity type.
-     * @param context - The context key.
-     */
-    addPathToContext(path, type, context) {
-        this._addPathToContext(this._constructPath(path), type, context);
-    }
-}
-/**
- * Unique symbol used to store ZodRef context in the parent’s common context.
- */
-const zodRefSymbol = Symbol('zod-ref');
-/**
- * ZodRef wraps an inner Zod type and enhances it with the ability to register
- * and process entity references. During parsing, it delegates to a builder (if present)
- * to collect references and entities before delegating to the inner type.
- *
- * @template T - The inner Zod type.
- */
-class ZodRef extends ZodType {
-    /**
-     * The core parse method that:
-     * 1. Retrieves (or creates) the builder context from the parent.
-     * 2. Runs the builder function (if present) to register references/entities.
-     * 3. Delegates parsing to the inner type.
-     * 4. Transforms the output to replace entity id placeholders with generated ids.
-     *
-     * @param input - The Zod parse input.
-     * @returns The parse result.
-     */
-    _parse(input) {
-        const context = input.parent.common;
-        // If no builder context or builder function exists, simply parse using the inner type.
-        const zodRefContext = context[zodRefSymbol];
-        if (!zodRefContext || !this._def.builder) {
-            return this._def.innerType._parse(input);
-        }
-        // Create a new builder instance for the current parsing context.
-        const builder = new ZodRefBuilder(input.path, zodRefContext.context, input.data);
-        // Execute the builder function to register references/entities.
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
-        this._def.builder(builder, input.data);
-        zodRefContext.references.push(...builder.references);
-        zodRefContext.entitiesWithNameResolver.push(...builder.entitiesWithNameResolver);
-        // Re-parse using the inner type but merge the updated context.
-        const parseOutput = this._def.innerType._parse({
-            ...input,
-            path: input.path,
-            parent: {
-                ...input.parent,
-                common: {
-                    ...input.parent.common,
-                    [zodRefSymbol]: {
-                        ...zodRefContext,
-                        context: {
-                            ...zodRefContext.context,
-                            // Merge new context entries from the builder.
-                            pathMap: new Map([
-                                ...zodRefContext.context.pathMap,
-                                ...builder.pathMap,
-                            ]),
-                        },
-                    },
-                },
-            },
-        });
-        /**
-         * Transforms the output of the inner parse by iterating through all registered
-         * entities and assigning the id to the corresponding path in the output in case
-         * it was generated by the builder.
-         *
-         * @param output - The result from the inner parse.
-         * @returns The transformed parse output.
-         */
-        function transformParseOutput(output) {
-            if (output.status === 'aborted')
-                return output;
-            // For each entity, assign the id to the corresponding path in the output
-            // in the event that it was generated by the builder.
-            for (const entity of builder.entitiesWithNameResolver) {
-                set(output.value, entity.idPath.slice(input.path.length), entity.id);
-            }
-            return output;
-        }
-        // If the parse result is a Promise, attach the transformation asynchronously.
-        if (isPromise(parseOutput)) {
-            return parseOutput.then(transformParseOutput);
-        }
-        return transformParseOutput(parseOutput);
-    }
-    /**
-     * Returns the inner Zod type.
-     * @returns The wrapped inner Zod type.
-     */
-    innerType() {
-        return this._def.innerType;
-    }
-    /**
-     * Adds an entity registration to the current ZodRef.
-     *
-     * @param entity - Either an entity definition or a function that returns one.
-     * @returns A new ZodRef instance with the entity registration added.
-     */
-    addEntity(entity) {
-        return ZodRef.create(this, (builder, data) => {
-            builder.addEntity(typeof entity === 'function' ? entity(data) : entity);
-        });
-    }
-    /**
-     * Adds a reference registration to the current ZodRef.
-     *
-     * @param reference - Either a reference definition or a function that returns one.
-     * @returns A new ZodRef instance with the reference registration added.
-     */
-    addReference(reference) {
-        return ZodRef.create(this, (builder, data) => {
-            builder.addReference(typeof reference === 'function' ? reference(data) : reference);
-        });
-    }
-    /**
-     * Applies a custom builder function to the ZodRef.
-     * @param builder - The builder function that registers additional references/entities.
-     * @returns A new ZodRef instance with the builder applied.
-     */
-    refBuilder(builder) {
-        return ZodRef.create(this, builder);
-    }
-}
-/**
- * Creates a new ZodRef instance wrapping a given Zod type with an optional builder.
- * @param type - The inner Zod type.
- * @param builder - Optional builder function to register references/entities.
- * @returns A new ZodRef instance.
- */
-Object.defineProperty(ZodRef, "create", {
-    enumerable: true,
-    configurable: true,
-    writable: true,
-    value: (type, builder) => new ZodRef({
-        innerType: type,
-        builder,
-    })
-});
-/**
- * Convenience function for creating a ZodRef using a schema and an optional builder.
- * @param schema - The base Zod schema.
- * @param builder - Optional builder function.
- * @returns A new ZodRef instance.
- */
-function zRefBuilder(schema, builder) {
-    return ZodRef.create(schema, builder);
-}
-/**
- * Convenience function for creating a ZodRef with a reference added.
- * @param schema - The base Zod schema.
- * @param reference - Either a reference definition or a function returning one.
- * @returns A new ZodRef instance with the reference registration.
- */
-function zRef(schema, reference) {
-    return ZodRef.create(schema).addReference(reference);
-}
-/**
- * Convenience function for creating a ZodRef that registers an entity.
- * This function also sets the id key on the schema using zRefId.
- *
- * @template TObject - The Zod object type.
- * @template TEntityType - The entity type.
- * @template TPath - The path type.
- * @param schema - The base Zod object schema.
- * @param entity - Either an entity definition or a function returning one.
- * @returns A new ZodRef instance with the entity registration.
- */
-function zEnt(schema, entity) {
-    // Set the "id" key on the schema using zRefId and then register the entity.
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-return, @typescript-eslint/no-explicit-any
-    return ZodRef.create(schema.setKey('id', zRefId)).addEntity(entity);
-}
-/**
- * ZodRefWrapper is used for initializing parsing that collects references and entities.
- *
- * @template T - The inner Zod type.
- */
-class ZodRefWrapper extends ZodType {
-    /**
-     * Core parse method that:
-     * 1. Initializes a fresh reference context.
-     * 2. Parses using the inner type while injecting the context.
-     * 3. Returns a payload containing the parsed data, along with references and entities.
-     *
-     * @param input - The parse input.
-     * @returns The parsed payload.
-     */
-    _parse(input) {
-        // Initialize the reference context.
-        const refContext = {
-            context: {
-                pathMap: new Map(),
-            },
-            references: [],
-            entitiesWithNameResolver: [],
-        };
-        // Inject the refContext into the parent's common context and parse the inner type.
-        const parseOutput = this._def.innerType._parse({
-            ...input,
-            parent: {
-                ...input.parent,
-                common: {
-                    ...input.parent.common,
-                    [zodRefSymbol]: refContext,
-                },
-            },
-        });
-        function transformParseOutput(output) {
-            if (output.status === 'aborted')
-                return output;
-            return {
-                ...output,
-                value: {
-                    data: output.value,
-                    entitiesWithNameResolver: refContext.entitiesWithNameResolver,
-                    references: refContext.references,
-                },
-            };
-        }
-        if (isPromise(parseOutput)) {
-            return parseOutput.then(transformParseOutput);
-        }
-        return transformParseOutput(parseOutput);
-    }
-}
-/**
- * Creates a new ZodRefWrapper instance.
- * @param type - The inner Zod type.
- * @param options - Options for the ZodRefWrapper.
- * @param options.skipReferenceNameResolution - Flag to skip resolving references to names (serialized definitions use resolved name references).
- * @param options.allowInvalidReferences - Flag to allow invalid references (used for testing deletes).
- * @returns A new instance of ZodRefWrapper.
- */
-Object.defineProperty(ZodRefWrapper, "create", {
-    enumerable: true,
-    configurable: true,
-    writable: true,
-    value: (type) => new ZodRefWrapper({
-        innerType: type,
-    })
-});
-
-function definitionSchema(creator) {
-    return (options) => creator(options);
-}
-
 const {z} = await importShared('zod');
 const featureEntityType = createEntityType('feature');
 const featureNameSchema = CASE_VALIDATORS.KEBAB_CASE;
-const createFeatureSchema = definitionSchema(() => zEnt(z.object({
+const createFeatureSchema = definitionSchema((ctx) => ctx.withEnt(z.object({
+    id: z.string(),
     name: z
         .string()
         .min(1)
@@ -1403,10 +1032,12 @@ const createFeatureSchema = definitionSchema(() => zEnt(z.object({
         .every((part) => featureNameSchema.safeParse(part).success), {
         message: 'Feature name must be lowercase and contain only letters, numbers, and dashes',
     }),
-    parentRef: zRef(z.string().nullish(), {
+    parentRef: ctx
+        .withRef({
         type: featureEntityType,
         onDelete: 'DELETE_PARENT',
-    }),
+    })
+        .optional(),
 }), { type: featureEntityType }));
 const createFeaturesSchema = definitionSchema((ctx) => z.array(createFeatureSchema(ctx)).default([]));
 
@@ -1460,7 +1091,7 @@ function ensureFeatureByNameRecursively(projectDefinition, nameOrId) {
     }
     const nameParts = nameOrId.split('/');
     let lastName = '';
-    let parentRef = null;
+    let parentRef = undefined;
     for (const part of nameParts) {
         const feature = projectDefinition.features.find((f) => f.name === part && f.parentRef === parentRef);
         const name = [lastName, part].filter(Boolean).join('/');
@@ -1830,9 +1461,10 @@ function serializeModelMergerModelInput(input, definitionContainer, siblingModel
             ...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),
+                fields: input.graphql?.objectType?.fields?.map(fieldNameFromId) ?? [],
+                localRelations: input.graphql?.objectType?.localRelations?.map(relationNameFromId) ??
+                    [],
+                foreignRelations: input.graphql?.objectType?.foreignRelations?.map(relationNameFromId) ?? [],
             },
         },
     };
@@ -1912,7 +1544,7 @@ function deserializeModelMergerModelInput(input, resolveForeignFieldRef, resolve
             ...inputWithIds.graphql,
             objectType: {
                 ...inputWithIds.graphql?.objectType,
-                fields: inputWithIds.graphql?.objectType?.fields.map((fieldRef) => resolveLocalFieldName(fieldRef)) ?? [],
+                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)) ?? [],
             },
@@ -1962,6 +1594,9 @@ function createModelMergerResult(current, desired, definitionContainer, { siblin
         changes: diff,
     };
 }
+function doesModelMergerResultsHaveChanges(results) {
+    return Object.values(results).some((result) => result?.changes);
+}
 /**
  * Creates a model merger result for a set of models.
  *
@@ -2045,5 +1680,5 @@ function createAndApplyModelMergerResults(draftConfig, current, desired, definit
         : 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-gxuB007n.js.map
+export { doesModelMergerResultsHaveChanges as A, createModelMergerResults as B, CASE_VALIDATORS as C, DefinitionReferenceMarker as D, applyModelMergerDiff as E, FeatureUtils as F, applyModelMergerResultInPlace as G, createAndApplyModelMergerResults as H, DefinitionDiffKeyedArrayField as I, DefinitionDiffReplacementField as J, DefinitionDiffArrayIncludesField as K, createDefinitionDiffConfig as L, ModelUtils as M, createDefinitionDiff as N, applyDefinitionDiff as O, REF_ANNOTATIONS_MARKER_SYMBOL as R, createEntityType as a, createDefinitionSchemaParserContext as b, createPluginSpec as c, definitionSchema as d, modelForeignRelationEntityType as e, modelLocalRelationEntityType as f, get as g, modelScalarFieldEntityType as h, isEqual as i, modelTransformerEntityType as j, modelEntityType as k, modelEnumValueEntityType as l, mapValues as m, featureEntityType as n, modelEnumEntityType as o, modelUniqueConstraintEntityType as p, createFeaturesSchema as q, omit as r, set as s, cloneDeep as t, createInitializedPluginSpec as u, DefinitionEntityType as v, featureNameSchema as w, createFeatureSchema as x, modelMergerDefinitionDiffConfig as y, createModelMergerResult as z };
+//# sourceMappingURL=model-merger-DYdmgijL.js.map