@postxl/generators 0.2.2

package/dist/backend-actions/generators/execution-interface.generator.js

@@ -0,0 +1,237 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateActionExecutionInterface = generateActionExecutionInterface;
+const generator_1 = require("@postxl/generator");
+function generateActionExecutionInterface({ actions, types }) {
+    const { execution } = actions;
+    const { mutations, transformation, errorOperation } = execution;
+    const id = execution.interface.actionOperationId.name;
+    const imports = generator_1.ImportGenerator
+        //
+        .from(execution.interface.location)
+        .addType(actions.summary.action)
+        .addType(types.modelNames)
+        .addType(types.user);
+    return /* ts */ `
+${imports.generate()}
+
+export type ${id} = string & { readonly ___type: 'Mutation' }
+
+/**
+ * Flags the given string as a ${id}.
+ */
+export const ${execution.interface.toBrandedActionOperationId.name} = (id: string): ${id} => id as ${id}
+
+/**
+ * The interface of the action executor.
+ */
+export interface ${execution.interface.name} {
+  name: string
+  user: User
+  init({ action, user }: { action: Action; user: User }): Promise<void>
+
+  /**
+   * Marks the ActionExecution as finished successfully.
+   *
+   * This method needs to accept anything that the actual dispatcher functions can return.
+   * This is often "void" - but can also be any other type.
+   */
+  // eslint-disable-next-line @typescript-eslint/no-invalid-void-type
+  success(result?: object | null | undefined | void): Promise<void>
+
+  /**
+   * Marks the ActionExecution as finished with an error.
+   */
+  error(error: unknown): Promise<void>
+
+  ${mutations.create.start}({
+    model,
+    createObject,
+  }: {
+    model: ModelName
+    createObject: object
+  }): Promise<${id}> 
+
+  ${mutations.createMany.start}({
+    model,
+    createObjects,
+  }: {
+    model: ModelName
+    createObjects: object[]
+  }): Promise<${id}> 
+
+  ${mutations.update.start}({
+    model,
+    entityId,
+    sourceObject,
+    updateObject,
+  }: {
+    model: ModelName
+    entityId: string
+    sourceObject: object
+    updateObject: object
+  }): Promise<${id}>
+
+  ${mutations.updateMany.start}({
+    model,
+    sourceObjects,
+    updateObjects,
+  }: {
+    model: ModelName
+    sourceObjects: object[]
+    updateObjects: object[]
+  }): Promise<${id}>
+
+  ${mutations.delete.start}({
+    model,
+    entityId,
+    sourceObject,
+  }: {
+    model: ModelName
+    entityId: string
+    sourceObject: object
+  }): Promise<${id}>
+
+  ${mutations.deleteMany.start}({
+    model,
+    entityIds,
+    sourceObjects,
+  }: {
+    model: ModelName
+    entityIds: string[]
+    sourceObjects: object[]
+  }): Promise<${id}>
+
+  ${mutations.clone.start}({
+    model,
+    entityId,
+    sourceObject,
+  }: {
+    model: ModelName
+    entityId: string
+    sourceObject: object
+  }): Promise<${id}>
+
+  ${mutations.create.finish}({
+    actionOperationId,
+    entityId,
+    createdObject,
+  }: {
+    actionOperationId: ${id}
+    entityId: string
+    createdObject: object
+  }): Promise<void>
+
+  ${mutations.createMany.finish}({
+    actionOperationId,
+    entityIds,
+    createdObjects,
+  }: {
+    actionOperationId: ${id}
+    entityIds: string[]
+    createdObjects: object[]
+  }): Promise<void>
+  
+  ${mutations.update.finish}({ actionOperationId, updatedObject }: { actionOperationId: ${id}; updatedObject: object }): Promise<void> 
+
+  ${mutations.updateMany.finish}({ actionOperationId, updatedObjects }: { actionOperationId: ${id}; updatedObjects: object[] }): Promise<void>
+
+  ${mutations.delete.finish}({ actionOperationId }: { actionOperationId: ${id} }): Promise<void>
+
+  ${mutations.deleteMany.finish}({ actionOperationId }: { actionOperationId: ${id} }): Promise<void>
+
+  ${mutations.clone.finish}({ actionOperationId, clonedObject }: { actionOperationId: ${id}; clonedObject: object }): Promise<void>
+
+  ${transformation.executeMultiple}<TInitial, T1>(
+    steps: readonly [[operation: string, predicate: (input: TInitial) => T1 | Promise<T1>]],
+    initialValue: TInitial,
+  ): Promise<T1>
+  ${transformation.executeMultiple}<TInitial, T1, T2>(
+    steps: readonly [
+      [operation: string, predicate: (input: TInitial) => T1 | Promise<T1>],
+      [operation: string, predicate: (input: T1) => T2 | Promise<T2>],
+    ],
+    initialValue: TInitial,
+  ): Promise<T2>
+  ${transformation.executeMultiple}<TInitial, T1, T2, T3>(
+    steps: readonly [
+      [operation: string, predicate: (input: TInitial) => T1 | Promise<T1>],
+      [operation: string, predicate: (input: T1) => T2 | Promise<T2>],
+      [operation: string, predicate: (input: T2) => T3 | Promise<T3>],
+    ],
+    initialValue: TInitial,
+  ): Promise<T3>
+  ${transformation.executeMultiple}<TInitial, T1, T2, T3, T4>(
+    steps: readonly [
+      [operation: string, predicate: (input: TInitial) => T1 | Promise<T1>],
+      [operation: string, predicate: (input: T1) => T2 | Promise<T2>],
+      [operation: string, predicate: (input: T2) => T3 | Promise<T3>],
+      [operation: string, predicate: (input: T3) => T4 | Promise<T4>],
+    ],
+    initialValue: TInitial,
+  ): Promise<T4>
+  ${transformation.executeMultiple}<TInitial, T1, T2, T3, T4, T5>(
+    steps: readonly [
+      [operation: string, predicate: (input: TInitial) => T1 | Promise<T1>],
+      [operation: string, predicate: (input: T1) => T2 | Promise<T2>],
+      [operation: string, predicate: (input: T2) => T3 | Promise<T3>],
+      [operation: string, predicate: (input: T3) => T4 | Promise<T4>],
+      [operation: string, predicate: (input: T4) => T5 | Promise<T5>],
+    ],
+    initialValue: TInitial,
+  ): Promise<T5>
+  ${transformation.executeMultiple}<TInitial, T1, T2, T3, T4, T5, T6>(
+    steps: readonly [
+      [operation: string, predicate: (input: TInitial) => T1 | Promise<T1>],
+      [operation: string, predicate: (input: T1) => T2 | Promise<T2>],
+      [operation: string, predicate: (input: T2) => T3 | Promise<T3>],
+      [operation: string, predicate: (input: T3) => T4 | Promise<T4>],
+      [operation: string, predicate: (input: T4) => T5 | Promise<T5>],
+      [operation: string, predicate: (input: T5) => T6 | Promise<T6>],
+    ],
+    initialValue: TInitial,
+  ): Promise<T6>
+  ${transformation.executeMultiple}<TInitial, T1, T2, T3, T4, T5, T6, T7>(
+    steps: readonly [
+      [operation: string, predicate: (input: TInitial) => T1 | Promise<T1>],
+      [operation: string, predicate: (input: T1) => T2 | Promise<T2>],
+      [operation: string, predicate: (input: T2) => T3 | Promise<T3>],
+      [operation: string, predicate: (input: T3) => T4 | Promise<T4>],
+      [operation: string, predicate: (input: T4) => T5 | Promise<T5>],
+      [operation: string, predicate: (input: T5) => T6 | Promise<T6>],
+      [operation: string, predicate: (input: T6) => T7 | Promise<T7>],
+    ],
+    initialValue: TInitial,
+  ): Promise<T7>
+
+  ${transformation.executeSingle}<Payload extends object, Result extends object>({
+    operation,
+    payload,
+    predicate,
+  }: {
+    operation: string
+    payload: Payload
+    predicate: (input: Payload) => Result | Promise<Result>
+  }): Promise<Result>
+
+  ${transformation.start}({
+    operation,
+    payload,
+  }: {
+    operation: string
+    payload: object
+  }): Promise<${id}>
+
+  ${transformation.finish}({
+    actionOperationId,
+    result,
+  }: {
+    actionOperationId: ${id}
+    result: object
+  }): Promise<void>
+  
+  ${errorOperation}({ actionOperationId, error }: { actionOperationId: ${id}; error: unknown }): Promise<void> 
+}
+`;
+}
+//# sourceMappingURL=execution-interface.generator.js.map

package/dist/backend-actions/generators/execution-interface.generator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"execution-interface.generator.js","sourceRoot":"","sources":["../../../src/backend-actions/generators/execution-interface.generator.ts"],"names":[],"mappings":";;AAIA,4EAyOC;AA7OD,iDAAmD;AAInD,SAAgB,gCAAgC,CAAC,EAAE,OAAO,EAAE,KAAK,EAAiB;IAChF,MAAM,EAAE,SAAS,EAAE,GAAG,OAAO,CAAA;IAC7B,MAAM,EAAE,SAAS,EAAE,cAAc,EAAE,cAAc,EAAE,GAAG,SAAS,CAAA;IAC/D,MAAM,EAAE,GAAG,SAAS,CAAC,SAAS,CAAC,iBAAiB,CAAC,IAAI,CAAA;IAErD,MAAM,OAAO,GAAG,2BAAe;QAC7B,EAAE;SACD,IAAI,CAAC,SAAS,CAAC,SAAS,CAAC,QAAQ,CAAC;SAClC,OAAO,CAAC,OAAO,CAAC,OAAO,CAAC,MAAM,CAAC;SAC/B,OAAO,CAAC,KAAK,CAAC,UAAU,CAAC;SACzB,OAAO,CAAC,KAAK,CAAC,IAAI,CAAC,CAAA;IAEtB,OAAO,QAAQ,CAAC;EAChB,OAAO,CAAC,QAAQ,EAAE;;cAEN,EAAE;;;iCAGiB,EAAE;;eAEpB,SAAS,CAAC,SAAS,CAAC,0BAA0B,CAAC,IAAI,oBAAoB,EAAE,aAAa,EAAE;;;;;mBAKpF,SAAS,CAAC,SAAS,CAAC,IAAI;;;;;;;;;;;;;;;;;;;IAmBvC,SAAS,CAAC,MAAM,CAAC,KAAK;;;;;;gBAMV,EAAE;;IAEd,SAAS,CAAC,UAAU,CAAC,KAAK;;;;;;gBAMd,EAAE;;IAEd,SAAS,CAAC,MAAM,CAAC,KAAK;;;;;;;;;;gBAUV,EAAE;;IAEd,SAAS,CAAC,UAAU,CAAC,KAAK;;;;;;;;gBAQd,EAAE;;IAEd,SAAS,CAAC,MAAM,CAAC,KAAK;;;;;;;;gBAQV,EAAE;;IAEd,SAAS,CAAC,UAAU,CAAC,KAAK;;;;;;;;gBAQd,EAAE;;IAEd,SAAS,CAAC,KAAK,CAAC,KAAK;;;;;;;;gBAQT,EAAE;;IAEd,SAAS,CAAC,MAAM,CAAC,MAAM;;;;;yBAKF,EAAE;;;;;IAKvB,SAAS,CAAC,UAAU,CAAC,MAAM;;;;;yBAKN,EAAE;;;;;IAKvB,SAAS,CAAC,MAAM,CAAC,MAAM,+DAA+D,EAAE;;IAExF,SAAS,CAAC,UAAU,CAAC,MAAM,gEAAgE,EAAE;;IAE7F,SAAS,CAAC,MAAM,CAAC,MAAM,gDAAgD,EAAE;;IAEzE,SAAS,CAAC,UAAU,CAAC,MAAM,gDAAgD,EAAE;;IAE7E,SAAS,CAAC,KAAK,CAAC,MAAM,8DAA8D,EAAE;;IAEtF,cAAc,CAAC,eAAe;;;;IAI9B,cAAc,CAAC,eAAe;;;;;;;IAO9B,cAAc,CAAC,eAAe;;;;;;;;IAQ9B,cAAc,CAAC,eAAe;;;;;;;;;IAS9B,cAAc,CAAC,eAAe;;;;;;;;;;IAU9B,cAAc,CAAC,eAAe;;;;;;;;;;;IAW9B,cAAc,CAAC,eAAe;;;;;;;;;;;;;IAa9B,cAAc,CAAC,aAAa;;;;;;;;;;IAU5B,cAAc,CAAC,KAAK;;;;;;gBAMR,EAAE;;IAEd,cAAc,CAAC,MAAM;;;;yBAIA,EAAE;;;;IAIvB,cAAc,uDAAuD,EAAE;;CAE1E,CAAA;AACD,CAAC"}

package/dist/backend-actions/index.d.ts

@@ -0,0 +1,9 @@
+import * as Generator from './actions.generator';
+export type WithActions<Context> = Generator.WithActions<Context>;
+export declare const backendActionsGenerator: import("@postxl/generator").GeneratorInterface;
+export declare const backendActionsGeneratorId: string & import("zod").BRAND<"PXL.GeneratorInterfaceId">;
+export type ActionProviderTypes = Generator.ActionProviderTypes;
+export type ActionProvider<Actions extends Record<string, Generator.ActionProviderTypes>> = Generator.ActionProvider<Actions>;
+export type ScopeName = Generator.ScopeName;
+export declare const toScopeName: (input: string) => string & import("zod").BRAND<"PXL.ScopeName">;
+export declare const mockActionProviderGenerator: import("@postxl/generator").GeneratorInterface;

package/dist/backend-actions/index.js

@@ -0,0 +1,43 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mockActionProviderGenerator = exports.toScopeName = exports.backendActionsGeneratorId = exports.backendActionsGenerator = void 0;
+const Generator = __importStar(require("./actions.generator"));
+const Mock = __importStar(require("./actions-provider.mock"));
+exports.backendActionsGenerator = Generator.generator;
+exports.backendActionsGeneratorId = Generator.generatorId;
+exports.toScopeName = Generator.toScopeName;
+exports.mockActionProviderGenerator = Mock.mockActionProviderGenerator;
+//# sourceMappingURL=index.js.map

package/dist/backend-actions/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/backend-actions/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,+DAAgD;AAChD,8DAA+C;AAGlC,QAAA,uBAAuB,GAAG,SAAS,CAAC,SAAS,CAAA;AAC7C,QAAA,yBAAyB,GAAG,SAAS,CAAC,WAAW,CAAA;AAMjD,QAAA,WAAW,GAAG,SAAS,CAAC,WAAW,CAAA;AAEnC,QAAA,2BAA2B,GAAG,IAAI,CAAC,2BAA2B,CAAA"}

package/dist/backend-actions/template/README.md

@@ -0,0 +1,21 @@
+# PXL Actions module
+
+# Concept
+
+An action is a single unit of work that can be executed by the backend. Every data mutation can only be executed through an action. As all actions are logged, this allows to audit any data changes. Furthermore, as the logged actions (or their operations) contain the initial state before the mutation, it allows to revert any changes. This is the foundation to enable offline work and data synchronization.
+
+An action typically has one or more ActionOperations/Transformations. These are the individual steps that are executed to perform the action - and are also logged.
+
+## Lifecycle
+
+- Any business logic has access to the `DispatcherService` and can dispatch actions through it
+- An action contains:
+  - `scope` - for the dispatcher to know which business logic service to dispatch the action to
+  - `type` - for the business logic's dispatcher to know which action to perform
+  - `payload` - the data that is passed to the action
+- Once an action is dispatched, the dispatcher initiates the action's `ActionExecution` (aka execution context). This logs the start of the action and its content
+- The dispatcher dispatches the action and the execution context to the business logic
+- The business logic can now perform any changes. Mutation is only possible in the data repositories and require the execution context.
+- Each mutation in the repositories will be wrapped in an `ActionOperation` and logged.
+- If an error occurs, the execution context will log the error (in both, the operation and the execution) and throw the error.
+- The execution context will then finish the action and log the end of the action

package/dist/backend-actions/template/src/execution/types.ts

@@ -0,0 +1,85 @@
+import type { ModelName, User } from '@types'
+
+import type { Action } from '../actions.types'
+
+export type MutationId = string & { readonly ___type: 'Mutation' }
+
+/**
+ * Flags the given string as a MutationId.
+ */
+export const toMutationId = (id: string): MutationId => id as MutationId
+
+/**
+ * The interface of the action executor.
+ */
+export type IActionExecution = {
+  name: string
+  user: User
+  init({ action, user }: { action: Action; user: User }): Promise<void>
+
+  /**
+   * Marks the ActionExecution as finished successfully.
+   *
+   * This method needs to accept anything that the actual dispatcher functions can return.
+   * This is often "void" - but can also be any other type.
+   */
+  // eslint-disable-next-line @typescript-eslint/no-invalid-void-type
+  success(result?: object | null | undefined | void): Promise<void>
+
+  /**
+   * Marks the ActionExecution as finished with an error.
+   */
+  error(error: unknown): Promise<void>
+
+  startCreateMutation({ model, createObject }: { model: ModelName; createObject: object }): Promise<MutationId>
+
+  startCreateManyMutation({ model, createObjects }: { model: ModelName; createObjects: object[] }): Promise<MutationId>
+
+  startUpdateMutation({
+    model,
+    entityId,
+    sourceObject,
+    updateObject,
+  }: {
+    model: ModelName
+    entityId: string
+    sourceObject: object
+    updateObject: object
+  }): Promise<MutationId>
+
+  startDeleteMutation({
+    model,
+    entityId,
+    sourceObject,
+  }: {
+    model: ModelName
+    entityId: string
+    sourceObject: object
+  }): Promise<MutationId>
+
+  finishCreateMutation({
+    mutationId,
+    entityId,
+    createdObject,
+  }: {
+    mutationId: MutationId
+    entityId: string
+    createdObject: object
+  }): Promise<void>
+
+  finishCreateManyMutation({
+    mutationId,
+    entityIds,
+    createdObjects,
+  }: {
+    mutationId: MutationId
+    entityIds: string[]
+    createdObjects: object
+  }): Promise<void>
+
+  finishUpdateMutation({ mutationId, updatedObject }: { mutationId: MutationId; updatedObject: object }): Promise<void>
+
+  finishDeleteMutation({ mutationId }: { mutationId: MutationId }): Promise<void>
+
+  errorMutation({ mutationId, error }: { mutationId: MutationId; error: unknown }): Promise<void>
+}

package/dist/backend-authentication/authentication.generator.d.ts

@@ -0,0 +1,29 @@
+import * as Generator from '@postxl/generator';
+import { WithActions } from '../backend-actions';
+import { WithBackend } from '../backend-core';
+import { WithView } from '../backend-view';
+import { WithBase } from '../base';
+import { WithTypes } from '../types';
+type ContextRequirements = WithView<WithActions<WithTypes<WithBackend<WithBase<Generator.Context>>>>>;
+export type ContextResult = WithAuthentication<ContextRequirements>;
+export type WithAuthentication<Context> = Generator.ExtendContext<Context, {
+    authentication: AuthenticationContext;
+}>;
+export type AuthenticationContext = {
+    module: Generator.ImportableItem & {
+        _filePath: Generator.FilePath;
+    };
+    guard: Generator.ImportableClass & {
+        _filePath: Generator.FilePath;
+    };
+    service: Generator.ImportableClass & {
+        _filePath: Generator.FilePath;
+    };
+    types: {
+        userInfo: Generator.ImportableType;
+        userRoles: Generator.ImportableType;
+    };
+};
+export declare const generatorId: string & import("zod").BRAND<"PXL.GeneratorInterfaceId">;
+export declare const generator: Generator.GeneratorInterface;
+export {};

package/dist/backend-authentication/authentication.generator.js

@@ -0,0 +1,145 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generator = exports.generatorId = void 0;
+const node_path_1 = require("node:path");
+const Generator = __importStar(require("@postxl/generator"));
+const backend_actions_1 = require("../backend-actions");
+const backend_core_1 = require("../backend-core");
+const backend_view_1 = require("../backend-view");
+const base_1 = require("../base");
+const auth_guard_generator_1 = require("./generators/auth-guard.generator");
+const authentication_module_generator_1 = require("./generators/authentication-module.generator");
+const authentication_service_generator_1 = require("./generators/authentication-service.generator");
+const authentication_types_generator_1 = require("./generators/authentication-types.generator");
+exports.generatorId = Generator.toGeneratorInterfaceId('backend-authentication');
+exports.generator = {
+    id: exports.generatorId,
+    requires: [backend_core_1.backendGeneratorId, base_1.baseGeneratorId, backend_view_1.backendViewGeneratorId, backend_actions_1.backendActionsGeneratorId],
+    register: (context) => {
+        context.backend.packageJson.devDependencies.push({ packageName: '@types/jsonwebtoken', version: '9.0.10' });
+        context.backend.packageJson.dependencies.push({ packageName: '@fastify/cookie', version: '11.0.2' }, { packageName: '@fastify/cors', version: '11.1.0' }, { packageName: '@fastify/helmet', version: '13.0.2' }, { packageName: 'jsonwebtoken', version: '9.0.2' }, { packageName: 'oidc-client-ts', version: '3.3.0' });
+        const module = {
+            name: Generator.toClassName('AuthenticationModule'),
+            location: Generator.toBackendModuleLocation(`@authentication/authentication.module`),
+            _filePath: Generator.toFilePath('./authentication.module'),
+        };
+        const authenticationModule = {
+            name: Generator.toBackendModuleName('authentication'),
+            moduleClass: module,
+            apiModuleRegistration: {
+                code: Generator.ts(`AuthenticationModule.forRoot(config.auth)`),
+            },
+            envConfig: {
+                decoder: Generator.ts(`
+          AUTH: zEnvBoolean.optional().default('true'),
+          KEYCLOAK_URL: z.string().url().transform((val) => new URL(val)),
+          KEYCLOAK_CLIENT_ID: z.string(),
+          KEYCLOAK_CLIENT_SECRET: z.string(),
+          KEYCLOAK_REALM: z.string(),
+          KEYCLOAK_REDIRECT_URL: z.string().url().transform((val) => new URL(val)),
+          KEYCLOAK_LOGOUT_REDIRECT_URL: z.string().url().transform((val) => new URL(val)),`),
+                transformer: Generator.ts(`
+          auth: val.AUTH ? {
+            enableAuthentication: true as const,
+            url: val.API_URL,
+            urlPrefix: val.API_PREFIX,
+            
+            frontendUrl: val.FRONTEND_URL,
+            
+            clientId: val.KEYCLOAK_CLIENT_ID,
+            clientSecret: val.KEYCLOAK_CLIENT_SECRET,
+            
+            realm: val.KEYCLOAK_REALM,
+            keycloakUrl: val.KEYCLOAK_URL,
+            redirectUrl: val.KEYCLOAK_REDIRECT_URL,
+            
+            postLogoutRedirectUrl: val.KEYCLOAK_LOGOUT_REDIRECT_URL,
+          } : {
+            enableAuthentication: false as const,
+          }`),
+                dotEnvExample: `
+          KEYCLOAK_URL=http://localhost:8080
+          KEYCLOAK_CLIENT_ID=development
+          KEYCLOAK_CLIENT_SECRET="secret"
+          KEYCLOAK_REALM=postxl
+          KEYCLOAK_REDIRECT_URL=\${API_URL}/auth/callback
+          KEYCLOAK_LOGOUT_REDIRECT_URL=\${FRONTEND_URL}
+          `,
+            },
+        };
+        context.backend.modules.push(authenticationModule);
+        const service = {
+            name: Generator.toClassName('AuthenticationService'),
+            location: Generator.toBackendModuleLocation('@authentication/authentication.service'),
+            _filePath: Generator.toFilePath('./authentication.service.ts'),
+        };
+        const guard = {
+            name: Generator.toClassName('AuthGuard'),
+            location: Generator.toBackendModuleLocation('@authentication/auth.guard'),
+            _filePath: Generator.toFilePath('./auth.guard.ts'),
+        };
+        const authenticationContext = {
+            module,
+            service,
+            guard,
+            types: {
+                userInfo: {
+                    name: Generator.toTypeName('UserInfo'),
+                    location: Generator.toBackendModuleLocation('@authentication/authentication.types'),
+                },
+                userRoles: {
+                    name: Generator.toTypeName('UserRoles'),
+                    location: Generator.toBackendModuleLocation('@authentication/authentication.types'),
+                },
+            },
+        };
+        return { ...context, authentication: authenticationContext };
+    },
+    generate: async (context) => {
+        const vfsSrc = new Generator.VirtualFileSystem();
+        vfsSrc.write(Generator.toLocalFile(context.authentication.module), (0, authentication_module_generator_1.generateAuthenticationModule)(context));
+        vfsSrc.write(context.authentication.guard._filePath, (0, auth_guard_generator_1.generateAuthGuard)(context));
+        vfsSrc.write(context.authentication.service._filePath, (0, authentication_service_generator_1.generateAuthenticationService)(context));
+        vfsSrc.write(Generator.toLocalFile(context.authentication.types.userInfo), (0, authentication_types_generator_1.generateAuthenticationTypes)(context));
+        const vfs = new Generator.VirtualFileSystem();
+        vfs.insertFromVfs({ vfs: vfsSrc, targetPath: 'src' });
+        await vfs.loadFolder({ diskPath: (0, node_path_1.resolve)(__dirname, './template') });
+        vfs.write('/tsconfig.lib.json', Generator.generateTsConfig('authentication'));
+        context.vfs.insertFromVfs({ targetPath: 'backend/libs/authentication', vfs });
+        return context;
+    },
+};
+//# sourceMappingURL=authentication.generator.js.map

package/dist/backend-authentication/authentication.generator.js.map

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

package/dist/backend-authentication/generators/auth-guard.generator.d.ts

@@ -0,0 +1,2 @@
+import { ContextResult } from '../authentication.generator';
+export declare function generateAuthGuard(context: ContextResult): string;