@baseplate-dev/plugin-auth 0.1.1

package/dist/web/assets/model-utils-CbQJy1wE.js

@@ -0,0 +1,1263 @@
+import { importShared } from './__federation_fn_import-BiwmVFwy.js';
+
+function createInitializedPluginSpec(spec, implementation) {
+    return { spec, implementation };
+}
+function createPluginSpec(name, options) {
+    const { platforms, defaultInitializer } = options ?? {};
+    return {
+        type: 'plugin-spec',
+        name,
+        platforms: platforms && (Array.isArray(platforms) ? platforms : [platforms]),
+        isOptional: false,
+        optional() {
+            return { ...this, isOptional: true };
+        },
+        defaultInitializer,
+    };
+}
+
+function noop() { }
+
+function getSymbols(object) {
+    return Object.getOwnPropertySymbols(object).filter(symbol => Object.prototype.propertyIsEnumerable.call(object, symbol));
+}
+
+function isPlainObject(value) {
+    if (!value || typeof value !== 'object') {
+        return false;
+    }
+    const proto = Object.getPrototypeOf(value);
+    const hasObjectPrototype = proto === null ||
+        proto === Object.prototype ||
+        Object.getPrototypeOf(proto) === null;
+    if (!hasObjectPrototype) {
+        return false;
+    }
+    return Object.prototype.toString.call(value) === '[object Object]';
+}
+
+function getTag(value) {
+    if (value == null) {
+        return value === undefined ? '[object Undefined]' : '[object Null]';
+    }
+    return Object.prototype.toString.call(value);
+}
+
+const regexpTag = '[object RegExp]';
+const stringTag = '[object String]';
+const numberTag = '[object Number]';
+const booleanTag = '[object Boolean]';
+const argumentsTag = '[object Arguments]';
+const symbolTag = '[object Symbol]';
+const dateTag = '[object Date]';
+const mapTag = '[object Map]';
+const setTag = '[object Set]';
+const arrayTag = '[object Array]';
+const functionTag = '[object Function]';
+const arrayBufferTag = '[object ArrayBuffer]';
+const objectTag = '[object Object]';
+const errorTag = '[object Error]';
+const dataViewTag = '[object DataView]';
+const uint8ArrayTag = '[object Uint8Array]';
+const uint8ClampedArrayTag = '[object Uint8ClampedArray]';
+const uint16ArrayTag = '[object Uint16Array]';
+const uint32ArrayTag = '[object Uint32Array]';
+const bigUint64ArrayTag = '[object BigUint64Array]';
+const int8ArrayTag = '[object Int8Array]';
+const int16ArrayTag = '[object Int16Array]';
+const int32ArrayTag = '[object Int32Array]';
+const bigInt64ArrayTag = '[object BigInt64Array]';
+const float32ArrayTag = '[object Float32Array]';
+const float64ArrayTag = '[object Float64Array]';
+
+function eq(value, other) {
+    return value === other || (Number.isNaN(value) && Number.isNaN(other));
+}
+
+function isEqualWith(a, b, areValuesEqual) {
+    return isEqualWithImpl(a, b, undefined, undefined, undefined, undefined, areValuesEqual);
+}
+function isEqualWithImpl(a, b, property, aParent, bParent, stack, areValuesEqual) {
+    const result = areValuesEqual(a, b, property, aParent, bParent, stack);
+    if (result !== undefined) {
+        return result;
+    }
+    if (typeof a === typeof b) {
+        switch (typeof a) {
+            case 'bigint':
+            case 'string':
+            case 'boolean':
+            case 'symbol':
+            case 'undefined': {
+                return a === b;
+            }
+            case 'number': {
+                return a === b || Object.is(a, b);
+            }
+            case 'function': {
+                return a === b;
+            }
+            case 'object': {
+                return areObjectsEqual(a, b, stack, areValuesEqual);
+            }
+        }
+    }
+    return areObjectsEqual(a, b, stack, areValuesEqual);
+}
+function areObjectsEqual(a, b, stack, areValuesEqual) {
+    if (Object.is(a, b)) {
+        return true;
+    }
+    let aTag = getTag(a);
+    let bTag = getTag(b);
+    if (aTag === argumentsTag) {
+        aTag = objectTag;
+    }
+    if (bTag === argumentsTag) {
+        bTag = objectTag;
+    }
+    if (aTag !== bTag) {
+        return false;
+    }
+    switch (aTag) {
+        case stringTag:
+            return a.toString() === b.toString();
+        case numberTag: {
+            const x = a.valueOf();
+            const y = b.valueOf();
+            return eq(x, y);
+        }
+        case booleanTag:
+        case dateTag:
+        case symbolTag:
+            return Object.is(a.valueOf(), b.valueOf());
+        case regexpTag: {
+            return a.source === b.source && a.flags === b.flags;
+        }
+        case functionTag: {
+            return a === b;
+        }
+    }
+    stack = stack ?? new Map();
+    const aStack = stack.get(a);
+    const bStack = stack.get(b);
+    if (aStack != null && bStack != null) {
+        return aStack === b;
+    }
+    stack.set(a, b);
+    stack.set(b, a);
+    try {
+        switch (aTag) {
+            case mapTag: {
+                if (a.size !== b.size) {
+                    return false;
+                }
+                for (const [key, value] of a.entries()) {
+                    if (!b.has(key) || !isEqualWithImpl(value, b.get(key), key, a, b, stack, areValuesEqual)) {
+                        return false;
+                    }
+                }
+                return true;
+            }
+            case setTag: {
+                if (a.size !== b.size) {
+                    return false;
+                }
+                const aValues = Array.from(a.values());
+                const bValues = Array.from(b.values());
+                for (let i = 0; i < aValues.length; i++) {
+                    const aValue = aValues[i];
+                    const index = bValues.findIndex(bValue => {
+                        return isEqualWithImpl(aValue, bValue, undefined, a, b, stack, areValuesEqual);
+                    });
+                    if (index === -1) {
+                        return false;
+                    }
+                    bValues.splice(index, 1);
+                }
+                return true;
+            }
+            case arrayTag:
+            case uint8ArrayTag:
+            case uint8ClampedArrayTag:
+            case uint16ArrayTag:
+            case uint32ArrayTag:
+            case bigUint64ArrayTag:
+            case int8ArrayTag:
+            case int16ArrayTag:
+            case int32ArrayTag:
+            case bigInt64ArrayTag:
+            case float32ArrayTag:
+            case float64ArrayTag: {
+                if (typeof Buffer !== 'undefined' && Buffer.isBuffer(a) !== Buffer.isBuffer(b)) {
+                    return false;
+                }
+                if (a.length !== b.length) {
+                    return false;
+                }
+                for (let i = 0; i < a.length; i++) {
+                    if (!isEqualWithImpl(a[i], b[i], i, a, b, stack, areValuesEqual)) {
+                        return false;
+                    }
+                }
+                return true;
+            }
+            case arrayBufferTag: {
+                if (a.byteLength !== b.byteLength) {
+                    return false;
+                }
+                return areObjectsEqual(new Uint8Array(a), new Uint8Array(b), stack, areValuesEqual);
+            }
+            case dataViewTag: {
+                if (a.byteLength !== b.byteLength || a.byteOffset !== b.byteOffset) {
+                    return false;
+                }
+                return areObjectsEqual(new Uint8Array(a), new Uint8Array(b), stack, areValuesEqual);
+            }
+            case errorTag: {
+                return a.name === b.name && a.message === b.message;
+            }
+            case objectTag: {
+                const areEqualInstances = areObjectsEqual(a.constructor, b.constructor, stack, areValuesEqual) ||
+                    (isPlainObject(a) && isPlainObject(b));
+                if (!areEqualInstances) {
+                    return false;
+                }
+                const aKeys = [...Object.keys(a), ...getSymbols(a)];
+                const bKeys = [...Object.keys(b), ...getSymbols(b)];
+                if (aKeys.length !== bKeys.length) {
+                    return false;
+                }
+                for (let i = 0; i < aKeys.length; i++) {
+                    const propKey = aKeys[i];
+                    const aProp = a[propKey];
+                    if (!Object.hasOwn(b, propKey)) {
+                        return false;
+                    }
+                    const bProp = b[propKey];
+                    if (!isEqualWithImpl(aProp, bProp, propKey, a, b, stack, areValuesEqual)) {
+                        return false;
+                    }
+                }
+                return true;
+            }
+            default: {
+                return false;
+            }
+        }
+    }
+    finally {
+        stack.delete(a);
+        stack.delete(b);
+    }
+}
+
+function isEqual(a, b) {
+    return isEqualWith(a, b, noop);
+}
+
+let random = bytes => crypto.getRandomValues(new Uint8Array(bytes));
+let customRandom = (alphabet, defaultSize, getRandom) => {
+  let mask = (2 << Math.log2(alphabet.length - 1)) - 1;
+  let step = -~((1.6 * mask * defaultSize) / alphabet.length);
+  return (size = defaultSize) => {
+    let id = '';
+    while (true) {
+      let bytes = getRandom(step);
+      let j = step | 0;
+      while (j--) {
+        id += alphabet[bytes[j] & mask] || '';
+        if (id.length >= size) return id
+      }
+    }
+  }
+};
+let customAlphabet = (alphabet, size = 21) =>
+  customRandom(alphabet, size | 0, random);
+
+const NUMBERS = '0123456789';
+const LOWERCASE = 'abcdefghijklmnopqrstuvwxyz';
+const UPPERCASE = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';
+/**
+ * Use custom ID generator for characters that be easily selected
+ */
+const customNanoid = customAlphabet(`${NUMBERS}${LOWERCASE}${UPPERCASE}_`, 12);
+/**
+ * Generate a random ID string made up of numbers, lowercase, and uppercase letters
+ * @returns A random ID string
+ */
+function randomUid(length = 12) {
+    return customNanoid(length);
+}
+
+const {z: z$2} = await importShared('zod');
+
+/**
+ * Regex for validating kebab case, e.g. "my-project".
+ */
+const KEBAB_CASE_REGEX = /^[a-z0-9-]+$/;
+/**
+ * Regex for validating pascal case, e.g. "MyProject".
+ */
+const PASCAL_CASE_REGEX = /^[A-Z][a-zA-Z0-9]*$/;
+/**
+ * Regex for validating camel case, e.g. "myProject".
+ */
+const CAMEL_CASE_REGEX = /^[a-z][a-zA-Z0-9]*$/;
+/**
+ * Regex for validating constant case, e.g. "MY_PROJECT".
+ */
+const CONSTANT_CASE_REGEX = /^[A-Z][A-Z0-9_]*$/;
+const CASE_VALIDATORS = {
+    /**
+     * Zod validator for validating kebab case, e.g. "my-project".
+     */
+    KEBAB_CASE: z$2.string().regex(KEBAB_CASE_REGEX),
+    /**
+     * Zod validator for validating pascal case, e.g. "MyProject".
+     */
+    PASCAL_CASE: z$2.string().regex(PASCAL_CASE_REGEX),
+    /**
+     * Zod validator for validating camel case, e.g. "myProject".
+     */
+    CAMEL_CASE: z$2.string().regex(CAMEL_CASE_REGEX),
+    /**
+     * Zod validator for validating constant case, e.g. "MY_PROJECT".
+     */
+    CONSTANT_CASE: z$2.string().regex(CONSTANT_CASE_REGEX),
+};
+
+/**
+ * Definition of an entity type.
+ */
+class DefinitionEntityType {
+    /**
+     * Creates a new entity type.
+     *
+     * @param name - The name of the entity type.
+     * @param prefix - The prefix of the entity type to use in the ID, defaults to the name.
+     * @param parentType - The type of the parent entity if any
+     */
+    constructor(name, prefix, parentType) {
+        Object.defineProperty(this, "name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: name
+        });
+        Object.defineProperty(this, "parentType", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: parentType
+        });
+        Object.defineProperty(this, "prefix", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.prefix = prefix ?? name.split('/').pop() ?? name;
+    }
+    /**
+     * Generates a new ID for the entity type.
+     *
+     * @returns The new ID.
+     */
+    generateNewId() {
+        return `${this.prefix}:${randomUid()}`;
+    }
+    fromUid(uid) {
+        if (!uid) {
+            return undefined;
+        }
+        return `${this.prefix}:${uid}`;
+    }
+    toUid(id) {
+        return id.split(':')[1];
+    }
+    isId(id) {
+        return id.startsWith(`${this.prefix}:`);
+    }
+}
+function createEntityType(name, options) {
+    const { parentType, prefix } = options ?? {};
+    return new DefinitionEntityType(name, prefix, parentType);
+}
+
+const zodPluginSymbol = Symbol('zod-plugin');
+
+/**
+ * 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,
+                },
+            },
+        });
+    }
+    get pluginStore() {
+        return this._def.pluginStore;
+    }
+}
+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);
+}
+
+function isDeepKey(key) {
+    switch (typeof key) {
+        case 'number':
+        case 'symbol': {
+            return false;
+        }
+        case 'string': {
+            return key.includes('.') || key.includes('[') || key.includes(']');
+        }
+    }
+}
+
+function toKey(value) {
+    if (Object.is(value, -0)) {
+        return '-0';
+    }
+    return value.toString();
+}
+
+function toPath(deepKey) {
+    const result = [];
+    const length = deepKey.length;
+    if (length === 0) {
+        return result;
+    }
+    let index = 0;
+    let key = '';
+    let quoteChar = '';
+    let bracket = false;
+    if (deepKey.charCodeAt(0) === 46) {
+        result.push('');
+        index++;
+    }
+    while (index < length) {
+        const char = deepKey[index];
+        if (quoteChar) {
+            if (char === '\\' && index + 1 < length) {
+                index++;
+                key += deepKey[index];
+            }
+            else if (char === quoteChar) {
+                quoteChar = '';
+            }
+            else {
+                key += char;
+            }
+        }
+        else if (bracket) {
+            if (char === '"' || char === "'") {
+                quoteChar = char;
+            }
+            else if (char === ']') {
+                bracket = false;
+                result.push(key);
+                key = '';
+            }
+            else {
+                key += char;
+            }
+        }
+        else {
+            if (char === '[') {
+                bracket = true;
+                if (key) {
+                    result.push(key);
+                    key = '';
+                }
+            }
+            else if (char === '.') {
+                if (key) {
+                    result.push(key);
+                    key = '';
+                }
+            }
+            else {
+                key += char;
+            }
+        }
+        index++;
+    }
+    if (key) {
+        result.push(key);
+    }
+    return result;
+}
+
+function get(object, path, defaultValue) {
+    if (object == null) {
+        return defaultValue;
+    }
+    switch (typeof path) {
+        case 'string': {
+            const result = object[path];
+            if (result === undefined) {
+                if (isDeepKey(path)) {
+                    return get(object, toPath(path), defaultValue);
+                }
+                else {
+                    return defaultValue;
+                }
+            }
+            return result;
+        }
+        case 'number':
+        case 'symbol': {
+            if (typeof path === 'number') {
+                path = toKey(path);
+            }
+            const result = object[path];
+            if (result === undefined) {
+                return defaultValue;
+            }
+            return result;
+        }
+        default: {
+            if (Array.isArray(path)) {
+                return getWithPath(object, path, defaultValue);
+            }
+            if (Object.is(path?.valueOf(), -0)) {
+                path = '-0';
+            }
+            else {
+                path = String(path);
+            }
+            const result = object[path];
+            if (result === undefined) {
+                return defaultValue;
+            }
+            return result;
+        }
+    }
+}
+function getWithPath(object, path, defaultValue) {
+    if (path.length === 0) {
+        return defaultValue;
+    }
+    let current = object;
+    for (let index = 0; index < path.length; index++) {
+        if (current == null) {
+            return defaultValue;
+        }
+        current = current[path[index]];
+    }
+    if (current === undefined) {
+        return defaultValue;
+    }
+    return current;
+}
+
+const IS_UNSIGNED_INTEGER = /^(?:0|[1-9]\d*)$/;
+function isIndex(value, length = Number.MAX_SAFE_INTEGER) {
+    switch (typeof value) {
+        case 'number': {
+            return Number.isInteger(value) && value >= 0 && value < length;
+        }
+        case 'symbol': {
+            return false;
+        }
+        case 'string': {
+            return IS_UNSIGNED_INTEGER.test(value);
+        }
+    }
+}
+
+function set(obj, path, value) {
+    const resolvedPath = Array.isArray(path) ? path : typeof path === 'string' ? toPath(path) : [path];
+    let current = obj;
+    for (let i = 0; i < resolvedPath.length - 1; i++) {
+        const key = resolvedPath[i];
+        const nextKey = resolvedPath[i + 1];
+        if (current[key] == null) {
+            current[key] = isIndex(nextKey) ? [] : {};
+        }
+        current = current[key];
+    }
+    const lastKey = resolvedPath[resolvedPath.length - 1];
+    current[lastKey] = 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'];
+        // TODO [>=0.9.16] Remove the fallback to generateNewId once a new version is released and manual setter
+        const id = get(this.data, idPath) ??
+            entity.type.generateNewId();
+        if (!get(this.data, idPath)) {
+            set(this.data, idPath, id);
+        }
+        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,
+    })
+});
+
+const {z} = await importShared('zod');
+const featureEntityType = createEntityType('feature');
+const featureNameSchema = CASE_VALIDATORS.KEBAB_CASE;
+const featureSchema = zEnt(z.object({
+    name: z
+        .string()
+        .min(1)
+        .refine((name) => name
+        .split('/')
+        .every((part) => featureNameSchema.safeParse(part).success), {
+        message: 'Feature name must be lowercase and contain only letters, numbers, and dashes',
+    }),
+    parentRef: zRef(z.string().nullish(), {
+        type: featureEntityType,
+        onDelete: 'DELETE_PARENT',
+    }),
+}), { type: featureEntityType });
+const featuresSchema = z.array(featureSchema).default([]);
+
+function getRootFeatures(projectDefinition) {
+    return projectDefinition.features.filter((f) => !f.parentRef);
+}
+function getFeatureById(projectDefinition, featureId) {
+    return projectDefinition.features.find((f) => f.id === featureId);
+}
+function getFeatureByIdOrThrow(projectDefinition, featureId) {
+    const feature = getFeatureById(projectDefinition, featureId);
+    if (!feature) {
+        throw new Error(`Could not find feature with ID ${featureId}`);
+    }
+    return feature;
+}
+function getFeatureChildren(projectDefinition, featureId) {
+    return projectDefinition.features.filter((f) => f.parentRef === featureId);
+}
+function getFeatureName(featureConfig) {
+    return featureConfig.name.split('/').pop() ?? '';
+}
+function getFeatureNameById(projectDefinition, featureId) {
+    const feature = getFeatureByIdOrThrow(projectDefinition, featureId);
+    return getFeatureName(feature);
+}
+function getFeaturePathById(projectDefinition, featureId) {
+    const feature = getFeatureByIdOrThrow(projectDefinition, featureId);
+    return feature.name;
+}
+function validateFeatureName(name) {
+    const nameParts = name.split('/');
+    return nameParts.every((part) => featureNameSchema.safeParse(part).success);
+}
+function ensureFeatureByNameRecursively(projectDefinition, nameOrId) {
+    if (featureEntityType.isId(nameOrId)) {
+        return nameOrId;
+    }
+    const nameParts = nameOrId.split('/');
+    let lastName = '';
+    let parentRef = null;
+    for (const part of nameParts) {
+        const feature = projectDefinition.features.find((f) => f.name === part && f.parentRef === parentRef);
+        const name = [lastName, part].filter(Boolean).join('/');
+        if (feature) {
+            parentRef = feature.id;
+        }
+        else {
+            const newFeature = {
+                id: featureEntityType.generateNewId(),
+                name,
+                parentRef,
+            };
+            projectDefinition.features.push(newFeature);
+            parentRef = newFeature.id;
+        }
+        lastName = name;
+    }
+    if (!parentRef) {
+        throw new Error('Failed to create feature');
+    }
+    return parentRef;
+}
+function getFeatureByName(projectDefinition, name) {
+    return projectDefinition.features.find((f) => f.name === name);
+}
+function getFeatureIdByNameOrDefault(projectDefinition, name) {
+    return getFeatureByName(projectDefinition, name)?.id ?? name;
+}
+const FeatureUtils = {
+    getRootFeatures,
+    getFeatureById,
+    getFeatureByIdOrThrow,
+    getFeatureChildren,
+    getFeatureName,
+    getFeatureNameById,
+    getFeaturePathById,
+    validateFeatureName,
+    ensureFeatureByNameRecursively,
+    getFeatureByName,
+    getFeatureIdByNameOrDefault,
+};
+
+function byId(projectDefinition, id) {
+    return projectDefinition.models.find((m) => m.id === id);
+}
+function byIdOrThrow(projectDefinition, id) {
+    const model = byId(projectDefinition, id);
+    if (!model) {
+        throw new Error(`Could not find model with ID ${id}`);
+    }
+    return model;
+}
+function getScalarFieldById(model, id) {
+    const field = model.model.fields.find((f) => f.id === id);
+    if (!field) {
+        throw new Error(`Could not find field with ID ${id}`);
+    }
+    return field;
+}
+function getRelationsToModel(projectDefinition, modelId) {
+    return projectDefinition.models.flatMap((m) => m.model.relations
+        ?.filter((r) => r.modelRef === modelId)
+        .map((r) => ({ model: m, relation: r })) ?? []);
+}
+function getModelsForFeature(projectDefinition, featureId) {
+    return projectDefinition.models.filter((m) => m.featureRef === featureId);
+}
+function getModelIdFields(model) {
+    return model.model.primaryKeyFieldRefs;
+}
+function hasService(model) {
+    return (!!model.service.create.enabled ||
+        !!model.service.update.enabled ||
+        !!model.service.delete.enabled ||
+        model.service.transformers.length > 0);
+}
+function validateModelName(name) {
+    return PASCAL_CASE_REGEX.test(name);
+}
+/**
+ * Returns the ID of a model by name, or the name if no model is found.
+ * @param projectDefinition - The project definition.
+ * @param name - The name of the model.
+ * @returns The ID of the model, or the name if no model is found.
+ */
+function getModelIdByNameOrDefault(projectDefinition, name) {
+    return projectDefinition.models.find((m) => m.name === name)?.id ?? name;
+}
+const ModelUtils = {
+    byId,
+    byIdOrThrow,
+    getScalarFieldById,
+    getRelationsToModel,
+    getModelsForFeature,
+    getModelIdFields,
+    hasService,
+    validateModelName,
+    getModelIdByNameOrDefault,
+};
+
+export { CASE_VALIDATORS as C, DefinitionEntityType as D, FeatureUtils as F, ModelUtils as M, ZodRefWrapper as Z, isEqual as a, createEntityType as b, createPluginSpec as c, get as d, eq as e, zRef as f, getSymbols as g, zEnt as h, isPlainObject as i, createDefinitionEntityNameResolver as j, ZodRef as k, featureEntityType as l, zRefBuilder as m, zRefId as n, featuresSchema as o, zPluginWrapper as p, ZodPluginWrapper as q, createInitializedPluginSpec as r, set as s, ZodRefBuilder as t, featureNameSchema as u, featureSchema as v, zodPluginSymbol as z };
+//# sourceMappingURL=model-utils-CbQJy1wE.js.map