@baseplate-dev/plugin-auth 0.1.2 → 0.6.2

package/dist/local-auth/core/generators/auth-email-password/generated/index.d.ts

@@ -0,0 +1,359 @@
+export declare const LOCAL_AUTH_CORE_AUTH_EMAIL_PASSWORD_GENERATED: {
+    imports: {
+        task: import("@baseplate-dev/sync").GeneratorTask<{
+            authEmailPasswordImports: import("@baseplate-dev/sync").ProviderExport<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+                authenticateUserWithEmailAndPassword: {};
+                cleanupExpiredPasswordResetTokens: {};
+                completePasswordReset: {};
+                createUserWithEmailAndPassword: {};
+                PASSWORD_MAX_LENGTH: {};
+                PASSWORD_MIN_LENGTH: {};
+                PASSWORD_RESET_TOKEN_EXPIRY_SEC: {};
+                registerUserWithEmailAndPassword: {};
+                requestPasswordReset: {};
+                validatePasswordResetToken: {};
+            }>>;
+        }, {
+            paths: import("@baseplate-dev/sync").ProviderType<import("./template-paths.js").LocalAuthCoreAuthEmailPasswordPaths>;
+        }, undefined>;
+    };
+    paths: {
+        provider: import("@baseplate-dev/sync").ProviderType<import("./template-paths.js").LocalAuthCoreAuthEmailPasswordPaths>;
+        task: import("@baseplate-dev/sync").GeneratorTask<{
+            localAuthCoreAuthEmailPasswordPaths: import("@baseplate-dev/sync").ProviderExport<import("./template-paths.js").LocalAuthCoreAuthEmailPasswordPaths>;
+        }, {
+            appModule: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/fastify-generators").AppModuleProvider>;
+        }, undefined>;
+    };
+    renderers: {
+        provider: import("@baseplate-dev/sync").ProviderType<import("./template-renderers.js").LocalAuthCoreAuthEmailPasswordRenderers>;
+        task: import("@baseplate-dev/sync").GeneratorTask<{
+            localAuthCoreAuthEmailPasswordRenderers: import("@baseplate-dev/sync").ProviderExport<import("./template-renderers.js").LocalAuthCoreAuthEmailPasswordRenderers>;
+        }, {
+            authModuleImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+                cleanupExpiredAuthVerifications: {};
+                createAuthVerification: {};
+                userSessionPayload: {};
+                validateAuthVerification: {};
+            }>>;
+            configServiceImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+                config: {};
+            }>>;
+            emailModuleImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+                EmailAdapter: {
+                    isTypeOnly: true;
+                };
+                EmailAttachment: {
+                    isTypeOnly: true;
+                };
+                EmailRawOptions: {
+                    isTypeOnly: true;
+                };
+                EmailSendOptions: {
+                    isTypeOnly: true;
+                };
+                sendEmail: {};
+                sendEmailQueue: {};
+                sendRawEmail: {};
+                TransformedEmailMessage: {
+                    isTypeOnly: true;
+                };
+            }>>;
+            errorHandlerServiceImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+                BadRequestError: {};
+                ForbiddenError: {};
+                handleZodRequestValidationError: {};
+                HttpError: {};
+                InternalServerError: {};
+                logError: {};
+                NotFoundError: {};
+                TooManyRequestsError: {};
+                UnauthorizedError: {};
+            }>>;
+            passwordHasherServiceImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+                createPasswordHash: {};
+                verifyPasswordHash: {};
+            }>>;
+            paths: import("@baseplate-dev/sync").ProviderType<import("./template-paths.js").LocalAuthCoreAuthEmailPasswordPaths>;
+            pothosImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+                builder: {};
+            }>>;
+            prismaGeneratedImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+                PrismaClient: {};
+                Prisma: {};
+                '*': {};
+                $Enums: {};
+            }>>;
+            prismaImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+                prisma: {};
+            }>>;
+            rateLimitImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+                createRateLimiter: {};
+                memoizeRateLimiter: {};
+                RateLimiter: {
+                    isTypeOnly: true;
+                };
+                RateLimiterConfig: {
+                    isTypeOnly: true;
+                };
+                RateLimitResult: {
+                    isTypeOnly: true;
+                };
+            }>>;
+            requestServiceContextImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+                createContextFromRequest: {};
+                RequestServiceContext: {
+                    isTypeOnly: true;
+                };
+            }>>;
+            typescriptFile: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").TypescriptFileProvider>;
+            userSessionServiceImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+                userSessionService: {};
+            }>>;
+            userSessionTypesImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+                UserSessionPayload: {
+                    isTypeOnly: true;
+                };
+                UserSessionService: {
+                    isTypeOnly: true;
+                };
+            }>>;
+        }, undefined>;
+    };
+    templates: {
+        moduleGroup: {
+            constantsPassword: import("@baseplate-dev/core-generators").TsTemplateFile<{}, {}, Record<never, Record<never, never>>>;
+            schemaPasswordResetMutations: import("@baseplate-dev/core-generators").TsTemplateFile<{}, {
+                pothosImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+                    builder: {};
+                }>>;
+            }, {
+                servicesPasswordReset: {};
+            }>;
+            schemaUserPasswordMutations: import("@baseplate-dev/core-generators").TsTemplateFile<{
+                TPL_ADMIN_ROLES: {};
+                TPL_USER_OBJECT_TYPE: {};
+            }, {
+                authModuleImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+                    cleanupExpiredAuthVerifications: {};
+                    createAuthVerification: {};
+                    userSessionPayload: {};
+                    validateAuthVerification: {};
+                }>>;
+                pothosImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+                    builder: {};
+                }>>;
+            }, {
+                servicesUserPassword: {};
+            }>;
+            servicesPasswordReset: import("@baseplate-dev/core-generators").TsTemplateFile<{
+                TPL_PASSWORD_CHANGED_EMAIL: {};
+                TPL_PASSWORD_RESET_EMAIL: {};
+            }, {
+                authModuleImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+                    cleanupExpiredAuthVerifications: {};
+                    createAuthVerification: {};
+                    userSessionPayload: {};
+                    validateAuthVerification: {};
+                }>>;
+                configServiceImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+                    config: {};
+                }>>;
+                emailModuleImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+                    EmailAdapter: {
+                        isTypeOnly: true;
+                    };
+                    EmailAttachment: {
+                        isTypeOnly: true;
+                    };
+                    EmailRawOptions: {
+                        isTypeOnly: true;
+                    };
+                    EmailSendOptions: {
+                        isTypeOnly: true;
+                    };
+                    sendEmail: {};
+                    sendEmailQueue: {};
+                    sendRawEmail: {};
+                    TransformedEmailMessage: {
+                        isTypeOnly: true;
+                    };
+                }>>;
+                errorHandlerServiceImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+                    BadRequestError: {};
+                    ForbiddenError: {};
+                    handleZodRequestValidationError: {};
+                    HttpError: {};
+                    InternalServerError: {};
+                    logError: {};
+                    NotFoundError: {};
+                    TooManyRequestsError: {};
+                    UnauthorizedError: {};
+                }>>;
+                passwordHasherServiceImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+                    createPasswordHash: {};
+                    verifyPasswordHash: {};
+                }>>;
+                prismaImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+                    prisma: {};
+                }>>;
+                rateLimitImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+                    createRateLimiter: {};
+                    memoizeRateLimiter: {};
+                    RateLimiter: {
+                        isTypeOnly: true;
+                    };
+                    RateLimiterConfig: {
+                        isTypeOnly: true;
+                    };
+                    RateLimitResult: {
+                        isTypeOnly: true;
+                    };
+                }>>;
+                requestServiceContextImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+                    createContextFromRequest: {};
+                    RequestServiceContext: {
+                        isTypeOnly: true;
+                    };
+                }>>;
+            }, {
+                constantsPassword: {};
+            }>;
+            servicesUserPassword: import("@baseplate-dev/core-generators").TsTemplateFile<{}, {
+                errorHandlerServiceImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+                    BadRequestError: {};
+                    ForbiddenError: {};
+                    handleZodRequestValidationError: {};
+                    HttpError: {};
+                    InternalServerError: {};
+                    logError: {};
+                    NotFoundError: {};
+                    TooManyRequestsError: {};
+                    UnauthorizedError: {};
+                }>>;
+                passwordHasherServiceImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+                    createPasswordHash: {};
+                    verifyPasswordHash: {};
+                }>>;
+                prismaGeneratedImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+                    PrismaClient: {};
+                    Prisma: {};
+                    '*': {};
+                    $Enums: {};
+                }>>;
+                prismaImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+                    prisma: {};
+                }>>;
+                rateLimitImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+                    createRateLimiter: {};
+                    memoizeRateLimiter: {};
+                    RateLimiter: {
+                        isTypeOnly: true;
+                    };
+                    RateLimiterConfig: {
+                        isTypeOnly: true;
+                    };
+                    RateLimitResult: {
+                        isTypeOnly: true;
+                    };
+                }>>;
+                requestServiceContextImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+                    createContextFromRequest: {};
+                    RequestServiceContext: {
+                        isTypeOnly: true;
+                    };
+                }>>;
+                userSessionServiceImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+                    userSessionService: {};
+                }>>;
+                userSessionTypesImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+                    UserSessionPayload: {
+                        isTypeOnly: true;
+                    };
+                    UserSessionService: {
+                        isTypeOnly: true;
+                    };
+                }>>;
+            }, {
+                constantsPassword: {};
+                servicesEmailVerification: {};
+            }>;
+        };
+        schemaEmailVerificationMutations: import("@baseplate-dev/core-generators").TsTemplateFile<{}, {
+            pothosImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+                builder: {};
+            }>>;
+        }, {
+            servicesEmailVerification: {};
+        }>;
+        servicesEmailVerification: import("@baseplate-dev/core-generators").TsTemplateFile<{
+            TPL_ACCOUNT_VERIFICATION_EMAIL: {};
+        }, {
+            authModuleImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+                cleanupExpiredAuthVerifications: {};
+                createAuthVerification: {};
+                userSessionPayload: {};
+                validateAuthVerification: {};
+            }>>;
+            configServiceImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+                config: {};
+            }>>;
+            emailModuleImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+                EmailAdapter: {
+                    isTypeOnly: true;
+                };
+                EmailAttachment: {
+                    isTypeOnly: true;
+                };
+                EmailRawOptions: {
+                    isTypeOnly: true;
+                };
+                EmailSendOptions: {
+                    isTypeOnly: true;
+                };
+                sendEmail: {};
+                sendEmailQueue: {};
+                sendRawEmail: {};
+                TransformedEmailMessage: {
+                    isTypeOnly: true;
+                };
+            }>>;
+            errorHandlerServiceImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+                BadRequestError: {};
+                ForbiddenError: {};
+                handleZodRequestValidationError: {};
+                HttpError: {};
+                InternalServerError: {};
+                logError: {};
+                NotFoundError: {};
+                TooManyRequestsError: {};
+                UnauthorizedError: {};
+            }>>;
+            prismaImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+                prisma: {};
+            }>>;
+            rateLimitImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+                createRateLimiter: {};
+                memoizeRateLimiter: {};
+                RateLimiter: {
+                    isTypeOnly: true;
+                };
+                RateLimiterConfig: {
+                    isTypeOnly: true;
+                };
+                RateLimitResult: {
+                    isTypeOnly: true;
+                };
+            }>>;
+            requestServiceContextImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+                createContextFromRequest: {};
+                RequestServiceContext: {
+                    isTypeOnly: true;
+                };
+            }>>;
+        }, {
+            constantsPassword: {};
+        }>;
+    };
+};
+//# sourceMappingURL=index.d.ts.map

package/dist/local-auth/core/generators/auth-email-password/generated/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/local-auth/core/generators/auth-email-password/generated/index.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,6CAA6C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAKzD,CAAC"}

package/dist/local-auth/core/generators/auth-email-password/generated/index.js

@@ -0,0 +1,11 @@
+import { LOCAL_AUTH_CORE_AUTH_EMAIL_PASSWORD_PATHS } from './template-paths.js';
+import { LOCAL_AUTH_CORE_AUTH_EMAIL_PASSWORD_RENDERERS } from './template-renderers.js';
+import { LOCAL_AUTH_CORE_AUTH_EMAIL_PASSWORD_IMPORTS } from './ts-import-providers.js';
+import { LOCAL_AUTH_CORE_AUTH_EMAIL_PASSWORD_TEMPLATES } from './typed-templates.js';
+export const LOCAL_AUTH_CORE_AUTH_EMAIL_PASSWORD_GENERATED = {
+    imports: LOCAL_AUTH_CORE_AUTH_EMAIL_PASSWORD_IMPORTS,
+    paths: LOCAL_AUTH_CORE_AUTH_EMAIL_PASSWORD_PATHS,
+    renderers: LOCAL_AUTH_CORE_AUTH_EMAIL_PASSWORD_RENDERERS,
+    templates: LOCAL_AUTH_CORE_AUTH_EMAIL_PASSWORD_TEMPLATES,
+};
+//# sourceMappingURL=index.js.map

package/dist/local-auth/core/generators/auth-email-password/generated/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../../src/local-auth/core/generators/auth-email-password/generated/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,yCAAyC,EAAE,MAAM,qBAAqB,CAAC;AAChF,OAAO,EAAE,6CAA6C,EAAE,MAAM,yBAAyB,CAAC;AACxF,OAAO,EAAE,2CAA2C,EAAE,MAAM,0BAA0B,CAAC;AACvF,OAAO,EAAE,6CAA6C,EAAE,MAAM,sBAAsB,CAAC;AAErF,MAAM,CAAC,MAAM,6CAA6C,GAAG;IAC3D,OAAO,EAAE,2CAA2C;IACpD,KAAK,EAAE,yCAAyC;IAChD,SAAS,EAAE,6CAA6C;IACxD,SAAS,EAAE,6CAA6C;CACzD,CAAC"}

package/dist/local-auth/core/generators/auth-email-password/generated/template-paths.d.ts

@@ -0,0 +1,18 @@
+export interface LocalAuthCoreAuthEmailPasswordPaths {
+    constantsPassword: string;
+    schemaEmailVerificationMutations: string;
+    schemaPasswordResetMutations: string;
+    schemaUserPasswordMutations: string;
+    servicesEmailVerification: string;
+    servicesPasswordReset: string;
+    servicesUserPassword: string;
+}
+export declare const LOCAL_AUTH_CORE_AUTH_EMAIL_PASSWORD_PATHS: {
+    provider: import("@baseplate-dev/sync").ProviderType<LocalAuthCoreAuthEmailPasswordPaths>;
+    task: import("@baseplate-dev/sync").GeneratorTask<{
+        localAuthCoreAuthEmailPasswordPaths: import("@baseplate-dev/sync").ProviderExport<LocalAuthCoreAuthEmailPasswordPaths>;
+    }, {
+        appModule: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/fastify-generators").AppModuleProvider>;
+    }, undefined>;
+};
+//# sourceMappingURL=template-paths.d.ts.map

package/dist/local-auth/core/generators/auth-email-password/generated/template-paths.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"template-paths.d.ts","sourceRoot":"","sources":["../../../../../../src/local-auth/core/generators/auth-email-password/generated/template-paths.ts"],"names":[],"mappings":"AAGA,MAAM,WAAW,mCAAmC;IAClD,iBAAiB,EAAE,MAAM,CAAC;IAC1B,gCAAgC,EAAE,MAAM,CAAC;IACzC,4BAA4B,EAAE,MAAM,CAAC;IACrC,2BAA2B,EAAE,MAAM,CAAC;IACpC,yBAAyB,EAAE,MAAM,CAAC;IAClC,qBAAqB,EAAE,MAAM,CAAC;IAC9B,oBAAoB,EAAE,MAAM,CAAC;CAC9B;AAgCD,eAAO,MAAM,yCAAyC;;;;;;;CAGrD,CAAC"}

package/dist/local-auth/core/generators/auth-email-password/generated/template-paths.js

@@ -0,0 +1,30 @@
+import { appModuleProvider } from '@baseplate-dev/fastify-generators';
+import { createGeneratorTask, createProviderType } from '@baseplate-dev/sync';
+const localAuthCoreAuthEmailPasswordPaths = createProviderType('local-auth-core-auth-email-password-paths');
+const localAuthCoreAuthEmailPasswordPathsTask = createGeneratorTask({
+    dependencies: { appModule: appModuleProvider },
+    exports: {
+        localAuthCoreAuthEmailPasswordPaths: localAuthCoreAuthEmailPasswordPaths.export(),
+    },
+    run({ appModule }) {
+        const moduleRoot = appModule.getModuleFolder();
+        return {
+            providers: {
+                localAuthCoreAuthEmailPasswordPaths: {
+                    constantsPassword: `${moduleRoot}/constants/password.constants.ts`,
+                    schemaEmailVerificationMutations: `${moduleRoot}/schema/email-verification.mutations.ts`,
+                    schemaPasswordResetMutations: `${moduleRoot}/schema/password-reset.mutations.ts`,
+                    schemaUserPasswordMutations: `${moduleRoot}/schema/user-password.mutations.ts`,
+                    servicesEmailVerification: `${moduleRoot}/services/email-verification.service.ts`,
+                    servicesPasswordReset: `${moduleRoot}/services/password-reset.service.ts`,
+                    servicesUserPassword: `${moduleRoot}/services/user-password.service.ts`,
+                },
+            },
+        };
+    },
+});
+export const LOCAL_AUTH_CORE_AUTH_EMAIL_PASSWORD_PATHS = {
+    provider: localAuthCoreAuthEmailPasswordPaths,
+    task: localAuthCoreAuthEmailPasswordPathsTask,
+};
+//# sourceMappingURL=template-paths.js.map

package/dist/local-auth/core/generators/auth-email-password/generated/template-paths.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"template-paths.js","sourceRoot":"","sources":["../../../../../../src/local-auth/core/generators/auth-email-password/generated/template-paths.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,mCAAmC,CAAC;AACtE,OAAO,EAAE,mBAAmB,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAC;AAY9E,MAAM,mCAAmC,GACvC,kBAAkB,CAChB,2CAA2C,CAC5C,CAAC;AAEJ,MAAM,uCAAuC,GAAG,mBAAmB,CAAC;IAClE,YAAY,EAAE,EAAE,SAAS,EAAE,iBAAiB,EAAE;IAC9C,OAAO,EAAE;QACP,mCAAmC,EACjC,mCAAmC,CAAC,MAAM,EAAE;KAC/C;IACD,GAAG,CAAC,EAAE,SAAS,EAAE;QACf,MAAM,UAAU,GAAG,SAAS,CAAC,eAAe,EAAE,CAAC;QAE/C,OAAO;YACL,SAAS,EAAE;gBACT,mCAAmC,EAAE;oBACnC,iBAAiB,EAAE,GAAG,UAAU,kCAAkC;oBAClE,gCAAgC,EAAE,GAAG,UAAU,yCAAyC;oBACxF,4BAA4B,EAAE,GAAG,UAAU,qCAAqC;oBAChF,2BAA2B,EAAE,GAAG,UAAU,oCAAoC;oBAC9E,yBAAyB,EAAE,GAAG,UAAU,yCAAyC;oBACjF,qBAAqB,EAAE,GAAG,UAAU,qCAAqC;oBACzE,oBAAoB,EAAE,GAAG,UAAU,oCAAoC;iBACxE;aACF;SACF,CAAC;IACJ,CAAC;CACF,CAAC,CAAC;AAEH,MAAM,CAAC,MAAM,yCAAyC,GAAG;IACvD,QAAQ,EAAE,mCAAmC;IAC7C,IAAI,EAAE,uCAAuC;CAC9C,CAAC"}

package/dist/local-auth/core/generators/auth-email-password/generated/template-renderers.d.ts

@@ -0,0 +1,110 @@
+import type { RenderTsTemplateFileActionInput, RenderTsTemplateGroupActionInput } from '@baseplate-dev/core-generators';
+import type { BuilderAction } from '@baseplate-dev/sync';
+import { LOCAL_AUTH_CORE_AUTH_EMAIL_PASSWORD_TEMPLATES } from './typed-templates.js';
+export interface LocalAuthCoreAuthEmailPasswordRenderers {
+    moduleGroup: {
+        render: (options: Omit<RenderTsTemplateGroupActionInput<typeof LOCAL_AUTH_CORE_AUTH_EMAIL_PASSWORD_TEMPLATES.moduleGroup>, 'importMapProviders' | 'group' | 'paths' | 'generatorPaths'>) => BuilderAction;
+    };
+    schemaEmailVerificationMutations: {
+        render: (options: Omit<RenderTsTemplateFileActionInput<typeof LOCAL_AUTH_CORE_AUTH_EMAIL_PASSWORD_TEMPLATES.schemaEmailVerificationMutations>, 'destination' | 'importMapProviders' | 'template' | 'generatorPaths'>) => BuilderAction;
+    };
+    servicesEmailVerification: {
+        render: (options: Omit<RenderTsTemplateFileActionInput<typeof LOCAL_AUTH_CORE_AUTH_EMAIL_PASSWORD_TEMPLATES.servicesEmailVerification>, 'destination' | 'importMapProviders' | 'template' | 'generatorPaths'>) => BuilderAction;
+    };
+}
+export declare const LOCAL_AUTH_CORE_AUTH_EMAIL_PASSWORD_RENDERERS: {
+    provider: import("@baseplate-dev/sync").ProviderType<LocalAuthCoreAuthEmailPasswordRenderers>;
+    task: import("@baseplate-dev/sync").GeneratorTask<{
+        localAuthCoreAuthEmailPasswordRenderers: import("@baseplate-dev/sync").ProviderExport<LocalAuthCoreAuthEmailPasswordRenderers>;
+    }, {
+        authModuleImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+            cleanupExpiredAuthVerifications: {};
+            createAuthVerification: {};
+            userSessionPayload: {};
+            validateAuthVerification: {};
+        }>>;
+        configServiceImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+            config: {};
+        }>>;
+        emailModuleImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+            EmailAdapter: {
+                isTypeOnly: true;
+            };
+            EmailAttachment: {
+                isTypeOnly: true;
+            };
+            EmailRawOptions: {
+                isTypeOnly: true;
+            };
+            EmailSendOptions: {
+                isTypeOnly: true;
+            };
+            sendEmail: {};
+            sendEmailQueue: {};
+            sendRawEmail: {};
+            TransformedEmailMessage: {
+                isTypeOnly: true;
+            };
+        }>>;
+        errorHandlerServiceImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+            BadRequestError: {};
+            ForbiddenError: {};
+            handleZodRequestValidationError: {};
+            HttpError: {};
+            InternalServerError: {};
+            logError: {};
+            NotFoundError: {};
+            TooManyRequestsError: {};
+            UnauthorizedError: {};
+        }>>;
+        passwordHasherServiceImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+            createPasswordHash: {};
+            verifyPasswordHash: {};
+        }>>;
+        paths: import("@baseplate-dev/sync").ProviderType<import("./template-paths.js").LocalAuthCoreAuthEmailPasswordPaths>;
+        pothosImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+            builder: {};
+        }>>;
+        prismaGeneratedImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+            PrismaClient: {};
+            Prisma: {};
+            '*': {};
+            $Enums: {};
+        }>>;
+        prismaImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+            prisma: {};
+        }>>;
+        rateLimitImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+            createRateLimiter: {};
+            memoizeRateLimiter: {};
+            RateLimiter: {
+                isTypeOnly: true;
+            };
+            RateLimiterConfig: {
+                isTypeOnly: true;
+            };
+            RateLimitResult: {
+                isTypeOnly: true;
+            };
+        }>>;
+        requestServiceContextImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+            createContextFromRequest: {};
+            RequestServiceContext: {
+                isTypeOnly: true;
+            };
+        }>>;
+        typescriptFile: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").TypescriptFileProvider>;
+        userSessionServiceImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+            userSessionService: {};
+        }>>;
+        userSessionTypesImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+            UserSessionPayload: {
+                isTypeOnly: true;
+            };
+            UserSessionService: {
+                isTypeOnly: true;
+            };
+        }>>;
+    }, undefined>;
+};
+//# sourceMappingURL=template-renderers.d.ts.map

package/dist/local-auth/core/generators/auth-email-password/generated/template-renderers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"template-renderers.d.ts","sourceRoot":"","sources":["../../../../../../src/local-auth/core/generators/auth-email-password/generated/template-renderers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,+BAA+B,EAC/B,gCAAgC,EACjC,MAAM,gCAAgC,CAAC;AACxC,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAqBzD,OAAO,EAAE,6CAA6C,EAAE,MAAM,sBAAsB,CAAC;AAErF,MAAM,WAAW,uCAAuC;IACtD,WAAW,EAAE;QACX,MAAM,EAAE,CACN,OAAO,EAAE,IAAI,CACX,gCAAgC,CAC9B,OAAO,6CAA6C,CAAC,WAAW,CACjE,EACD,oBAAoB,GAAG,OAAO,GAAG,OAAO,GAAG,gBAAgB,CAC5D,KACE,aAAa,CAAC;KACpB,CAAC;IACF,gCAAgC,EAAE;QAChC,MAAM,EAAE,CACN,OAAO,EAAE,IAAI,CACX,+BAA+B,CAC7B,OAAO,6CAA6C,CAAC,gCAAgC,CACtF,EACD,aAAa,GAAG,oBAAoB,GAAG,UAAU,GAAG,gBAAgB,CACrE,KACE,aAAa,CAAC;KACpB,CAAC;IACF,yBAAyB,EAAE;QACzB,MAAM,EAAE,CACN,OAAO,EAAE,IAAI,CACX,+BAA+B,CAC7B,OAAO,6CAA6C,CAAC,yBAAyB,CAC/E,EACD,aAAa,GAAG,oBAAoB,GAAG,UAAU,GAAG,gBAAgB,CACrE,KACE,aAAa,CAAC;KACpB,CAAC;CACH;AA6GD,eAAO,MAAM,6CAA6C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAGzD,CAAC"}

package/dist/local-auth/core/generators/auth-email-password/generated/template-renderers.js

@@ -0,0 +1,93 @@
+import { typescriptFileProvider } from '@baseplate-dev/core-generators';
+import { configServiceImportsProvider, errorHandlerServiceImportsProvider, passwordHasherServiceImportsProvider, pothosImportsProvider, prismaGeneratedImportsProvider, prismaImportsProvider, requestServiceContextImportsProvider, userSessionServiceImportsProvider, userSessionTypesImportsProvider, } from '@baseplate-dev/fastify-generators';
+import { emailModuleImportsProvider } from '@baseplate-dev/plugin-email';
+import { rateLimitImportsProvider } from '@baseplate-dev/plugin-rate-limit';
+import { createGeneratorTask, createProviderType } from '@baseplate-dev/sync';
+import { authModuleImportsProvider } from '#src/local-auth/core/generators/auth-module/generated/ts-import-providers.js';
+import { LOCAL_AUTH_CORE_AUTH_EMAIL_PASSWORD_PATHS } from './template-paths.js';
+import { LOCAL_AUTH_CORE_AUTH_EMAIL_PASSWORD_TEMPLATES } from './typed-templates.js';
+const localAuthCoreAuthEmailPasswordRenderers = createProviderType('local-auth-core-auth-email-password-renderers');
+const localAuthCoreAuthEmailPasswordRenderersTask = createGeneratorTask({
+    dependencies: {
+        authModuleImports: authModuleImportsProvider,
+        configServiceImports: configServiceImportsProvider,
+        emailModuleImports: emailModuleImportsProvider,
+        errorHandlerServiceImports: errorHandlerServiceImportsProvider,
+        passwordHasherServiceImports: passwordHasherServiceImportsProvider,
+        paths: LOCAL_AUTH_CORE_AUTH_EMAIL_PASSWORD_PATHS.provider,
+        pothosImports: pothosImportsProvider,
+        prismaGeneratedImports: prismaGeneratedImportsProvider,
+        prismaImports: prismaImportsProvider,
+        rateLimitImports: rateLimitImportsProvider,
+        requestServiceContextImports: requestServiceContextImportsProvider,
+        typescriptFile: typescriptFileProvider,
+        userSessionServiceImports: userSessionServiceImportsProvider,
+        userSessionTypesImports: userSessionTypesImportsProvider,
+    },
+    exports: {
+        localAuthCoreAuthEmailPasswordRenderers: localAuthCoreAuthEmailPasswordRenderers.export(),
+    },
+    run({ authModuleImports, configServiceImports, emailModuleImports, errorHandlerServiceImports, passwordHasherServiceImports, paths, pothosImports, prismaGeneratedImports, prismaImports, rateLimitImports, requestServiceContextImports, typescriptFile, userSessionServiceImports, userSessionTypesImports, }) {
+        return {
+            providers: {
+                localAuthCoreAuthEmailPasswordRenderers: {
+                    moduleGroup: {
+                        render: (options) => typescriptFile.renderTemplateGroup({
+                            group: LOCAL_AUTH_CORE_AUTH_EMAIL_PASSWORD_TEMPLATES.moduleGroup,
+                            paths,
+                            importMapProviders: {
+                                authModuleImports,
+                                configServiceImports,
+                                emailModuleImports,
+                                errorHandlerServiceImports,
+                                passwordHasherServiceImports,
+                                pothosImports,
+                                prismaGeneratedImports,
+                                prismaImports,
+                                rateLimitImports,
+                                requestServiceContextImports,
+                                userSessionServiceImports,
+                                userSessionTypesImports,
+                            },
+                            generatorPaths: paths,
+                            ...options,
+                        }),
+                    },
+                    schemaEmailVerificationMutations: {
+                        render: (options) => typescriptFile.renderTemplateFile({
+                            template: LOCAL_AUTH_CORE_AUTH_EMAIL_PASSWORD_TEMPLATES.schemaEmailVerificationMutations,
+                            destination: paths.schemaEmailVerificationMutations,
+                            importMapProviders: {
+                                pothosImports,
+                            },
+                            generatorPaths: paths,
+                            ...options,
+                        }),
+                    },
+                    servicesEmailVerification: {
+                        render: (options) => typescriptFile.renderTemplateFile({
+                            template: LOCAL_AUTH_CORE_AUTH_EMAIL_PASSWORD_TEMPLATES.servicesEmailVerification,
+                            destination: paths.servicesEmailVerification,
+                            importMapProviders: {
+                                authModuleImports,
+                                configServiceImports,
+                                emailModuleImports,
+                                errorHandlerServiceImports,
+                                prismaImports,
+                                rateLimitImports,
+                                requestServiceContextImports,
+                            },
+                            generatorPaths: paths,
+                            ...options,
+                        }),
+                    },
+                },
+            },
+        };
+    },
+});
+export const LOCAL_AUTH_CORE_AUTH_EMAIL_PASSWORD_RENDERERS = {
+    provider: localAuthCoreAuthEmailPasswordRenderers,
+    task: localAuthCoreAuthEmailPasswordRenderersTask,
+};
+//# sourceMappingURL=template-renderers.js.map

package/dist/local-auth/core/generators/auth-email-password/generated/template-renderers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"template-renderers.js","sourceRoot":"","sources":["../../../../../../src/local-auth/core/generators/auth-email-password/generated/template-renderers.ts"],"names":[],"mappings":"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"}