@clemax/nest-keycloak-connect 2.1.0 → 2.1.1

package/dist/keycloak-connect.module.js

@@ -0,0 +1,126 @@
+"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 __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var KeycloakConnectModule_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KeycloakConnectModule = void 0;
+const common_1 = require("@nestjs/common");
+const constants_1 = require("./constants");
+const keycloak_connect_providers_1 = require("./keycloak-connect.providers");
+const keycloak_multitenant_service_1 = require("./services/keycloak-multitenant.service");
+__exportStar(require("./constants"), exports);
+__exportStar(require("./decorators/access-token.decorator"), exports);
+__exportStar(require("./decorators/enforcer-options.decorator"), exports);
+__exportStar(require("./decorators/keycloak-user.decorator"), exports);
+__exportStar(require("./decorators/public.decorator"), exports);
+__exportStar(require("./decorators/resource.decorator"), exports);
+__exportStar(require("./decorators/roles.decorator"), exports);
+__exportStar(require("./decorators/scopes.decorator"), exports);
+__exportStar(require("./guards/auth.guard"), exports);
+__exportStar(require("./guards/resource.guard"), exports);
+__exportStar(require("./guards/role.guard"), exports);
+__exportStar(require("./interface/keycloak-connect-module-async-options.interface"), exports);
+__exportStar(require("./interface/keycloak-connect-options-factory.interface"), exports);
+__exportStar(require("./interface/keycloak-connect-options.interface"), exports);
+__exportStar(require("./services/keycloak-multitenant.service"), exports);
+__exportStar(require("./util"), exports);
+let KeycloakConnectModule = KeycloakConnectModule_1 = class KeycloakConnectModule {
+    /**
+     * Register the `KeycloakConnect` module.
+     * @param opts `keycloak.json` path in string or {@link NestKeycloakConfig} object.
+     * @param config {@link NestKeycloakConfig} when using `keycloak.json` path, optional
+     * @returns
+     */
+    static register(opts, config) {
+        const keycloakConnectProviders = [
+            (0, keycloak_connect_providers_1.createKeycloakConnectOptionProvider)(opts, config),
+            keycloak_connect_providers_1.keycloakProvider,
+            keycloak_multitenant_service_1.KeycloakMultiTenantService,
+            {
+                provide: constants_1.KEYCLOAK_MULTITENANT_SERVICE,
+                useClass: keycloak_multitenant_service_1.KeycloakMultiTenantService,
+            },
+        ];
+        return {
+            module: KeycloakConnectModule_1,
+            providers: keycloakConnectProviders,
+            exports: keycloakConnectProviders,
+        };
+    }
+    static registerAsync(opts) {
+        const optsProvider = this.createAsyncProviders(opts);
+        return {
+            module: KeycloakConnectModule_1,
+            imports: opts.imports || [],
+            providers: optsProvider,
+            exports: optsProvider,
+        };
+    }
+    static createAsyncProviders(options) {
+        const reqProviders = [
+            this.createAsyncOptionsProvider(options),
+            keycloak_connect_providers_1.keycloakProvider,
+            keycloak_multitenant_service_1.KeycloakMultiTenantService,
+            {
+                provide: constants_1.KEYCLOAK_MULTITENANT_SERVICE,
+                useClass: keycloak_multitenant_service_1.KeycloakMultiTenantService,
+            },
+        ];
+        if (options.useExisting || options.useFactory) {
+            return reqProviders;
+        }
+        return [
+            ...reqProviders,
+            {
+                provide: options.useClass,
+                useClass: options.useClass,
+            },
+        ];
+    }
+    static createAsyncOptionsProvider(options) {
+        if (options.useFactory) {
+            return {
+                provide: constants_1.KEYCLOAK_CONNECT_OPTIONS,
+                useFactory: options.useFactory,
+                inject: options.inject || [],
+            };
+        }
+        return {
+            provide: constants_1.KEYCLOAK_CONNECT_OPTIONS,
+            useFactory: (optionsFactory) => __awaiter(this, void 0, void 0, function* () { return yield optionsFactory.createKeycloakConnectOptions(); }),
+            inject: [options.useExisting || options.useClass],
+        };
+    }
+};
+exports.KeycloakConnectModule = KeycloakConnectModule;
+KeycloakConnectModule.logger = new common_1.Logger(KeycloakConnectModule_1.name);
+exports.KeycloakConnectModule = KeycloakConnectModule = KeycloakConnectModule_1 = __decorate([
+    (0, common_1.Module)({})
+], KeycloakConnectModule);

package/dist/keycloak-connect.providers.d.ts

@@ -0,0 +1,7 @@
+import { Provider } from '@nestjs/common';
+import { KeycloakConnectConfig, KeycloakConnectOptions, NestKeycloakConfig } from './interface/keycloak-connect-options.interface';
+export declare const keycloakProvider: Provider;
+export declare const createKeycloakConnectOptionProvider: (opts: KeycloakConnectOptions, config?: NestKeycloakConfig) => {
+    provide: string;
+    useValue: KeycloakConnectConfig;
+};

package/dist/keycloak-connect.providers.js

@@ -0,0 +1,81 @@
+"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 (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createKeycloakConnectOptionProvider = exports.keycloakProvider = void 0;
+const fs = __importStar(require("fs"));
+const keycloak_connect_1 = __importDefault(require("keycloak-connect"));
+const path = __importStar(require("path"));
+const constants_1 = require("./constants");
+const keycloak_connect_module_1 = require("./keycloak-connect.module");
+exports.keycloakProvider = {
+    provide: constants_1.KEYCLOAK_INSTANCE,
+    useFactory: (opts) => {
+        const keycloakOpts = opts;
+        const keycloak = new keycloak_connect_1.default({}, keycloakOpts);
+        // Warn if using token validation none
+        if (typeof opts !== 'string' &&
+            opts.tokenValidation &&
+            opts.tokenValidation === constants_1.TokenValidation.NONE) {
+            keycloak_connect_module_1.KeycloakConnectModule.logger.warn(`Token validation is disabled, please only do this on development/special use-cases.`);
+        }
+        // Access denied is called, add a flag to request so our resource guard knows
+        keycloak.accessDenied = (req, res, next) => {
+            req.resourceDenied = true;
+            next();
+        };
+        return keycloak;
+    },
+    inject: [constants_1.KEYCLOAK_CONNECT_OPTIONS],
+};
+const parseConfig = (opts, config) => {
+    if (typeof opts === 'string') {
+        const configPathRelative = path.join(__dirname, opts);
+        const configPathRoot = path.join(process.cwd(), opts);
+        let configPath;
+        if (fs.existsSync(configPathRelative)) {
+            configPath = configPathRelative;
+        }
+        else if (fs.existsSync(configPathRoot)) {
+            configPath = configPathRoot;
+        }
+        else {
+            throw new Error(`Cannot find files, looked in [ ${configPathRelative}, ${configPathRoot} ]`);
+        }
+        const json = fs.readFileSync(configPath);
+        const keycloakConfig = JSON.parse(json.toString());
+        return Object.assign(keycloakConfig, config);
+    }
+    return opts;
+};
+const createKeycloakConnectOptionProvider = (opts, config) => {
+    return {
+        provide: constants_1.KEYCLOAK_CONNECT_OPTIONS,
+        useValue: parseConfig(opts, config),
+    };
+};
+exports.createKeycloakConnectOptionProvider = createKeycloakConnectOptionProvider;

package/dist/services/keycloak-multitenant.service.d.ts

@@ -0,0 +1,24 @@
+import KeycloakConnect from 'keycloak-connect';
+import { KeycloakConnectOptions } from '../interface/keycloak-connect-options.interface';
+/**
+ * Stores all keycloak instances when multi tenant option is defined.
+ */
+export declare class KeycloakMultiTenantService {
+    private keycloakOpts;
+    private instances;
+    constructor(keycloakOpts: KeycloakConnectOptions);
+    /**
+     * Clears the cached Keycloak instances.
+     */
+    clear(): void;
+    /**
+     * Retrieves a keycloak instance based on the realm provided.
+     * @param realm the realm to retrieve from
+     * @param request the request instance, defaults to undefined
+     * @returns the multi tenant keycloak instance
+     */
+    get(realm: string, request?: any): Promise<KeycloakConnect.Keycloak>;
+    resolveAuthServerUrl(realm: string, request?: any): Promise<string>;
+    resolveClientId(realm: string, request?: any): Promise<string>;
+    resolveSecret(realm: string, request?: any): Promise<string>;
+}

package/dist/services/keycloak-multitenant.service.js

@@ -0,0 +1,174 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KeycloakMultiTenantService = void 0;
+const common_1 = require("@nestjs/common");
+const keycloak_connect_1 = __importDefault(require("keycloak-connect"));
+const constants_1 = require("../constants");
+/**
+ * Stores all keycloak instances when multi tenant option is defined.
+ */
+let KeycloakMultiTenantService = class KeycloakMultiTenantService {
+    constructor(keycloakOpts) {
+        this.keycloakOpts = keycloakOpts;
+        this.instances = new Map();
+    }
+    /**
+     * Clears the cached Keycloak instances.
+     */
+    clear() {
+        this.instances.clear();
+    }
+    /**
+     * Retrieves a keycloak instance based on the realm provided.
+     * @param realm the realm to retrieve from
+     * @param request the request instance, defaults to undefined
+     * @returns the multi tenant keycloak instance
+     */
+    get(realm_1) {
+        return __awaiter(this, arguments, void 0, function* (realm, request = undefined) {
+            if (typeof this.keycloakOpts === 'string') {
+                throw new Error('Keycloak configuration is a configuration path. This should not happen after module load.');
+            }
+            if (this.keycloakOpts.multiTenant === null ||
+                this.keycloakOpts.multiTenant === undefined) {
+                throw new Error('Multi tenant is not defined yet multi tenant service is being called.');
+            }
+            const authServerUrl = yield this.resolveAuthServerUrl(realm, request);
+            const secret = yield this.resolveSecret(realm, request);
+            const clientId = yield this.resolveClientId(realm, request);
+            // Check if existing
+            if (this.instances.has(realm) &&
+                !this.keycloakOpts.multiTenant.resolveAlways) {
+                // Otherwise return the instance
+                return this.instances.get(realm);
+            }
+            else {
+                // TODO: Repeating code from  provider, will need to rework this in 2.0
+                // Override realm, secret, and authServerUrl
+                const keycloakOpts = Object.assign(this.keycloakOpts, {
+                    authServerUrl,
+                    realm,
+                    secret,
+                    clientId,
+                });
+                const keycloak = new keycloak_connect_1.default({}, keycloakOpts);
+                // The most important part
+                keycloak.accessDenied = (req, res, next) => {
+                    req.resourceDenied = true;
+                    next();
+                };
+                // Save instance
+                this.instances.set(realm, keycloak);
+                return keycloak;
+            }
+        });
+    }
+    resolveAuthServerUrl(realm_1) {
+        return __awaiter(this, arguments, void 0, function* (realm, request = undefined) {
+            if (typeof this.keycloakOpts === 'string') {
+                throw new Error('Keycloak configuration is a configuration path. This should not happen after module load.');
+            }
+            if (this.keycloakOpts.multiTenant === null ||
+                this.keycloakOpts.multiTenant === undefined) {
+                throw new Error('Multi tenant is not defined yet multi tenant service is being called.');
+            }
+            // If no realm auth server url resolver is defined, return defaults
+            if (!this.keycloakOpts.multiTenant.realmAuthServerUrlResolver) {
+                return (this.keycloakOpts.authServerUrl ||
+                    this.keycloakOpts['auth-server-url'] ||
+                    this.keycloakOpts.serverUrl ||
+                    this.keycloakOpts['server-url']);
+            }
+            // Resolve realm authServerUrl
+            const resolvedAuthServerUrl = this.keycloakOpts.multiTenant.realmAuthServerUrlResolver(realm, request);
+            const authServerUrl = resolvedAuthServerUrl || resolvedAuthServerUrl instanceof Promise
+                ? yield resolvedAuthServerUrl
+                : resolvedAuthServerUrl;
+            // Override auth server url
+            // Order of priority: resolved realm auth server url > provided auth server url
+            return (authServerUrl ||
+                this.keycloakOpts.authServerUrl ||
+                this.keycloakOpts['auth-server-url'] ||
+                this.keycloakOpts.serverUrl ||
+                this.keycloakOpts['server-url']);
+        });
+    }
+    resolveClientId(realm_1) {
+        return __awaiter(this, arguments, void 0, function* (realm, request = undefined) {
+            if (typeof this.keycloakOpts === 'string') {
+                throw new Error('Keycloak configuration is a configuration path. This should not happen after module load.');
+            }
+            if (this.keycloakOpts.multiTenant === null ||
+                this.keycloakOpts.multiTenant === undefined) {
+                throw new Error('Multi tenant is not defined yet multi tenant service is being called.');
+            }
+            // If no realm client-id resolver is defined, return defaults
+            if (!this.keycloakOpts.multiTenant.realmClientIdResolver) {
+                return this.keycloakOpts.clientId || this.keycloakOpts['client-id'];
+            }
+            // Resolve realm client-id
+            const resolvedClientId = this.keycloakOpts.multiTenant.realmClientIdResolver(realm, request);
+            const realmClientId = resolvedClientId || resolvedClientId instanceof Promise
+                ? yield resolvedClientId
+                : resolvedClientId;
+            // Override client-id
+            // Order of priority: resolved realm secret > default global secret
+            return (realmClientId ||
+                this.keycloakOpts.clientId ||
+                this.keycloakOpts['client-id']);
+        });
+    }
+    resolveSecret(realm_1) {
+        return __awaiter(this, arguments, void 0, function* (realm, request = undefined) {
+            if (typeof this.keycloakOpts === 'string') {
+                throw new Error('Keycloak configuration is a configuration path. This should not happen after module load.');
+            }
+            if (this.keycloakOpts.multiTenant === null ||
+                this.keycloakOpts.multiTenant === undefined) {
+                throw new Error('Multi tenant is not defined yet multi tenant service is being called.');
+            }
+            // If no realm secret resolver is defined, return defaults
+            if (!this.keycloakOpts.multiTenant.realmSecretResolver) {
+                return this.keycloakOpts.secret;
+            }
+            // Resolve realm secret
+            const resolvedRealmSecret = this.keycloakOpts.multiTenant.realmSecretResolver(realm, request);
+            const realmSecret = resolvedRealmSecret || resolvedRealmSecret instanceof Promise
+                ? yield resolvedRealmSecret
+                : resolvedRealmSecret;
+            // Override secret
+            // Order of priority: resolved realm secret > default global secret
+            return realmSecret || this.keycloakOpts.secret;
+        });
+    }
+};
+exports.KeycloakMultiTenantService = KeycloakMultiTenantService;
+exports.KeycloakMultiTenantService = KeycloakMultiTenantService = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, common_1.Inject)(constants_1.KEYCLOAK_CONNECT_OPTIONS)),
+    __metadata("design:paramtypes", [Object])
+], KeycloakMultiTenantService);

package/dist/util.d.ts

@@ -0,0 +1 @@
+export declare const parseToken: (token: string) => any;

package/dist/util.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseToken = void 0;
+const parseToken = (token) => {
+    const parts = token.split('.');
+    return JSON.parse(Buffer.from(parts[1], 'base64').toString());
+};
+exports.parseToken = parseToken;

package/package.json

@@ -1,9 +1,19 @@
 {
   "name": "@clemax/nest-keycloak-connect",
-  "version": "2.1.0",
+  "version": "2.1.1",
   "description": "keycloak-nodejs-connect module for Nest",
   "author": "John Joshua Ferrer <johnjoshuaferrer@disroot.org>",
   "license": "MIT",
+  "scripts": {
+    "start:dev": "tsc -w",
+    "clean": "rimraf dist",
+    "build": "tsc",
+    "release": "release-it",
+    "release:alpha": "release-it --preReleaseId=alpha --npm.tag=next --github.preRelease",
+    "format": "prettier src --write",
+    "lint": "eslint src",
+    "prepare": "husky"
+  },
   "keywords": [
     "nestjs",
     "keycloak",
@@ -88,13 +98,5 @@
       "eslint"
     ]
   },
-  "scripts": {
-    "start:dev": "tsc -w",
-    "clean": "rimraf dist",
-    "build": "tsc",
-    "release": "release-it",
-    "release:alpha": "release-it --preReleaseId=alpha --npm.tag=next --github.preRelease",
-    "format": "prettier src --write",
-    "lint": "eslint src"
-  }
-}
+  "packageManager": "pnpm@9.1.0-0+sha512.568e95e38592215a03fa2cb02a58b67c6452e51b176d9941d546a59a471c42e2b4c2428bf286addcbe4e2dec98e682e2df0fa93a5082cf3493afc496affd8ffb"
+}