@baseplate-dev/plugin-auth 0.1.3 → 0.6.2

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

@@ -0,0 +1,281 @@
+export declare const LOCAL_AUTH_CORE_AUTH_MODULE_GENERATED: {
+    imports: {
+        task: import("@baseplate-dev/sync").GeneratorTask<{
+            authModuleImports: import("@baseplate-dev/sync").ProviderExport<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+                cleanupExpiredAuthVerifications: {};
+                createAuthVerification: {};
+                userSessionPayload: {};
+                validateAuthVerification: {};
+            }>>;
+            userSessionServiceImports: import("@baseplate-dev/sync").ProviderExport<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+                userSessionService: {};
+            }>>;
+        }, {
+            paths: import("@baseplate-dev/sync").ProviderType<import("./template-paths.js").LocalAuthCoreAuthModulePaths>;
+        }, undefined>;
+    };
+    paths: {
+        provider: import("@baseplate-dev/sync").ProviderType<import("./template-paths.js").LocalAuthCoreAuthModulePaths>;
+        task: import("@baseplate-dev/sync").GeneratorTask<{
+            localAuthCoreAuthModulePaths: import("@baseplate-dev/sync").ProviderExport<import("./template-paths.js").LocalAuthCoreAuthModulePaths>;
+        }, {
+            appModule: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/fastify-generators").AppModuleProvider>;
+        }, undefined>;
+    };
+    renderers: {
+        provider: import("@baseplate-dev/sync").ProviderType<import("./template-renderers.js").LocalAuthCoreAuthModuleRenderers>;
+        task: import("@baseplate-dev/sync").GeneratorTask<{
+            localAuthCoreAuthModuleRenderers: import("@baseplate-dev/sync").ProviderExport<import("./template-renderers.js").LocalAuthCoreAuthModuleRenderers>;
+        }, {
+            authContextImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+                AuthContext: {
+                    isTypeOnly: true;
+                };
+                AuthSessionInfo: {
+                    isTypeOnly: true;
+                };
+                AuthUserSessionInfo: {
+                    isTypeOnly: true;
+                };
+                createAnonymousAuthContext: {};
+                createAuthContextFromSessionInfo: {};
+                createSystemAuthContext: {};
+                InvalidSessionError: {};
+            }>>;
+            authRolesImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+                AUTH_ROLE_CONFIG: {};
+                AuthRole: {
+                    isTypeOnly: true;
+                };
+                DEFAULT_PUBLIC_ROLES: {};
+                DEFAULT_USER_ROLES: {};
+                RoleConfig: {
+                    isTypeOnly: true;
+                };
+            }>>;
+            configServiceImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+                config: {};
+            }>>;
+            errorHandlerServiceImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+                BadRequestError: {};
+                ForbiddenError: {};
+                handleZodRequestValidationError: {};
+                HttpError: {};
+                InternalServerError: {};
+                logError: {};
+                NotFoundError: {};
+                TooManyRequestsError: {};
+                UnauthorizedError: {};
+            }>>;
+            paths: import("@baseplate-dev/sync").ProviderType<import("./template-paths.js").LocalAuthCoreAuthModulePaths>;
+            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: {};
+            }>>;
+            queueServiceImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+                createQueue: {};
+            }>>;
+            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>;
+            userSessionTypesImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+                UserSessionPayload: {
+                    isTypeOnly: true;
+                };
+                UserSessionService: {
+                    isTypeOnly: true;
+                };
+            }>>;
+        }, undefined>;
+    };
+    templates: {
+        constantsGroup: {
+            userSessionConstants: import("@baseplate-dev/core-generators").TsTemplateFile<{}, {}, Record<never, Record<never, never>>>;
+        };
+        moduleGroup: {
+            authRoleEnum: import("@baseplate-dev/core-generators").TsTemplateFile<{}, {
+                authRolesImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+                    AUTH_ROLE_CONFIG: {};
+                    AuthRole: {
+                        isTypeOnly: true;
+                    };
+                    DEFAULT_PUBLIC_ROLES: {};
+                    DEFAULT_USER_ROLES: {};
+                    RoleConfig: {
+                        isTypeOnly: true;
+                    };
+                }>>;
+                pothosImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+                    builder: {};
+                }>>;
+            }, Record<never, Record<never, never>>>;
+            schemaUserSessionMutations: import("@baseplate-dev/core-generators").TsTemplateFile<{}, {
+                pothosImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+                    builder: {};
+                }>>;
+            }, {
+                userSessionService: {};
+            }>;
+            schemaUserSessionPayloadObjectType: import("@baseplate-dev/core-generators").TsTemplateFile<{
+                TPL_PRISMA_USER: {};
+                TPL_USER_OBJECT_TYPE: {};
+            }, {
+                pothosImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+                    builder: {};
+                }>>;
+            }, {
+                authRoleEnum: {};
+            }>;
+            schemaUserSessionQueries: import("@baseplate-dev/core-generators").TsTemplateFile<{
+                TPL_USER_OBJECT_TYPE: {};
+            }, {
+                pothosImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+                    builder: {};
+                }>>;
+                prismaImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+                    prisma: {};
+                }>>;
+            }, {
+                schemaUserSessionPayloadObjectType: {};
+            }>;
+            userRolesMutations: import("@baseplate-dev/core-generators").TsTemplateFile<{
+                TPL_ADMIN_ROLES: {};
+                TPL_USER_OBJECT_TYPE: {};
+            }, {
+                pothosImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+                    builder: {};
+                }>>;
+            }, {
+                userRolesService: {};
+            }>;
+            userRolesService: import("@baseplate-dev/core-generators").TsTemplateFile<{}, {
+                authRolesImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+                    AUTH_ROLE_CONFIG: {};
+                    AuthRole: {
+                        isTypeOnly: true;
+                    };
+                    DEFAULT_PUBLIC_ROLES: {};
+                    DEFAULT_USER_ROLES: {};
+                    RoleConfig: {
+                        isTypeOnly: true;
+                    };
+                }>>;
+                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: {};
+                }>>;
+            }, Record<never, Record<never, never>>>;
+        };
+        queuesCleanupAuthVerification: import("@baseplate-dev/core-generators").TsTemplateFile<{}, {
+            queueServiceImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+                createQueue: {};
+            }>>;
+        }, {
+            servicesAuthVerification: {};
+        }>;
+        servicesAuthVerification: import("@baseplate-dev/core-generators").TsTemplateFile<{}, {
+            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: {};
+            }>>;
+        }, Record<never, Record<never, never>>>;
+        userSessionService: import("@baseplate-dev/core-generators").TsTemplateFile<{
+            TPL_PRISMA_USER_SESSION: {};
+        }, {
+            authContextImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+                AuthContext: {
+                    isTypeOnly: true;
+                };
+                AuthSessionInfo: {
+                    isTypeOnly: true;
+                };
+                AuthUserSessionInfo: {
+                    isTypeOnly: true;
+                };
+                createAnonymousAuthContext: {};
+                createAuthContextFromSessionInfo: {};
+                createSystemAuthContext: {};
+                InvalidSessionError: {};
+            }>>;
+            authRolesImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+                AUTH_ROLE_CONFIG: {};
+                AuthRole: {
+                    isTypeOnly: true;
+                };
+                DEFAULT_PUBLIC_ROLES: {};
+                DEFAULT_USER_ROLES: {};
+                RoleConfig: {
+                    isTypeOnly: true;
+                };
+            }>>;
+            configServiceImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+                config: {};
+            }>>;
+            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: {};
+            }>>;
+            requestServiceContextImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+                createContextFromRequest: {};
+                RequestServiceContext: {
+                    isTypeOnly: true;
+                };
+            }>>;
+            userSessionTypesImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+                UserSessionPayload: {
+                    isTypeOnly: true;
+                };
+                UserSessionService: {
+                    isTypeOnly: true;
+                };
+            }>>;
+        }, {
+            cookieSigner: {};
+            sessionCookie: {};
+            userSessionConstants: {};
+            verifyRequestOrigin: {};
+        }>;
+        utilsGroup: {
+            cookieSigner: import("@baseplate-dev/core-generators").TsTemplateFile<{}, {}, Record<never, Record<never, never>>>;
+            sessionCookie: import("@baseplate-dev/core-generators").TsTemplateFile<{}, {
+                configServiceImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+                    config: {};
+                }>>;
+            }, Record<never, Record<never, never>>>;
+            verifyRequestOrigin: import("@baseplate-dev/core-generators").TsTemplateFile<{}, {}, Record<never, Record<never, never>>>;
+        };
+    };
+};
+//# sourceMappingURL=index.d.ts.map

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

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

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

@@ -0,0 +1,11 @@
+import { LOCAL_AUTH_CORE_AUTH_MODULE_PATHS } from './template-paths.js';
+import { LOCAL_AUTH_CORE_AUTH_MODULE_RENDERERS } from './template-renderers.js';
+import { LOCAL_AUTH_CORE_AUTH_MODULE_IMPORTS } from './ts-import-providers.js';
+import { LOCAL_AUTH_CORE_AUTH_MODULE_TEMPLATES } from './typed-templates.js';
+export const LOCAL_AUTH_CORE_AUTH_MODULE_GENERATED = {
+    imports: LOCAL_AUTH_CORE_AUTH_MODULE_IMPORTS,
+    paths: LOCAL_AUTH_CORE_AUTH_MODULE_PATHS,
+    renderers: LOCAL_AUTH_CORE_AUTH_MODULE_RENDERERS,
+    templates: LOCAL_AUTH_CORE_AUTH_MODULE_TEMPLATES,
+};
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../../src/local-auth/core/generators/auth-module/generated/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iCAAiC,EAAE,MAAM,qBAAqB,CAAC;AACxE,OAAO,EAAE,qCAAqC,EAAE,MAAM,yBAAyB,CAAC;AAChF,OAAO,EAAE,mCAAmC,EAAE,MAAM,0BAA0B,CAAC;AAC/E,OAAO,EAAE,qCAAqC,EAAE,MAAM,sBAAsB,CAAC;AAE7E,MAAM,CAAC,MAAM,qCAAqC,GAAG;IACnD,OAAO,EAAE,mCAAmC;IAC5C,KAAK,EAAE,iCAAiC;IACxC,SAAS,EAAE,qCAAqC;IAChD,SAAS,EAAE,qCAAqC;CACjD,CAAC"}

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

@@ -0,0 +1,24 @@
+export interface LocalAuthCoreAuthModulePaths {
+    authRoleEnum: string;
+    cookieSigner: string;
+    queuesCleanupAuthVerification: string;
+    schemaUserSessionMutations: string;
+    schemaUserSessionPayloadObjectType: string;
+    schemaUserSessionQueries: string;
+    servicesAuthVerification: string;
+    sessionCookie: string;
+    userRolesMutations: string;
+    userRolesService: string;
+    userSessionConstants: string;
+    userSessionService: string;
+    verifyRequestOrigin: string;
+}
+export declare const LOCAL_AUTH_CORE_AUTH_MODULE_PATHS: {
+    provider: import("@baseplate-dev/sync").ProviderType<LocalAuthCoreAuthModulePaths>;
+    task: import("@baseplate-dev/sync").GeneratorTask<{
+        localAuthCoreAuthModulePaths: import("@baseplate-dev/sync").ProviderExport<LocalAuthCoreAuthModulePaths>;
+    }, {
+        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-module/generated/template-paths.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"template-paths.d.ts","sourceRoot":"","sources":["../../../../../../src/local-auth/core/generators/auth-module/generated/template-paths.ts"],"names":[],"mappings":"AAGA,MAAM,WAAW,4BAA4B;IAC3C,YAAY,EAAE,MAAM,CAAC;IACrB,YAAY,EAAE,MAAM,CAAC;IACrB,6BAA6B,EAAE,MAAM,CAAC;IACtC,0BAA0B,EAAE,MAAM,CAAC;IACnC,kCAAkC,EAAE,MAAM,CAAC;IAC3C,wBAAwB,EAAE,MAAM,CAAC;IACjC,wBAAwB,EAAE,MAAM,CAAC;IACjC,aAAa,EAAE,MAAM,CAAC;IACtB,kBAAkB,EAAE,MAAM,CAAC;IAC3B,gBAAgB,EAAE,MAAM,CAAC;IACzB,oBAAoB,EAAE,MAAM,CAAC;IAC7B,kBAAkB,EAAE,MAAM,CAAC;IAC3B,mBAAmB,EAAE,MAAM,CAAC;CAC7B;AAqCD,eAAO,MAAM,iCAAiC;;;;;;;CAG7C,CAAC"}

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

@@ -0,0 +1,36 @@
+import { appModuleProvider } from '@baseplate-dev/fastify-generators';
+import { createGeneratorTask, createProviderType } from '@baseplate-dev/sync';
+const localAuthCoreAuthModulePaths = createProviderType('local-auth-core-auth-module-paths');
+const localAuthCoreAuthModulePathsTask = createGeneratorTask({
+    dependencies: { appModule: appModuleProvider },
+    exports: {
+        localAuthCoreAuthModulePaths: localAuthCoreAuthModulePaths.export(),
+    },
+    run({ appModule }) {
+        const moduleRoot = appModule.getModuleFolder();
+        return {
+            providers: {
+                localAuthCoreAuthModulePaths: {
+                    authRoleEnum: `${moduleRoot}/schema/auth-role.enum.ts`,
+                    cookieSigner: `${moduleRoot}/utils/cookie-signer.ts`,
+                    queuesCleanupAuthVerification: `${moduleRoot}/queues/cleanup-auth-verification.queue.ts`,
+                    schemaUserSessionMutations: `${moduleRoot}/schema/user-session.mutations.ts`,
+                    schemaUserSessionPayloadObjectType: `${moduleRoot}/schema/user-session-payload.object-type.ts`,
+                    schemaUserSessionQueries: `${moduleRoot}/schema/user-session.queries.ts`,
+                    servicesAuthVerification: `${moduleRoot}/services/auth-verification.service.ts`,
+                    sessionCookie: `${moduleRoot}/utils/session-cookie.ts`,
+                    userRolesMutations: `${moduleRoot}/schema/user-roles.mutations.ts`,
+                    userRolesService: `${moduleRoot}/services/user-roles.service.ts`,
+                    userSessionConstants: `${moduleRoot}/constants/user-session.constants.ts`,
+                    userSessionService: `${moduleRoot}/services/user-session.service.ts`,
+                    verifyRequestOrigin: `${moduleRoot}/utils/verify-request-origin.ts`,
+                },
+            },
+        };
+    },
+});
+export const LOCAL_AUTH_CORE_AUTH_MODULE_PATHS = {
+    provider: localAuthCoreAuthModulePaths,
+    task: localAuthCoreAuthModulePathsTask,
+};
+//# sourceMappingURL=template-paths.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"template-paths.js","sourceRoot":"","sources":["../../../../../../src/local-auth/core/generators/auth-module/generated/template-paths.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,mCAAmC,CAAC;AACtE,OAAO,EAAE,mBAAmB,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAC;AAkB9E,MAAM,4BAA4B,GAChC,kBAAkB,CAChB,mCAAmC,CACpC,CAAC;AAEJ,MAAM,gCAAgC,GAAG,mBAAmB,CAAC;IAC3D,YAAY,EAAE,EAAE,SAAS,EAAE,iBAAiB,EAAE;IAC9C,OAAO,EAAE;QACP,4BAA4B,EAAE,4BAA4B,CAAC,MAAM,EAAE;KACpE;IACD,GAAG,CAAC,EAAE,SAAS,EAAE;QACf,MAAM,UAAU,GAAG,SAAS,CAAC,eAAe,EAAE,CAAC;QAE/C,OAAO;YACL,SAAS,EAAE;gBACT,4BAA4B,EAAE;oBAC5B,YAAY,EAAE,GAAG,UAAU,2BAA2B;oBACtD,YAAY,EAAE,GAAG,UAAU,yBAAyB;oBACpD,6BAA6B,EAAE,GAAG,UAAU,4CAA4C;oBACxF,0BAA0B,EAAE,GAAG,UAAU,mCAAmC;oBAC5E,kCAAkC,EAAE,GAAG,UAAU,6CAA6C;oBAC9F,wBAAwB,EAAE,GAAG,UAAU,iCAAiC;oBACxE,wBAAwB,EAAE,GAAG,UAAU,wCAAwC;oBAC/E,aAAa,EAAE,GAAG,UAAU,0BAA0B;oBACtD,kBAAkB,EAAE,GAAG,UAAU,iCAAiC;oBAClE,gBAAgB,EAAE,GAAG,UAAU,iCAAiC;oBAChE,oBAAoB,EAAE,GAAG,UAAU,sCAAsC;oBACzE,kBAAkB,EAAE,GAAG,UAAU,mCAAmC;oBACpE,mBAAmB,EAAE,GAAG,UAAU,iCAAiC;iBACpE;aACF;SACF,CAAC;IACJ,CAAC;CACF,CAAC,CAAC;AAEH,MAAM,CAAC,MAAM,iCAAiC,GAAG;IAC/C,QAAQ,EAAE,4BAA4B;IACtC,IAAI,EAAE,gCAAgC;CACvC,CAAC"}

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

@@ -0,0 +1,102 @@
+import type { RenderTsTemplateFileActionInput, RenderTsTemplateGroupActionInput } from '@baseplate-dev/core-generators';
+import type { BuilderAction } from '@baseplate-dev/sync';
+import { LOCAL_AUTH_CORE_AUTH_MODULE_TEMPLATES } from './typed-templates.js';
+export interface LocalAuthCoreAuthModuleRenderers {
+    constantsGroup: {
+        render: (options: Omit<RenderTsTemplateGroupActionInput<typeof LOCAL_AUTH_CORE_AUTH_MODULE_TEMPLATES.constantsGroup>, 'importMapProviders' | 'group' | 'paths' | 'generatorPaths'>) => BuilderAction;
+    };
+    moduleGroup: {
+        render: (options: Omit<RenderTsTemplateGroupActionInput<typeof LOCAL_AUTH_CORE_AUTH_MODULE_TEMPLATES.moduleGroup>, 'importMapProviders' | 'group' | 'paths' | 'generatorPaths'>) => BuilderAction;
+    };
+    queuesCleanupAuthVerification: {
+        render: (options: Omit<RenderTsTemplateFileActionInput<typeof LOCAL_AUTH_CORE_AUTH_MODULE_TEMPLATES.queuesCleanupAuthVerification>, 'destination' | 'importMapProviders' | 'template' | 'generatorPaths'>) => BuilderAction;
+    };
+    servicesAuthVerification: {
+        render: (options: Omit<RenderTsTemplateFileActionInput<typeof LOCAL_AUTH_CORE_AUTH_MODULE_TEMPLATES.servicesAuthVerification>, 'destination' | 'importMapProviders' | 'template' | 'generatorPaths'>) => BuilderAction;
+    };
+    userSessionService: {
+        render: (options: Omit<RenderTsTemplateFileActionInput<typeof LOCAL_AUTH_CORE_AUTH_MODULE_TEMPLATES.userSessionService>, 'destination' | 'importMapProviders' | 'template' | 'generatorPaths'>) => BuilderAction;
+    };
+    utilsGroup: {
+        render: (options: Omit<RenderTsTemplateGroupActionInput<typeof LOCAL_AUTH_CORE_AUTH_MODULE_TEMPLATES.utilsGroup>, 'importMapProviders' | 'group' | 'paths' | 'generatorPaths'>) => BuilderAction;
+    };
+}
+export declare const LOCAL_AUTH_CORE_AUTH_MODULE_RENDERERS: {
+    provider: import("@baseplate-dev/sync").ProviderType<LocalAuthCoreAuthModuleRenderers>;
+    task: import("@baseplate-dev/sync").GeneratorTask<{
+        localAuthCoreAuthModuleRenderers: import("@baseplate-dev/sync").ProviderExport<LocalAuthCoreAuthModuleRenderers>;
+    }, {
+        authContextImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+            AuthContext: {
+                isTypeOnly: true;
+            };
+            AuthSessionInfo: {
+                isTypeOnly: true;
+            };
+            AuthUserSessionInfo: {
+                isTypeOnly: true;
+            };
+            createAnonymousAuthContext: {};
+            createAuthContextFromSessionInfo: {};
+            createSystemAuthContext: {};
+            InvalidSessionError: {};
+        }>>;
+        authRolesImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+            AUTH_ROLE_CONFIG: {};
+            AuthRole: {
+                isTypeOnly: true;
+            };
+            DEFAULT_PUBLIC_ROLES: {};
+            DEFAULT_USER_ROLES: {};
+            RoleConfig: {
+                isTypeOnly: true;
+            };
+        }>>;
+        configServiceImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+            config: {};
+        }>>;
+        errorHandlerServiceImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+            BadRequestError: {};
+            ForbiddenError: {};
+            handleZodRequestValidationError: {};
+            HttpError: {};
+            InternalServerError: {};
+            logError: {};
+            NotFoundError: {};
+            TooManyRequestsError: {};
+            UnauthorizedError: {};
+        }>>;
+        paths: import("@baseplate-dev/sync").ProviderType<import("./template-paths.js").LocalAuthCoreAuthModulePaths>;
+        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: {};
+        }>>;
+        queueServiceImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+            createQueue: {};
+        }>>;
+        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>;
+        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-module/generated/template-renderers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"template-renderers.d.ts","sourceRoot":"","sources":["../../../../../../src/local-auth/core/generators/auth-module/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;AAkBzD,OAAO,EAAE,qCAAqC,EAAE,MAAM,sBAAsB,CAAC;AAE7E,MAAM,WAAW,gCAAgC;IAC/C,cAAc,EAAE;QACd,MAAM,EAAE,CACN,OAAO,EAAE,IAAI,CACX,gCAAgC,CAC9B,OAAO,qCAAqC,CAAC,cAAc,CAC5D,EACD,oBAAoB,GAAG,OAAO,GAAG,OAAO,GAAG,gBAAgB,CAC5D,KACE,aAAa,CAAC;KACpB,CAAC;IACF,WAAW,EAAE;QACX,MAAM,EAAE,CACN,OAAO,EAAE,IAAI,CACX,gCAAgC,CAC9B,OAAO,qCAAqC,CAAC,WAAW,CACzD,EACD,oBAAoB,GAAG,OAAO,GAAG,OAAO,GAAG,gBAAgB,CAC5D,KACE,aAAa,CAAC;KACpB,CAAC;IACF,6BAA6B,EAAE;QAC7B,MAAM,EAAE,CACN,OAAO,EAAE,IAAI,CACX,+BAA+B,CAC7B,OAAO,qCAAqC,CAAC,6BAA6B,CAC3E,EACD,aAAa,GAAG,oBAAoB,GAAG,UAAU,GAAG,gBAAgB,CACrE,KACE,aAAa,CAAC;KACpB,CAAC;IACF,wBAAwB,EAAE;QACxB,MAAM,EAAE,CACN,OAAO,EAAE,IAAI,CACX,+BAA+B,CAC7B,OAAO,qCAAqC,CAAC,wBAAwB,CACtE,EACD,aAAa,GAAG,oBAAoB,GAAG,UAAU,GAAG,gBAAgB,CACrE,KACE,aAAa,CAAC;KACpB,CAAC;IACF,kBAAkB,EAAE;QAClB,MAAM,EAAE,CACN,OAAO,EAAE,IAAI,CACX,+BAA+B,CAC7B,OAAO,qCAAqC,CAAC,kBAAkB,CAChE,EACD,aAAa,GAAG,oBAAoB,GAAG,UAAU,GAAG,gBAAgB,CACrE,KACE,aAAa,CAAC;KACpB,CAAC;IACF,UAAU,EAAE;QACV,MAAM,EAAE,CACN,OAAO,EAAE,IAAI,CACX,gCAAgC,CAC9B,OAAO,qCAAqC,CAAC,UAAU,CACxD,EACD,oBAAoB,GAAG,OAAO,GAAG,OAAO,GAAG,gBAAgB,CAC5D,KACE,aAAa,CAAC;KACpB,CAAC;CACH;AA+HD,eAAO,MAAM,qCAAqC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAGjD,CAAC"}

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

@@ -0,0 +1,109 @@
+import { typescriptFileProvider } from '@baseplate-dev/core-generators';
+import { authContextImportsProvider, authRolesImportsProvider, configServiceImportsProvider, errorHandlerServiceImportsProvider, pothosImportsProvider, prismaGeneratedImportsProvider, prismaImportsProvider, requestServiceContextImportsProvider, userSessionTypesImportsProvider, } from '@baseplate-dev/fastify-generators';
+import { queueServiceImportsProvider } from '@baseplate-dev/plugin-queue';
+import { createGeneratorTask, createProviderType } from '@baseplate-dev/sync';
+import { LOCAL_AUTH_CORE_AUTH_MODULE_PATHS } from './template-paths.js';
+import { LOCAL_AUTH_CORE_AUTH_MODULE_TEMPLATES } from './typed-templates.js';
+const localAuthCoreAuthModuleRenderers = createProviderType('local-auth-core-auth-module-renderers');
+const localAuthCoreAuthModuleRenderersTask = createGeneratorTask({
+    dependencies: {
+        authContextImports: authContextImportsProvider,
+        authRolesImports: authRolesImportsProvider,
+        configServiceImports: configServiceImportsProvider,
+        errorHandlerServiceImports: errorHandlerServiceImportsProvider,
+        paths: LOCAL_AUTH_CORE_AUTH_MODULE_PATHS.provider,
+        pothosImports: pothosImportsProvider,
+        prismaGeneratedImports: prismaGeneratedImportsProvider,
+        prismaImports: prismaImportsProvider,
+        queueServiceImports: queueServiceImportsProvider,
+        requestServiceContextImports: requestServiceContextImportsProvider,
+        typescriptFile: typescriptFileProvider,
+        userSessionTypesImports: userSessionTypesImportsProvider,
+    },
+    exports: {
+        localAuthCoreAuthModuleRenderers: localAuthCoreAuthModuleRenderers.export(),
+    },
+    run({ authContextImports, authRolesImports, configServiceImports, errorHandlerServiceImports, paths, pothosImports, prismaGeneratedImports, prismaImports, queueServiceImports, requestServiceContextImports, typescriptFile, userSessionTypesImports, }) {
+        return {
+            providers: {
+                localAuthCoreAuthModuleRenderers: {
+                    constantsGroup: {
+                        render: (options) => typescriptFile.renderTemplateGroup({
+                            group: LOCAL_AUTH_CORE_AUTH_MODULE_TEMPLATES.constantsGroup,
+                            paths,
+                            ...options,
+                        }),
+                    },
+                    moduleGroup: {
+                        render: (options) => typescriptFile.renderTemplateGroup({
+                            group: LOCAL_AUTH_CORE_AUTH_MODULE_TEMPLATES.moduleGroup,
+                            paths,
+                            importMapProviders: {
+                                authRolesImports,
+                                pothosImports,
+                                prismaGeneratedImports,
+                                prismaImports,
+                            },
+                            generatorPaths: paths,
+                            ...options,
+                        }),
+                    },
+                    queuesCleanupAuthVerification: {
+                        render: (options) => typescriptFile.renderTemplateFile({
+                            template: LOCAL_AUTH_CORE_AUTH_MODULE_TEMPLATES.queuesCleanupAuthVerification,
+                            destination: paths.queuesCleanupAuthVerification,
+                            importMapProviders: {
+                                queueServiceImports,
+                            },
+                            generatorPaths: paths,
+                            ...options,
+                        }),
+                    },
+                    servicesAuthVerification: {
+                        render: (options) => typescriptFile.renderTemplateFile({
+                            template: LOCAL_AUTH_CORE_AUTH_MODULE_TEMPLATES.servicesAuthVerification,
+                            destination: paths.servicesAuthVerification,
+                            importMapProviders: {
+                                prismaGeneratedImports,
+                                prismaImports,
+                            },
+                            ...options,
+                        }),
+                    },
+                    userSessionService: {
+                        render: (options) => typescriptFile.renderTemplateFile({
+                            template: LOCAL_AUTH_CORE_AUTH_MODULE_TEMPLATES.userSessionService,
+                            destination: paths.userSessionService,
+                            importMapProviders: {
+                                authContextImports,
+                                authRolesImports,
+                                configServiceImports,
+                                errorHandlerServiceImports,
+                                prismaImports,
+                                requestServiceContextImports,
+                                userSessionTypesImports,
+                            },
+                            generatorPaths: paths,
+                            ...options,
+                        }),
+                    },
+                    utilsGroup: {
+                        render: (options) => typescriptFile.renderTemplateGroup({
+                            group: LOCAL_AUTH_CORE_AUTH_MODULE_TEMPLATES.utilsGroup,
+                            paths,
+                            importMapProviders: {
+                                configServiceImports,
+                            },
+                            ...options,
+                        }),
+                    },
+                },
+            },
+        };
+    },
+});
+export const LOCAL_AUTH_CORE_AUTH_MODULE_RENDERERS = {
+    provider: localAuthCoreAuthModuleRenderers,
+    task: localAuthCoreAuthModuleRenderersTask,
+};
+//# sourceMappingURL=template-renderers.js.map

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

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

package/dist/local-auth/core/generators/auth-module/generated/ts-import-providers.d.ts

@@ -0,0 +1,30 @@
+import type { TsImportMapProviderFromSchema } from '@baseplate-dev/core-generators';
+export declare const authModuleImportsSchema: {
+    cleanupExpiredAuthVerifications: {};
+    createAuthVerification: {};
+    userSessionPayload: {};
+    validateAuthVerification: {};
+};
+export type AuthModuleImportsProvider = TsImportMapProviderFromSchema<typeof authModuleImportsSchema>;
+export declare const authModuleImportsProvider: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+    cleanupExpiredAuthVerifications: {};
+    createAuthVerification: {};
+    userSessionPayload: {};
+    validateAuthVerification: {};
+}>>;
+export declare const LOCAL_AUTH_CORE_AUTH_MODULE_IMPORTS: {
+    task: import("@baseplate-dev/sync").GeneratorTask<{
+        authModuleImports: import("@baseplate-dev/sync").ProviderExport<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+            cleanupExpiredAuthVerifications: {};
+            createAuthVerification: {};
+            userSessionPayload: {};
+            validateAuthVerification: {};
+        }>>;
+        userSessionServiceImports: import("@baseplate-dev/sync").ProviderExport<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+            userSessionService: {};
+        }>>;
+    }, {
+        paths: import("@baseplate-dev/sync").ProviderType<import("./template-paths.js").LocalAuthCoreAuthModulePaths>;
+    }, undefined>;
+};
+//# sourceMappingURL=ts-import-providers.d.ts.map

package/dist/local-auth/core/generators/auth-module/generated/ts-import-providers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ts-import-providers.d.ts","sourceRoot":"","sources":["../../../../../../src/local-auth/core/generators/auth-module/generated/ts-import-providers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,6BAA6B,EAAE,MAAM,gCAAgC,CAAC;AAkBpF,eAAO,MAAM,uBAAuB;;;;;CAKlC,CAAC;AAEH,MAAM,MAAM,yBAAyB,GAAG,6BAA6B,CACnE,OAAO,uBAAuB,CAC/B,CAAC;AAEF,eAAO,MAAM,yBAAyB;;;;;GACwC,CAAC;AA6B/E,eAAO,MAAM,mCAAmC;;;;;;;;;;;;;;CAE/C,CAAC"}