@telia-ace/alliance-internal-node-utilities 1.0.3-next.4 → 1.0.4-next.0

package/dist/{index.mjs → index.js}

@@ -1,19 +1,196 @@
-import { InjectPinoLogger, LoggerModule as LoggerModule$1 } from 'nestjs-pino';
+import { InjectPinoLogger, LoggerModule as LoggerModule$1, PinoLogger } from 'nestjs-pino';
 export { LoggerErrorInterceptor } from 'nestjs-pino';
-import RedisStore from 'connect-redis';
+import { Store } from 'express-session';
 import { auth } from 'express-openid-connect';
 import { createClient } from 'redis';
 import { sign } from 'jsonwebtoken';
 import { validate } from 'jsonschema';
-import { resolve, dirname, relative } from 'node:path';
-import { readFileSync, writeFileSync, rmSync, existsSync, mkdirSync, createWriteStream, createReadStream, renameSync } from 'node:fs';
+import { existsSync, mkdirSync, writeFileSync, readFileSync, rmSync } from 'node:fs';
+import { resolve } from 'node:path';
 import { GraphQLError } from 'graphql';
 import { HttpStatus, HttpException, Catch, Injectable, Module } from '@nestjs/common';
 import { ConfigModule, ConfigService } from '@nestjs/config';
 import _slugify from 'slugify';
-import { pipeline } from 'node:stream/promises';
 
-var SharedConfigKeys = /* @__PURE__ */ ((SharedConfigKeys2) => {
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var noop = /* @__PURE__ */ __name((_err, _data) => {
+}, "noop");
+var RedisStore = class RedisStore2 extends Store {
+  static {
+    __name(this, "RedisStore");
+  }
+  constructor(opts) {
+    super();
+    this.prefix = opts.prefix == null ? "sess:" : opts.prefix;
+    this.scanCount = opts.scanCount || 100;
+    this.serializer = opts.serializer || JSON;
+    this.ttl = opts.ttl || 86400;
+    this.disableTTL = opts.disableTTL || false;
+    this.disableTouch = opts.disableTouch || false;
+    this.client = this.normalizeClient(opts.client);
+  }
+  // Create a redis and ioredis compatible client
+  normalizeClient(client) {
+    let isRedis = "scanIterator" in client;
+    return {
+      get: (key) => client.get(key),
+      set: (key, val, ttl) => {
+        if (ttl) {
+          return isRedis ? client.set(key, val, {
+            EX: ttl
+          }) : client.set(key, val, "EX", ttl);
+        }
+        return client.set(key, val);
+      },
+      del: (key) => client.del(key),
+      expire: (key, ttl) => client.expire(key, ttl),
+      mget: (keys) => isRedis ? client.mGet(keys) : client.mget(keys),
+      scanIterator: (match, count) => {
+        if (isRedis)
+          return client.scanIterator({
+            MATCH: match,
+            COUNT: count
+          });
+        return async function* () {
+          let [c, xs] = await client.scan("0", "MATCH", match, "COUNT", count);
+          for (let key of xs)
+            yield key;
+          while (c !== "0") {
+            [c, xs] = await client.scan(c, "MATCH", match, "COUNT", count);
+            for (let key of xs)
+              yield key;
+          }
+        }();
+      }
+    };
+  }
+  async get(sid, cb = noop) {
+    let key = this.prefix + sid;
+    try {
+      let data = await this.client.get(key);
+      if (!data)
+        return cb();
+      return cb(null, await this.serializer.parse(data));
+    } catch (err) {
+      return cb(err);
+    }
+  }
+  async set(sid, sess, cb = noop) {
+    let key = this.prefix + sid;
+    let ttl = this._getTTL(sess);
+    try {
+      let val = this.serializer.stringify(sess);
+      if (ttl > 0) {
+        if (this.disableTTL)
+          await this.client.set(key, val);
+        else
+          await this.client.set(key, val, ttl);
+        return cb();
+      } else {
+        return this.destroy(sid, cb);
+      }
+    } catch (err) {
+      return cb(err);
+    }
+  }
+  async touch(sid, sess, cb = noop) {
+    let key = this.prefix + sid;
+    if (this.disableTouch || this.disableTTL)
+      return cb();
+    try {
+      await this.client.expire(key, this._getTTL(sess));
+      return cb();
+    } catch (err) {
+      return cb(err);
+    }
+  }
+  async destroy(sid, cb = noop) {
+    let key = this.prefix + sid;
+    try {
+      await this.client.del([
+        key
+      ]);
+      return cb();
+    } catch (err) {
+      return cb(err);
+    }
+  }
+  async clear(cb = noop) {
+    try {
+      let keys = await this._getAllKeys();
+      if (!keys.length)
+        return cb();
+      await this.client.del(keys);
+      return cb();
+    } catch (err) {
+      return cb(err);
+    }
+  }
+  async length(cb = noop) {
+    try {
+      let keys = await this._getAllKeys();
+      return cb(null, keys.length);
+    } catch (err) {
+      return cb(err);
+    }
+  }
+  async ids(cb = noop) {
+    let len = this.prefix.length;
+    try {
+      let keys = await this._getAllKeys();
+      return cb(null, keys.map((k) => k.substring(len)));
+    } catch (err) {
+      return cb(err);
+    }
+  }
+  async all(cb = noop) {
+    let len = this.prefix.length;
+    try {
+      let keys = await this._getAllKeys();
+      if (keys.length === 0)
+        return cb(null, []);
+      let data = await this.client.mget(keys);
+      let results = data.reduce((acc, raw, idx) => {
+        if (!raw)
+          return acc;
+        let sess = this.serializer.parse(raw);
+        sess.id = keys[idx].substring(len);
+        acc.push(sess);
+        return acc;
+      }, []);
+      return cb(null, results);
+    } catch (err) {
+      return cb(err);
+    }
+  }
+  _getTTL(sess) {
+    if (typeof this.ttl === "function") {
+      return this.ttl(sess);
+    }
+    let ttl;
+    if (sess && sess.cookie && sess.cookie.expires) {
+      let ms = Number(new Date(sess.cookie.expires)) - Date.now();
+      ttl = Math.ceil(ms / 1e3);
+    } else {
+      ttl = this.ttl;
+    }
+    return ttl;
+  }
+  async _getAllKeys() {
+    let pattern = this.prefix + "*";
+    let keys = [];
+    for await (let key of this.client.scanIterator(pattern, this.scanCount)) {
+      keys.push(key);
+    }
+    return keys;
+  }
+};
+var esm_default = RedisStore;
+
+// src/constants/config.ts
+var SharedConfigKeys;
+(function(SharedConfigKeys2) {
   SharedConfigKeys2["AuthCookieName"] = "AUTH_COOKIE_NAME";
   SharedConfigKeys2["AuthCookieSecret"] = "AUTH_COOKIE_SECRET";
   SharedConfigKeys2["DbEndpoint"] = "DB_ENDPOINT";
@@ -22,33 +199,30 @@ var SharedConfigKeys = /* @__PURE__ */ ((SharedConfigKeys2) => {
   SharedConfigKeys2["ServicePort"] = "SERVICE_PORT";
   SharedConfigKeys2["RedisHost"] = "REDIS_HOST";
   SharedConfigKeys2["RedisPassword"] = "REDIS_PASSWORD";
-  return SharedConfigKeys2;
-})(SharedConfigKeys || {});
+})(SharedConfigKeys || (SharedConfigKeys = {}));
 
-var AllianceHeaders = /* @__PURE__ */ ((AllianceHeaders2) => {
+// src/constants/headers.ts
+var AllianceHeaders;
+(function(AllianceHeaders2) {
   AllianceHeaders2["TargetUrl"] = "alliance-target-url";
   AllianceHeaders2["TargetApp"] = "alliance-target-app";
   AllianceHeaders2["TargetWorkspace"] = "alliance-target-workspace";
-  return AllianceHeaders2;
-})(AllianceHeaders || {});
-
-function authMiddleware(configService, {
-  baseURL = "https://127.0.0.1",
-  clientSecret,
-  clientID = " ",
-  authRequired = true,
-  authorizationParams = {},
-  afterCallback,
-  issuerBaseURL = "https://127.0.0.1"
-} = {}) {
-  const redisClient = createClient({
-    url: configService.getOrThrow(SharedConfigKeys.RedisHost),
-    password: configService.get(SharedConfigKeys.RedisPassword)
-  });
-  redisClient.connect().catch(console.error);
-  const redisStore = new RedisStore({
-    client: redisClient
-  });
+})(AllianceHeaders || (AllianceHeaders = {}));
+
+// src/auth/auth.middleware.ts
+function authMiddleware(configService, { baseURL = "https://127.0.0.1", clientSecret, clientID = " ", authRequired = true, authorizationParams = {}, afterCallback, issuerBaseURL = "https://127.0.0.1", sessionCookiePath } = {}) {
+  let store;
+  const redisHostUrl = configService.get(SharedConfigKeys.RedisHost);
+  if (redisHostUrl) {
+    const redisClient = createClient({
+      url: configService.getOrThrow(SharedConfigKeys.RedisHost),
+      password: configService.get(SharedConfigKeys.RedisPassword)
+    });
+    redisClient.connect().catch(console.error);
+    store = new esm_default({
+      client: redisClient
+    });
+  }
   return auth({
     baseURL,
     clientSecret,
@@ -60,47 +234,42 @@ function authMiddleware(configService, {
     secret: configService.getOrThrow(SharedConfigKeys.AuthCookieSecret),
     session: {
       name: configService.getOrThrow(SharedConfigKeys.AuthCookieName),
-      store: redisStore
+      // @ts-ignore
+      store,
+      cookie: {
+        path: sessionCookiePath
+      }
     },
     routes: {
       callback: "/signin-oidc"
     }
   });
 }
-
-function createBearerToken({
-  privateKey,
-  aud,
-  sub,
-  name,
-  user,
-  workspace
-}) {
-  const jwt = sign(
-    {
-      iss: "Alliance",
-      aud,
-      sub,
-      name,
-      "https://alliance.teliacompany.net/user_type": user.type,
-      "https://alliance.teliacompany.net/user_privileges": user.permissions,
-      "https://alliance.teliacompany.net/workspace": workspace.slug,
-      "https://alliance.teliacompany.net/workspace_name": workspace.name,
-      "https://alliance.teliacompany.net/tenant": workspace.slug,
-      "https://alliance.teliacompany.net/tenant_name": workspace.name
-    },
-    privateKey,
-    {
-      expiresIn: "1h",
-      algorithm: "RS256"
-    }
-  );
+__name(authMiddleware, "authMiddleware");
+function createBearerToken({ privateKey, aud, sub, name, user, workspace }) {
+  const jwt = sign({
+    iss: "Alliance",
+    aud,
+    sub,
+    name,
+    "https://alliance.teliacompany.net/user_type": user.type,
+    "https://alliance.teliacompany.net/user_privileges": user.permissions,
+    "https://alliance.teliacompany.net/workspace": workspace.slug,
+    "https://alliance.teliacompany.net/workspace_name": workspace.name,
+    "https://alliance.teliacompany.net/tenant": workspace.slug,
+    "https://alliance.teliacompany.net/tenant_name": workspace.name
+  }, privateKey, {
+    expiresIn: "1h",
+    algorithm: "RS256"
+  });
   return `Bearer ${jwt}`;
 }
+__name(createBearerToken, "createBearerToken");
 function getPrivateKey(configService) {
   const privateKey = configService.getOrThrow(SharedConfigKeys.JwtPrivateKey);
   return "-----BEGIN RSA PRIVATE KEY-----\n" + privateKey + "\n-----END RSA PRIVATE KEY-----";
 }
+__name(getPrivateKey, "getPrivateKey");
 function createSystemUserToken(configService) {
   return createBearerToken({
     aud: "system",
@@ -117,7 +286,9 @@ function createSystemUserToken(configService) {
     privateKey: getPrivateKey(configService)
   });
 }
+__name(createSystemUserToken, "createSystemUserToken");
 
+// src/distribution/cookie-policy.ts
 function generateCookiePolicyHtml(appManifests) {
   const cookiePolicyTableRows = [];
   for (const appName in appManifests) {
@@ -132,8 +303,11 @@ function generateCookiePolicyHtml(appManifests) {
   }
   return cookiePolicyHtml.replace("{APP_COOKIES}", cookiePolicyTableRows.join(""));
 }
+__name(generateCookiePolicyHtml, "generateCookiePolicyHtml");
 function createCookiePolicyTableRow(key, claimEntry) {
-  const rows = ["<tr>"];
+  const rows = [
+    "<tr>"
+  ];
   const { category, purpose, lifespan } = claimEntry;
   rows.push(`<td>${key}</td>`);
   rows.push(`<td>${category}</td>`);
@@ -142,7 +316,8 @@ function createCookiePolicyTableRow(key, claimEntry) {
   rows.push("</tr>");
   return rows.join("");
 }
-const cookiePolicyHtml = `
+__name(createCookiePolicyTableRow, "createCookiePolicyTableRow");
+var cookiePolicyHtml = `
 <!DOCTYPE html>
 <html lang="en">
     <head>
@@ -430,14 +605,8 @@ const cookiePolicyHtml = `
     </body>
 </html>
 `;
-
 function getJsonSchemas() {
-  const frameworkDistDirPath = resolve(
-    process.cwd(),
-    "node_modules",
-    "@telia-ace/alliance-framework",
-    "dist"
-  );
+  const frameworkDistDirPath = resolve(process.cwd(), "node_modules", "@telia-ace/alliance-framework", "dist");
   const appConfigSchemaPath = resolve(frameworkDistDirPath, "config.schema.json");
   const appManifestSchemaPath = resolve(frameworkDistDirPath, "manifest.schema.json");
   const appConfigSchemaFile = readFileSync(appConfigSchemaPath).toString();
@@ -449,14 +618,17 @@ function getJsonSchemas() {
     appManifest
   };
 }
-
+__name(getJsonSchemas, "getJsonSchemas");
 async function createTempModuleAndImport(moduleString, fileName) {
   const file = resolve(process.cwd(), `${fileName}.mjs`);
   writeFileSync(file, moduleString);
   const importedModule = await import(`file:///${file}`);
-  rmSync(file, { force: true });
+  rmSync(file, {
+    force: true
+  });
   return importedModule;
 }
+__name(createTempModuleAndImport, "createTempModuleAndImport");
 async function getAppManifests(apps) {
   const moduleStringParts = [];
   const manifestImportVariables = [];
@@ -466,18 +638,18 @@ async function getAppManifests(apps) {
     moduleStringParts.push(`import ${manifestImportVariable} from '${packageName}/manifest';`);
   }
   moduleStringParts.push(`export default [${manifestImportVariables.join(", ")}];`);
-  const result = await createTempModuleAndImport(
-    moduleStringParts.join("\n"),
-    "app-manifests"
-  );
+  const result = await createTempModuleAndImport(moduleStringParts.join("\n"), "app-manifests");
   return result.default;
 }
+__name(getAppManifests, "getAppManifests");
 
+// src/distribution/pkg-json.ts
 function getPkgJson() {
   const packageJson = resolve(process.cwd(), "package.json");
   const pkgJsonFile = readFileSync(packageJson).toString();
   return JSON.parse(pkgJsonFile);
 }
+__name(getPkgJson, "getPkgJson");
 async function getManifests(pkgJson) {
   if (!pkgJson || !pkgJson.alliance || !pkgJson.alliance.apps) {
     throw new Error("Alliance apps not defined in package.json.");
@@ -488,12 +660,14 @@ async function getManifests(pkgJson) {
     return acc;
   }, {});
 }
-
-const PUBLIC_DIR_NAME = "public";
-const MANIFESTS_FILE_NAME = "manifests.json";
-const COOKIE_POLICY_FILE_NAME = "cookie-policy.html";
-const APP_CONFIG_SCHEMA_FILE_NAME = "config.schema.json";
-const APP_MANIFEST_SCHEMA_FILE_NAME = "manifest.schema.json";
+__name(getManifests, "getManifests");
+
+// src/distribution/create-public-files.ts
+var PUBLIC_DIR_NAME = "public";
+var MANIFESTS_FILE_NAME = "manifests.json";
+var COOKIE_POLICY_FILE_NAME = "cookie-policy.html";
+var APP_CONFIG_SCHEMA_FILE_NAME = "config.schema.json";
+var APP_MANIFEST_SCHEMA_FILE_NAME = "manifest.schema.json";
 async function createPublicDistributionFiles() {
   const pkgJson = getPkgJson();
   const manifests = await getManifests(pkgJson);
@@ -503,12 +677,8 @@ async function createPublicDistributionFiles() {
     const validationResult = validate(manifest, schemas.appManifest);
     if (validationResult.errors.length) {
       const errors = validationResult.errors.map((e) => JSON.stringify(e, null, 2));
-      throw new Error(
-        `Validation of app manifest for app '${appName}' failed with the following errors:
-${errors.join(
-          "\n"
-        )}`
-      );
+      throw new Error(`Validation of app manifest for app '${appName}' failed with the following errors:
+${errors.join("\n")}`);
     }
   }
   const publicDirPath = resolve(process.cwd(), PUBLIC_DIR_NAME);
@@ -524,8 +694,9 @@ ${errors.join(
   writeFileSync(appConfigSchemaFilePath, JSON.stringify(schemas.appConfig));
   writeFileSync(appManifestSchemaFilePath, JSON.stringify(schemas.appManifest));
 }
-
-var GatewayErrorCodes = /* @__PURE__ */ ((GatewayErrorCodes2) => {
+__name(createPublicDistributionFiles, "createPublicDistributionFiles");
+var GatewayErrorCodes;
+(function(GatewayErrorCodes2) {
   GatewayErrorCodes2[GatewayErrorCodes2["NoObjectId"] = 10001] = "NoObjectId";
   GatewayErrorCodes2[GatewayErrorCodes2["NoTargetAppHeader"] = 10002] = "NoTargetAppHeader";
   GatewayErrorCodes2[GatewayErrorCodes2["NoTargetWorkspaceHeader"] = 10003] = "NoTargetWorkspaceHeader";
@@ -538,145 +709,158 @@ var GatewayErrorCodes = /* @__PURE__ */ ((GatewayErrorCodes2) => {
   GatewayErrorCodes2[GatewayErrorCodes2["NoWorkspaceInRequestContext"] = 10010] = "NoWorkspaceInRequestContext";
   GatewayErrorCodes2[GatewayErrorCodes2["NoUserPermissionsInRequestContext"] = 10012] = "NoUserPermissionsInRequestContext";
   GatewayErrorCodes2[GatewayErrorCodes2["WorkspacePermissionDenied"] = 10013] = "WorkspacePermissionDenied";
-  return GatewayErrorCodes2;
-})(GatewayErrorCodes || {});
-var DatabasesErrorCodes = /* @__PURE__ */ ((DatabasesErrorCodes2) => {
+})(GatewayErrorCodes || (GatewayErrorCodes = {}));
+var DatabasesErrorCodes;
+(function(DatabasesErrorCodes2) {
   DatabasesErrorCodes2[DatabasesErrorCodes2["NoPublicKey"] = 11e3] = "NoPublicKey";
   DatabasesErrorCodes2[DatabasesErrorCodes2["NoAuthHeader"] = 11001] = "NoAuthHeader";
   DatabasesErrorCodes2[DatabasesErrorCodes2["FailedFileStore"] = 11002] = "FailedFileStore";
   DatabasesErrorCodes2[DatabasesErrorCodes2["FailedFileRead"] = 11003] = "FailedFileRead";
   DatabasesErrorCodes2[DatabasesErrorCodes2["NoRecord"] = 11004] = "NoRecord";
   DatabasesErrorCodes2[DatabasesErrorCodes2["UniqueConstrain"] = 11005] = "UniqueConstrain";
-  return DatabasesErrorCodes2;
-})(DatabasesErrorCodes || {});
-var PortalErrorCodes = /* @__PURE__ */ ((PortalErrorCodes2) => {
+})(DatabasesErrorCodes || (DatabasesErrorCodes = {}));
+var PortalErrorCodes;
+(function(PortalErrorCodes2) {
   PortalErrorCodes2[PortalErrorCodes2["NoObjectId"] = 12e3] = "NoObjectId";
-  return PortalErrorCodes2;
-})(PortalErrorCodes || {});
-const allianceErrors = {
+})(PortalErrorCodes || (PortalErrorCodes = {}));
+var allianceErrors = {
   // gateway
-  [10001 /* NoObjectId */]: {
+  [10001]: {
     httpCode: HttpStatus.UNAUTHORIZED,
     message: "No object id available on authenticated user."
   },
-  [10002 /* NoTargetAppHeader */]: {
+  [10002]: {
     httpCode: HttpStatus.BAD_REQUEST,
     message: `Request missing header '${AllianceHeaders.TargetApp}'.`
   },
-  [10003 /* NoTargetWorkspaceHeader */]: {
+  [10003]: {
     httpCode: HttpStatus.BAD_REQUEST,
     message: `Request missing header '${AllianceHeaders.TargetWorkspace}'.`
   },
-  [10004 /* NoManifestsInCache */]: {
+  [10004]: {
     httpCode: HttpStatus.INTERNAL_SERVER_ERROR,
     message: "App manifests missing in cache."
   },
-  [10005 /* NoDevSessionInCache */]: {
+  [10005]: {
     httpCode: HttpStatus.INTERNAL_SERVER_ERROR,
     message: "No dev session in memory cache."
   },
-  [10006 /* NoManifest */]: {
+  [10006]: {
     httpCode: HttpStatus.INTERNAL_SERVER_ERROR,
     message: "Could not find manifest for app '{{appSlug}}'."
   },
-  [10007 /* NoRequestContext */]: {
+  [10007]: {
     httpCode: HttpStatus.INTERNAL_SERVER_ERROR,
     message: "No request context."
   },
-  [10008 /* NoUserInRequestContext */]: {
+  [10008]: {
     httpCode: HttpStatus.INTERNAL_SERVER_ERROR,
     message: "No user in request context."
   },
-  [10009 /* NoAppInRequestContext */]: {
+  [10009]: {
     httpCode: HttpStatus.INTERNAL_SERVER_ERROR,
     message: "No app in request context."
   },
-  [10010 /* NoWorkspaceInRequestContext */]: {
+  [10010]: {
     httpCode: HttpStatus.INTERNAL_SERVER_ERROR,
     message: "No workspace in request context."
   },
-  [10012 /* NoUserPermissionsInRequestContext */]: {
+  [10012]: {
     httpCode: HttpStatus.INTERNAL_SERVER_ERROR,
     message: "No user permissions in request context."
   },
-  [10013 /* WorkspacePermissionDenied */]: {
+  [10013]: {
     httpCode: HttpStatus.FORBIDDEN,
     message: "User does not have access to the current workspace."
   },
   // databases
-  [11e3 /* NoPublicKey */]: {
+  [11e3]: {
     httpCode: HttpStatus.UNAUTHORIZED,
     message: "No public key available to decode JWT."
   },
-  [11001 /* NoAuthHeader */]: {
+  [11001]: {
     httpCode: HttpStatus.UNAUTHORIZED,
     message: "No authorization header found."
   },
-  [11002 /* FailedFileStore */]: {
+  [11002]: {
     httpCode: HttpStatus.INTERNAL_SERVER_ERROR,
     message: "Error storing file."
   },
-  [11003 /* FailedFileRead */]: {
+  [11003]: {
     httpCode: HttpStatus.INTERNAL_SERVER_ERROR,
     message: "Error reading file."
   },
-  [11004 /* NoRecord */]: {
+  [11004]: {
     httpCode: HttpStatus.INTERNAL_SERVER_ERROR,
     message: "Missing database record."
   },
-  [11005 /* UniqueConstrain */]: {
+  [11005]: {
     httpCode: HttpStatus.CONFLICT,
     message: "Field has to be unique."
   },
   // portal
-  [12e3 /* NoObjectId */]: {
+  [12e3]: {
     httpCode: HttpStatus.UNAUTHORIZED,
     message: "No object id found in user claims."
   }
 };
 
-function parseTemplates$1(message, variables) {
+// src/exceptions/alliance-gql.exception.ts
+function parseTemplates(message, variables) {
   return Object.entries(variables).reduce((acc, [key, value]) => {
     return acc.replaceAll(`{{${key}}}`, value);
   }, message);
 }
-class AllianceGqlException extends GraphQLError {
+__name(parseTemplates, "parseTemplates");
+var AllianceGqlException = class extends GraphQLError {
+  static {
+    __name(this, "AllianceGqlException");
+  }
+  info;
+  code;
   constructor(code, variables = {}, extensions) {
     const { message } = allianceErrors[code];
-    super(parseTemplates$1(message, variables), {
+    super(parseTemplates(message, variables), {
       extensions
     });
     this.code = code;
     this.info = `https://github.com/telia-company/ace-alliance-sdk/wiki/error-codes#${code}`;
   }
-}
-
-function parseTemplates(message, variables) {
+};
+function parseTemplates2(message, variables) {
   return Object.entries(variables).reduce((acc, [key, value]) => {
     return acc.replaceAll(`{{${key}}}`, value);
   }, message);
 }
-class AllianceException extends HttpException {
+__name(parseTemplates2, "parseTemplates");
+var AllianceException = class extends HttpException {
+  static {
+    __name(this, "AllianceException");
+  }
+  info;
+  code;
   constructor(code, variables = {}) {
     const { message, httpCode } = allianceErrors[code];
-    super(parseTemplates(message, variables), httpCode);
+    super(parseTemplates2(message, variables), httpCode);
     this.code = code;
     this.info = `https://github.com/telia-company/ace-alliance-sdk/wiki/error-codes#${code}`;
   }
-}
-
-var __defProp$2 = Object.defineProperty;
-var __getOwnPropDesc$2 = Object.getOwnPropertyDescriptor;
-var __decorateClass$2 = (decorators, target, key, kind) => {
-  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$2(target, key) : target;
-  for (var i = decorators.length - 1, decorator; i >= 0; i--)
-    if (decorator = decorators[i])
-      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
-  if (kind && result)
-    __defProp$2(target, key, result);
-  return result;
 };
-let AllianceExceptionFilter = class {
+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");
+var AllianceExceptionFilter = class AllianceExceptionFilter2 {
+  static {
+    __name(this, "AllianceExceptionFilter");
+  }
   catch(exception, host) {
     const ctx = host.switchToHttp();
     const response = ctx.getResponse();
@@ -689,23 +873,36 @@ let AllianceExceptionFilter = class {
     });
   }
 };
-AllianceExceptionFilter = __decorateClass$2([
+AllianceExceptionFilter = _ts_decorate([
   Catch(AllianceException)
 ], AllianceExceptionFilter);
-
-var __defProp$1 = Object.defineProperty;
-var __getOwnPropDesc$1 = Object.getOwnPropertyDescriptor;
-var __decorateClass$1 = (decorators, target, key, kind) => {
-  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$1(target, key) : target;
-  for (var i = decorators.length - 1, decorator; i >= 0; i--)
-    if (decorator = decorators[i])
-      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
-  if (kind && result)
-    __defProp$1(target, key, result);
-  return result;
-};
-var __decorateParam = (index, decorator) => (target, key) => decorator(target, key, index);
-let LoggerService = class {
+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");
+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 LoggerService = class LoggerService2 {
+  static {
+    __name(this, "LoggerService");
+  }
+  logger;
   constructor(logger) {
     this.logger = logger;
     this.log = (...args) => this.logger.info(...args);
@@ -716,32 +913,51 @@ let LoggerService = class {
     this.error = (...args) => this.logger.error(...args);
     this.fatal = (...args) => this.logger.fatal(...args);
   }
+  log;
+  trace;
+  debug;
+  info;
+  warn;
+  error;
+  fatal;
 };
-LoggerService = __decorateClass$1([
+LoggerService = _ts_decorate2([
   Injectable(),
-  __decorateParam(0, InjectPinoLogger())
+  _ts_param(0, InjectPinoLogger()),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    typeof PinoLogger === "undefined" ? Object : PinoLogger
+  ])
 ], LoggerService);
 
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __decorateClass = (decorators, target, key, kind) => {
-  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
-  for (var i = decorators.length - 1, decorator; i >= 0; i--)
-    if (decorator = decorators[i])
-      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
-  if (kind && result)
-    __defProp(target, key, result);
-  return result;
-};
-let LoggerModule = class {
+// src/logging/logging.module.ts
+function _ts_decorate3(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_decorate3, "_ts_decorate");
+var LoggerModule = class LoggerModule2 {
+  static {
+    __name(this, "LoggerModule");
+  }
   static forRoot({ logLevel, redact = true } = {}) {
     return {
-      module: LoggerModule,
+      module: LoggerModule2,
       controllers: [],
       imports: [
         LoggerModule$1.forRootAsync({
-          imports: [ConfigModule],
-          inject: [ConfigService],
+          imports: [
+            ConfigModule
+          ],
+          inject: [
+            ConfigService
+          ],
           useFactory: async (configService) => ({
             pinoHttp: {
               level: logLevel || configService.get(SharedConfigKeys.ServiceLogLevel) || "silent",
@@ -756,53 +972,32 @@ let LoggerModule = class {
         })
       ],
       global: true,
-      providers: [LoggerService],
+      providers: [
+        LoggerService
+      ],
       exports: []
     };
   }
 };
-LoggerModule = __decorateClass([
+LoggerModule = _ts_decorate3([
   Module({
-    providers: [LoggerService],
-    exports: [LoggerService]
+    providers: [
+      LoggerService
+    ],
+    exports: [
+      LoggerService
+    ]
   })
 ], LoggerModule);
-
 function slugify(name) {
-  return _slugify(name, { strict: true, replacement: "-", lower: true });
-}
-
-function viteCssImportPlugin(outFilePath, relativePath = false) {
-  return {
-    name: "vite-plugin-css-import",
-    apply: "build",
-    enforce: "post",
-    writeBundle: async (_, bundle) => {
-      const cssFiles = Object.keys(bundle).filter((fileName) => fileName.endsWith(".css"));
-      if (!cssFiles.length) {
-        return;
-      }
-      const tempTargetFilePath = resolve(process.cwd(), `${outFilePath}-temp.js`);
-      const targetFilePath = resolve(process.cwd(), `${outFilePath}.js`);
-      const cssImportStatement = cssFiles.reduce((acc, cssFile) => {
-        if (relativePath) {
-          const targetDirname = dirname(targetFilePath);
-          const relativePath2 = relative(targetDirname, cssFile);
-          return `${acc}import "${relativePath2.replaceAll("\\", "/")}";
-`;
-        }
-        return `${acc}import "./${cssFile}";
-`;
-      }, "");
-      const writeStream = createWriteStream(tempTargetFilePath);
-      writeStream.write(cssImportStatement, "utf8");
-      const readStream = createReadStream(targetFilePath);
-      await pipeline(readStream, writeStream);
-      rmSync(targetFilePath, { force: true });
-      renameSync(tempTargetFilePath, targetFilePath);
-      writeStream.end();
-    }
-  };
+  return _slugify(name, {
+    strict: true,
+    replacement: "-",
+    lower: true
+  });
 }
+__name(slugify, "slugify");
 
-export { AllianceException, AllianceExceptionFilter, AllianceGqlException, AllianceHeaders, DatabasesErrorCodes, GatewayErrorCodes, LoggerModule, LoggerService, PortalErrorCodes, SharedConfigKeys, authMiddleware, createBearerToken, createPublicDistributionFiles, createSystemUserToken, getAppManifests, getPrivateKey, slugify, viteCssImportPlugin };
+export { AllianceException, AllianceExceptionFilter, AllianceGqlException, AllianceHeaders, DatabasesErrorCodes, GatewayErrorCodes, LoggerModule, LoggerService, PortalErrorCodes, SharedConfigKeys, authMiddleware, createBearerToken, createPublicDistributionFiles, createSystemUserToken, getAppManifests, getPrivateKey, slugify };
+//# sourceMappingURL=out.js.map
+//# sourceMappingURL=index.js.map