@adatechnology/keycloak-admin 0.1.1 → 0.1.3

package/dist/index.d.ts

@@ -0,0 +1,91 @@
+import { DynamicModule } from "@nestjs/common";
+
+export interface KeycloakAdminConfig {
+  baseUrl: string;
+  realm: string;
+  adminUser: string;
+  adminPassword: string;
+}
+
+export interface GetAdminTokenResult {
+  accessToken: string;
+  expiresIn: number;
+  tokenType: string;
+}
+
+export interface UpdateUserParams {
+  userId: string;
+  userData: Record<string, unknown>;
+  adminToken: string;
+}
+
+export interface ResetPasswordParams {
+  userId: string;
+  password: string;
+  temporary: boolean;
+  adminToken: string;
+}
+
+export interface ToggleUserEnabledParams {
+  userId: string;
+  enabled: boolean;
+  adminToken: string;
+}
+
+export interface DeleteUserParams {
+  userId: string;
+  adminToken: string;
+}
+
+export interface UpdateUserAttributesParams {
+  userId: string;
+  attributes: Record<string, string | string[]>;
+  adminToken: string;
+}
+
+export interface SendVerifyEmailParams {
+  userId: string;
+  adminToken: string;
+}
+
+export interface KeycloakAdminClientInterface {
+  getAdminToken(): Promise<GetAdminTokenResult>;
+  updateUser(params: UpdateUserParams): Promise<void>;
+  resetPassword(params: ResetPasswordParams): Promise<void>;
+  toggleUserEnabled(params: ToggleUserEnabledParams): Promise<void>;
+  deleteUser(params: DeleteUserParams): Promise<void>;
+  updateUserAttributes(params: UpdateUserAttributesParams): Promise<void>;
+  sendVerifyEmail(params: SendVerifyEmailParams): Promise<void>;
+}
+
+export class KeycloakAdminError extends Error {
+  readonly statusCode?: number;
+  readonly code?: string;
+  readonly context?: Record<string, unknown>;
+  constructor(params: {
+    message: string;
+    statusCode?: number;
+    code?: string;
+    context?: Record<string, unknown>;
+  });
+}
+
+export class KeycloakAdminClient implements KeycloakAdminClientInterface {
+  getAdminToken(): Promise<GetAdminTokenResult>;
+  updateUser(params: UpdateUserParams): Promise<void>;
+  resetPassword(params: ResetPasswordParams): Promise<void>;
+  toggleUserEnabled(params: ToggleUserEnabledParams): Promise<void>;
+  deleteUser(params: DeleteUserParams): Promise<void>;
+  updateUserAttributes(params: UpdateUserAttributesParams): Promise<void>;
+  sendVerifyEmail(params: SendVerifyEmailParams): Promise<void>;
+}
+
+export class KeycloakAdminModule {
+  static forRoot(config: KeycloakAdminConfig): DynamicModule;
+}
+
+export function validateKeycloakAdminConfig(config: KeycloakAdminConfig): void;
+
+export const KEYCLOAK_ADMIN_CLIENT = "KEYCLOAK_ADMIN_CLIENT";
+export const KEYCLOAK_ADMIN_CONFIG = "KEYCLOAK_ADMIN_CONFIG";
+export const KEYCLOAK_ADMIN_PROVIDER = "KEYCLOAK_ADMIN_PROVIDER";

package/dist/index.js

@@ -0,0 +1,601 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  KEYCLOAK_ADMIN_CLIENT: () => KEYCLOAK_ADMIN_CLIENT,
+  KEYCLOAK_ADMIN_CONFIG: () => KEYCLOAK_ADMIN_CONFIG,
+  KEYCLOAK_ADMIN_PROVIDER: () => KEYCLOAK_ADMIN_PROVIDER,
+  KeycloakAdminClient: () => KeycloakAdminClient,
+  KeycloakAdminError: () => KeycloakAdminError,
+  KeycloakAdminModule: () => KeycloakAdminModule,
+  validateKeycloakAdminConfig: () => validateKeycloakAdminConfig
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/keycloak-admin.module.ts
+var import_common2 = require("@nestjs/common");
+var import_http_client2 = require("@adatechnology/http-client");
+
+// src/keycloak-admin.token.ts
+var KEYCLOAK_ADMIN_CLIENT = "KEYCLOAK_ADMIN_CLIENT";
+var KEYCLOAK_ADMIN_CONFIG = "KEYCLOAK_ADMIN_CONFIG";
+var KEYCLOAK_ADMIN_PROVIDER = "KEYCLOAK_ADMIN_PROVIDER";
+
+// src/keycloak-admin.client.ts
+var import_common = require("@nestjs/common");
+var import_http_client = require("@adatechnology/http-client");
+var import_logger = require("@adatechnology/logger");
+
+// src/errors/keycloak-admin.error.ts
+var _KeycloakAdminError = class _KeycloakAdminError extends Error {
+  statusCode;
+  code;
+  context;
+  constructor(params) {
+    super(params.message);
+    this.name = "KeycloakAdminError";
+    this.statusCode = params.statusCode;
+    this.code = params.code;
+    this.context = params.context;
+    Object.setPrototypeOf(this, _KeycloakAdminError.prototype);
+  }
+};
+__name(_KeycloakAdminError, "KeycloakAdminError");
+var KeycloakAdminError = _KeycloakAdminError;
+
+// src/constants/keycloak-admin.constants.ts
+var KEYCLOAK_ADMIN_LIB_NAME = "@adatechnology/keycloak-admin";
+var KEYCLOAK_ADMIN_LIB_VERSION = "0.1.2";
+var KEYCLOAK_ADMIN_GRANT_TYPE_PASSWORD = "password";
+var KEYCLOAK_ADMIN_CLIENT_ID_ADMIN_CLI = "admin-cli";
+var KEYCLOAK_ADMIN_CONTENT_TYPE_FORM = "application/x-www-form-urlencoded";
+var KEYCLOAK_ADMIN_CONTENT_TYPE_JSON = "application/json";
+var KEYCLOAK_ADMIN_AUTHORIZATION_HEADER = "Authorization";
+var KEYCLOAK_ADMIN_BEARER_PREFIX = "Bearer ";
+var KEYCLOAK_ADMIN_ENDPOINTS = {
+  MASTER_TOKEN: "/realms/master/protocol/openid-connect/token",
+  ADMIN_USERS: /* @__PURE__ */ __name((baseUrl, realm, userId) => `${baseUrl}/admin/realms/${realm}/users/${userId}`, "ADMIN_USERS"),
+  ADMIN_RESET_PASSWORD: /* @__PURE__ */ __name((baseUrl, realm, userId) => `${baseUrl}/admin/realms/${realm}/users/${userId}/reset-password`, "ADMIN_RESET_PASSWORD"),
+  ADMIN_SEND_VERIFY_EMAIL: /* @__PURE__ */ __name((baseUrl, realm, userId) => `${baseUrl}/admin/realms/${realm}/users/${userId}/send-verify-email`, "ADMIN_SEND_VERIFY_EMAIL")
+};
+var KEYCLOAK_ADMIN_ERROR_CODES = {
+  ADMIN_TOKEN_ERROR: "KEYCLOAK_ADMIN_TOKEN_ERROR",
+  UPDATE_USER_ERROR: "KEYCLOAK_UPDATE_USER_ERROR",
+  RESET_PASSWORD_ERROR: "KEYCLOAK_RESET_PASSWORD_ERROR",
+  TOGGLE_ENABLED_ERROR: "KEYCLOAK_TOGGLE_ENABLED_ERROR",
+  DELETE_USER_ERROR: "KEYCLOAK_DELETE_USER_ERROR",
+  UPDATE_ATTRIBUTES_ERROR: "KEYCLOAK_UPDATE_ATTRIBUTES_ERROR",
+  SEND_VERIFY_EMAIL_ERROR: "KEYCLOAK_SEND_VERIFY_EMAIL_ERROR"
+};
+
+// src/utils/extract-http-error.ts
+function extractHttpError(err) {
+  const unknownErr = err;
+  const response = unknownErr == null ? void 0 : unknownErr.response;
+  const responseData = response == null ? void 0 : response.data;
+  let statusCode = void 0;
+  if (typeof (unknownErr == null ? void 0 : unknownErr.status) === "number") {
+    statusCode = unknownErr.status;
+  } else if (typeof (response == null ? void 0 : response.status) === "number") {
+    statusCode = response.status;
+  }
+  const details = responseData ?? (unknownErr == null ? void 0 : unknownErr.message);
+  const rawError = (responseData == null ? void 0 : responseData.error) ?? (responseData == null ? void 0 : responseData.errorMessage);
+  const errorCode = typeof rawError === "string" ? rawError : typeof (unknownErr == null ? void 0 : unknownErr.code) === "string" ? unknownErr.code : void 0;
+  return {
+    statusCode,
+    details,
+    errorCode
+  };
+}
+__name(extractHttpError, "extractHttpError");
+
+// src/keycloak-admin.client.ts
+function _ts_decorate(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;
+}
+__name(_ts_decorate, "_ts_decorate");
+function _ts_metadata(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata, "_ts_metadata");
+function _ts_param(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param, "_ts_param");
+var _KeycloakAdminClient = class _KeycloakAdminClient {
+  config;
+  httpProvider;
+  logger;
+  className = this.constructor.name;
+  constructor(config, httpProvider, logger) {
+    this.config = config;
+    this.httpProvider = httpProvider;
+    this.logger = logger;
+  }
+  log(level, message, libMethod, meta) {
+    if (!this.logger) return;
+    const payload = {
+      message,
+      context: this.className,
+      lib: KEYCLOAK_ADMIN_LIB_NAME,
+      libVersion: KEYCLOAK_ADMIN_LIB_VERSION,
+      libMethod,
+      meta
+    };
+    if (level === "info") this.logger.info(payload);
+    else if (level === "warn") this.logger.warn(payload);
+    else if (level === "error") this.logger.error(payload);
+  }
+  async getAdminToken() {
+    const method = "getAdminToken";
+    this.log("info", `${method} - Start`, method, {
+      realm: this.config.realm
+    });
+    const url = `${this.config.baseUrl}${KEYCLOAK_ADMIN_ENDPOINTS.MASTER_TOKEN}`;
+    const body = new URLSearchParams();
+    body.append("grant_type", KEYCLOAK_ADMIN_GRANT_TYPE_PASSWORD);
+    body.append("client_id", KEYCLOAK_ADMIN_CLIENT_ID_ADMIN_CLI);
+    body.append("username", this.config.adminUser);
+    body.append("password", this.config.adminPassword);
+    try {
+      const response = await this.httpProvider.post({
+        url,
+        data: body,
+        config: {
+          headers: {
+            "Content-Type": KEYCLOAK_ADMIN_CONTENT_TYPE_FORM
+          }
+        }
+      });
+      const result = {
+        accessToken: response.data.access_token,
+        expiresIn: response.data.expires_in,
+        tokenType: response.data.token_type
+      };
+      this.log("info", `${method} - Success`, method);
+      return result;
+    } catch (err) {
+      const { statusCode, details, errorCode } = extractHttpError(err);
+      this.log("error", `${method} - Failed`, method, {
+        statusCode,
+        errorCode
+      });
+      throw new KeycloakAdminError({
+        message: "Keycloak admin token request failed",
+        statusCode: statusCode ?? 502,
+        code: KEYCLOAK_ADMIN_ERROR_CODES.ADMIN_TOKEN_ERROR,
+        context: {
+          url,
+          method: "POST",
+          details,
+          errorCode
+        }
+      });
+    }
+  }
+  async updateUser(params) {
+    const method = "updateUser";
+    const { userId, userData, adminToken } = params;
+    this.log("info", `${method} - Start`, method, {
+      userId
+    });
+    const url = KEYCLOAK_ADMIN_ENDPOINTS.ADMIN_USERS(this.config.baseUrl, this.config.realm, userId);
+    try {
+      await this.httpProvider.put({
+        url,
+        data: userData,
+        config: {
+          headers: {
+            [KEYCLOAK_ADMIN_AUTHORIZATION_HEADER]: `${KEYCLOAK_ADMIN_BEARER_PREFIX}${adminToken}`,
+            "Content-Type": KEYCLOAK_ADMIN_CONTENT_TYPE_JSON
+          }
+        }
+      });
+      this.log("info", `${method} - Success`, method, {
+        userId
+      });
+    } catch (err) {
+      const { statusCode, details, errorCode } = extractHttpError(err);
+      this.log("error", `${method} - Failed`, method, {
+        userId,
+        statusCode,
+        errorCode
+      });
+      throw new KeycloakAdminError({
+        message: "Keycloak update user failed",
+        statusCode: statusCode ?? 502,
+        code: KEYCLOAK_ADMIN_ERROR_CODES.UPDATE_USER_ERROR,
+        context: {
+          url,
+          method: "PUT",
+          userId,
+          details,
+          errorCode
+        }
+      });
+    }
+  }
+  async resetPassword(params) {
+    const method = "resetPassword";
+    const { userId, password, temporary, adminToken } = params;
+    this.log("info", `${method} - Start`, method, {
+      userId,
+      temporary
+    });
+    const url = KEYCLOAK_ADMIN_ENDPOINTS.ADMIN_RESET_PASSWORD(this.config.baseUrl, this.config.realm, userId);
+    try {
+      await this.httpProvider.put({
+        url,
+        data: {
+          type: "password",
+          value: password,
+          temporary
+        },
+        config: {
+          headers: {
+            [KEYCLOAK_ADMIN_AUTHORIZATION_HEADER]: `${KEYCLOAK_ADMIN_BEARER_PREFIX}${adminToken}`,
+            "Content-Type": KEYCLOAK_ADMIN_CONTENT_TYPE_JSON
+          }
+        }
+      });
+      this.log("info", `${method} - Success`, method, {
+        userId
+      });
+    } catch (err) {
+      const { statusCode, details, errorCode } = extractHttpError(err);
+      this.log("error", `${method} - Failed`, method, {
+        userId,
+        statusCode,
+        errorCode
+      });
+      throw new KeycloakAdminError({
+        message: "Keycloak reset password failed",
+        statusCode: statusCode ?? 502,
+        code: KEYCLOAK_ADMIN_ERROR_CODES.RESET_PASSWORD_ERROR,
+        context: {
+          url,
+          method: "PUT",
+          userId,
+          details,
+          errorCode
+        }
+      });
+    }
+  }
+  async toggleUserEnabled(params) {
+    const method = "toggleUserEnabled";
+    const { userId, enabled, adminToken } = params;
+    this.log("info", `${method} - Start`, method, {
+      userId,
+      enabled
+    });
+    const url = KEYCLOAK_ADMIN_ENDPOINTS.ADMIN_USERS(this.config.baseUrl, this.config.realm, userId);
+    try {
+      await this.httpProvider.put({
+        url,
+        data: {
+          enabled
+        },
+        config: {
+          headers: {
+            [KEYCLOAK_ADMIN_AUTHORIZATION_HEADER]: `${KEYCLOAK_ADMIN_BEARER_PREFIX}${adminToken}`,
+            "Content-Type": KEYCLOAK_ADMIN_CONTENT_TYPE_JSON
+          }
+        }
+      });
+      this.log("info", `${method} - Success`, method, {
+        userId,
+        enabled
+      });
+    } catch (err) {
+      const { statusCode, details, errorCode } = extractHttpError(err);
+      this.log("error", `${method} - Failed`, method, {
+        userId,
+        enabled,
+        statusCode,
+        errorCode
+      });
+      throw new KeycloakAdminError({
+        message: "Keycloak toggle user enabled failed",
+        statusCode: statusCode ?? 502,
+        code: KEYCLOAK_ADMIN_ERROR_CODES.TOGGLE_ENABLED_ERROR,
+        context: {
+          url,
+          method: "PUT",
+          userId,
+          enabled,
+          details,
+          errorCode
+        }
+      });
+    }
+  }
+  async deleteUser(params) {
+    const method = "deleteUser";
+    const { userId, adminToken } = params;
+    this.log("info", `${method} - Start`, method, {
+      userId
+    });
+    const url = KEYCLOAK_ADMIN_ENDPOINTS.ADMIN_USERS(this.config.baseUrl, this.config.realm, userId);
+    try {
+      await this.httpProvider.delete({
+        url,
+        config: {
+          headers: {
+            [KEYCLOAK_ADMIN_AUTHORIZATION_HEADER]: `${KEYCLOAK_ADMIN_BEARER_PREFIX}${adminToken}`
+          }
+        }
+      });
+      this.log("info", `${method} - Success`, method, {
+        userId
+      });
+    } catch (err) {
+      const { statusCode, details, errorCode } = extractHttpError(err);
+      this.log("error", `${method} - Failed`, method, {
+        userId,
+        statusCode,
+        errorCode
+      });
+      throw new KeycloakAdminError({
+        message: "Keycloak delete user failed",
+        statusCode: statusCode ?? 502,
+        code: KEYCLOAK_ADMIN_ERROR_CODES.DELETE_USER_ERROR,
+        context: {
+          url,
+          method: "DELETE",
+          userId,
+          details,
+          errorCode
+        }
+      });
+    }
+  }
+  async updateUserAttributes(params) {
+    const method = "updateUserAttributes";
+    const { userId, attributes, adminToken } = params;
+    this.log("info", `${method} - Start`, method, {
+      userId,
+      attributeKeys: Object.keys(attributes)
+    });
+    const url = KEYCLOAK_ADMIN_ENDPOINTS.ADMIN_USERS(this.config.baseUrl, this.config.realm, userId);
+    try {
+      await this.httpProvider.put({
+        url,
+        data: {
+          attributes
+        },
+        config: {
+          headers: {
+            [KEYCLOAK_ADMIN_AUTHORIZATION_HEADER]: `${KEYCLOAK_ADMIN_BEARER_PREFIX}${adminToken}`,
+            "Content-Type": KEYCLOAK_ADMIN_CONTENT_TYPE_JSON
+          }
+        }
+      });
+      this.log("info", `${method} - Success`, method, {
+        userId
+      });
+    } catch (err) {
+      const { statusCode, details, errorCode } = extractHttpError(err);
+      this.log("error", `${method} - Failed`, method, {
+        userId,
+        statusCode,
+        errorCode
+      });
+      throw new KeycloakAdminError({
+        message: "Keycloak update user attributes failed",
+        statusCode: statusCode ?? 502,
+        code: KEYCLOAK_ADMIN_ERROR_CODES.UPDATE_ATTRIBUTES_ERROR,
+        context: {
+          url,
+          method: "PUT",
+          userId,
+          details,
+          errorCode
+        }
+      });
+    }
+  }
+  async sendVerifyEmail(params) {
+    const method = "sendVerifyEmail";
+    const { userId, adminToken } = params;
+    this.log("info", `${method} - Start`, method, {
+      userId
+    });
+    const url = KEYCLOAK_ADMIN_ENDPOINTS.ADMIN_SEND_VERIFY_EMAIL(this.config.baseUrl, this.config.realm, userId);
+    try {
+      await this.httpProvider.put({
+        url,
+        data: {},
+        config: {
+          headers: {
+            [KEYCLOAK_ADMIN_AUTHORIZATION_HEADER]: `${KEYCLOAK_ADMIN_BEARER_PREFIX}${adminToken}`,
+            "Content-Type": KEYCLOAK_ADMIN_CONTENT_TYPE_JSON
+          }
+        }
+      });
+      this.log("info", `${method} - Success`, method, {
+        userId
+      });
+    } catch (err) {
+      const { statusCode, details, errorCode } = extractHttpError(err);
+      this.log("error", `${method} - Failed`, method, {
+        userId,
+        statusCode,
+        errorCode
+      });
+      throw new KeycloakAdminError({
+        message: "Keycloak send verify email failed",
+        statusCode: statusCode ?? 502,
+        code: KEYCLOAK_ADMIN_ERROR_CODES.SEND_VERIFY_EMAIL_ERROR,
+        context: {
+          url,
+          method: "PUT",
+          userId,
+          details,
+          errorCode
+        }
+      });
+    }
+  }
+};
+__name(_KeycloakAdminClient, "KeycloakAdminClient");
+var KeycloakAdminClient = _KeycloakAdminClient;
+KeycloakAdminClient = _ts_decorate([
+  (0, import_common.Injectable)(),
+  _ts_param(0, (0, import_common.Inject)(KEYCLOAK_ADMIN_CONFIG)),
+  _ts_param(1, (0, import_common.Inject)(import_http_client.HTTP_PROVIDER)),
+  _ts_param(2, (0, import_common.Optional)()),
+  _ts_param(2, (0, import_common.Inject)(import_logger.LOGGER_PROVIDER)),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    typeof KeycloakAdminConfig === "undefined" ? Object : KeycloakAdminConfig,
+    typeof HttpProviderInterface === "undefined" ? Object : HttpProviderInterface,
+    typeof LoggerProviderInterface === "undefined" ? Object : LoggerProviderInterface
+  ])
+], KeycloakAdminClient);
+
+// src/utils/validate-config.ts
+function validateKeycloakAdminConfig(config) {
+  const issues = [];
+  if (!config) {
+    throw new KeycloakAdminError({
+      message: "KeycloakAdminConfig is required. Provide an object with baseUrl, realm, adminUser and adminPassword.",
+      statusCode: 400,
+      code: "KEYCLOAK_ADMIN_CONFIG_MISSING"
+    });
+  }
+  if (typeof config.baseUrl !== "string" || config.baseUrl.trim() === "") {
+    issues.push({
+      field: "baseUrl",
+      message: "baseUrl is required and must be a non-empty string (e.g. 'http://localhost:8081')"
+    });
+  } else if (!config.baseUrl.startsWith("http://") && !config.baseUrl.startsWith("https://")) {
+    issues.push({
+      field: "baseUrl",
+      message: `baseUrl must start with 'http://' or 'https://'. Received: '${config.baseUrl}'`
+    });
+  }
+  if (typeof config.realm !== "string" || config.realm.trim() === "") {
+    issues.push({
+      field: "realm",
+      message: "realm is required and must be a non-empty string (e.g. 'BACKEND')"
+    });
+  }
+  if (typeof config.adminUser !== "string" || config.adminUser.trim() === "") {
+    issues.push({
+      field: "adminUser",
+      message: "adminUser is required and must be a non-empty string"
+    });
+  }
+  if (typeof config.adminPassword !== "string" || config.adminPassword.trim() === "") {
+    issues.push({
+      field: "adminPassword",
+      message: "adminPassword is required and must be a non-empty string"
+    });
+  }
+  if (issues.length > 0) {
+    const summary = issues.map((i) => `  - ${i.field}: ${i.message}`).join("\n");
+    throw new KeycloakAdminError({
+      message: `KeycloakAdminConfig validation failed:
+${summary}`,
+      statusCode: 400,
+      code: "KEYCLOAK_ADMIN_CONFIG_INVALID",
+      context: {
+        issues
+      }
+    });
+  }
+}
+__name(validateKeycloakAdminConfig, "validateKeycloakAdminConfig");
+
+// src/keycloak-admin.module.ts
+function _ts_decorate2(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;
+}
+__name(_ts_decorate2, "_ts_decorate");
+var _KeycloakAdminModule = class _KeycloakAdminModule {
+  static forRoot(config) {
+    validateKeycloakAdminConfig(config);
+    return {
+      module: _KeycloakAdminModule,
+      global: true,
+      imports: [
+        import_http_client2.HttpModule.forRoot({
+          baseURL: config.baseUrl,
+          timeout: 5e3
+        }, {
+          logging: {
+            enabled: true,
+            includeBody: true,
+            context: "KeycloakAdminHttpClient",
+            environments: [
+              "development",
+              "test"
+            ]
+          }
+        })
+      ],
+      providers: [
+        {
+          provide: KEYCLOAK_ADMIN_CONFIG,
+          useValue: config
+        },
+        {
+          provide: KEYCLOAK_ADMIN_CLIENT,
+          useClass: KeycloakAdminClient
+        },
+        {
+          provide: KEYCLOAK_ADMIN_PROVIDER,
+          useExisting: KEYCLOAK_ADMIN_CLIENT
+        }
+      ],
+      exports: [
+        KEYCLOAK_ADMIN_CLIENT,
+        KEYCLOAK_ADMIN_PROVIDER,
+        KEYCLOAK_ADMIN_CONFIG
+      ]
+    };
+  }
+};
+__name(_KeycloakAdminModule, "KeycloakAdminModule");
+var KeycloakAdminModule = _KeycloakAdminModule;
+KeycloakAdminModule = _ts_decorate2([
+  (0, import_common2.Module)({})
+], KeycloakAdminModule);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  KEYCLOAK_ADMIN_CLIENT,
+  KEYCLOAK_ADMIN_CONFIG,
+  KEYCLOAK_ADMIN_PROVIDER,
+  KeycloakAdminClient,
+  KeycloakAdminError,
+  KeycloakAdminModule,
+  validateKeycloakAdminConfig
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adatechnology/keycloak-admin",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "publishConfig": {
     "access": "public"
   },
@@ -11,7 +11,7 @@
     "dist"
   ],
   "dependencies": {
-    "@adatechnology/http-client": "0.0.10",
+    "@adatechnology/http-client": "0.0.11",
     "@adatechnology/logger": "0.0.10"
   },
   "peerDependencies": {