@baseplate-dev/plugin-auth 3.0.1 → 3.0.2

package/dist/web/assets/{model-merger-CI1pu411.js → model-merger-kOQ_dmiE.js}

@@ -1,4 +1,4 @@
-import { importShared } from './__federation_fn_import-BVpKhyMw.js';
+import { importShared } from './__federation_fn_import-CVjKjdRb.js';
 import { g as getSymbols, a as isPlainObject, e as eq } from './isEqual-DAXqKRba.js';
 
 function createInitializedPluginSpec(spec, implementation) {
@@ -243,171 +243,6 @@ function createEntityType(name, options) {
     return new DefinitionEntityType(name, prefix, parentType);
 }
 
-class DefinitionReferenceMarker {
-    value;
-    reference;
-    constructor(value, reference) {
-        this.value = value;
-        this.reference = reference;
-    }
-    toString() {
-        return this.value ?? '';
-    }
-}
-const REF_ANNOTATIONS_MARKER_SYMBOL = Symbol('refAnnotationsMarker');
-
-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;
-        });
-    }
-    return {
-        withRef,
-        withEnt,
-        withRefBuilder,
-    };
-}
-
-const {z: z$1} = await importShared('zod');
-
-function isEmpty(value) {
-    if (value === undefined || value === null) {
-        return true;
-    }
-    if (Array.isArray(value)) {
-        return value.length === 0;
-    }
-    if (typeof value === 'object' &&
-        Object.getPrototypeOf(value) === Object.prototype) {
-        return Object.values(value).every((val) => val === undefined);
-    }
-    if (typeof value === 'string') {
-        return value === '';
-    }
-    return false;
-}
-/**
- * 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) {
     switch (typeof key) {
         case 'number':
@@ -689,6 +524,324 @@ function set(obj, path, value) {
     return obj;
 }
 
+class DefinitionReferenceMarker {
+    value;
+    reference;
+    constructor(value, reference) {
+        this.value = value;
+        this.reference = reference;
+    }
+    toString() {
+        return this.value ?? '';
+    }
+}
+const REF_ANNOTATIONS_MARKER_SYMBOL = Symbol('refAnnotationsMarker');
+
+/**
+ * Creates a new ref context slot for the given entity type.
+ * Each call creates a unique slot, even for the same entity type.
+ *
+ * @param name - A descriptive name for debugging (shows in Symbol description)
+ * @param entityType - The entity type this slot will be associated with
+ * @returns A new unique RefContextSlot instance
+ *
+ * @example
+ * ```typescript
+ * const modelSlot = createRefContextSlot('modelSlot', modelEntityType);
+ * const anotherModelSlot = createRefContextSlot('anotherModelSlot', modelEntityType);
+ *
+ * // These are different slots despite same entity type
+ * modelSlot.id !== anotherModelSlot.id
+ * // modelSlot.id.toString() === 'Symbol(modelSlot)'
+ * ```
+ */
+function createRefContextSlot(name, entityType) {
+    return {
+        entityType,
+        id: Symbol(name),
+    };
+}
+/**
+ * Creates a RefContextSlotMap from a slot definition.
+ * Used internally by ctx.refContext().
+ *
+ * @param slotDefinition - Map of slot names to entity types
+ * @returns Map of slot names to RefContextSlot instances
+ */
+function createRefContextSlotMap(slotDefinition) {
+    return Object.fromEntries(Object.entries(slotDefinition).map(([key, entityType]) => [
+        key,
+        createRefContextSlot(key, entityType),
+    ]));
+}
+
+/**
+ * Strips the DefinitionReferenceMarker from the value recursively.
+ * @param value - The value to strip the DefinitionReferenceMarker from.
+ * @returns The value without the DefinitionReferenceMarker.
+ */
+function stripRefMarkers(value) {
+    if (value instanceof DefinitionReferenceMarker) {
+        return value.value;
+    }
+    if (Array.isArray(value)) {
+        return value.map(stripRefMarkers);
+    }
+    if (typeof value === 'object' && value !== null) {
+        return Object.fromEntries(Object.entries(value).map(([key, childValue]) => [
+            key,
+            stripRefMarkers(childValue),
+        ]));
+    }
+    return value;
+}
+
+const {z: z$1} = await importShared('zod');
+function extendParserContextWithRefs({ transformReferences, }) {
+    function modifyAnnotations(value, ctx, modifier) {
+        if (value === null || value === undefined)
+            return value;
+        if (typeof value !== 'object') {
+            ctx.addIssue({
+                code: 'invalid_type',
+                expected: 'object',
+                message: `Entity must be an object`,
+                input: value,
+            });
+            return value;
+        }
+        if (transformReferences) {
+            const existingAnnotations = REF_ANNOTATIONS_MARKER_SYMBOL in value
+                ? value[REF_ANNOTATIONS_MARKER_SYMBOL]
+                : { entities: [], references: [], slots: [] };
+            return {
+                ...value,
+                [REF_ANNOTATIONS_MARKER_SYMBOL]: modifier(existingAnnotations),
+            };
+        }
+        return value;
+    }
+    function withRef(reference) {
+        return z$1.string().transform((value) => {
+            if (transformReferences && value) {
+                return new DefinitionReferenceMarker(value, {
+                    path: [],
+                    type: reference.type,
+                    onDelete: reference.onDelete,
+                    parentSlot: reference.parentSlot,
+                    provides: reference.provides,
+                });
+            }
+            return value;
+        });
+    }
+    function withEnt(schema, entity) {
+        return schema.transform((value, ctx) => {
+            if (value === null || value === undefined)
+                return value;
+            if (transformReferences) {
+                if (typeof value !== 'object') {
+                    ctx.addIssue({
+                        code: 'invalid_type',
+                        expected: 'object',
+                        message: `Entity must be an object`,
+                        input: value,
+                    });
+                    return value;
+                }
+                // Check if the id is valid
+                const idPath = entity.idPath ?? ['id'];
+                const id = get(value, idPath);
+                if (typeof id !== 'string' || !id || !entity.type.isId(id)) {
+                    ctx.addIssue({
+                        code: 'custom',
+                        message: `Unable to find string id field '${entity.idPath?.join('.') ?? 'id'}' in entity ${entity.type.name}`,
+                        input: value,
+                    });
+                    return value;
+                }
+                const nameResolver = (() => {
+                    if (entity.getNameResolver) {
+                        return entity.getNameResolver(stripRefMarkers(value));
+                    }
+                    if (!('name' in value) || typeof value.name !== 'string') {
+                        ctx.addIssue({
+                            code: 'custom',
+                            message: `Unable to find string name field in entity ${entity.type.name}`,
+                            input: value,
+                        });
+                        return 'invalid';
+                    }
+                    return value.name;
+                })();
+                const newEntity = {
+                    id,
+                    idPath,
+                    path: [],
+                    type: entity.type,
+                    nameResolver,
+                    parentSlot: entity.parentSlot,
+                    provides: entity.provides,
+                };
+                return modifyAnnotations(value, ctx, (annotations) => ({
+                    ...annotations,
+                    entities: [...annotations.entities, newEntity],
+                }));
+            }
+            return value;
+        });
+    }
+    /**
+     * Creates ref context slots for use within a schema definition.
+     * Slots provide type-safe context for parent-child entity relationships.
+     *
+     * @example
+     * ```typescript
+     * ctx.refContext(
+     *   { modelSlot: modelEntityType },
+     *   ({ modelSlot }) =>
+     *     ctx.withEnt(schema, {
+     *       type: modelEntityType,
+     *       provides: modelSlot,
+     *     }),
+     * );
+     * ```
+     */
+    function refContext(slotDefinition, schemaBuilder) {
+        const slots = createRefContextSlotMap(slotDefinition);
+        return schemaBuilder(slots).transform((value, ctx) => modifyAnnotations(value, ctx, (annotations) => ({
+            ...annotations,
+            slots: [
+                ...annotations.slots,
+                ...Object.values(slots).map((slot) => ({
+                    path: [],
+                    slot,
+                })),
+            ],
+        })));
+    }
+    return {
+        withRef,
+        withEnt,
+        refContext,
+    };
+}
+
+function isEmpty(value) {
+    if (value === undefined || value === null) {
+        return true;
+    }
+    if (Array.isArray(value)) {
+        return value.length === 0;
+    }
+    if (typeof value === 'object' &&
+        Object.getPrototypeOf(value) === Object.prototype) {
+        return Object.values(value).every((val) => val === undefined);
+    }
+    if (typeof value === 'string') {
+        return value === '';
+    }
+    return false;
+}
+/**
+ * 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) {
+            switch (mode) {
+                case 'populate': {
+                    return schema.prefault(defaultValue).optional();
+                }
+                case 'strip': {
+                    // Use transform to remove values matching defaults after validation
+                    return schema
+                        .transform((value) => {
+                        if (value === defaultValue)
+                            return undefined;
+                        if (isEmpty(value)) {
+                            return undefined;
+                        }
+                        return value;
+                    })
+                        .optional();
+                }
+                case 'preserve': {
+                    // Return schema with .optional() added
+                    return schema.transform((x) => x).optional();
+                }
+            }
+        },
+    };
+}
+
+function createDefinitionSchemaParserContext(options) {
+    return {
+        ...options,
+        ...extendParserContextWithRefs(options),
+        ...extendParserContextWithDefaults(options),
+    };
+}
+function definitionSchema(creator) {
+    return (context) => creator(context);
+}
+/**
+ * Creates a schema that requires slots to be passed from parent schemas.
+ * Used when a schema needs to reference entities from a parent context.
+ *
+ * @example
+ * ```typescript
+ * // Child schema requiring modelSlot from parent
+ * export const createModelScalarFieldSchema = definitionSchemaWithSlots(
+ *   { modelSlot: modelEntityType },
+ *   (ctx, { modelSlot }) =>
+ *     ctx.withEnt(schema, {
+ *       type: modelScalarFieldEntityType,
+ *       parentSlot: modelSlot,
+ *     }),
+ * );
+ *
+ * // Called from parent:
+ * createModelScalarFieldSchema(ctx, { modelSlot: parentModelSlot })
+ * ```
+ */
+function definitionSchemaWithSlots(slotDefinition, creator) {
+    const creatorWithSlots = (context, slots) => creator(context, slots);
+    creatorWithSlots.slotDefinition = slotDefinition;
+    return creatorWithSlots;
+}
+/**
+ * Wraps a schema creator that requires slots with placeholder slots,
+ * producing a simple schema creator that can be used for validation-only
+ * contexts (e.g., React Hook Form).
+ *
+ * The placeholder slots allow the schema to parse without actual parent context,
+ * which is useful when you only need schema validation without ref extraction.
+ *
+ * @example
+ * ```typescript
+ * // Schema that normally requires modelSlot from parent
+ * const createModelScalarFieldSchema = definitionSchemaWithSlots(
+ *   { modelSlot: modelEntityType },
+ *   (ctx, { modelSlot }) => ctx.withEnt(schema, { parentSlot: modelSlot }),
+ * );
+ *
+ * // For React Hook Form validation, wrap with placeholder slots
+ * const fieldSchema = withPlaceholderSlots(createModelScalarFieldSchema);
+ * const zodSchema = fieldSchema(ctx); // No slots needed
+ * ```
+ */
+function withPlaceholderSlots(schemaCreator) {
+    return (ctx) => {
+        const placeholderSlots = createRefContextSlotMap(schemaCreator.slotDefinition);
+        return schemaCreator(ctx, placeholderSlots);
+    };
+}
+
 const {CASE_VALIDATORS} = await importShared('@baseplate-dev/utils');
 
 const {z} = await importShared('zod');
@@ -1300,7 +1453,8 @@ function applyModelMergerDiff(model, diff, definitionContainer, siblingModels =
                 }
                 return field.id;
             }
-            const model = ModelUtils.byIdOrThrow(definitionContainer.definition, modelId);
+            const model = ModelUtils.byName(definitionContainer.definition, modelId) ??
+                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}`);
@@ -1331,7 +1485,9 @@ function applyModelMergerDiff(model, diff, definitionContainer, siblingModels =
             if (siblingModel) {
                 return siblingModel.id;
             }
-            return modelRef;
+            const model = ModelUtils.byName(definitionContainer.definition, modelRef) ??
+                ModelUtils.byIdOrThrow(definitionContainer.definition, modelRef);
+            return model.id;
         }),
     };
 }
@@ -1375,5 +1531,5 @@ function createAndApplyModelMergerResults(draftConfig, current, desired, definit
     return resultIds;
 }
 
-export { createModelMergerResults as A, applyModelMergerDiff as B, applyModelMergerResultInPlace as C, DefinitionReferenceMarker as D, createAndApplyModelMergerResults as E, FeatureUtils as F, DefinitionDiffKeyedArrayField as G, DefinitionDiffReplacementField as H, DefinitionDiffArrayIncludesField as I, createDefinitionDiffConfig as J, createDefinitionDiff as K, applyDefinitionDiff as L, ModelUtils as M, 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, modelEntityType as i, modelTransformerEntityType as j, modelEnumValueEntityType as k, featureEntityType as l, mapValues as m, modelEnumEntityType as n, modelUniqueConstraintEntityType as o, createFeaturesSchema as p, omit as q, cloneDeep as r, set as s, createInitializedPluginSpec as t, DefinitionEntityType as u, featureNameSchema as v, createFeatureSchema as w, modelMergerDefinitionDiffConfig as x, createModelMergerResult as y, doesModelMergerResultsHaveChanges as z };
-//# sourceMappingURL=model-merger-CI1pu411.js.map
+export { featureNameSchema as A, createFeatureSchema as B, modelMergerDefinitionDiffConfig as C, DefinitionReferenceMarker as D, createModelMergerResult as E, FeatureUtils as F, doesModelMergerResultsHaveChanges as G, createModelMergerResults as H, applyModelMergerDiff as I, applyModelMergerResultInPlace as J, createAndApplyModelMergerResults as K, DefinitionDiffKeyedArrayField as L, ModelUtils as M, DefinitionDiffReplacementField as N, DefinitionDiffArrayIncludesField as O, createDefinitionDiffConfig as P, createDefinitionDiff as Q, REF_ANNOTATIONS_MARKER_SYMBOL as R, applyDefinitionDiff as S, createEntityType as a, createDefinitionSchemaParserContext as b, createPluginSpec as c, definitionSchemaWithSlots as d, set as e, definitionSchema as f, get as g, modelForeignRelationEntityType as h, modelLocalRelationEntityType as i, modelScalarFieldEntityType as j, modelEntityType as k, modelTransformerEntityType as l, mapValues as m, modelEnumValueEntityType as n, modelEnumEntityType as o, featureEntityType as p, modelUniqueConstraintEntityType as q, createFeaturesSchema as r, stripRefMarkers as s, omit as t, cloneDeep as u, createInitializedPluginSpec as v, createRefContextSlot as w, createRefContextSlotMap as x, DefinitionEntityType as y, withPlaceholderSlots as z };
+//# sourceMappingURL=model-merger-kOQ_dmiE.js.map