@baseplate-dev/plugin-auth 1.0.6 → 1.0.8

package/dist/local-auth/core/node.js

@@ -0,0 +1,76 @@
+import { appModuleGenerator, passwordHasherServiceGenerator, } from '@baseplate-dev/fastify-generators';
+import { emailTemplateSpec } from '@baseplate-dev/plugin-email';
+import { appCompilerSpec, backendAppEntryType, createPluginModule, PluginUtils, webAppEntryType, } from '@baseplate-dev/project-builder-lib';
+import { getAuthPluginDefinition } from '#src/auth/index.js';
+import { authApolloGenerator } from './generators/auth-apollo/auth-apollo.generator.js';
+import { authEmailPasswordGenerator } from './generators/auth-email-password/auth-email-password.generator.js';
+import { authEmailTemplatesGenerator } from './generators/auth-email-templates/auth-email-templates.generator.js';
+import { authHooksGenerator } from './generators/auth-hooks/auth-hooks.generator.js';
+import { authRoutesGenerator } from './generators/auth-routes/auth-routes.generator.js';
+import { authModuleGenerator, reactAuthGenerator, seedInitialUserGenerator, } from './generators/index.js';
+import { reactSessionGenerator } from './generators/react-session/react-session.generator.js';
+export default createPluginModule({
+    name: 'node',
+    dependencies: {
+        appCompiler: appCompilerSpec,
+        emailTemplate: emailTemplateSpec,
+    },
+    initialize: ({ appCompiler, emailTemplate }, { pluginKey }) => {
+        // Register auth email templates with the transactional lib
+        emailTemplate.generators.push(authEmailTemplatesGenerator({}));
+        // register backend compiler
+        appCompiler.compilers.push({
+            pluginKey,
+            appType: backendAppEntryType,
+            compile: ({ projectDefinition, definitionContainer, appCompiler }) => {
+                const localAuthDefinition = PluginUtils.configByKeyOrThrow(projectDefinition, pluginKey);
+                const authDefinition = getAuthPluginDefinition(projectDefinition);
+                // Get web app ports
+                const webApps = projectDefinition.apps.filter((app) => app.type === 'web');
+                const devWebPorts = webApps.map((app) => app.devPort);
+                const devWebDomainPort = devWebPorts[0] ??
+                    projectDefinition.settings.general.portOffset + 30;
+                const additionalAdminRoles = localAuthDefinition.additionalUserAdminRoles.map((role) => definitionContainer.nameFromId(role));
+                // 'admin' is always included since it is now a built-in role guaranteed to exist
+                const adminRoles = [...new Set(['admin', ...additionalAdminRoles])];
+                appCompiler.addChildrenToFeature(authDefinition.authFeatureRef, {
+                    seedInitialUser: seedInitialUserGenerator({
+                        initialUserRoles: ['admin'],
+                    }),
+                    authModule: authModuleGenerator({
+                        userAdminRoles: adminRoles,
+                        devWebPorts,
+                    }),
+                    emailPassword: appModuleGenerator({
+                        id: 'email-password',
+                        name: 'password',
+                        children: {
+                            module: authEmailPasswordGenerator({
+                                adminRoles,
+                                devWebDomainPort,
+                                requireNameOnRegistration: localAuthDefinition.requireNameOnRegistration,
+                            }),
+                            hasher: passwordHasherServiceGenerator({}),
+                        },
+                    }),
+                });
+            },
+        }, {
+            pluginKey,
+            appType: webAppEntryType,
+            compile: ({ projectDefinition, appCompiler }) => {
+                const localAuthDefinition = PluginUtils.configByKeyOrThrow(projectDefinition, pluginKey);
+                appCompiler.addRootChildren({
+                    authApollo: authApolloGenerator({}),
+                    reactAuth: reactAuthGenerator({}),
+                    authHooks: authHooksGenerator({}),
+                    reactSession: reactSessionGenerator({}),
+                    authRoutes: authRoutesGenerator({
+                        requireNameOnRegistration: localAuthDefinition.requireNameOnRegistration,
+                    }),
+                });
+            },
+        });
+    },
+});
+//# sourceMappingURL=node.js.map

package/dist/local-auth/core/schema/models.d.ts

@@ -0,0 +1,3 @@
+import type { PartialProjectDefinitionInput } from '@baseplate-dev/project-builder-lib';
+export declare function createLocalAuthPartialDefinition(authFeatureName: string, accountsFeatureName: string): PartialProjectDefinitionInput;
+//# sourceMappingURL=models.d.ts.map

package/dist/local-auth/core/schema/models.js

@@ -0,0 +1,281 @@
+import { LOCAL_AUTH_MODELS } from '#src/local-auth/constants/model-names.js';
+export function createLocalAuthPartialDefinition(authFeatureName, accountsFeatureName) {
+    return {
+        models: [
+            {
+                name: LOCAL_AUTH_MODELS.user,
+                featureRef: accountsFeatureName,
+                model: {
+                    fields: [
+                        {
+                            name: 'id',
+                            type: 'uuid',
+                            options: { defaultGeneration: 'uuidv7' },
+                        },
+                        {
+                            name: 'name',
+                            type: 'string',
+                            isOptional: true,
+                        },
+                        {
+                            name: 'email',
+                            type: 'string',
+                        },
+                        {
+                            name: 'emailVerified',
+                            type: 'boolean',
+                            options: { default: 'false' },
+                        },
+                        {
+                            name: 'updatedAt',
+                            type: 'dateTime',
+                            options: { defaultToNow: true, updatedAt: true },
+                        },
+                        {
+                            name: 'createdAt',
+                            type: 'dateTime',
+                            options: { defaultToNow: true },
+                        },
+                    ],
+                    primaryKeyFieldRefs: ['id'],
+                    uniqueConstraints: [
+                        {
+                            fields: [{ fieldRef: 'email' }],
+                        },
+                    ],
+                },
+                graphql: {
+                    objectType: {
+                        enabled: true,
+                        fields: [
+                            { ref: 'id' },
+                            {
+                                ref: 'email',
+                                globalRoles: ['admin'],
+                                instanceRoles: ['self'],
+                            },
+                        ],
+                    },
+                },
+                authorizer: {
+                    roles: [
+                        {
+                            name: 'self',
+                            expression: 'model.id === userId',
+                        },
+                    ],
+                },
+            },
+            {
+                name: LOCAL_AUTH_MODELS.userAccount,
+                featureRef: accountsFeatureName,
+                model: {
+                    fields: [
+                        {
+                            name: 'id',
+                            type: 'uuid',
+                            options: { defaultGeneration: 'uuidv7' },
+                        },
+                        {
+                            name: 'userId',
+                            type: 'uuid',
+                        },
+                        {
+                            name: 'accountId',
+                            type: 'string',
+                        },
+                        {
+                            name: 'providerId',
+                            type: 'string',
+                        },
+                        {
+                            name: 'password',
+                            type: 'string',
+                            isOptional: true,
+                        },
+                        {
+                            name: 'createdAt',
+                            type: 'dateTime',
+                            options: { defaultToNow: true },
+                        },
+                        {
+                            name: 'updatedAt',
+                            type: 'dateTime',
+                            options: { defaultToNow: true, updatedAt: true },
+                        },
+                    ],
+                    primaryKeyFieldRefs: ['id'],
+                    uniqueConstraints: [
+                        {
+                            fields: [{ fieldRef: 'accountId' }, { fieldRef: 'providerId' }],
+                        },
+                    ],
+                    relations: [
+                        {
+                            name: 'user',
+                            references: [{ localRef: 'userId', foreignRef: 'id' }],
+                            modelRef: LOCAL_AUTH_MODELS.user,
+                            foreignRelationName: 'accounts',
+                            onDelete: 'Cascade',
+                            onUpdate: 'Restrict',
+                        },
+                    ],
+                },
+            },
+            {
+                name: LOCAL_AUTH_MODELS.userRole,
+                featureRef: accountsFeatureName,
+                model: {
+                    fields: [
+                        {
+                            name: 'userId',
+                            type: 'uuid',
+                        },
+                        {
+                            name: 'role',
+                            type: 'string',
+                        },
+                        {
+                            name: 'updatedAt',
+                            type: 'dateTime',
+                            options: { defaultToNow: true, updatedAt: true },
+                        },
+                        {
+                            name: 'createdAt',
+                            type: 'dateTime',
+                            options: { defaultToNow: true },
+                        },
+                    ],
+                    primaryKeyFieldRefs: ['userId', 'role'],
+                    relations: [
+                        {
+                            name: 'user',
+                            references: [{ localRef: 'userId', foreignRef: 'id' }],
+                            modelRef: LOCAL_AUTH_MODELS.user,
+                            foreignRelationName: 'roles',
+                            onDelete: 'Cascade',
+                            onUpdate: 'Restrict',
+                        },
+                    ],
+                },
+            },
+            {
+                name: LOCAL_AUTH_MODELS.userSession,
+                featureRef: accountsFeatureName,
+                model: {
+                    fields: [
+                        {
+                            name: 'id',
+                            type: 'uuid',
+                            options: { defaultGeneration: 'uuidv7' },
+                        },
+                        {
+                            name: 'userId',
+                            type: 'uuid',
+                        },
+                        {
+                            name: 'token',
+                            type: 'string',
+                        },
+                        {
+                            name: 'expiresAt',
+                            type: 'dateTime',
+                        },
+                        {
+                            name: 'renewedAt',
+                            type: 'dateTime',
+                            options: { defaultToNow: true },
+                        },
+                        {
+                            name: 'createdAt',
+                            type: 'dateTime',
+                            options: { defaultToNow: true },
+                        },
+                        {
+                            name: 'updatedAt',
+                            type: 'dateTime',
+                            options: { defaultToNow: true, updatedAt: true },
+                        },
+                    ],
+                    primaryKeyFieldRefs: ['id'],
+                    uniqueConstraints: [
+                        {
+                            fields: [{ fieldRef: 'token' }],
+                        },
+                    ],
+                    relations: [
+                        {
+                            name: 'user',
+                            references: [{ localRef: 'userId', foreignRef: 'id' }],
+                            modelRef: LOCAL_AUTH_MODELS.user,
+                            foreignRelationName: 'sessions',
+                            onDelete: 'Cascade',
+                            onUpdate: 'Restrict',
+                        },
+                    ],
+                },
+            },
+            {
+                name: LOCAL_AUTH_MODELS.authVerification,
+                featureRef: authFeatureName,
+                model: {
+                    fields: [
+                        {
+                            name: 'id',
+                            type: 'uuid',
+                            options: { defaultGeneration: 'uuidv4' },
+                        },
+                        {
+                            name: 'type',
+                            type: 'string',
+                        },
+                        {
+                            name: 'identifier',
+                            type: 'string',
+                        },
+                        {
+                            name: 'value',
+                            type: 'string',
+                        },
+                        {
+                            name: 'userId',
+                            type: 'uuid',
+                            isOptional: true,
+                        },
+                        {
+                            name: 'metadata',
+                            type: 'json',
+                            isOptional: true,
+                        },
+                        {
+                            name: 'expiresAt',
+                            type: 'dateTime',
+                        },
+                        {
+                            name: 'createdAt',
+                            type: 'dateTime',
+                            options: { defaultToNow: true },
+                        },
+                    ],
+                    primaryKeyFieldRefs: ['id'],
+                    uniqueConstraints: [
+                        {
+                            fields: [{ fieldRef: 'type' }, { fieldRef: 'identifier' }],
+                        },
+                    ],
+                    relations: [
+                        {
+                            name: 'user',
+                            references: [{ localRef: 'userId', foreignRef: 'id' }],
+                            modelRef: LOCAL_AUTH_MODELS.user,
+                            foreignRelationName: 'authVerifications',
+                            onDelete: 'Cascade',
+                            onUpdate: 'Restrict',
+                        },
+                    ],
+                },
+            },
+        ],
+    };
+}
+//# sourceMappingURL=models.js.map

package/dist/local-auth/core/schema/plugin-definition.d.ts

@@ -0,0 +1,9 @@
+import type { def } from '@baseplate-dev/project-builder-lib';
+import { z } from 'zod';
+export declare const createLocalAuthPluginDefinitionSchema: (context: import("@baseplate-dev/project-builder-lib").DefinitionSchemaParserContext) => z.ZodObject<{
+    additionalUserAdminRoles: z.ZodPrefault<z.ZodArray<z.ZodType<string, string, z.core.$ZodTypeInternals<string, string>>>>;
+    requireNameOnRegistration: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>;
+export type LocalAuthPluginDefinition = def.InferOutput<typeof createLocalAuthPluginDefinitionSchema>;
+export type LocalAuthPluginDefinitionInput = def.InferInput<typeof createLocalAuthPluginDefinitionSchema>;
+//# sourceMappingURL=plugin-definition.d.ts.map

package/dist/local-auth/core/schema/plugin-definition.js

@@ -0,0 +1,10 @@
+import { authRoleEntityType, definitionSchema, } from '@baseplate-dev/project-builder-lib';
+import { z } from 'zod';
+export const createLocalAuthPluginDefinitionSchema = definitionSchema((ctx) => z.object({
+    additionalUserAdminRoles: ctx.withDefault(z.array(ctx.withRef({
+        type: authRoleEntityType,
+        onDelete: 'DELETE',
+    })), []),
+    requireNameOnRegistration: z.boolean().default(false),
+}));
+//# sourceMappingURL=plugin-definition.js.map

package/dist/local-auth/core/schema/schema-issue-checker.d.ts

@@ -0,0 +1,3 @@
+import type { DefinitionIssueChecker } from '@baseplate-dev/project-builder-lib';
+export declare function createLocalAuthSchemaChecker(pluginKey: string): DefinitionIssueChecker;
+//# sourceMappingURL=schema-issue-checker.d.ts.map

package/dist/local-auth/core/schema/schema-issue-checker.js

@@ -0,0 +1,21 @@
+import { createPluginModelSyncChecker, FeatureUtils, } from '@baseplate-dev/project-builder-lib';
+import { getAuthPluginDefinition } from '#src/auth/index.js';
+import { createLocalAuthPartialDefinition } from './models.js';
+export function createLocalAuthSchemaChecker(pluginKey) {
+    return createPluginModelSyncChecker({
+        pluginKey,
+        pluginLabel: 'Local Auth',
+        buildPartialDef: (container) => {
+            const authConfig = getAuthPluginDefinition(container.definition);
+            try {
+                const authFeatureName = FeatureUtils.getFeaturePathByIdOrThrow(container.definition, authConfig.authFeatureRef);
+                const accountsFeatureName = FeatureUtils.getFeaturePathByIdOrThrow(container.definition, authConfig.accountsFeatureRef);
+                return createLocalAuthPartialDefinition(authFeatureName, accountsFeatureName);
+            }
+            catch {
+                return undefined;
+            }
+        },
+    });
+}
+//# sourceMappingURL=schema-issue-checker.js.map

package/dist/local-auth/core/web.d.ts

@@ -0,0 +1,6 @@
+import '../../styles.css';
+declare const _default: import("@baseplate-dev/project-builder-lib").PluginModule<{
+    [x: string]: import("@baseplate-dev/project-builder-lib").PluginSpec<object, object>;
+}>;
+export default _default;
+//# sourceMappingURL=web.d.ts.map

package/dist/local-auth/core/web.js

@@ -0,0 +1,26 @@
+import { createPluginModule, FeatureUtils, pluginDefaultsSpec, webConfigSpec, } from '@baseplate-dev/project-builder-lib';
+import { LocalAuthDefinitionEditor } from './components/local-auth-definition-editor.js';
+import { createLocalAuthPartialDefinition } from './schema/models.js';
+import '../../styles.css';
+const AUTH_FEATURE_NAME = 'accounts/auth';
+const ACCOUNTS_FEATURE_NAME = 'accounts/users';
+export default createPluginModule({
+    name: 'web',
+    dependencies: {
+        webConfig: webConfigSpec,
+        pluginDefaults: pluginDefaultsSpec,
+    },
+    initialize: ({ webConfig, pluginDefaults }, { pluginKey }) => {
+        webConfig.components.set(pluginKey, LocalAuthDefinitionEditor);
+        pluginDefaults.builders.set(pluginKey, ({ draft }) => {
+            // Idempotent with the parent auth builder, which also ensures these.
+            FeatureUtils.ensureFeatureByNameRecursively(draft, AUTH_FEATURE_NAME);
+            FeatureUtils.ensureFeatureByNameRecursively(draft, ACCOUNTS_FEATURE_NAME);
+            return {
+                config: {},
+                partialDef: createLocalAuthPartialDefinition(AUTH_FEATURE_NAME, ACCOUNTS_FEATURE_NAME),
+            };
+        });
+    },
+});
+//# sourceMappingURL=web.js.map

package/dist/local-auth/index.d.ts

@@ -0,0 +1,2 @@
+export * from './core/index.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/local-auth/index.js

@@ -0,0 +1,2 @@
+export * from './core/index.js';
+//# sourceMappingURL=index.js.map

package/dist/local-auth/plugin.json

@@ -0,0 +1,14 @@
+{
+  "name": "local-auth",
+  "displayName": "Local Auth",
+  "icon": "icon.svg",
+  "description": "This plugin sets up a self-hosted auth service using email/password authentication.",
+  "version": "0.1.0",
+  "moduleDirectories": ["core", "admin"],
+  "managedBy": "@baseplate-dev/plugin-auth:auth",
+  "pluginDependencies": [
+    { "plugin": "@baseplate-dev/plugin-email:email" },
+    { "plugin": "@baseplate-dev/plugin-queue:queue" },
+    { "plugin": "@baseplate-dev/plugin-rate-limit:rate-limit" }
+  ]
+}

package/dist/local-auth/static/icon.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" height="24px" viewBox="0 -960 960 960" width="24px" fill="#1f1f1f"><path d="M120-160v-112q0-34 17.5-62.5T184-378q62-31 126-46.5T440-440q20 0 40 1.5t40 4.5q-4 58 21 109.5t73 84.5v80H120ZM760-40l-60-60v-186q-44-13-72-49.5T600-420q0-58 41-99t99-41q58 0 99 41t41 99q0 45-25.5 80T790-290l50 50-60 60 60 60-80 80ZM440-480q-66 0-113-47t-47-113q0-66 47-113t113-47q66 0 113 47t47 113q0 66-47 113t-113 47Zm300 80q17 0 28.5-11.5T780-440q0-17-11.5-28.5T740-480q-17 0-28.5 11.5T700-440q0 17 11.5 28.5T740-400Z"/></svg>

package/dist/placeholder-auth/constants/model-names.d.ts

@@ -0,0 +1,4 @@
+export declare const PLACEHOLDER_AUTH_MODELS: {
+    readonly user: "User";
+};
+//# sourceMappingURL=model-names.d.ts.map

package/dist/placeholder-auth/constants/model-names.js

@@ -0,0 +1,4 @@
+export const PLACEHOLDER_AUTH_MODELS = {
+    user: 'User',
+};
+//# sourceMappingURL=model-names.js.map

package/dist/placeholder-auth/core/common.d.ts

@@ -1,8 +1,5 @@
-export type { PluginPlatformModule } from '@baseplate-dev/project-builder-lib';
-declare const _default: import("@baseplate-dev/project-builder-lib").PluginPlatformModule<{
-    config: import("@baseplate-dev/project-builder-lib").PluginSpecWithInitializer<import("@baseplate-dev/project-builder-lib").PluginConfigSpec>;
-}, {
-    authConfig: import("@baseplate-dev/project-builder-lib").PluginSpec<import("@baseplate-dev/project-builder-lib").AuthConfigSpec>;
+declare const _default: import("@baseplate-dev/project-builder-lib").PluginModule<{
+    [x: string]: import("@baseplate-dev/project-builder-lib").PluginSpec<object, object>;
 }>;
 export default _default;
 //# sourceMappingURL=common.d.ts.map

package/dist/placeholder-auth/core/common.js

@@ -1,26 +1,17 @@
-import { authConfigSpec, createPlatformPluginExport, pluginConfigSpec, PluginUtils, } from '@baseplate-dev/project-builder-lib';
+import { authModelsSpec, createPluginModule, pluginConfigSpec, } from '@baseplate-dev/project-builder-lib';
+import { PLACEHOLDER_AUTH_MODELS } from '#src/placeholder-auth/constants/model-names.js';
 import { createPlaceholderAuthPluginDefinitionSchema } from './schema/plugin-definition.js';
-export default createPlatformPluginExport({
+export default createPluginModule({
+    name: 'common',
     dependencies: {
-        config: pluginConfigSpec,
+        pluginConfig: pluginConfigSpec,
+        authModels: authModelsSpec,
     },
-    exports: {
-        authConfig: authConfigSpec,
-    },
-    initialize: ({ config }, { pluginId }) => {
-        config.registerSchemaCreator(pluginId, createPlaceholderAuthPluginDefinitionSchema);
-        return {
-            authConfig: {
-                getUserModel: (definition) => {
-                    const pluginConfig = PluginUtils.configByIdOrThrow(definition, pluginId);
-                    return pluginConfig.modelRefs.user;
-                },
-                getAuthRoles: (definition) => {
-                    const pluginConfig = PluginUtils.configByIdOrThrow(definition, pluginId);
-                    return pluginConfig.roles;
-                },
-            },
-        };
+    initialize: ({ pluginConfig, authModels }, { pluginKey }) => {
+        pluginConfig.schemas.set(pluginKey, createPlaceholderAuthPluginDefinitionSchema);
+        authModels.getAuthModels.set(() => ({
+            user: PLACEHOLDER_AUTH_MODELS.user,
+        }));
     },
 });
 //# sourceMappingURL=common.js.map

package/dist/placeholder-auth/core/components/placeholder-auth-definition-editor.js

@@ -1,58 +1,50 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { createAndApplyModelMergerResults, createModelMergerResults, doesModelMergerResultsHaveChanges, FeatureUtils, ModelUtils, PluginUtils, } from '@baseplate-dev/project-builder-lib';
-import { FeatureComboboxFieldController, ModelComboboxFieldController, ModelMergerResultAlert, useBlockUnsavedChangesNavigate, useDefinitionSchema, useProjectDefinition, useResettableForm, } from '@baseplate-dev/project-builder-lib/web';
+import { applyMergedDefinition, diffDefinition, PluginUtils, } from '@baseplate-dev/project-builder-lib';
+import { DefinitionDiffAlert, useBlockUnsavedChangesNavigate, useDefinitionSchema, useProjectDefinition, useResettableForm, } from '@baseplate-dev/project-builder-lib/web';
 import { FormActionBar, SectionList, SectionListSection, SectionListSectionContent, SectionListSectionDescription, SectionListSectionHeader, SectionListSectionTitle, } from '@baseplate-dev/ui-components';
-import { useLens } from '@hookform/lenses';
 import { zodResolver } from '@hookform/resolvers/zod';
 import { useMemo } from 'react';
-import { RoleEditorForm } from '#src/common/roles/components/index.js';
-import { createDefaultAuthRoles } from '#src/common/roles/index.js';
-import { createAuthModels } from '../schema/models.js';
+import { getAuthPluginDefinition } from '#src/auth/index.js';
+import { AuthConfigTabs } from '#src/common/components/auth-config-tabs.js';
+import { createPlaceholderAuthPartialDefinition } from '../schema/models.js';
 import { createPlaceholderAuthPluginDefinitionSchema } from '../schema/plugin-definition.js';
 import '#src/styles.css';
 export function PlaceholderAuthDefinitionEditor({ definition: pluginMetadata, metadata, onSave, }) {
     const { definition, definitionContainer, saveDefinitionWithFeedback } = useProjectDefinition();
+    const authDefinition = getAuthPluginDefinition(definition);
     const authPluginDefinitionSchema = useDefinitionSchema(createPlaceholderAuthPluginDefinitionSchema);
     const defaultValues = useMemo(() => {
         if (pluginMetadata?.config) {
             return pluginMetadata.config;
         }
-        return {
-            modelRefs: {
-                user: ModelUtils.getModelIdByNameOrDefault(definition, 'User'),
-            },
-            authFeatureRef: FeatureUtils.getFeatureIdByNameOrDefault(definition, 'auth'),
-            roles: createDefaultAuthRoles(),
-        };
-    }, [definition, pluginMetadata?.config]);
+        return {};
+    }, [pluginMetadata?.config]);
     const form = useResettableForm({
         resolver: zodResolver(authPluginDefinitionSchema),
         defaultValues,
     });
-    const { control, reset, handleSubmit, watch } = form;
-    const modelRefs = watch('modelRefs');
-    const authFeatureRef = watch('authFeatureRef');
-    const pendingModelChanges = useMemo(() => {
-        const desiredModels = createAuthModels({ modelRefs, authFeatureRef });
-        return createModelMergerResults(modelRefs, desiredModels, definitionContainer);
-    }, [definitionContainer, authFeatureRef, modelRefs]);
+    const { control, reset, handleSubmit } = form;
+    const authFeature = definition.features.find((f) => f.id === authDefinition.authFeatureRef);
+    if (!authFeature) {
+        throw new Error(`Auth feature not found for ref: ${authDefinition.authFeatureRef}`);
+    }
+    const partialDef = useMemo(() => createPlaceholderAuthPartialDefinition(authFeature.name), [authFeature.name]);
+    const diff = useMemo(() => diffDefinition(definitionContainer.schema, definitionContainer.definition, partialDef), [definitionContainer, partialDef]);
     const onSubmit = handleSubmit((data) => saveDefinitionWithFeedback((draftConfig) => {
-        const featureRef = FeatureUtils.ensureFeatureByNameRecursively(draftConfig, data.authFeatureRef);
         const updatedData = {
             ...data,
-            authFeatureRef: featureRef,
         };
-        updatedData.modelRefs = createAndApplyModelMergerResults(draftConfig, updatedData.modelRefs, createAuthModels(updatedData), definitionContainer);
-        PluginUtils.setPluginConfig(draftConfig, metadata, updatedData, definitionContainer.pluginStore);
+        applyMergedDefinition(definitionContainer, partialDef)(draftConfig);
+        PluginUtils.setPluginConfig(draftConfig, metadata, updatedData, definitionContainer);
     }, {
-        successMessage: 'Successfully saved auth plugin!',
+        successMessage: 'Successfully saved placeholder auth plugin!',
         onSuccess: () => {
             onSave();
         },
     }));
     useBlockUnsavedChangesNavigate({ control, reset, onSubmit });
-    const lens = useLens({ control });
-    return (_jsxs("form", { onSubmit: onSubmit, className: "auth:mb-[--action-bar-height] auth:max-w-6xl", children: [_jsx("div", { className: "auth:pb-16", children: _jsxs(SectionList, { children: [_jsxs(SectionListSection, { children: [_jsxs(SectionListSectionHeader, { children: [_jsx(SectionListSectionTitle, { children: "Placeholder Auth Configuration" }), _jsx(SectionListSectionDescription, { children: "Configure your placeholder auth settings, user model, and role definitions." })] }), _jsxs(SectionListSectionContent, { className: "auth:space-y-6", children: [_jsx(ModelMergerResultAlert, { pendingModelChanges: pendingModelChanges }), _jsxs("div", { className: "auth:grid auth:grid-cols-1 auth:gap-6 auth:md:grid-cols-2", children: [_jsx(ModelComboboxFieldController, { label: "User Model", name: "modelRefs.user", control: control, canCreate: true, description: "Select or create the model that will store user authentication data" }), _jsx(FeatureComboboxFieldController, { label: "Auth Feature Path", name: "authFeatureRef", control: control, canCreate: true, description: "Specify the feature path where authentication endpoints will be generated" })] })] })] }), _jsx(RoleEditorForm, { lens: lens.focus('roles') })] }) }), _jsx(FormActionBar, { form: form, allowSaveWithoutDirty: !pluginMetadata ||
-                    doesModelMergerResultsHaveChanges(pendingModelChanges) })] }));
+    return (_jsxs("div", { className: "auth:relative auth:flex auth:h-full auth:flex-1 auth:flex-col auth:gap-4 auth:overflow-hidden", children: [_jsx(AuthConfigTabs, {}), _jsx("div", { className: "auth:mb-[--action-bar-height] auth:flex auth:flex-1 auth:overflow-y-auto", style: {
+                    '--action-bar-height': '52px',
+                }, children: _jsxs("form", { onSubmit: onSubmit, className: "auth:max-w-6xl auth:flex-1", children: [_jsx("div", { className: "auth:pb-16", children: _jsx(SectionList, { children: _jsxs(SectionListSection, { children: [_jsxs(SectionListSectionHeader, { children: [_jsx(SectionListSectionTitle, { children: "Placeholder Auth Configuration" }), _jsx(SectionListSectionDescription, { children: "The plugin will automatically configure the models it needs." })] }), _jsx(SectionListSectionContent, { className: "auth:space-y-6", children: _jsx(DefinitionDiffAlert, { diff: diff, upToDateMessage: "All required models are already configured correctly. No changes needed." }) })] }) }) }), _jsx(FormActionBar, { form: form, allowSaveWithoutDirty: !pluginMetadata || diff.hasChanges })] }) })] }));
 }
 //# sourceMappingURL=placeholder-auth-definition-editor.js.map