@baseplate-dev/plugin-auth 1.0.6 → 1.0.8

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

@@ -0,0 +1,402 @@
+export declare const constantsGroup: {
+    userSessionConstants: import("@baseplate-dev/core-generators").TsTemplateFile<{}, {}, Record<never, Record<never, never>>>;
+};
+export declare const 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: {};
+        }>>;
+    }, Record<never, Record<never, never>>>;
+    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;
+            };
+        }>>;
+        errorHandlerServiceImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+            BadRequestError: {};
+            ForbiddenError: {};
+            handleZodRequestValidationError: {};
+            HttpError: {};
+            InternalServerError: {};
+            logError: {};
+            NotFoundError: {};
+            throwIfPrismaNotFound: {};
+            TooManyRequestsError: {};
+            UnauthorizedError: {};
+        }>>;
+        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>>>;
+};
+export declare const 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<{
+            getConfig: {};
+            isDevelopment: {};
+        }>>;
+    }, Record<never, Record<never, never>>>;
+    verifyRequestOrigin: import("@baseplate-dev/core-generators").TsTemplateFile<{}, {}, Record<never, Record<never, never>>>;
+};
+export declare const LOCAL_AUTH_CORE_AUTH_MODULE_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: {};
+            }>>;
+        }, Record<never, Record<never, never>>>;
+        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;
+                };
+            }>>;
+            errorHandlerServiceImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+                BadRequestError: {};
+                ForbiddenError: {};
+                handleZodRequestValidationError: {};
+                HttpError: {};
+                InternalServerError: {};
+                logError: {};
+                NotFoundError: {};
+                throwIfPrismaNotFound: {};
+                TooManyRequestsError: {};
+                UnauthorizedError: {};
+            }>>;
+            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<{}, {
+        queuesImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+            bindQueueHandler: {};
+            DEFAULT_QUEUE_CONCURRENCY: {};
+            defineQueue: {};
+            EnqueueOptions: {
+                isTypeOnly: true;
+            };
+            QueueHandlerBinding: {
+                isTypeOnly: true;
+            };
+            QueueHandlerBindingConfig: {
+                isTypeOnly: true;
+            };
+            QueueHandlerBindingInput: {
+                isTypeOnly: true;
+            };
+            QueueInfo: {
+                isTypeOnly: true;
+            };
+            QueueIntrospection: {
+                isTypeOnly: true;
+            };
+            QueueJob: {
+                isTypeOnly: true;
+            };
+            QueueJobHandler: {
+                isTypeOnly: true;
+            };
+            QueuePolicyFixPlan: {
+                isTypeOnly: true;
+            };
+            QueuePolicyFixResult: {
+                isTypeOnly: true;
+            };
+            QueueRuntime: {
+                isTypeOnly: true;
+            };
+            QueueService: {
+                isTypeOnly: true;
+            };
+            QueueToken: {
+                isTypeOnly: true;
+            };
+            QueueWorkers: {
+                isTypeOnly: true;
+            };
+            RepeatableConfig: {
+                isTypeOnly: true;
+            };
+            ScheduledJob: {
+                isTypeOnly: true;
+            };
+        }>>;
+    }, Record<never, Record<never, never>>>;
+    queuesCleanupAuthVerificationWorker: import("@baseplate-dev/core-generators").TsTemplateFile<{}, {
+        queuesImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+            bindQueueHandler: {};
+            DEFAULT_QUEUE_CONCURRENCY: {};
+            defineQueue: {};
+            EnqueueOptions: {
+                isTypeOnly: true;
+            };
+            QueueHandlerBinding: {
+                isTypeOnly: true;
+            };
+            QueueHandlerBindingConfig: {
+                isTypeOnly: true;
+            };
+            QueueHandlerBindingInput: {
+                isTypeOnly: true;
+            };
+            QueueInfo: {
+                isTypeOnly: true;
+            };
+            QueueIntrospection: {
+                isTypeOnly: true;
+            };
+            QueueJob: {
+                isTypeOnly: true;
+            };
+            QueueJobHandler: {
+                isTypeOnly: true;
+            };
+            QueuePolicyFixPlan: {
+                isTypeOnly: true;
+            };
+            QueuePolicyFixResult: {
+                isTypeOnly: true;
+            };
+            QueueRuntime: {
+                isTypeOnly: true;
+            };
+            QueueService: {
+                isTypeOnly: true;
+            };
+            QueueToken: {
+                isTypeOnly: true;
+            };
+            QueueWorkers: {
+                isTypeOnly: true;
+            };
+            RepeatableConfig: {
+                isTypeOnly: true;
+            };
+            ScheduledJob: {
+                isTypeOnly: true;
+            };
+        }>>;
+    }, {
+        queuesCleanupAuthVerification: {};
+        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<{
+            getConfig: {};
+            isDevelopment: {};
+        }>>;
+        errorHandlerServiceImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+            BadRequestError: {};
+            ForbiddenError: {};
+            handleZodRequestValidationError: {};
+            HttpError: {};
+            InternalServerError: {};
+            logError: {};
+            NotFoundError: {};
+            throwIfPrismaNotFound: {};
+            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;
+            };
+            RequestServiceContextWith: {
+                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<{
+                getConfig: {};
+                isDevelopment: {};
+            }>>;
+        }, Record<never, Record<never, never>>>;
+        verifyRequestOrigin: import("@baseplate-dev/core-generators").TsTemplateFile<{}, {}, Record<never, Record<never, never>>>;
+    };
+};
+//# sourceMappingURL=typed-templates.d.ts.map

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

@@ -0,0 +1,207 @@
+import { createTsTemplateFile } from '@baseplate-dev/core-generators';
+import { authContextImportsProvider, authRolesImportsProvider, configServiceImportsProvider, errorHandlerServiceImportsProvider, pothosImportsProvider, prismaGeneratedImportsProvider, prismaImportsProvider, requestServiceContextImportsProvider, userSessionTypesImportsProvider, } from '@baseplate-dev/fastify-generators';
+import { queuesImportsProvider } from '@baseplate-dev/plugin-queue';
+import path from 'node:path';
+const userSessionConstants = createTsTemplateFile({
+    fileOptions: { kind: 'singleton' },
+    group: 'constants',
+    importMapProviders: {},
+    name: 'user-session-constants',
+    source: {
+        path: path.join(import.meta.dirname, '../templates/module/constants/user-session.constants.ts'),
+    },
+    variables: {},
+});
+export const constantsGroup = { userSessionConstants };
+const authRoleEnum = createTsTemplateFile({
+    fileOptions: { kind: 'singleton' },
+    group: 'module',
+    importMapProviders: {
+        authRolesImports: authRolesImportsProvider,
+        pothosImports: pothosImportsProvider,
+    },
+    name: 'auth-role-enum',
+    projectExports: {},
+    source: {
+        path: path.join(import.meta.dirname, '../templates/module/schema/auth-role.enum.ts'),
+    },
+    variables: {},
+});
+const schemaUserSessionMutations = createTsTemplateFile({
+    fileOptions: { kind: 'singleton' },
+    group: 'module',
+    importMapProviders: { pothosImports: pothosImportsProvider },
+    name: 'schema-user-session-mutations',
+    source: {
+        path: path.join(import.meta.dirname, '../templates/module/schema/user-session.mutations.ts'),
+    },
+    variables: {},
+});
+const schemaUserSessionPayloadObjectType = createTsTemplateFile({
+    fileOptions: { kind: 'singleton' },
+    group: 'module',
+    importMapProviders: { pothosImports: pothosImportsProvider },
+    name: 'schema-user-session-payload-object-type',
+    projectExports: { userSessionPayload: {} },
+    referencedGeneratorTemplates: { authRoleEnum: {} },
+    source: {
+        path: path.join(import.meta.dirname, '../templates/module/schema/user-session-payload.object-type.ts'),
+    },
+    variables: { TPL_PRISMA_USER: {}, TPL_USER_OBJECT_TYPE: {} },
+});
+const schemaUserSessionQueries = createTsTemplateFile({
+    fileOptions: { kind: 'singleton' },
+    group: 'module',
+    importMapProviders: {
+        pothosImports: pothosImportsProvider,
+        prismaImports: prismaImportsProvider,
+    },
+    name: 'schema-user-session-queries',
+    referencedGeneratorTemplates: { schemaUserSessionPayloadObjectType: {} },
+    source: {
+        path: path.join(import.meta.dirname, '../templates/module/schema/user-session.queries.ts'),
+    },
+    variables: { TPL_USER_OBJECT_TYPE: {} },
+});
+const userRolesMutations = createTsTemplateFile({
+    fileOptions: { kind: 'singleton' },
+    group: 'module',
+    importMapProviders: { pothosImports: pothosImportsProvider },
+    name: 'user-roles-mutations',
+    projectExports: {},
+    referencedGeneratorTemplates: { userRolesService: {} },
+    source: {
+        path: path.join(import.meta.dirname, '../templates/module/schema/user-roles.mutations.ts'),
+    },
+    variables: { TPL_ADMIN_ROLES: {}, TPL_USER_OBJECT_TYPE: {} },
+});
+const userRolesService = createTsTemplateFile({
+    fileOptions: { kind: 'singleton' },
+    group: 'module',
+    importMapProviders: {
+        authRolesImports: authRolesImportsProvider,
+        errorHandlerServiceImports: errorHandlerServiceImportsProvider,
+        prismaGeneratedImports: prismaGeneratedImportsProvider,
+        prismaImports: prismaImportsProvider,
+    },
+    name: 'user-roles-service',
+    projectExports: {},
+    source: {
+        path: path.join(import.meta.dirname, '../templates/module/services/user-roles.service.ts'),
+    },
+    variables: {},
+});
+export const moduleGroup = {
+    authRoleEnum,
+    schemaUserSessionMutations,
+    schemaUserSessionPayloadObjectType,
+    schemaUserSessionQueries,
+    userRolesMutations,
+    userRolesService,
+};
+const queuesCleanupAuthVerification = createTsTemplateFile({
+    fileOptions: { kind: 'singleton' },
+    importMapProviders: { queuesImports: queuesImportsProvider },
+    name: 'queues-cleanup-auth-verification',
+    projectExports: { cleanupAuthVerificationQueue: { isTypeOnly: false } },
+    source: {
+        path: path.join(import.meta.dirname, '../templates/module/queues/cleanup-auth-verification.queue.ts'),
+    },
+    variables: {},
+});
+const queuesCleanupAuthVerificationWorker = createTsTemplateFile({
+    fileOptions: { kind: 'singleton' },
+    importMapProviders: { queuesImports: queuesImportsProvider },
+    name: 'queues-cleanup-auth-verification-worker',
+    projectExports: { cleanupAuthVerificationWorker: { isTypeOnly: false } },
+    referencedGeneratorTemplates: {
+        queuesCleanupAuthVerification: {},
+        servicesAuthVerification: {},
+    },
+    source: {
+        path: path.join(import.meta.dirname, '../templates/module/queues/cleanup-auth-verification.worker.ts'),
+    },
+    variables: {},
+});
+const servicesAuthVerification = createTsTemplateFile({
+    fileOptions: { kind: 'singleton' },
+    importMapProviders: {
+        prismaGeneratedImports: prismaGeneratedImportsProvider,
+        prismaImports: prismaImportsProvider,
+    },
+    name: 'services-auth-verification',
+    projectExports: {
+        cleanupExpiredAuthVerifications: { isTypeOnly: false },
+        createAuthVerification: { isTypeOnly: false },
+        validateAuthVerification: { isTypeOnly: false },
+    },
+    source: {
+        path: path.join(import.meta.dirname, '../templates/module/services/auth-verification.service.ts'),
+    },
+    variables: {},
+});
+const userSessionService = createTsTemplateFile({
+    fileOptions: { kind: 'singleton' },
+    importMapProviders: {
+        authContextImports: authContextImportsProvider,
+        authRolesImports: authRolesImportsProvider,
+        configServiceImports: configServiceImportsProvider,
+        errorHandlerServiceImports: errorHandlerServiceImportsProvider,
+        prismaImports: prismaImportsProvider,
+        requestServiceContextImports: requestServiceContextImportsProvider,
+        userSessionTypesImports: userSessionTypesImportsProvider,
+    },
+    name: 'user-session-service',
+    projectExports: { CookieUserSessionService: { isTypeOnly: false } },
+    referencedGeneratorTemplates: {
+        cookieSigner: {},
+        sessionCookie: {},
+        userSessionConstants: {},
+        verifyRequestOrigin: {},
+    },
+    source: {
+        path: path.join(import.meta.dirname, '../templates/module/services/user-session.service.ts'),
+    },
+    variables: { TPL_PRISMA_USER_SESSION: {} },
+});
+const cookieSigner = createTsTemplateFile({
+    fileOptions: { kind: 'singleton' },
+    group: 'utils',
+    importMapProviders: {},
+    name: 'cookie-signer',
+    source: {
+        path: path.join(import.meta.dirname, '../templates/module/utils/cookie-signer.ts'),
+    },
+    variables: {},
+});
+const sessionCookie = createTsTemplateFile({
+    fileOptions: { kind: 'singleton' },
+    group: 'utils',
+    importMapProviders: { configServiceImports: configServiceImportsProvider },
+    name: 'session-cookie',
+    source: {
+        path: path.join(import.meta.dirname, '../templates/module/utils/session-cookie.ts'),
+    },
+    variables: {},
+});
+const verifyRequestOrigin = createTsTemplateFile({
+    fileOptions: { kind: 'singleton' },
+    group: 'utils',
+    importMapProviders: {},
+    name: 'verify-request-origin',
+    source: {
+        path: path.join(import.meta.dirname, '../templates/module/utils/verify-request-origin.ts'),
+    },
+    variables: {},
+});
+export const utilsGroup = { cookieSigner, sessionCookie, verifyRequestOrigin };
+export const LOCAL_AUTH_CORE_AUTH_MODULE_TEMPLATES = {
+    constantsGroup,
+    moduleGroup,
+    queuesCleanupAuthVerification,
+    queuesCleanupAuthVerificationWorker,
+    servicesAuthVerification,
+    userSessionService,
+    utilsGroup,
+};
+//# sourceMappingURL=typed-templates.js.map

package/dist/local-auth/core/generators/auth-module/templates/module/queues/cleanup-auth-verification.queue.d.ts

@@ -0,0 +1,2 @@
+export declare const cleanupAuthVerificationQueue: any;
+//# sourceMappingURL=cleanup-auth-verification.queue.d.ts.map

package/dist/local-auth/core/generators/auth-module/templates/module/queues/cleanup-auth-verification.queue.js

@@ -0,0 +1,4 @@
+// @ts-nocheck
+import { defineQueue } from '%queuesImports';
+export const cleanupAuthVerificationQueue = defineQueue('cleanup-auth-verification');
+//# sourceMappingURL=cleanup-auth-verification.queue.js.map

package/dist/local-auth/core/generators/auth-module/templates/module/queues/cleanup-auth-verification.queue.ts

@@ -0,0 +1,7 @@
+// @ts-nocheck
+
+import { defineQueue } from '%queuesImports';
+
+export const cleanupAuthVerificationQueue = defineQueue<undefined>(
+  'cleanup-auth-verification',
+);

package/dist/local-auth/core/generators/auth-module/templates/module/queues/cleanup-auth-verification.worker.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Periodic worker to clean up expired auth verification tokens.
+ * Runs hourly to maintain database hygiene.
+ */
+export declare const cleanupAuthVerificationWorker: any;
+//# sourceMappingURL=cleanup-auth-verification.worker.d.ts.map

package/dist/local-auth/core/generators/auth-module/templates/module/queues/cleanup-auth-verification.worker.js

@@ -0,0 +1,18 @@
+// @ts-nocheck
+import { cleanupAuthVerificationQueue } from '$queuesCleanupAuthVerification';
+import { cleanupExpiredAuthVerifications } from '$servicesAuthVerification';
+import { bindQueueHandler } from '%queuesImports';
+/**
+ * Periodic worker to clean up expired auth verification tokens.
+ * Runs hourly to maintain database hygiene.
+ */
+export const cleanupAuthVerificationWorker = bindQueueHandler(cleanupAuthVerificationQueue, {
+    handler: async () => {
+        const result = await cleanupExpiredAuthVerifications();
+        return { deletedCount: result.deletedCount };
+    },
+    repeatable: {
+        pattern: '15 * * * *', // Every hour at minute 15
+    },
+});
+//# sourceMappingURL=cleanup-auth-verification.worker.js.map

package/dist/local-auth/core/generators/auth-module/templates/module/queues/cleanup-auth-verification.worker.ts

@@ -0,0 +1,22 @@
+// @ts-nocheck
+
+import { cleanupAuthVerificationQueue } from '$queuesCleanupAuthVerification';
+import { cleanupExpiredAuthVerifications } from '$servicesAuthVerification';
+import { bindQueueHandler } from '%queuesImports';
+
+/**
+ * Periodic worker to clean up expired auth verification tokens.
+ * Runs hourly to maintain database hygiene.
+ */
+export const cleanupAuthVerificationWorker = bindQueueHandler(
+  cleanupAuthVerificationQueue,
+  {
+    handler: async () => {
+      const result = await cleanupExpiredAuthVerifications();
+      return { deletedCount: result.deletedCount };
+    },
+    repeatable: {
+      pattern: '15 * * * *', // Every hour at minute 15
+    },
+  },
+);

package/dist/local-auth/core/generators/auth-module/templates/module/schema/auth-role.enum.d.ts

@@ -0,0 +1,8 @@
+/**
+ * GraphQL enum for authentication roles.
+ *
+ * This enum represents all available roles that can be assigned to users
+ * or used for authorization checks in the application.
+ */
+export declare const authRoleEnum: any;
+//# sourceMappingURL=auth-role.enum.d.ts.map