@baseplate-dev/fastify-generators 0.1.1

package/dist/generators/auth/auth-context/auth-context.generator.js

@@ -0,0 +1,77 @@
+import { projectScope, tsCodeFragment, TsCodeUtils, tsImportBuilder, typescriptFileProvider, } from '@baseplate-dev/core-generators';
+import { createGenerator, createGeneratorTask, createProviderTask, } from '@baseplate-dev/sync';
+import { z } from 'zod';
+import { errorHandlerServiceImportsProvider } from '#src/generators/core/error-handler-service/generated/ts-import-maps.js';
+import { appModuleProvider, loggerServiceConfigProvider, } from '#src/generators/core/index.js';
+import { requestServiceContextConfigProvider } from '#src/generators/core/request-service-context/request-service-context.generator.js';
+import { serviceContextConfigProvider } from '#src/generators/core/service-context/service-context.generator.js';
+import { authRolesImportsProvider } from '../auth-roles/generated/ts-import-maps.js';
+import { authContextImportsProvider, createAuthContextImports, } from './generated/ts-import-maps.js';
+import { AUTH_AUTH_CONTEXT_TS_TEMPLATES } from './generated/ts-templates.js';
+const descriptorSchema = z.object({});
+export const authContextGenerator = createGenerator({
+    name: 'auth/auth-context',
+    generatorFileUrl: import.meta.url,
+    descriptorSchema,
+    buildTasks: () => ({
+        requestServiceContextConfig: createProviderTask(requestServiceContextConfigProvider, (requestServiceContextConfig) => {
+            requestServiceContextConfig.contextPassthroughs.set('auth', {
+                name: 'auth',
+                creator: (req) => tsCodeFragment(`${req}.auth`),
+            });
+        }),
+        loggerSetup: createGeneratorTask({
+            dependencies: {
+                loggerServiceConfig: loggerServiceConfigProvider,
+            },
+            run({ loggerServiceConfig }) {
+                loggerServiceConfig.mixins.set('userId', tsCodeFragment("requestContext.get('userId')", tsImportBuilder()
+                    .named('requestContext')
+                    .from('@fastify/request-context')));
+            },
+        }),
+        main: createGeneratorTask({
+            dependencies: {
+                serviceContextConfig: serviceContextConfigProvider,
+                authRolesImports: authRolesImportsProvider,
+                appModule: appModuleProvider,
+                typescriptFile: typescriptFileProvider,
+                errorHandlerServiceImports: errorHandlerServiceImportsProvider,
+            },
+            exports: {
+                authContextImports: authContextImportsProvider.export(projectScope),
+            },
+            run({ serviceContextConfig, appModule, typescriptFile, errorHandlerServiceImports, authRolesImports, }) {
+                const authContextImports = createAuthContextImports(appModule.getModuleFolder());
+                return {
+                    providers: {
+                        authContextImports,
+                    },
+                    build: async (builder) => {
+                        await builder.apply(typescriptFile.renderTemplateGroup({
+                            group: AUTH_AUTH_CONTEXT_TS_TEMPLATES.mainGroup,
+                            baseDirectory: appModule.getModuleFolder(),
+                            importMapProviders: {
+                                authRolesImports,
+                                errorHandlerServiceImports,
+                            },
+                        }));
+                        serviceContextConfig.contextFields.set('auth', {
+                            type: authContextImports.AuthContext.typeFragment(),
+                            setter: 'auth',
+                            creatorArguments: [
+                                {
+                                    name: 'auth',
+                                    type: authContextImports.AuthContext.typeFragment(),
+                                    testDefault: TsCodeUtils.template `${authContextImports.createAuthContextFromSessionInfo.fragment()}(undefined)`,
+                                },
+                            ],
+                        });
+                    },
+                };
+            },
+        }),
+    }),
+});
+export { authContextImportsProvider } from './generated/ts-import-maps.js';
+//# sourceMappingURL=auth-context.generator.js.map

package/dist/generators/auth/auth-context/auth-context.generator.js.map

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

package/dist/generators/auth/auth-context/generated/ts-import-maps.d.ts

@@ -0,0 +1,31 @@
+import type { TsImportMapProviderFromSchema } from '@baseplate-dev/core-generators';
+declare const authContextImportsSchema: {
+    AuthContext: {
+        isTypeOnly: true;
+    };
+    AuthSessionInfo: {
+        isTypeOnly: true;
+    };
+    AuthUserSessionInfo: {
+        isTypeOnly: true;
+    };
+    createAuthContextFromSessionInfo: {};
+    InvalidSessionError: {};
+};
+type AuthContextImportsProvider = TsImportMapProviderFromSchema<typeof authContextImportsSchema>;
+export declare const authContextImportsProvider: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+    AuthContext: {
+        isTypeOnly: true;
+    };
+    AuthSessionInfo: {
+        isTypeOnly: true;
+    };
+    AuthUserSessionInfo: {
+        isTypeOnly: true;
+    };
+    createAuthContextFromSessionInfo: {};
+    InvalidSessionError: {};
+}>>;
+export declare function createAuthContextImports(importBase: string): AuthContextImportsProvider;
+export {};
+//# sourceMappingURL=ts-import-maps.d.ts.map

package/dist/generators/auth/auth-context/generated/ts-import-maps.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ts-import-maps.d.ts","sourceRoot":"","sources":["../../../../../src/generators/auth/auth-context/generated/ts-import-maps.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,6BAA6B,EAAE,MAAM,gCAAgC,CAAC;AASpF,QAAA,MAAM,wBAAwB;;;;;;;;;;;;CAM5B,CAAC;AAEH,KAAK,0BAA0B,GAAG,6BAA6B,CAC7D,OAAO,wBAAwB,CAChC,CAAC;AAEF,eAAO,MAAM,0BAA0B;;;;;;;;;;;;GAGpC,CAAC;AAEJ,wBAAgB,wBAAwB,CACtC,UAAU,EAAE,MAAM,GACjB,0BAA0B,CAe5B"}

package/dist/generators/auth/auth-context/generated/ts-import-maps.js

@@ -0,0 +1,24 @@
+import { createTsImportMap, createTsImportMapSchema, } from '@baseplate-dev/core-generators';
+import { createReadOnlyProviderType } from '@baseplate-dev/sync';
+import path from 'node:path/posix';
+const authContextImportsSchema = createTsImportMapSchema({
+    AuthContext: { isTypeOnly: true },
+    AuthSessionInfo: { isTypeOnly: true },
+    AuthUserSessionInfo: { isTypeOnly: true },
+    createAuthContextFromSessionInfo: {},
+    InvalidSessionError: {},
+});
+export const authContextImportsProvider = createReadOnlyProviderType('auth-context-imports');
+export function createAuthContextImports(importBase) {
+    if (!importBase.startsWith('@/')) {
+        throw new Error('importBase must start with @/');
+    }
+    return createTsImportMap(authContextImportsSchema, {
+        AuthContext: path.join(importBase, 'types/auth-context.types.js'),
+        AuthSessionInfo: path.join(importBase, 'types/auth-session.types.js'),
+        AuthUserSessionInfo: path.join(importBase, 'types/auth-session.types.js'),
+        createAuthContextFromSessionInfo: path.join(importBase, 'utils/auth-context.utils.js'),
+        InvalidSessionError: path.join(importBase, 'types/auth-session.types.js'),
+    });
+}
+//# sourceMappingURL=ts-import-maps.js.map

package/dist/generators/auth/auth-context/generated/ts-import-maps.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ts-import-maps.js","sourceRoot":"","sources":["../../../../../src/generators/auth/auth-context/generated/ts-import-maps.ts"],"names":[],"mappings":"AAEA,OAAO,EACL,iBAAiB,EACjB,uBAAuB,GACxB,MAAM,gCAAgC,CAAC;AACxC,OAAO,EAAE,0BAA0B,EAAE,MAAM,qBAAqB,CAAC;AACjE,OAAO,IAAI,MAAM,iBAAiB,CAAC;AAEnC,MAAM,wBAAwB,GAAG,uBAAuB,CAAC;IACvD,WAAW,EAAE,EAAE,UAAU,EAAE,IAAI,EAAE;IACjC,eAAe,EAAE,EAAE,UAAU,EAAE,IAAI,EAAE;IACrC,mBAAmB,EAAE,EAAE,UAAU,EAAE,IAAI,EAAE;IACzC,gCAAgC,EAAE,EAAE;IACpC,mBAAmB,EAAE,EAAE;CACxB,CAAC,CAAC;AAMH,MAAM,CAAC,MAAM,0BAA0B,GACrC,0BAA0B,CACxB,sBAAsB,CACvB,CAAC;AAEJ,MAAM,UAAU,wBAAwB,CACtC,UAAkB;IAElB,IAAI,CAAC,UAAU,CAAC,UAAU,CAAC,IAAI,CAAC,EAAE,CAAC;QACjC,MAAM,IAAI,KAAK,CAAC,+BAA+B,CAAC,CAAC;IACnD,CAAC;IAED,OAAO,iBAAiB,CAAC,wBAAwB,EAAE;QACjD,WAAW,EAAE,IAAI,CAAC,IAAI,CAAC,UAAU,EAAE,6BAA6B,CAAC;QACjE,eAAe,EAAE,IAAI,CAAC,IAAI,CAAC,UAAU,EAAE,6BAA6B,CAAC;QACrE,mBAAmB,EAAE,IAAI,CAAC,IAAI,CAAC,UAAU,EAAE,6BAA6B,CAAC;QACzE,gCAAgC,EAAE,IAAI,CAAC,IAAI,CACzC,UAAU,EACV,6BAA6B,CAC9B;QACD,mBAAmB,EAAE,IAAI,CAAC,IAAI,CAAC,UAAU,EAAE,6BAA6B,CAAC;KAC1E,CAAC,CAAC;AACL,CAAC"}

package/dist/generators/auth/auth-context/generated/ts-templates.d.ts

@@ -0,0 +1,70 @@
+export declare const AUTH_AUTH_CONTEXT_TS_TEMPLATES: {
+    mainGroup: import("@baseplate-dev/core-generators").TsTemplateGroup<{
+        authContextTypes: {
+            destination: string;
+            template: import("@baseplate-dev/core-generators").TsTemplateFile<{}, {
+                authRolesImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+                    AuthRole: {
+                        isTypeOnly: true;
+                    };
+                    DEFAULT_PUBLIC_ROLES: {};
+                    DEFAULT_USER_ROLES: {};
+                    RoleConfig: {
+                        isTypeOnly: true;
+                    };
+                }>>;
+            }>;
+        };
+        authContextUtils: {
+            destination: string;
+            template: import("@baseplate-dev/core-generators").TsTemplateFile<{}, {
+                authRolesImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+                    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: {};
+                    UnauthorizedError: {};
+                }>>;
+            }>;
+        };
+        authSessionTypes: {
+            destination: string;
+            template: import("@baseplate-dev/core-generators").TsTemplateFile<{}, {
+                authRolesImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+                    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: {};
+                    UnauthorizedError: {};
+                }>>;
+            }>;
+        };
+    }>;
+};
+//# sourceMappingURL=ts-templates.d.ts.map

package/dist/generators/auth/auth-context/generated/ts-templates.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ts-templates.d.ts","sourceRoot":"","sources":["../../../../../src/generators/auth/auth-context/generated/ts-templates.ts"],"names":[],"mappings":"AA8DA,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAgB,CAAC"}

package/dist/generators/auth/auth-context/generated/ts-templates.js

@@ -0,0 +1,55 @@
+import { createTsTemplateFile, createTsTemplateGroup, } from '@baseplate-dev/core-generators';
+import { errorHandlerServiceImportsProvider } from '../../../core/error-handler-service/generated/ts-import-maps.js';
+import { authRolesImportsProvider } from '../../auth-roles/generated/ts-import-maps.js';
+const authContextTypes = createTsTemplateFile({
+    group: 'main',
+    importMapProviders: { authRolesImports: authRolesImportsProvider },
+    name: 'auth-context-types',
+    projectExports: { AuthContext: { isTypeOnly: true } },
+    source: { path: 'types/auth-context.types.ts' },
+    variables: {},
+});
+const authContextUtils = createTsTemplateFile({
+    group: 'main',
+    importMapProviders: {
+        authRolesImports: authRolesImportsProvider,
+        errorHandlerServiceImports: errorHandlerServiceImportsProvider,
+    },
+    name: 'auth-context-utils',
+    projectExports: { createAuthContextFromSessionInfo: {} },
+    source: { path: 'utils/auth-context.utils.ts' },
+    variables: {},
+});
+const authSessionTypes = createTsTemplateFile({
+    group: 'main',
+    importMapProviders: {
+        authRolesImports: authRolesImportsProvider,
+        errorHandlerServiceImports: errorHandlerServiceImportsProvider,
+    },
+    name: 'auth-session-types',
+    projectExports: {
+        AuthSessionInfo: { isTypeOnly: true },
+        AuthUserSessionInfo: { isTypeOnly: true },
+        InvalidSessionError: {},
+    },
+    source: { path: 'types/auth-session.types.ts' },
+    variables: {},
+});
+const mainGroup = createTsTemplateGroup({
+    templates: {
+        authContextTypes: {
+            destination: 'types/auth-context.types.ts',
+            template: authContextTypes,
+        },
+        authContextUtils: {
+            destination: 'utils/auth-context.utils.ts',
+            template: authContextUtils,
+        },
+        authSessionTypes: {
+            destination: 'types/auth-session.types.ts',
+            template: authSessionTypes,
+        },
+    },
+});
+export const AUTH_AUTH_CONTEXT_TS_TEMPLATES = { mainGroup };
+//# sourceMappingURL=ts-templates.js.map

package/dist/generators/auth/auth-context/generated/ts-templates.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ts-templates.js","sourceRoot":"","sources":["../../../../../src/generators/auth/auth-context/generated/ts-templates.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,oBAAoB,EACpB,qBAAqB,GACtB,MAAM,gCAAgC,CAAC;AAExC,OAAO,EAAE,kCAAkC,EAAE,MAAM,iEAAiE,CAAC;AACrH,OAAO,EAAE,wBAAwB,EAAE,MAAM,8CAA8C,CAAC;AAExF,MAAM,gBAAgB,GAAG,oBAAoB,CAAC;IAC5C,KAAK,EAAE,MAAM;IACb,kBAAkB,EAAE,EAAE,gBAAgB,EAAE,wBAAwB,EAAE;IAClE,IAAI,EAAE,oBAAoB;IAC1B,cAAc,EAAE,EAAE,WAAW,EAAE,EAAE,UAAU,EAAE,IAAI,EAAE,EAAE;IACrD,MAAM,EAAE,EAAE,IAAI,EAAE,6BAA6B,EAAE;IAC/C,SAAS,EAAE,EAAE;CACd,CAAC,CAAC;AAEH,MAAM,gBAAgB,GAAG,oBAAoB,CAAC;IAC5C,KAAK,EAAE,MAAM;IACb,kBAAkB,EAAE;QAClB,gBAAgB,EAAE,wBAAwB;QAC1C,0BAA0B,EAAE,kCAAkC;KAC/D;IACD,IAAI,EAAE,oBAAoB;IAC1B,cAAc,EAAE,EAAE,gCAAgC,EAAE,EAAE,EAAE;IACxD,MAAM,EAAE,EAAE,IAAI,EAAE,6BAA6B,EAAE;IAC/C,SAAS,EAAE,EAAE;CACd,CAAC,CAAC;AAEH,MAAM,gBAAgB,GAAG,oBAAoB,CAAC;IAC5C,KAAK,EAAE,MAAM;IACb,kBAAkB,EAAE;QAClB,gBAAgB,EAAE,wBAAwB;QAC1C,0BAA0B,EAAE,kCAAkC;KAC/D;IACD,IAAI,EAAE,oBAAoB;IAC1B,cAAc,EAAE;QACd,eAAe,EAAE,EAAE,UAAU,EAAE,IAAI,EAAE;QACrC,mBAAmB,EAAE,EAAE,UAAU,EAAE,IAAI,EAAE;QACzC,mBAAmB,EAAE,EAAE;KACxB;IACD,MAAM,EAAE,EAAE,IAAI,EAAE,6BAA6B,EAAE;IAC/C,SAAS,EAAE,EAAE;CACd,CAAC,CAAC;AAEH,MAAM,SAAS,GAAG,qBAAqB,CAAC;IACtC,SAAS,EAAE;QACT,gBAAgB,EAAE;YAChB,WAAW,EAAE,6BAA6B;YAC1C,QAAQ,EAAE,gBAAgB;SAC3B;QACD,gBAAgB,EAAE;YAChB,WAAW,EAAE,6BAA6B;YAC1C,QAAQ,EAAE,gBAAgB;SAC3B;QACD,gBAAgB,EAAE;YAChB,WAAW,EAAE,6BAA6B;YAC1C,QAAQ,EAAE,gBAAgB;SAC3B;KACF;CACF,CAAC,CAAC;AAEH,MAAM,CAAC,MAAM,8BAA8B,GAAG,EAAE,SAAS,EAAE,CAAC"}

package/dist/generators/auth/auth-context/templates/types/auth-context.types.ts

@@ -0,0 +1,15 @@
+// @ts-nocheck
+
+import type { AuthRole } from '%authRolesImports';
+
+import type { AuthSessionInfo } from './auth-session.types.js';
+
+export interface AuthContext {
+  session: AuthSessionInfo | undefined;
+  sessionOrThrow: () => AuthSessionInfo;
+  userId: string | undefined;
+  userIdOrThrow: () => string;
+  roles: readonly AuthRole[];
+  hasRole: (role: AuthRole) => boolean;
+  hasSomeRole: (roles: AuthRole[]) => boolean;
+}

package/dist/generators/auth/auth-context/templates/types/auth-session.types.ts

@@ -0,0 +1,31 @@
+// @ts-nocheck
+
+import type { AuthRole } from '%authRolesImports';
+
+import { UnauthorizedError } from '%errorHandlerServiceImports';
+
+/**
+ * Error thrown when a session is invalid
+ */
+export class InvalidSessionError extends UnauthorizedError {
+  constructor(message = 'Invalid Session') {
+    super(message, 'invalid-session');
+  }
+}
+
+interface AuthBaseSessionInfo {
+  id: string;
+  expiresAt?: Date;
+  roles: AuthRole[];
+}
+
+export interface AuthUserSessionInfo extends AuthBaseSessionInfo {
+  type: 'user';
+  userId: string;
+}
+
+export interface AuthSystemSessionInfo extends AuthBaseSessionInfo {
+  type: 'system';
+}
+
+export type AuthSessionInfo = AuthUserSessionInfo | AuthSystemSessionInfo;

package/dist/generators/auth/auth-context/templates/utils/auth-context.utils.ts

@@ -0,0 +1,34 @@
+// @ts-nocheck
+
+import { DEFAULT_PUBLIC_ROLES } from '%authRolesImports';
+import { UnauthorizedError } from '%errorHandlerServiceImports';
+
+import type { AuthContext } from '../types/auth-context.types.js';
+import type { AuthSessionInfo } from '../types/auth-session.types.js';
+
+export function createAuthContextFromSessionInfo(
+  session: AuthSessionInfo | undefined,
+): AuthContext {
+  const roles = session?.roles ?? DEFAULT_PUBLIC_ROLES;
+
+  return {
+    session,
+    sessionOrThrow: () => {
+      if (!session) {
+        throw new UnauthorizedError('Session is required');
+      }
+      return session;
+    },
+    userId: session?.type === 'user' ? session.userId : undefined,
+    userIdOrThrow: () => {
+      if (!session || session.type !== 'user') {
+        throw new UnauthorizedError('User session is required');
+      }
+      return session.userId;
+    },
+    roles,
+    hasRole: (role) => roles.includes(role),
+    hasSomeRole: (possibleRoles) =>
+      possibleRoles.some((role) => roles.includes(role)),
+  };
+}

package/dist/generators/auth/auth-plugin/auth-plugin.generator.d.ts

@@ -0,0 +1,32 @@
+export declare const authPluginGenerator: import("@baseplate-dev/sync").GeneratorBundleCreator<{}, {
+    nodePackages: import("@baseplate-dev/sync").AnyGeneratorTask;
+    main: import("@baseplate-dev/sync").GeneratorTask<any, {
+        typescriptFile: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").TypescriptFileProvider>;
+        appModule: import("@baseplate-dev/sync").ProviderType<import("#src/generators/core/app-module/app-module.generator.js").AppModuleProvider>;
+        authContextImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+            AuthContext: {
+                isTypeOnly: true;
+            };
+            AuthSessionInfo: {
+                isTypeOnly: true;
+            };
+            AuthUserSessionInfo: {
+                isTypeOnly: true;
+            };
+            createAuthContextFromSessionInfo: {};
+            InvalidSessionError: {};
+        }>>;
+        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;
+            };
+        }>>;
+    }, any>;
+}>;
+//# sourceMappingURL=auth-plugin.generator.d.ts.map

package/dist/generators/auth/auth-plugin/auth-plugin.generator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"auth-plugin.generator.d.ts","sourceRoot":"","sources":["../../../../src/generators/auth/auth-plugin/auth-plugin.generator.ts"],"names":[],"mappings":"AAqBA,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAyD9B,CAAC"}

package/dist/generators/auth/auth-plugin/auth-plugin.generator.js

@@ -0,0 +1,50 @@
+import { createNodePackagesTask, extractPackageVersions, tsCodeFragment, tsImportBuilder, typescriptFileProvider, } from '@baseplate-dev/core-generators';
+import { createGenerator, createGeneratorTask } from '@baseplate-dev/sync';
+import path from 'node:path';
+import { z } from 'zod';
+import { FASTIFY_PACKAGES } from '#src/constants/fastify-packages.js';
+import { appModuleProvider } from '#src/generators/core/app-module/app-module.generator.js';
+import { userSessionServiceImportsProvider } from '../_providers/index.js';
+import { authContextImportsProvider } from '../auth-context/auth-context.generator.js';
+import { userSessionTypesImportsProvider } from '../user-session-types/user-session-types.generator.js';
+import { AUTH_AUTH_PLUGIN_TS_TEMPLATES } from './generated/ts-templates.js';
+const descriptorSchema = z.object({});
+export const authPluginGenerator = createGenerator({
+    name: 'auth/auth-plugin',
+    generatorFileUrl: import.meta.url,
+    descriptorSchema,
+    buildTasks: () => ({
+        nodePackages: createNodePackagesTask({
+            prod: extractPackageVersions(FASTIFY_PACKAGES, [
+                '@fastify/request-context',
+            ]),
+        }),
+        main: createGeneratorTask({
+            dependencies: {
+                typescriptFile: typescriptFileProvider,
+                appModule: appModuleProvider,
+                authContextImports: authContextImportsProvider,
+                userSessionServiceImports: userSessionServiceImportsProvider,
+                userSessionTypesImports: userSessionTypesImportsProvider,
+            },
+            run({ typescriptFile, appModule, authContextImports, userSessionServiceImports, userSessionTypesImports, }) {
+                const authPluginPath = path.posix.join(appModule.getModuleFolder(), 'plugins', 'auth.plugin.ts');
+                appModule.moduleFields.set('plugins', 'authPlugin', tsCodeFragment('authPlugin', tsImportBuilder(['authPlugin']).from(authPluginPath)));
+                return {
+                    build: async (builder) => {
+                        await builder.apply(typescriptFile.renderTemplateFile({
+                            template: AUTH_AUTH_PLUGIN_TS_TEMPLATES.authPlugin,
+                            destination: authPluginPath,
+                            importMapProviders: {
+                                authContextImports,
+                                userSessionServiceImports,
+                                userSessionTypesImports,
+                            },
+                        }));
+                    },
+                };
+            },
+        }),
+    }),
+});
+//# sourceMappingURL=auth-plugin.generator.js.map

package/dist/generators/auth/auth-plugin/auth-plugin.generator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"auth-plugin.generator.js","sourceRoot":"","sources":["../../../../src/generators/auth/auth-plugin/auth-plugin.generator.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,sBAAsB,EACtB,sBAAsB,EACtB,cAAc,EACd,eAAe,EACf,sBAAsB,GACvB,MAAM,gCAAgC,CAAC;AACxC,OAAO,EAAE,eAAe,EAAE,mBAAmB,EAAE,MAAM,qBAAqB,CAAC;AAC3E,OAAO,IAAI,MAAM,WAAW,CAAC;AAC7B,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,EAAE,gBAAgB,EAAE,MAAM,oCAAoC,CAAC;AACtE,OAAO,EAAE,iBAAiB,EAAE,MAAM,yDAAyD,CAAC;AAE5F,OAAO,EAAE,iCAAiC,EAAE,MAAM,wBAAwB,CAAC;AAC3E,OAAO,EAAE,0BAA0B,EAAE,MAAM,2CAA2C,CAAC;AACvF,OAAO,EAAE,+BAA+B,EAAE,MAAM,uDAAuD,CAAC;AACxG,OAAO,EAAE,6BAA6B,EAAE,MAAM,6BAA6B,CAAC;AAE5E,MAAM,gBAAgB,GAAG,CAAC,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC;AAEtC,MAAM,CAAC,MAAM,mBAAmB,GAAG,eAAe,CAAC;IACjD,IAAI,EAAE,kBAAkB;IACxB,gBAAgB,EAAE,MAAM,CAAC,IAAI,CAAC,GAAG;IACjC,gBAAgB;IAChB,UAAU,EAAE,GAAG,EAAE,CAAC,CAAC;QACjB,YAAY,EAAE,sBAAsB,CAAC;YACnC,IAAI,EAAE,sBAAsB,CAAC,gBAAgB,EAAE;gBAC7C,0BAA0B;aAC3B,CAAC;SACH,CAAC;QACF,IAAI,EAAE,mBAAmB,CAAC;YACxB,YAAY,EAAE;gBACZ,cAAc,EAAE,sBAAsB;gBACtC,SAAS,EAAE,iBAAiB;gBAC5B,kBAAkB,EAAE,0BAA0B;gBAC9C,yBAAyB,EAAE,iCAAiC;gBAC5D,uBAAuB,EAAE,+BAA+B;aACzD;YACD,GAAG,CAAC,EACF,cAAc,EACd,SAAS,EACT,kBAAkB,EAClB,yBAAyB,EACzB,uBAAuB,GACxB;gBACC,MAAM,cAAc,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CACpC,SAAS,CAAC,eAAe,EAAE,EAC3B,SAAS,EACT,gBAAgB,CACjB,CAAC;gBACF,SAAS,CAAC,YAAY,CAAC,GAAG,CACxB,SAAS,EACT,YAAY,EACZ,cAAc,CACZ,YAAY,EACZ,eAAe,CAAC,CAAC,YAAY,CAAC,CAAC,CAAC,IAAI,CAAC,cAAc,CAAC,CACrD,CACF,CAAC;gBAEF,OAAO;oBACL,KAAK,EAAE,KAAK,EAAE,OAAO,EAAE,EAAE;wBACvB,MAAM,OAAO,CAAC,KAAK,CACjB,cAAc,CAAC,kBAAkB,CAAC;4BAChC,QAAQ,EAAE,6BAA6B,CAAC,UAAU;4BAClD,WAAW,EAAE,cAAc;4BAC3B,kBAAkB,EAAE;gCAClB,kBAAkB;gCAClB,yBAAyB;gCACzB,uBAAuB;6BACxB;yBACF,CAAC,CACH,CAAC;oBACJ,CAAC;iBACF,CAAC;YACJ,CAAC;SACF,CAAC;KACH,CAAC;CACH,CAAC,CAAC"}

package/dist/generators/auth/auth-plugin/generated/ts-templates.d.ts

@@ -0,0 +1,29 @@
+export declare const AUTH_AUTH_PLUGIN_TS_TEMPLATES: {
+    authPlugin: import("@baseplate-dev/core-generators").TsTemplateFile<{}, {
+        authContextImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+            AuthContext: {
+                isTypeOnly: true;
+            };
+            AuthSessionInfo: {
+                isTypeOnly: true;
+            };
+            AuthUserSessionInfo: {
+                isTypeOnly: true;
+            };
+            createAuthContextFromSessionInfo: {};
+            InvalidSessionError: {};
+        }>>;
+        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;
+            };
+        }>>;
+    }>;
+};
+//# sourceMappingURL=ts-templates.d.ts.map

package/dist/generators/auth/auth-plugin/generated/ts-templates.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ts-templates.d.ts","sourceRoot":"","sources":["../../../../../src/generators/auth/auth-plugin/generated/ts-templates.ts"],"names":[],"mappings":"AAkBA,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAiB,CAAC"}

package/dist/generators/auth/auth-plugin/generated/ts-templates.js

@@ -0,0 +1,17 @@
+import { createTsTemplateFile } from '@baseplate-dev/core-generators';
+import { userSessionServiceImportsProvider } from '../../_providers/user-session.js';
+import { authContextImportsProvider } from '../../auth-context/generated/ts-import-maps.js';
+import { userSessionTypesImportsProvider } from '../../user-session-types/generated/ts-import-maps.js';
+const authPlugin = createTsTemplateFile({
+    importMapProviders: {
+        authContextImports: authContextImportsProvider,
+        userSessionServiceImports: userSessionServiceImportsProvider,
+        userSessionTypesImports: userSessionTypesImportsProvider,
+    },
+    name: 'auth-plugin',
+    projectExports: {},
+    source: { path: 'auth.plugin.ts' },
+    variables: {},
+});
+export const AUTH_AUTH_PLUGIN_TS_TEMPLATES = { authPlugin };
+//# sourceMappingURL=ts-templates.js.map

package/dist/generators/auth/auth-plugin/generated/ts-templates.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ts-templates.js","sourceRoot":"","sources":["../../../../../src/generators/auth/auth-plugin/generated/ts-templates.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,gCAAgC,CAAC;AAEtE,OAAO,EAAE,iCAAiC,EAAE,MAAM,kCAAkC,CAAC;AACrF,OAAO,EAAE,0BAA0B,EAAE,MAAM,gDAAgD,CAAC;AAC5F,OAAO,EAAE,+BAA+B,EAAE,MAAM,sDAAsD,CAAC;AAEvG,MAAM,UAAU,GAAG,oBAAoB,CAAC;IACtC,kBAAkB,EAAE;QAClB,kBAAkB,EAAE,0BAA0B;QAC9C,yBAAyB,EAAE,iCAAiC;QAC5D,uBAAuB,EAAE,+BAA+B;KACzD;IACD,IAAI,EAAE,aAAa;IACnB,cAAc,EAAE,EAAE;IAClB,MAAM,EAAE,EAAE,IAAI,EAAE,gBAAgB,EAAE;IAClC,SAAS,EAAE,EAAE;CACd,CAAC,CAAC;AAEH,MAAM,CAAC,MAAM,6BAA6B,GAAG,EAAE,UAAU,EAAE,CAAC"}

package/dist/generators/auth/auth-plugin/templates/auth.plugin.ts

@@ -0,0 +1,39 @@
+// @ts-nocheck
+
+import type { AuthContext } from '%authContextImports';
+import type { UserSessionService } from '%userSessionTypesImports';
+
+import { createAuthContextFromSessionInfo } from '%authContextImports';
+import { userSessionService } from '%userSessionServiceImports';
+import { requestContext } from '@fastify/request-context';
+import fp from 'fastify-plugin';
+
+declare module 'fastify' {
+  interface FastifyRequest {
+    auth: AuthContext;
+  }
+}
+
+declare module '@fastify/request-context' {
+  interface RequestContextData {
+    userId?: string;
+  }
+}
+
+export const authPlugin = fp((fastify, opts, done) => {
+  fastify.decorateRequest('auth');
+
+  fastify.addHook('onRequest', async (req, res) => {
+    const userSessionInfo = await (
+      userSessionService as UserSessionService
+    ).getSessionInfoFromRequest(req, res);
+
+    const authContext = createAuthContextFromSessionInfo(userSessionInfo);
+
+    req.auth = authContext;
+
+    requestContext.set('userId', userSessionInfo?.userId);
+  });
+
+  done();
+});

package/dist/generators/auth/auth-roles/auth-roles.generator.d.ts

@@ -0,0 +1,25 @@
+export declare const authRolesGenerator: import("@baseplate-dev/sync").GeneratorBundleCreator<{
+    roles: {
+        name: string;
+        comment: string;
+        builtIn: boolean;
+    }[];
+}, {
+    main: import("@baseplate-dev/sync").GeneratorTask<{
+        authRolesImports: import("@baseplate-dev/sync").ProviderExport<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+            AuthRole: {
+                isTypeOnly: true;
+            };
+            DEFAULT_PUBLIC_ROLES: {};
+            DEFAULT_USER_ROLES: {};
+            RoleConfig: {
+                isTypeOnly: true;
+            };
+        }>>;
+    }, {
+        typescriptFile: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").TypescriptFileProvider>;
+        appModule: import("@baseplate-dev/sync").ProviderType<import("#src/generators/core/app-module/app-module.generator.js").AppModuleProvider>;
+    }, any>;
+}>;
+export { authRolesImportsProvider } from './generated/ts-import-maps.js';
+//# sourceMappingURL=auth-roles.generator.d.ts.map

package/dist/generators/auth/auth-roles/auth-roles.generator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"auth-roles.generator.d.ts","sourceRoot":"","sources":["../../../../src/generators/auth/auth-roles/auth-roles.generator.ts"],"names":[],"mappings":"AAiCA,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;EAqD7B,CAAC;AAEH,OAAO,EAAE,wBAAwB,EAAE,MAAM,+BAA+B,CAAC"}