@baseplate-dev/plugin-auth 0.1.3 → 1.0.1

package/dist/web/assets/__federation_shared_@baseplate-dev/{project-builder-lib-GtzVuDsM.js → project-builder-lib-BAwM_-SS.js}

@@ -1,6 +1,6 @@
-import { c as createPluginSpec, i as isEqual, m as mapValues, a as createEntityType, z as zodPluginSymbol, Z as ZodRefWrapper, g as get$1, s as set$1, C as CASE_VALIDATORS, b as zRef, d as modelForeignRelationEntityType, e as modelLocalRelationEntityType, f as modelScalarFieldEntityType, h as zEnt, j as modelTransformerEntityType, k as createDefinitionEntityNameResolver, l as modelEntityType, n as ZodRef, o as modelEnumValueEntityType, p as featureEntityType, q as modelEnumEntityType, r as zRefBuilder, t as zRefId, u as modelUniqueConstraintEntityType, v as featuresSchema, M as ModelUtils, w as zPluginWrapper, x as omit, y as cloneDeep } from '../model-merger-CdV-7CWE.js';
-export { R as DefinitionDiffArrayIncludesField, P as DefinitionDiffKeyedArrayField, Q as DefinitionDiffReplacementField, E as DefinitionEntityType, F as FeatureUtils, A as ZodPluginWrapper, D as ZodRefBuilder, U as applyDefinitionDiff, L as applyModelMergerDiff, N as applyModelMergerResultInPlace, O as createAndApplyModelMergerResults, T as createDefinitionDiff, S as createDefinitionDiffConfig, B as createInitializedPluginSpec, J as createModelMergerResult, K as createModelMergerResults, G as featureNameSchema, H as featureSchema, I as modelMergerDefinitionDiffConfig } from '../model-merger-CdV-7CWE.js';
-import { importShared } from '../__federation_fn_import-dzKjrTzS.js';
+import { c as createPluginSpec, i as isEqual, m as mapValues, a as createEntityType, z as zodPluginSymbol, Z as ZodRefWrapper, g as get$1, s as set$1, C as CASE_VALIDATORS, d as definitionSchema, b as zRef, e as modelForeignRelationEntityType, f as modelLocalRelationEntityType, h as modelScalarFieldEntityType, j as zEnt, k as modelTransformerEntityType, l as createDefinitionEntityNameResolver, n as modelEntityType, o as modelEnumValueEntityType, p as featureEntityType, q as modelEnumEntityType, r as zRefBuilder, t as zRefId, u as modelUniqueConstraintEntityType, v as createFeaturesSchema, M as ModelUtils, w as zPluginWrapper, x as omit, y as cloneDeep } from '../model-merger-gxuB007n.js';
+export { S as DefinitionDiffArrayIncludesField, Q as DefinitionDiffKeyedArrayField, R as DefinitionDiffReplacementField, G as DefinitionEntityType, F as FeatureUtils, A as ZodPluginWrapper, E as ZodRef, D as ZodRefBuilder, V as applyDefinitionDiff, N as applyModelMergerDiff, O as applyModelMergerResultInPlace, P as createAndApplyModelMergerResults, U as createDefinitionDiff, T as createDefinitionDiffConfig, I as createFeatureSchema, B as createInitializedPluginSpec, K as createModelMergerResult, L as createModelMergerResults, H as featureNameSchema, J as modelMergerDefinitionDiffConfig } from '../model-merger-gxuB007n.js';
+import { importShared } from '../__federation_fn_import-CxP86CUK.js';
 
 function createAdminCrudInputCompilerImplementation() {
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -1473,27 +1473,27 @@ function createPluginConfigImplementation() {
     const schemas = new Map();
     const migrationsMap = new Map();
     return {
-        registerSchema(pluginId, schema) {
-            if (schemas.has(pluginId)) {
-                throw new Error(`Schema for plugin ${pluginId} is already registered`);
+        registerSchema(pluginKey, schema) {
+            if (schemas.has(pluginKey)) {
+                throw new Error(`Schema for plugin ${pluginKey} is already registered`);
             }
-            schemas.set(pluginId, schema);
+            schemas.set(pluginKey, schema);
         },
-        registerMigrations(pluginId, migrations) {
-            if (migrationsMap.has(pluginId)) {
-                throw new Error(`Migrations for plugin ${pluginId} are already registered`);
+        registerMigrations(pluginKey, migrations) {
+            if (migrationsMap.has(pluginKey)) {
+                throw new Error(`Migrations for plugin ${pluginKey} are already registered`);
             }
             const sortedMigrations = sortAndValidateMigrations(migrations);
-            migrationsMap.set(pluginId, sortedMigrations);
+            migrationsMap.set(pluginKey, sortedMigrations);
         },
-        getSchema(pluginId) {
-            return schemas.get(pluginId);
+        getSchema(pluginKey) {
+            return schemas.get(pluginKey);
         },
-        getMigrations(pluginId) {
-            return migrationsMap.get(pluginId);
+        getMigrations(pluginKey) {
+            return migrationsMap.get(pluginKey);
         },
-        getLastMigrationVersion(pluginId) {
-            const migrations = migrationsMap.get(pluginId);
+        getLastMigrationVersion(pluginKey) {
+            const migrations = migrationsMap.get(pluginKey);
             return migrations?.[migrations.length - 1]?.version;
         },
     };
@@ -1518,7 +1518,7 @@ function runPluginMigrations(projectDefinition, pluginImplementationStore) {
     setAutoFreeze(false);
     return produce(projectDefinition, (draft) => {
         for (const pluginDefinition of draft.plugins ?? []) {
-            const pluginMigrations = pluginConfigService.getMigrations(pluginEntityType.toUid(pluginDefinition.id));
+            const pluginMigrations = pluginConfigService.getMigrations(pluginEntityType.keyFromId(pluginDefinition.id));
             const currentSchemaVersion = pluginDefinition.configSchemaVersion ?? -1;
             if (!pluginMigrations)
                 continue;
@@ -2568,7 +2568,7 @@ const palettesSchema = z$i.object({
     base: paletteSchema,
     primary: paletteSchema,
 });
-const themeSchema = z$i.object({
+const createThemeSchema = definitionSchema(() => z$i.object({
     palettes: z$i.object({
         base: paletteSchema,
         primary: paletteSchema,
@@ -2577,7 +2577,7 @@ const themeSchema = z$i.object({
         light: themeColorSchema,
         dark: themeColorSchema,
     }),
-});
+}));
 
 const {z: z$h} = await importShared('zod');
 
@@ -2605,7 +2605,7 @@ const roleArray = z$g
     onDelete: 'DELETE',
 }))
     .optional();
-const modelGraphqlSchema = z$g.object({
+const createModelGraphqlSchema = definitionSchema(() => z$g.object({
     objectType: z$g
         .object({
         enabled: z$g.boolean().default(false),
@@ -2689,7 +2689,7 @@ const modelGraphqlSchema = z$g.object({
         }),
     })
         .default({}),
-});
+}));
 
 const {z: z$f} = await importShared('zod');
 
@@ -2705,15 +2705,15 @@ function createModelTransformerType(payload) {
 }
 
 const {z: z$e} = await importShared('zod');
-const passwordTransformerSchema = zEnt(z$e.object({
+const createPasswordTransformerSchema = definitionSchema(() => zEnt(z$e.object({
     ...baseTransformerFields,
     type: z$e.literal('password'),
 }), {
     type: modelTransformerEntityType,
     parentPath: { context: 'model' },
     getNameResolver: () => 'password',
-});
-const embeddedRelationTransformerSchema = zEnt(z$e.object({
+}));
+const createEmbeddedRelationTransformerSchema = definitionSchema(() => zEnt(z$e.object({
     ...baseTransformerFields,
     foreignRelationRef: zRef(z$e.string().min(1), {
         type: modelForeignRelationEntityType,
@@ -2746,16 +2746,16 @@ const embeddedRelationTransformerSchema = zEnt(z$e.object({
     }),
 }).refBuilder((builder) => {
     builder.addPathToContext('modelRef', modelEntityType, 'embeddedModel');
-});
+}));
 const BUILT_IN_TRANSFORMERS = [
     createModelTransformerType({
         name: 'password',
-        schema: passwordTransformerSchema,
+        schema: createPasswordTransformerSchema,
         getName: () => 'Password',
     }),
     createModelTransformerType({
         name: 'embeddedRelation',
-        schema: embeddedRelationTransformerSchema,
+        schema: createEmbeddedRelationTransformerSchema,
         getName: (definitionContainer, definition) => definitionContainer.nameFromId(definition.foreignRelationRef),
     }),
 ];
@@ -2771,10 +2771,6 @@ function createModelTransformerImplementation() {
             if (transformers[transformer.name]) {
                 throw new Error(`Model transformer with name ${transformer.name} is already registered`);
             }
-            // check transformer schema is a zEnt
-            if (!(transformer.schema instanceof ZodRef)) {
-                throw new TypeError(`Model transformer schema for ${transformer.name} is not a zEnt`);
-            }
             transformers[transformer.name] =
                 transformer;
         },
@@ -2797,38 +2793,38 @@ const modelTransformerSpec = createPluginSpec('core/model-transformer', {
     defaultInitializer: createModelTransformerImplementation,
 });
 
-const transformerSchema = zWithPlugins((plugins, data) => {
+const createTransformerSchema = definitionSchema((ctx) => zWithPlugins((plugins, data) => {
     const { type } = baseTransformerSchema.parse(data);
     const transformer = plugins
         .getPluginSpec(modelTransformerSpec)
         .getModelTransformer(type);
-    return transformer.schema;
-});
+    return transformer.schema(ctx);
+}));
 
 const {z: z$d} = await importShared('zod');
-const enumValueSchema = zEnt(z$d.object({
+const createEnumValueSchema = definitionSchema(() => zEnt(z$d.object({
     name: z$d.string().min(1),
     friendlyName: z$d.string().min(1),
 }), {
     type: modelEnumValueEntityType,
     parentPath: { context: 'enum' },
-});
-const enumBaseSchema = z$d.object({
+}));
+const createEnumBaseSchema = definitionSchema((ctx) => z$d.object({
     name: z$d.string().min(1),
     featureRef: zRef(z$d.string().min(1), {
         type: featureEntityType,
         onDelete: 'RESTRICT',
     }),
-    values: z$d.array(enumValueSchema),
+    values: z$d.array(createEnumValueSchema(ctx)),
     isExposed: z$d.boolean(),
-});
-const enumSchema = zEnt(enumBaseSchema, {
+}));
+const createEnumSchema = definitionSchema((ctx) => zEnt(createEnumBaseSchema(ctx), {
     type: modelEnumEntityType,
     addContext: 'enum',
-});
+}));
 
 const {z: z$c} = await importShared('zod');
-const modelScalarFieldSchema = zEnt(z$c.object({
+const createModelScalarFieldSchema = definitionSchema(() => zEnt(z$c.object({
     name: VALIDATORS.CAMEL_CASE_STRING,
     type: z$c.enum(SCALAR_FIELD_TYPES),
     isOptional: z$c.boolean().default(false),
@@ -2890,7 +2886,7 @@ const modelScalarFieldSchema = zEnt(z$c.object({
         };
     }
     return value;
-});
+}));
 const REFERENTIAL_ACTIONS = [
     'Cascade',
     'Restrict',
@@ -2898,7 +2894,7 @@ const REFERENTIAL_ACTIONS = [
     'SetNull',
     'SetDefault',
 ];
-const modelRelationFieldSchema = zRefBuilder(z$c.object({
+const createModelRelationFieldSchema = definitionSchema(() => zRefBuilder(z$c.object({
     id: zRefId,
     foreignId: z$c
         .string()
@@ -2937,8 +2933,8 @@ const modelRelationFieldSchema = zRefBuilder(z$c.object({
         getNameResolver: (entity) => entity.foreignRelationName,
         parentPath: 'modelRef',
     });
-});
-const modelUniqueConstraintSchema = zEnt(z$c.object({
+}));
+const createModelUniqueConstraintSchema = definitionSchema(() => zEnt(z$c.object({
     fields: z$c.array(z$c.object({
         fieldRef: zRef(z$c.string().min(1), {
             type: modelScalarFieldEntityType,
@@ -2955,8 +2951,8 @@ const modelUniqueConstraintSchema = zEnt(z$c.object({
             resolveName: (entityNames) => entityNames.fields.join('_'),
         });
     },
-});
-const modelServiceSchema = z$c.object({
+}));
+const createModelServiceSchema = definitionSchema((ctx) => z$c.object({
     create: z$c
         .object({
         enabled: z$c.boolean().default(false),
@@ -3002,9 +2998,9 @@ const modelServiceSchema = z$c.object({
         .default({
         enabled: false,
     }),
-    transformers: z$c.array(transformerSchema).default([]),
-});
-const modelBaseSchema = z$c.object({
+    transformers: z$c.array(createTransformerSchema(ctx)).default([]),
+}));
+const createModelBaseSchema = definitionSchema((ctx) => z$c.object({
     id: zRefId,
     name: VALIDATORS.PASCAL_CASE_STRING,
     featureRef: zRef(z$c.string().min(1), {
@@ -3012,8 +3008,8 @@ const modelBaseSchema = z$c.object({
         onDelete: 'RESTRICT',
     }),
     model: z$c.object({
-        fields: z$c.array(modelScalarFieldSchema),
-        relations: z$c.array(modelRelationFieldSchema).optional(),
+        fields: z$c.array(createModelScalarFieldSchema(ctx)),
+        relations: z$c.array(createModelRelationFieldSchema(ctx)).optional(),
         primaryKeyFieldRefs: z$c
             .array(zRef(z$c.string(), {
             type: modelScalarFieldEntityType,
@@ -3021,20 +3017,22 @@ const modelBaseSchema = z$c.object({
             parentPath: { context: 'model' },
         }))
             .min(1),
-        uniqueConstraints: z$c.array(modelUniqueConstraintSchema).optional(),
+        uniqueConstraints: z$c
+            .array(createModelUniqueConstraintSchema(ctx))
+            .optional(),
     }),
-    service: modelServiceSchema.default({
+    service: createModelServiceSchema(ctx).default({
         create: { enabled: false },
         update: { enabled: false },
         delete: { enabled: false },
         transformers: [],
     }),
-    graphql: modelGraphqlSchema.optional(),
-});
-const modelSchema = zEnt(modelBaseSchema, {
+    graphql: createModelGraphqlSchema(ctx).optional(),
+}));
+const createModelSchema = definitionSchema((ctx) => zEnt(createModelBaseSchema(ctx), {
     type: modelEntityType,
     addContext: 'model',
-});
+}));
 
 const adminSectionEntityType = createEntityType('admin-section', {
     parentType: appEntityType,
@@ -3065,7 +3063,7 @@ const adminCrudEmbeddedFormEntityType = createEntityType('admin-crud-embedded-fo
 });
 
 const {z: z$9} = await importShared('zod');
-const adminCrudTextInputSchema = z$9.object({
+const createAdminCrudTextInputSchema = definitionSchema(() => z$9.object({
     type: z$9.literal('text'),
     label: z$9.string().min(1),
     modelFieldRef: zRef(z$9.string(), {
@@ -3074,12 +3072,12 @@ const adminCrudTextInputSchema = z$9.object({
         parentPath: { context: 'model' },
     }),
     validation: z$9.string().optional(),
-});
+}));
 const adminCrudTextInputType = createAdminCrudInputType({
     name: 'text',
-    schema: adminCrudTextInputSchema,
+    schema: createAdminCrudTextInputSchema,
 });
-const adminCrudForeignInputSchema = z$9.object({
+const createAdminCrudForeignInputSchema = definitionSchema(() => z$9.object({
     type: z$9.literal('foreign'),
     label: z$9.string().min(1),
     localRelationRef: zRef(z$9.string(), {
@@ -3091,12 +3089,12 @@ const adminCrudForeignInputSchema = z$9.object({
     valueExpression: z$9.string().min(1),
     defaultLabel: z$9.string().optional(),
     nullLabel: z$9.string().optional(),
-});
+}));
 const adminCrudForeignInputType = createAdminCrudInputType({
     name: 'foreign',
-    schema: adminCrudForeignInputSchema,
+    schema: createAdminCrudForeignInputSchema,
 });
-const adminCrudEnumInputSchema = z$9.object({
+const createAdminCrudEnumInputSchema = definitionSchema(() => z$9.object({
     type: z$9.literal('enum'),
     label: z$9.string().min(1),
     modelFieldRef: zRef(z$9.string(), {
@@ -3104,12 +3102,12 @@ const adminCrudEnumInputSchema = z$9.object({
         onDelete: 'RESTRICT',
         parentPath: { context: 'model' },
     }),
-});
+}));
 const adminCrudEnumInputType = createAdminCrudInputType({
     name: 'enum',
-    schema: adminCrudEnumInputSchema,
+    schema: createAdminCrudEnumInputSchema,
 });
-const adminCrudEmbeddedInputSchema = z$9.object({
+const createAdminCrudEmbeddedInputSchema = definitionSchema(() => z$9.object({
     type: z$9.literal('embedded'),
     label: z$9.string().min(1),
     modelRelationRef: zRef(z$9.string(), {
@@ -3122,12 +3120,12 @@ const adminCrudEmbeddedInputSchema = z$9.object({
         parentPath: { context: 'admin-section' },
         onDelete: 'RESTRICT',
     }),
-});
+}));
 const adminCrudEmbeddedInputType = createAdminCrudInputType({
     name: 'embedded',
-    schema: adminCrudEmbeddedInputSchema,
+    schema: createAdminCrudEmbeddedInputSchema,
 });
-const adminCrudEmbeddedLocalInputSchema = z$9.object({
+const createAdminCrudEmbeddedLocalInputSchema = definitionSchema(() => z$9.object({
     type: z$9.literal('embeddedLocal'),
     label: z$9.string().min(1),
     localRelationRef: zRef(z$9.string(), {
@@ -3140,18 +3138,18 @@ const adminCrudEmbeddedLocalInputSchema = z$9.object({
         parentPath: { context: 'admin-section' },
         onDelete: 'RESTRICT',
     }),
-});
+}));
 const adminCrudEmbeddedLocalInputType = createAdminCrudInputType({
     name: 'embeddedLocal',
-    schema: adminCrudEmbeddedLocalInputSchema,
+    schema: createAdminCrudEmbeddedLocalInputSchema,
 });
-const adminCrudPasswordInputSchema = z$9.object({
+const createAdminCrudPasswordInputSchema = definitionSchema(() => z$9.object({
     type: z$9.literal('password'),
     label: z$9.string().min(1),
-});
+}));
 const adminCrudPasswordInputType = createAdminCrudInputType({
     name: 'password',
-    schema: adminCrudPasswordInputSchema,
+    schema: createAdminCrudPasswordInputSchema,
 });
 const BUILT_IN_ADMIN_CRUD_INPUTS = [
     adminCrudTextInputType,
@@ -3190,17 +3188,17 @@ const adminCrudInputSpec = createPluginSpec('core/admin-crud-input', {
     defaultInitializer: createAdminCrudInputImplementation,
 });
 
-const adminCrudInputSchema = zWithPlugins((plugins, data) => {
+const createAdminCrudInputSchema = definitionSchema((ctx) => zWithPlugins((plugins, data) => {
     const { type } = baseAdminCrudInputSchema.parse(data);
     const input = plugins
         .getPluginSpec(adminCrudInputSpec)
         .getAdminCrudInput(type);
-    return input.schema;
-});
+    return input.schema(ctx);
+}));
 
 const {z: z$8} = await importShared('zod');
 // Table Columns
-const adminCrudForeignDisplaySchema = z$8.object({
+const createAdminCrudForeignDisplaySchema = definitionSchema(() => z$8.object({
     type: z$8.literal('foreign'),
     localRelationRef: zRef(z$8.string(), {
         type: modelLocalRelationEntityType,
@@ -3209,31 +3207,27 @@ const adminCrudForeignDisplaySchema = z$8.object({
     }),
     labelExpression: z$8.string().min(1),
     valueExpression: z$8.string().min(1),
-});
-const adminCrudTextDisplaySchema = z$8.object({
+}));
+const createAdminCrudTextDisplaySchema = definitionSchema(() => z$8.object({
     type: z$8.literal('text'),
     modelFieldRef: zRef(z$8.string(), {
         type: modelScalarFieldEntityType,
         onDelete: 'RESTRICT',
         parentPath: { context: 'model' },
     }),
-});
-const adminCrudDisplaySchema = z$8.discriminatedUnion('type', [
-    adminCrudTextDisplaySchema,
-    adminCrudForeignDisplaySchema,
-]);
-function primitiveMapToKeys(map) {
-    return [...map.keys()]
-        .map((m) => m?.valueOf())
-        .filter((x) => x !== undefined);
-}
-const adminCrudDisplayTypes = primitiveMapToKeys(adminCrudDisplaySchema.optionsMap);
-const adminCrudTableColumnSchema = z$8.object({
+}));
+const createAdminCrudDisplaySchema = definitionSchema((ctx) => z$8.discriminatedUnion('type', [
+    createAdminCrudTextDisplaySchema(ctx),
+    createAdminCrudForeignDisplaySchema(ctx),
+]));
+// TODO: Improve this to be more dynamic in the future
+const adminCrudDisplayTypes = ['text', 'foreign'];
+const createAdminCrudTableColumnSchema = definitionSchema((ctx) => z$8.object({
     label: z$8.string().min(1),
-    display: adminCrudDisplaySchema,
-});
+    display: createAdminCrudDisplaySchema(ctx),
+}));
 // Embedded Crud
-const adminCrudEmbeddedObjectSchema = z$8.object({
+const createAdminCrudEmbeddedObjectSchema = definitionSchema((ctx) => z$8.object({
     id: z$8.string().min(1),
     name: z$8.string().min(1),
     modelRef: zRef(z$8.string().min(1), {
@@ -3243,10 +3237,10 @@ const adminCrudEmbeddedObjectSchema = z$8.object({
     includeIdField: z$8.boolean().optional(),
     type: z$8.literal('object'),
     form: z$8.object({
-        fields: z$8.array(adminCrudInputSchema),
+        fields: z$8.array(createAdminCrudInputSchema(ctx)),
     }),
-});
-const adminCrudEmbeddedListSchema = z$8.object({
+}));
+const createAdminCrudEmbeddedListSchema = definitionSchema((ctx) => z$8.object({
     id: z$8.string().min(1),
     name: z$8.string().min(1),
     modelRef: zRef(z$8.string().min(1), {
@@ -3258,24 +3252,24 @@ const adminCrudEmbeddedListSchema = z$8.object({
     // NOTE: These two fields need to be synced with crud section schema
     // because the web app expects that (TODO)
     table: z$8.object({
-        columns: z$8.array(adminCrudTableColumnSchema),
+        columns: z$8.array(createAdminCrudTableColumnSchema(ctx)),
     }),
     form: z$8.object({
-        fields: z$8.array(adminCrudInputSchema),
+        fields: z$8.array(createAdminCrudInputSchema(ctx)),
     }),
-});
-const adminCrudEmbeddedFormSchema = zRefBuilder(z$8.discriminatedUnion('type', [
-    adminCrudEmbeddedObjectSchema,
-    adminCrudEmbeddedListSchema,
+}));
+const createAdminCrudEmbeddedFormSchema = definitionSchema((ctx) => zRefBuilder(z$8.discriminatedUnion('type', [
+    createAdminCrudEmbeddedObjectSchema(ctx),
+    createAdminCrudEmbeddedListSchema(ctx),
 ]), (builder) => {
     builder.addEntity({
         type: adminCrudEmbeddedFormEntityType,
         parentPath: { context: 'admin-section' },
     });
     builder.addPathToContext('modelRef', modelEntityType, 'model');
-});
+}));
 // Admin Section
-const adminCrudSectionSchema = zRefBuilder(z$8.object({
+const createAdminCrudSectionSchema = definitionSchema((ctx) => zRefBuilder(z$8.object({
     ...baseAdminSectionValidators,
     type: z$8.literal('crud'),
     modelRef: zRef(z$8.string().min(1), {
@@ -3284,25 +3278,25 @@ const adminCrudSectionSchema = zRefBuilder(z$8.object({
     }),
     disableCreate: z$8.boolean().optional(),
     table: z$8.object({
-        columns: z$8.array(adminCrudTableColumnSchema),
+        columns: z$8.array(createAdminCrudTableColumnSchema(ctx)),
     }),
     form: z$8.object({
-        fields: z$8.array(adminCrudInputSchema),
+        fields: z$8.array(createAdminCrudInputSchema(ctx)),
     }),
-    embeddedForms: z$8.array(adminCrudEmbeddedFormSchema).optional(),
+    embeddedForms: z$8.array(createAdminCrudEmbeddedFormSchema(ctx)).optional(),
 }), (builder) => {
     builder.addPathToContext('modelRef', modelEntityType, 'model');
-});
+}));
 
 const {z: z$7} = await importShared('zod');
-const adminSectionSchema = zRefBuilder(adminCrudSectionSchema, (builder) => {
+const createAdminSectionSchema = definitionSchema((ctx) => zRefBuilder(createAdminCrudSectionSchema(ctx), (builder) => {
     builder.addEntity({
         type: adminSectionEntityType,
         parentPath: { context: 'app' },
         addContext: 'admin-section',
     });
-});
-const adminAppSchema = z$7.object({
+}));
+const createAdminAppSchema = definitionSchema((ctx) => z$7.object({
     ...baseAppValidators,
     type: z$7.literal('admin'),
     allowedRoles: z$7
@@ -3311,12 +3305,12 @@ const adminAppSchema = z$7.object({
         onDelete: 'DELETE',
     }))
         .optional(),
-    sections: z$7.array(adminSectionSchema).optional(),
-});
+    sections: z$7.array(createAdminSectionSchema(ctx)).optional(),
+}));
 const adminAppEntryType = createAppEntryType('admin');
 
 const {z: z$6} = await importShared('zod');
-const backendAppSchema = z$6.object({
+const createBackendAppSchema = definitionSchema(() => z$6.object({
     ...baseAppValidators,
     type: z$6.literal('backend'),
     enableStripe: z$6.boolean().optional(),
@@ -3325,11 +3319,11 @@ const backendAppSchema = z$6.object({
     enablePostmark: z$6.boolean().optional(),
     enableSubscriptions: z$6.boolean().optional(),
     enableAxios: z$6.boolean().optional(),
-});
+}));
 const backendAppEntryType = createAppEntryType('backend');
 
 const {z: z$5} = await importShared('zod');
-const webAppSchema = z$5.object({
+const createWebAppSchema = definitionSchema(() => z$5.object({
     ...baseAppValidators,
     type: z$5.literal('web'),
     includeAuth: z$5.boolean().optional(),
@@ -3343,41 +3337,38 @@ const webAppSchema = z$5.object({
         .optional(),
     includeUploadComponents: z$5.boolean().optional(),
     enableSubscriptions: z$5.boolean().optional(),
-});
+}));
 const webAppEntryType = createAppEntryType('web');
 
-function definitionSchema(creator) {
-    return (options) => creator(options);
-}
-
 const {z: z$4} = await importShared('zod');
-const basePluginDefinitionSchema = zEnt(z$4.object({
+const basePluginDefinitionSchema = z$4.object({
+    id: z$4.string().min(1),
     packageName: z$4.string(),
     name: z$4.string(),
     version: z$4.string(),
     config: z$4.unknown(),
     configSchemaVersion: z$4.number().optional(),
-}), {
-    type: pluginEntityType,
 });
-const pluginWithConfigSchema = zWithPlugins((plugins, data) => {
-    const parsedBasePluginSchema = basePluginDefinitionSchema.parse(data);
-    const pluginId = pluginEntityType.toUid(parsedBasePluginSchema.id);
+const createPluginWithConfigSchema = definitionSchema(() => zWithPlugins((plugins, data) => {
+    const parsedBasePlugin = basePluginDefinitionSchema.parse(data);
+    const pluginKey = pluginEntityType.keyFromId(parsedBasePlugin.id);
     const configSchema = plugins
         .getPluginSpec(pluginConfigSpec)
-        .getSchema(pluginId);
+        .getSchema(pluginKey);
+    const pluginDefinitionWithEnt = zEnt(basePluginDefinitionSchema, {
+        type: pluginEntityType,
+    });
     if (!configSchema) {
-        return basePluginDefinitionSchema;
+        return pluginDefinitionWithEnt;
     }
-    return basePluginDefinitionSchema.and(z$4.object({
+    return pluginDefinitionWithEnt.and(z$4.object({
         config: configSchema,
     }));
-});
-const pluginsSchema = z$4.array(pluginWithConfigSchema);
+}));
+const createPluginsSchema = definitionSchema((ctx) => z$4.array(createPluginWithConfigSchema(ctx)));
 
 const {z: z$3} = await importShared('zod');
-
-const templateExtractorSchema = z$3.object({
+const createTemplateExtractorSchema = definitionSchema(() => z$3.object({
     /**
      * Whether to write template extractor metadata when writing files to the project.
      *
@@ -3392,7 +3383,7 @@ const templateExtractorSchema = z$3.object({
      * The list is delimited by a newline and can include a * to match any number of characters.
      */
     fileIdRegexWhitelist: z$3.string().default(''),
-});
+}));
 
 const {z: z$2} = await importShared('zod');
 const generalSettingsSchema = z$2.object({
@@ -3416,32 +3407,32 @@ const generalSettingsSchema = z$2.object({
         .int()
         .refine((portOffset) => portOffset % 1000 === 0, 'Port offset must be a multiple of 1000, e.g. 1000, 2000, 3000, etc.'),
 });
-const createSettingsSchema = definitionSchema(() => z$2.object({
+const createSettingsSchema = definitionSchema((ctx) => z$2.object({
     general: generalSettingsSchema,
-    templateExtractor: templateExtractorSchema.optional(),
-    theme: themeSchema.optional(),
+    templateExtractor: createTemplateExtractorSchema(ctx).optional(),
+    theme: createThemeSchema(ctx).optional(),
 }));
 
 const {z: z$1} = await importShared('zod');
-const appSchema = zRefBuilder(z$1.discriminatedUnion('type', [
-    backendAppSchema,
-    webAppSchema,
-    adminAppSchema,
+const createAppSchema = definitionSchema((ctx) => zRefBuilder(z$1.discriminatedUnion('type', [
+    createBackendAppSchema(ctx),
+    createWebAppSchema(ctx),
+    createAdminAppSchema(ctx),
 ]), (builder) => {
     builder.addEntity({
         type: appEntityType,
         addContext: 'app',
     });
-});
+}));
 const createProjectDefinitionSchema = definitionSchema((ctx) => z$1.object({
     cliVersion: z$1.string().nullish(),
-    apps: z$1.array(appSchema).default([]),
-    features: featuresSchema,
-    models: z$1.array(modelSchema).default([]),
-    enums: z$1.array(enumSchema).optional(),
+    apps: z$1.array(createAppSchema(ctx)).default([]),
+    features: createFeaturesSchema(ctx),
+    models: z$1.array(createModelSchema(ctx)).default([]),
+    enums: z$1.array(createEnumSchema(ctx)).optional(),
     isInitialized: z$1.boolean().default(false),
     schemaVersion: z$1.number(),
-    plugins: pluginsSchema.optional(),
+    plugins: createPluginsSchema(ctx).optional(),
     settings: createSettingsSchema(ctx),
 }));
 
@@ -3556,7 +3547,7 @@ function getTransformName(definitionContainer, transformer, pluginStore) {
 const ModelTransformerUtils = { getTransformer, getTransformName };
 
 function byId(projectDefinition, id) {
-    const pluginEntityId = pluginEntityType.fromUid(id);
+    const pluginEntityId = pluginEntityType.idFromKey(id);
     const plugin = projectDefinition.plugins?.find((m) => m.id === pluginEntityId);
     return plugin ?? null;
 }
@@ -3573,7 +3564,7 @@ function configByIdOrThrow(projectDefinition, id) {
 }
 function setPluginConfig(projectDefinition, plugin, pluginConfig, pluginImplementationStore) {
     const plugins = projectDefinition.plugins ?? [];
-    const pluginEntityId = pluginEntityType.fromUid(plugin.id);
+    const pluginEntityId = pluginEntityType.idFromKey(plugin.id);
     const pluginConfigService = pluginImplementationStore.getPluginSpec(pluginConfigSpec);
     const lastMigrationVersion = pluginConfigService.getLastMigrationVersion(plugin.id);
     projectDefinition.plugins = plugins.some((p) => p.id === pluginEntityId)
@@ -8642,7 +8633,7 @@ const migration011PluginId = createSchemaMigration({
     version: 11,
     name: 'pluginId',
     description: 'Convert plugin ids to use the plugin entity type',
-    migrate: (config) => transformJsonPath(config, 'plugins.*.id', (id) => pluginEntityType.fromUid(id)),
+    migrate: (config) => transformJsonPath(config, 'plugins.*.id', (id) => pluginEntityType.idFromKey(id)),
 });
 
 const migration012MigrateAuthConfig = createSchemaMigration({
@@ -9897,5 +9888,5 @@ function generateDefaultTheme() {
     };
 }
 
-export { AVAILABLE_FLAGS, AppUtils, BUILT_IN_ADMIN_CRUD_INPUTS, BUILT_IN_TRANSFORMERS, COLOR_PALETTES, EnumUtils, FIXED_COLOR_MAPPINGS, ModelFieldUtils, ModelTransformerUtils, ModelUtils, PALETTE_SHADES, PluginImplementationStore, PluginUtils, ProjectDefinitionContainer, REFERENTIAL_ACTIONS, SCALAR_FIELD_TYPES, SCHEMA_MIGRATIONS, SchemaMigrationError, THEME_COLORS, THEME_COLOR_KEYS, VALIDATORS, ZodRef, ZodRefWrapper, ZodWithPlugins, adminAppEntryType, adminAppSchema, adminCrudDisplaySchema, adminCrudDisplayTypes, adminCrudEmbeddedFormEntityType, adminCrudEmbeddedFormSchema, adminCrudEmbeddedInputSchema, adminCrudEmbeddedInputType, adminCrudEmbeddedListSchema, adminCrudEmbeddedLocalInputSchema, adminCrudEmbeddedLocalInputType, adminCrudEmbeddedObjectSchema, adminCrudEnumInputSchema, adminCrudForeignDisplaySchema, adminCrudForeignInputSchema, adminCrudInputCompilerSpec, adminCrudInputSchema, adminCrudInputSpec, adminCrudPasswordInputSchema, adminCrudSectionSchema, adminCrudTableColumnSchema, adminCrudTextDisplaySchema, adminCrudTextInputSchema, adminSectionEntityType, adminSectionSchema, appCompilerSpec, appEntityType, appSchema, authConfigSpec, authRoleEntityType, backendAppEntryType, backendAppSchema, baseAdminCrudInputSchema, baseAdminSectionValidators, baseAppSchema, baseAppValidators, basePluginDefinitionSchema, baseTransformerFields, baseTransformerSchema, convertColorNameToOklch, convertHexToOklch, convertOklchToColorName, convertOklchToHex, createAdminCrudInputCompilerImplementation, createAdminCrudInputImplementation, createAdminCrudInputType, createAppCompiler, createAppCompilerPlugin, createAppEntryType, createDefinitionEntityNameResolver, createEntityType, createModelTransformerCompilerImplementation, createModelTransformerImplementation, createModelTransformerType, createPlatformPluginExport, createPluginConfigImplementation, createPluginImplementationStore, createPluginSpec, createProjectDefinitionSchema, createProjectDefinitionSchemaWithContext, createSettingsSchema, createTestProjectDefinition, createTestProjectDefinitionContainer, createTestProjectDefinitionInput, createWebConfigImplementation, definitionSchema, deserializeSchemaWithReferences, embeddedRelationTransformerSchema, enumBaseSchema, enumSchema, enumValueSchema, featureEntityType, featuresSchema, fixRefDeletions, generalSettingsSchema, generateCssFromThemeConfig, generateDefaultTheme, generateThemeColorsFromShade, getBackendRelativePath, getDefaultThemeColorFromShade, getLatestMigrationVersion, initializePlugins, isMigrateableProjectDefinition, modelBaseSchema, modelEntityType, modelEnumEntityType, modelEnumValueEntityType, modelForeignRelationEntityType, modelGraphqlSchema, modelLocalRelationEntityType, modelRelationFieldSchema, modelScalarFieldEntityType, modelScalarFieldSchema, modelSchema, modelServiceSchema, modelTransformerCompilerSpec, modelTransformerEntityType, modelTransformerSpec, modelUniqueConstraintEntityType, modelUniqueConstraintSchema, oklchColor, paletteSchema, palettesSchema, parseOklch, parseProjectDefinitionWithContext, parseProjectDefinitionWithReferences, passwordTransformerSchema, pluginConfigSpec, pluginEntityType, pluginManifestJsonSchema, pluginMetadataSchema, pluginSpecDependencySchema, pluginSpecSupportSchema, pluginWithConfigSchema, pluginsSchema, runPluginMigrations, runSchemaMigrations, serializeSchema, serializeSchemaFromRefPayload, stripEmptyGeneratorChildren, stripUndefinedValues, templateExtractorSchema, themeColorSchema, themeSchema, transformerSchema, undefinedIfEmpty, undefinedIfFalsy, webAppEntryType, webAppSchema, webConfigSpec, zEnt, zPluginWrapper, zRef, zRefBuilder, zRefId, zWithPlugins };
-//# sourceMappingURL=project-builder-lib-GtzVuDsM.js.map
+export { AVAILABLE_FLAGS, AppUtils, BUILT_IN_ADMIN_CRUD_INPUTS, BUILT_IN_TRANSFORMERS, COLOR_PALETTES, EnumUtils, FIXED_COLOR_MAPPINGS, ModelFieldUtils, ModelTransformerUtils, ModelUtils, PALETTE_SHADES, PluginImplementationStore, PluginUtils, ProjectDefinitionContainer, REFERENTIAL_ACTIONS, SCALAR_FIELD_TYPES, SCHEMA_MIGRATIONS, SchemaMigrationError, THEME_COLORS, THEME_COLOR_KEYS, VALIDATORS, ZodRefWrapper, ZodWithPlugins, adminAppEntryType, adminCrudDisplayTypes, adminCrudEmbeddedFormEntityType, adminCrudEmbeddedInputType, adminCrudEmbeddedLocalInputType, adminCrudInputCompilerSpec, adminCrudInputSpec, adminSectionEntityType, appCompilerSpec, appEntityType, authConfigSpec, authRoleEntityType, backendAppEntryType, baseAdminCrudInputSchema, baseAdminSectionValidators, baseAppSchema, baseAppValidators, basePluginDefinitionSchema, baseTransformerFields, baseTransformerSchema, convertColorNameToOklch, convertHexToOklch, convertOklchToColorName, convertOklchToHex, createAdminAppSchema, createAdminCrudDisplaySchema, createAdminCrudEmbeddedFormSchema, createAdminCrudEmbeddedInputSchema, createAdminCrudEmbeddedListSchema, createAdminCrudEmbeddedLocalInputSchema, createAdminCrudEmbeddedObjectSchema, createAdminCrudEnumInputSchema, createAdminCrudForeignDisplaySchema, createAdminCrudForeignInputSchema, createAdminCrudInputCompilerImplementation, createAdminCrudInputImplementation, createAdminCrudInputSchema, createAdminCrudInputType, createAdminCrudPasswordInputSchema, createAdminCrudSectionSchema, createAdminCrudTableColumnSchema, createAdminCrudTextDisplaySchema, createAdminCrudTextInputSchema, createAdminSectionSchema, createAppCompiler, createAppCompilerPlugin, createAppEntryType, createAppSchema, createBackendAppSchema, createDefinitionEntityNameResolver, createEmbeddedRelationTransformerSchema, createEntityType, createEnumBaseSchema, createEnumSchema, createEnumValueSchema, createFeaturesSchema, createModelBaseSchema, createModelGraphqlSchema, createModelRelationFieldSchema, createModelScalarFieldSchema, createModelSchema, createModelServiceSchema, createModelTransformerCompilerImplementation, createModelTransformerImplementation, createModelTransformerType, createModelUniqueConstraintSchema, createPasswordTransformerSchema, createPlatformPluginExport, createPluginConfigImplementation, createPluginImplementationStore, createPluginSpec, createPluginWithConfigSchema, createPluginsSchema, createProjectDefinitionSchema, createProjectDefinitionSchemaWithContext, createSettingsSchema, createTemplateExtractorSchema, createTestProjectDefinition, createTestProjectDefinitionContainer, createTestProjectDefinitionInput, createThemeSchema, createTransformerSchema, createWebAppSchema, createWebConfigImplementation, definitionSchema, deserializeSchemaWithReferences, featureEntityType, fixRefDeletions, generalSettingsSchema, generateCssFromThemeConfig, generateDefaultTheme, generateThemeColorsFromShade, getBackendRelativePath, getDefaultThemeColorFromShade, getLatestMigrationVersion, initializePlugins, isMigrateableProjectDefinition, modelEntityType, modelEnumEntityType, modelEnumValueEntityType, modelForeignRelationEntityType, modelLocalRelationEntityType, modelScalarFieldEntityType, modelTransformerCompilerSpec, modelTransformerEntityType, modelTransformerSpec, modelUniqueConstraintEntityType, oklchColor, paletteSchema, palettesSchema, parseOklch, parseProjectDefinitionWithContext, parseProjectDefinitionWithReferences, pluginConfigSpec, pluginEntityType, pluginManifestJsonSchema, pluginMetadataSchema, pluginSpecDependencySchema, pluginSpecSupportSchema, runPluginMigrations, runSchemaMigrations, serializeSchema, serializeSchemaFromRefPayload, stripEmptyGeneratorChildren, stripUndefinedValues, themeColorSchema, undefinedIfEmpty, undefinedIfFalsy, webAppEntryType, webConfigSpec, zEnt, zPluginWrapper, zRef, zRefBuilder, zRefId, zWithPlugins };
+//# sourceMappingURL=project-builder-lib-BAwM_-SS.js.map