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

package/dist/index.cjs

@@ -1,25 +1,201 @@
 'use strict';
 
-const nestjsPino = require('nestjs-pino');
-const RedisStore = require('connect-redis');
-const expressOpenidConnect = require('express-openid-connect');
-const redis = require('redis');
-const jsonwebtoken = require('jsonwebtoken');
-const jsonschema = require('jsonschema');
-const node_path = require('node:path');
-const node_fs = require('node:fs');
-const graphql = require('graphql');
-const common = require('@nestjs/common');
-const config = require('@nestjs/config');
-const _slugify = require('slugify');
-const promises = require('node:stream/promises');
+var nestjsPino = require('nestjs-pino');
+var expressSession = require('express-session');
+var expressOpenidConnect = require('express-openid-connect');
+var redis = require('redis');
+var jsonwebtoken = require('jsonwebtoken');
+var jsonschema = require('jsonschema');
+var fs = require('fs');
+var path = require('path');
+var graphql = require('graphql');
+var common = require('@nestjs/common');
+var config = require('@nestjs/config');
+var _slugify = require('slugify');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var _slugify__default = /*#__PURE__*/_interopDefault(_slugify);
 
-function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e.default : e; }
-
-const RedisStore__default = /*#__PURE__*/_interopDefaultCompat(RedisStore);
-const _slugify__default = /*#__PURE__*/_interopDefaultCompat(_slugify);
+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 expressSession.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;
 
-var SharedConfigKeys = /* @__PURE__ */ ((SharedConfigKeys2) => {
+// src/constants/config.ts
+exports.SharedConfigKeys = void 0;
+(function(SharedConfigKeys2) {
   SharedConfigKeys2["AuthCookieName"] = "AUTH_COOKIE_NAME";
   SharedConfigKeys2["AuthCookieSecret"] = "AUTH_COOKIE_SECRET";
   SharedConfigKeys2["DbEndpoint"] = "DB_ENDPOINT";
@@ -28,33 +204,30 @@ var SharedConfigKeys = /* @__PURE__ */ ((SharedConfigKeys2) => {
   SharedConfigKeys2["ServicePort"] = "SERVICE_PORT";
   SharedConfigKeys2["RedisHost"] = "REDIS_HOST";
   SharedConfigKeys2["RedisPassword"] = "REDIS_PASSWORD";
-  return SharedConfigKeys2;
-})(SharedConfigKeys || {});
+})(exports.SharedConfigKeys || (exports.SharedConfigKeys = {}));
 
-var AllianceHeaders = /* @__PURE__ */ ((AllianceHeaders2) => {
+// src/constants/headers.ts
+exports.AllianceHeaders = void 0;
+(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 = redis.createClient({
-    url: configService.getOrThrow(SharedConfigKeys.RedisHost),
-    password: configService.get(SharedConfigKeys.RedisPassword)
-  });
-  redisClient.connect().catch(console.error);
-  const redisStore = new RedisStore__default({
-    client: redisClient
-  });
+})(exports.AllianceHeaders || (exports.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(exports.SharedConfigKeys.RedisHost);
+  if (redisHostUrl) {
+    const redisClient = redis.createClient({
+      url: configService.getOrThrow(exports.SharedConfigKeys.RedisHost),
+      password: configService.get(exports.SharedConfigKeys.RedisPassword)
+    });
+    redisClient.connect().catch(console.error);
+    store = new esm_default({
+      client: redisClient
+    });
+  }
   return expressOpenidConnect.auth({
     baseURL,
     clientSecret,
@@ -63,50 +236,46 @@ function authMiddleware(configService, {
     authorizationParams,
     afterCallback,
     issuerBaseURL,
-    secret: configService.getOrThrow(SharedConfigKeys.AuthCookieSecret),
+    secret: configService.getOrThrow(exports.SharedConfigKeys.AuthCookieSecret),
     session: {
-      name: configService.getOrThrow(SharedConfigKeys.AuthCookieName),
-      store: redisStore
+      name: configService.getOrThrow(exports.SharedConfigKeys.AuthCookieName),
+      // @ts-ignore
+      store,
+      cookie: {
+        path: sessionCookiePath
+      }
     },
     routes: {
       callback: "/signin-oidc"
     }
   });
 }
-
-function createBearerToken({
-  privateKey,
-  aud,
-  sub,
-  name,
-  user,
-  workspace
-}) {
-  const jwt = jsonwebtoken.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 = jsonwebtoken.sign({
+    iss: "Alliance",
+    aud,
+    sub,
+    name,
+    "https://alliance.teliacompany.net/user_type": user.type,
+    "https://alliance.teliacompany.net/user_email": user.email,
+    "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);
+  const privateKey = configService.getOrThrow(exports.SharedConfigKeys.JwtPrivateKey);
   return "-----BEGIN RSA PRIVATE KEY-----\n" + privateKey + "\n-----END RSA PRIVATE KEY-----";
 }
+__name(getPrivateKey, "getPrivateKey");
 function createSystemUserToken(configService) {
   return createBearerToken({
     aud: "system",
@@ -118,12 +287,15 @@ function createSystemUserToken(configService) {
     },
     user: {
       type: "system",
-      permissions: []
+      permissions: [],
+      email: "system"
     },
     privateKey: getPrivateKey(configService)
   });
 }
+__name(createSystemUserToken, "createSystemUserToken");
 
+// src/distribution/cookie-policy.ts
 function generateCookiePolicyHtml(appManifests) {
   const cookiePolicyTableRows = [];
   for (const appName in appManifests) {
@@ -138,8 +310,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>`);
@@ -148,7 +323,8 @@ function createCookiePolicyTableRow(key, claimEntry) {
   rows.push("</tr>");
   return rows.join("");
 }
-const cookiePolicyHtml = `
+__name(createCookiePolicyTableRow, "createCookiePolicyTableRow");
+var cookiePolicyHtml = `
 <!DOCTYPE html>
 <html lang="en">
     <head>
@@ -436,18 +612,12 @@ const cookiePolicyHtml = `
     </body>
 </html>
 `;
-
 function getJsonSchemas() {
-  const frameworkDistDirPath = node_path.resolve(
-    process.cwd(),
-    "node_modules",
-    "@telia-ace/alliance-framework",
-    "dist"
-  );
-  const appConfigSchemaPath = node_path.resolve(frameworkDistDirPath, "config.schema.json");
-  const appManifestSchemaPath = node_path.resolve(frameworkDistDirPath, "manifest.schema.json");
-  const appConfigSchemaFile = node_fs.readFileSync(appConfigSchemaPath).toString();
-  const appManifestSchemaFile = node_fs.readFileSync(appManifestSchemaPath).toString();
+  const frameworkDistDirPath = path.resolve(process.cwd(), "node_modules", "@telia-ace/alliance-framework", "dist");
+  const appConfigSchemaPath = path.resolve(frameworkDistDirPath, "config.schema.json");
+  const appManifestSchemaPath = path.resolve(frameworkDistDirPath, "manifest.schema.json");
+  const appConfigSchemaFile = fs.readFileSync(appConfigSchemaPath).toString();
+  const appManifestSchemaFile = fs.readFileSync(appManifestSchemaPath).toString();
   const appConfig = JSON.parse(appConfigSchemaFile);
   const appManifest = JSON.parse(appManifestSchemaFile);
   return {
@@ -455,14 +625,17 @@ function getJsonSchemas() {
     appManifest
   };
 }
-
+__name(getJsonSchemas, "getJsonSchemas");
 async function createTempModuleAndImport(moduleString, fileName) {
-  const file = node_path.resolve(process.cwd(), `${fileName}.mjs`);
-  node_fs.writeFileSync(file, moduleString);
+  const file = path.resolve(process.cwd(), `${fileName}.mjs`);
+  fs.writeFileSync(file, moduleString);
   const importedModule = await import(`file:///${file}`);
-  node_fs.rmSync(file, { force: true });
+  fs.rmSync(file, {
+    force: true
+  });
   return importedModule;
 }
+__name(createTempModuleAndImport, "createTempModuleAndImport");
 async function getAppManifests(apps) {
   const moduleStringParts = [];
   const manifestImportVariables = [];
@@ -472,18 +645,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 = node_path.resolve(process.cwd(), "package.json");
-  const pkgJsonFile = node_fs.readFileSync(packageJson).toString();
+  const packageJson = path.resolve(process.cwd(), "package.json");
+  const pkgJsonFile = fs.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.");
@@ -494,12 +667,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);
@@ -509,29 +684,26 @@ async function createPublicDistributionFiles() {
     const validationResult = jsonschema.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 = node_path.resolve(process.cwd(), PUBLIC_DIR_NAME);
-  if (!node_fs.existsSync(publicDirPath)) {
-    node_fs.mkdirSync(publicDirPath);
+  const publicDirPath = path.resolve(process.cwd(), PUBLIC_DIR_NAME);
+  if (!fs.existsSync(publicDirPath)) {
+    fs.mkdirSync(publicDirPath);
   }
-  const manifestsFilePath = node_path.resolve(publicDirPath, MANIFESTS_FILE_NAME);
-  node_fs.writeFileSync(manifestsFilePath, JSON.stringify(manifests));
-  const cookiePolicyFilePath = node_path.resolve(publicDirPath, COOKIE_POLICY_FILE_NAME);
-  node_fs.writeFileSync(cookiePolicyFilePath, generateCookiePolicyHtml(manifests));
-  const appConfigSchemaFilePath = node_path.resolve(publicDirPath, APP_CONFIG_SCHEMA_FILE_NAME);
-  const appManifestSchemaFilePath = node_path.resolve(publicDirPath, APP_MANIFEST_SCHEMA_FILE_NAME);
-  node_fs.writeFileSync(appConfigSchemaFilePath, JSON.stringify(schemas.appConfig));
-  node_fs.writeFileSync(appManifestSchemaFilePath, JSON.stringify(schemas.appManifest));
+  const manifestsFilePath = path.resolve(publicDirPath, MANIFESTS_FILE_NAME);
+  fs.writeFileSync(manifestsFilePath, JSON.stringify(manifests));
+  const cookiePolicyFilePath = path.resolve(publicDirPath, COOKIE_POLICY_FILE_NAME);
+  fs.writeFileSync(cookiePolicyFilePath, generateCookiePolicyHtml(manifests));
+  const appConfigSchemaFilePath = path.resolve(publicDirPath, APP_CONFIG_SCHEMA_FILE_NAME);
+  const appManifestSchemaFilePath = path.resolve(publicDirPath, APP_MANIFEST_SCHEMA_FILE_NAME);
+  fs.writeFileSync(appConfigSchemaFilePath, JSON.stringify(schemas.appConfig));
+  fs.writeFileSync(appManifestSchemaFilePath, JSON.stringify(schemas.appManifest));
 }
-
-var GatewayErrorCodes = /* @__PURE__ */ ((GatewayErrorCodes2) => {
+__name(createPublicDistributionFiles, "createPublicDistributionFiles");
+exports.GatewayErrorCodes = void 0;
+(function(GatewayErrorCodes2) {
   GatewayErrorCodes2[GatewayErrorCodes2["NoObjectId"] = 10001] = "NoObjectId";
   GatewayErrorCodes2[GatewayErrorCodes2["NoTargetAppHeader"] = 10002] = "NoTargetAppHeader";
   GatewayErrorCodes2[GatewayErrorCodes2["NoTargetWorkspaceHeader"] = 10003] = "NoTargetWorkspaceHeader";
@@ -544,145 +716,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) => {
+})(exports.GatewayErrorCodes || (exports.GatewayErrorCodes = {}));
+exports.DatabasesErrorCodes = void 0;
+(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) => {
+})(exports.DatabasesErrorCodes || (exports.DatabasesErrorCodes = {}));
+exports.PortalErrorCodes = void 0;
+(function(PortalErrorCodes2) {
   PortalErrorCodes2[PortalErrorCodes2["NoObjectId"] = 12e3] = "NoObjectId";
-  return PortalErrorCodes2;
-})(PortalErrorCodes || {});
-const allianceErrors = {
+})(exports.PortalErrorCodes || (exports.PortalErrorCodes = {}));
+var allianceErrors = {
   // gateway
-  [10001 /* NoObjectId */]: {
+  [10001]: {
     httpCode: common.HttpStatus.UNAUTHORIZED,
     message: "No object id available on authenticated user."
   },
-  [10002 /* NoTargetAppHeader */]: {
+  [10002]: {
     httpCode: common.HttpStatus.BAD_REQUEST,
-    message: `Request missing header '${AllianceHeaders.TargetApp}'.`
+    message: `Request missing header '${exports.AllianceHeaders.TargetApp}'.`
   },
-  [10003 /* NoTargetWorkspaceHeader */]: {
+  [10003]: {
     httpCode: common.HttpStatus.BAD_REQUEST,
-    message: `Request missing header '${AllianceHeaders.TargetWorkspace}'.`
+    message: `Request missing header '${exports.AllianceHeaders.TargetWorkspace}'.`
   },
-  [10004 /* NoManifestsInCache */]: {
+  [10004]: {
     httpCode: common.HttpStatus.INTERNAL_SERVER_ERROR,
     message: "App manifests missing in cache."
   },
-  [10005 /* NoDevSessionInCache */]: {
+  [10005]: {
     httpCode: common.HttpStatus.INTERNAL_SERVER_ERROR,
     message: "No dev session in memory cache."
   },
-  [10006 /* NoManifest */]: {
+  [10006]: {
     httpCode: common.HttpStatus.INTERNAL_SERVER_ERROR,
     message: "Could not find manifest for app '{{appSlug}}'."
   },
-  [10007 /* NoRequestContext */]: {
+  [10007]: {
     httpCode: common.HttpStatus.INTERNAL_SERVER_ERROR,
     message: "No request context."
   },
-  [10008 /* NoUserInRequestContext */]: {
+  [10008]: {
     httpCode: common.HttpStatus.INTERNAL_SERVER_ERROR,
     message: "No user in request context."
   },
-  [10009 /* NoAppInRequestContext */]: {
+  [10009]: {
     httpCode: common.HttpStatus.INTERNAL_SERVER_ERROR,
     message: "No app in request context."
   },
-  [10010 /* NoWorkspaceInRequestContext */]: {
+  [10010]: {
     httpCode: common.HttpStatus.INTERNAL_SERVER_ERROR,
     message: "No workspace in request context."
   },
-  [10012 /* NoUserPermissionsInRequestContext */]: {
+  [10012]: {
     httpCode: common.HttpStatus.INTERNAL_SERVER_ERROR,
     message: "No user permissions in request context."
   },
-  [10013 /* WorkspacePermissionDenied */]: {
+  [10013]: {
     httpCode: common.HttpStatus.FORBIDDEN,
     message: "User does not have access to the current workspace."
   },
   // databases
-  [11e3 /* NoPublicKey */]: {
+  [11e3]: {
     httpCode: common.HttpStatus.UNAUTHORIZED,
     message: "No public key available to decode JWT."
   },
-  [11001 /* NoAuthHeader */]: {
+  [11001]: {
     httpCode: common.HttpStatus.UNAUTHORIZED,
     message: "No authorization header found."
   },
-  [11002 /* FailedFileStore */]: {
+  [11002]: {
     httpCode: common.HttpStatus.INTERNAL_SERVER_ERROR,
     message: "Error storing file."
   },
-  [11003 /* FailedFileRead */]: {
+  [11003]: {
     httpCode: common.HttpStatus.INTERNAL_SERVER_ERROR,
     message: "Error reading file."
   },
-  [11004 /* NoRecord */]: {
+  [11004]: {
     httpCode: common.HttpStatus.INTERNAL_SERVER_ERROR,
     message: "Missing database record."
   },
-  [11005 /* UniqueConstrain */]: {
+  [11005]: {
     httpCode: common.HttpStatus.CONFLICT,
     message: "Field has to be unique."
   },
   // portal
-  [12e3 /* NoObjectId */]: {
+  [12e3]: {
     httpCode: common.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 graphql.GraphQLError {
+__name(parseTemplates, "parseTemplates");
+var AllianceGqlException = class extends graphql.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 common.HttpException {
+__name(parseTemplates2, "parseTemplates");
+var AllianceException = class extends common.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;
 };
-exports.AllianceExceptionFilter = class AllianceExceptionFilter {
+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");
+exports.AllianceExceptionFilter = class AllianceExceptionFilter2 {
+  static {
+    __name(this, "AllianceExceptionFilter");
+  }
   catch(exception, host) {
     const ctx = host.switchToHttp();
     const response = ctx.getResponse();
@@ -695,23 +880,36 @@ exports.AllianceExceptionFilter = class AllianceExceptionFilter {
     });
   }
 };
-exports.AllianceExceptionFilter = __decorateClass$2([
+exports.AllianceExceptionFilter = _ts_decorate([
   common.Catch(AllianceException)
 ], exports.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);
-exports.LoggerService = class LoggerService {
+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");
+exports.LoggerService = class LoggerService2 {
+  static {
+    __name(this, "LoggerService");
+  }
+  logger;
   constructor(logger) {
     this.logger = logger;
     this.log = (...args) => this.logger.info(...args);
@@ -722,35 +920,54 @@ exports.LoggerService = class LoggerService {
     this.error = (...args) => this.logger.error(...args);
     this.fatal = (...args) => this.logger.fatal(...args);
   }
+  log;
+  trace;
+  debug;
+  info;
+  warn;
+  error;
+  fatal;
 };
-exports.LoggerService = __decorateClass$1([
+exports.LoggerService = _ts_decorate2([
   common.Injectable(),
-  __decorateParam(0, nestjsPino.InjectPinoLogger())
+  _ts_param(0, nestjsPino.InjectPinoLogger()),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    typeof nestjsPino.PinoLogger === "undefined" ? Object : nestjsPino.PinoLogger
+  ])
 ], exports.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;
-};
-exports.LoggerModule = class LoggerModule {
+// 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");
+exports.LoggerModule = class LoggerModule2 {
+  static {
+    __name(this, "LoggerModule");
+  }
   static forRoot({ logLevel, redact = true } = {}) {
     return {
-      module: exports.LoggerModule,
+      module: LoggerModule2,
       controllers: [],
       imports: [
         nestjsPino.LoggerModule.forRootAsync({
-          imports: [config.ConfigModule],
-          inject: [config.ConfigService],
+          imports: [
+            config.ConfigModule
+          ],
+          inject: [
+            config.ConfigService
+          ],
           useFactory: async (configService) => ({
             pinoHttp: {
-              level: logLevel || configService.get(SharedConfigKeys.ServiceLogLevel) || "silent",
+              level: logLevel || configService.get(exports.SharedConfigKeys.ServiceLogLevel) || "silent",
               redact: redact ? [
                 "authorization",
                 "headers.authorization",
@@ -762,63 +979,38 @@ exports.LoggerModule = class LoggerModule {
         })
       ],
       global: true,
-      providers: [exports.LoggerService],
+      providers: [
+        exports.LoggerService
+      ],
       exports: []
     };
   }
 };
-exports.LoggerModule = __decorateClass([
+exports.LoggerModule = _ts_decorate3([
   common.Module({
-    providers: [exports.LoggerService],
-    exports: [exports.LoggerService]
+    providers: [
+      exports.LoggerService
+    ],
+    exports: [
+      exports.LoggerService
+    ]
   })
 ], exports.LoggerModule);
-
 function slugify(name) {
-  return _slugify__default(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 = node_path.resolve(process.cwd(), `${outFilePath}-temp.js`);
-      const targetFilePath = node_path.resolve(process.cwd(), `${outFilePath}.js`);
-      const cssImportStatement = cssFiles.reduce((acc, cssFile) => {
-        if (relativePath) {
-          const targetDirname = node_path.dirname(targetFilePath);
-          const relativePath2 = node_path.relative(targetDirname, cssFile);
-          return `${acc}import "${relativePath2.replaceAll("\\", "/")}";
-`;
-        }
-        return `${acc}import "./${cssFile}";
-`;
-      }, "");
-      const writeStream = node_fs.createWriteStream(tempTargetFilePath);
-      writeStream.write(cssImportStatement, "utf8");
-      const readStream = node_fs.createReadStream(targetFilePath);
-      await promises.pipeline(readStream, writeStream);
-      node_fs.rmSync(targetFilePath, { force: true });
-      node_fs.renameSync(tempTargetFilePath, targetFilePath);
-      writeStream.end();
-    }
-  };
+  return _slugify__default.default(name, {
+    strict: true,
+    replacement: "-",
+    lower: true
+  });
 }
+__name(slugify, "slugify");
 
-exports.LoggerErrorInterceptor = nestjsPino.LoggerErrorInterceptor;
+Object.defineProperty(exports, 'LoggerErrorInterceptor', {
+  enumerable: true,
+  get: function () { return nestjsPino.LoggerErrorInterceptor; }
+});
 exports.AllianceException = AllianceException;
 exports.AllianceGqlException = AllianceGqlException;
-exports.AllianceHeaders = AllianceHeaders;
-exports.DatabasesErrorCodes = DatabasesErrorCodes;
-exports.GatewayErrorCodes = GatewayErrorCodes;
-exports.PortalErrorCodes = PortalErrorCodes;
-exports.SharedConfigKeys = SharedConfigKeys;
 exports.authMiddleware = authMiddleware;
 exports.createBearerToken = createBearerToken;
 exports.createPublicDistributionFiles = createPublicDistributionFiles;
@@ -826,4 +1018,5 @@ exports.createSystemUserToken = createSystemUserToken;
 exports.getAppManifests = getAppManifests;
 exports.getPrivateKey = getPrivateKey;
 exports.slugify = slugify;
-exports.viteCssImportPlugin = viteCssImportPlugin;
+//# sourceMappingURL=out.js.map
+//# sourceMappingURL=index.cjs.map