@boxyhq/saml-jackson 0.2.3-beta.236 → 0.2.3-beta.241

package/dist/db/sql/sql.d.ts

@@ -0,0 +1,20 @@
+import { DatabaseDriver, DatabaseOption, Index, Encrypted } from '../../typings';
+declare class Sql implements DatabaseDriver {
+    private options;
+    private connection;
+    private storeRepository;
+    private indexRepository;
+    private ttlRepository;
+    private ttlCleanup;
+    private timerId;
+    constructor(options: DatabaseOption);
+    init(): Promise<Sql>;
+    get(namespace: string, key: string): Promise<any>;
+    getByIndex(namespace: string, idx: Index): Promise<any>;
+    put(namespace: string, key: string, val: Encrypted, ttl?: number, ...indexes: any[]): Promise<void>;
+    delete(namespace: string, key: string): Promise<any>;
+}
+declare const _default: {
+    new: (options: DatabaseOption) => Promise<Sql>;
+};
+export default _default;

package/dist/db/sql/sql.js

@@ -0,0 +1,174 @@
+"use strict";
+/*eslint no-constant-condition: ["error", { "checkLoops": false }]*/
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (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 __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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+require('reflect-metadata');
+const typeorm_1 = require("typeorm");
+const dbutils = __importStar(require("../utils"));
+const JacksonStore_1 = require("./entity/JacksonStore");
+const JacksonIndex_1 = require("./entity/JacksonIndex");
+const JacksonTTL_1 = require("./entity/JacksonTTL");
+class Sql {
+    constructor(options) {
+        this.options = options;
+    }
+    init() {
+        return __awaiter(this, void 0, void 0, function* () {
+            while (true) {
+                try {
+                    this.connection = yield (0, typeorm_1.createConnection)({
+                        name: this.options.type + Math.floor(Math.random() * 100000),
+                        type: this.options.type,
+                        url: this.options.url,
+                        synchronize: true,
+                        migrationsTableName: '_jackson_migrations',
+                        logging: ['error'],
+                        entities: [JacksonStore_1.JacksonStore, JacksonIndex_1.JacksonIndex, JacksonTTL_1.JacksonTTL],
+                    });
+                    break;
+                }
+                catch (err) {
+                    console.error(`error connecting to ${this.options.type} db: ${err}`);
+                    yield dbutils.sleep(1000);
+                    continue;
+                }
+            }
+            this.storeRepository = this.connection.getRepository(JacksonStore_1.JacksonStore);
+            this.indexRepository = this.connection.getRepository(JacksonIndex_1.JacksonIndex);
+            this.ttlRepository = this.connection.getRepository(JacksonTTL_1.JacksonTTL);
+            if (this.options.ttl && this.options.cleanupLimit) {
+                this.ttlCleanup = () => __awaiter(this, void 0, void 0, function* () {
+                    const now = Date.now();
+                    while (true) {
+                        const ids = yield this.ttlRepository
+                            .createQueryBuilder('jackson_ttl')
+                            .limit(this.options.cleanupLimit)
+                            .where('jackson_ttl.expiresAt <= :expiresAt', {
+                            expiresAt: now,
+                        })
+                            .getMany();
+                        if (ids.length <= 0) {
+                            break;
+                        }
+                        const delIds = ids.map((id) => {
+                            return id.key;
+                        });
+                        yield this.storeRepository.remove(ids);
+                        yield this.ttlRepository.delete(delIds);
+                    }
+                    this.timerId = setTimeout(this.ttlCleanup, this.options.ttl * 1000);
+                });
+                this.timerId = setTimeout(this.ttlCleanup, this.options.ttl * 1000);
+            }
+            else {
+                console.log('Warning: ttl cleanup not enabled, set both "ttl" and "cleanupLimit" options to enable it!');
+            }
+            return this;
+        });
+    }
+    get(namespace, key) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let res = yield this.storeRepository.findOne({
+                key: dbutils.key(namespace, key),
+            });
+            if (res && res.value) {
+                return {
+                    value: res.value,
+                    iv: res.iv,
+                    tag: res.tag,
+                };
+            }
+            return null;
+        });
+    }
+    getByIndex(namespace, idx) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const res = yield this.indexRepository.find({
+                key: dbutils.keyForIndex(namespace, idx),
+            });
+            const ret = [];
+            if (res) {
+                res.forEach((r) => {
+                    ret.push({
+                        value: r.store.value,
+                        iv: r.store.iv,
+                        tag: r.store.tag,
+                    });
+                });
+            }
+            return ret;
+        });
+    }
+    put(namespace, key, val, ttl = 0, ...indexes) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.connection.transaction((transactionalEntityManager) => __awaiter(this, void 0, void 0, function* () {
+                const dbKey = dbutils.key(namespace, key);
+                const store = new JacksonStore_1.JacksonStore();
+                store.key = dbKey;
+                store.value = val.value;
+                store.iv = val.iv;
+                store.tag = val.tag;
+                yield transactionalEntityManager.save(store);
+                if (ttl) {
+                    const ttlRec = new JacksonTTL_1.JacksonTTL();
+                    ttlRec.key = dbKey;
+                    ttlRec.expiresAt = Date.now() + ttl * 1000;
+                    yield transactionalEntityManager.save(ttlRec);
+                }
+                // no ttl support for secondary indexes
+                for (const idx of indexes || []) {
+                    const key = dbutils.keyForIndex(namespace, idx);
+                    const rec = yield this.indexRepository.findOne({
+                        key,
+                        storeKey: store.key,
+                    });
+                    if (!rec) {
+                        const ji = new JacksonIndex_1.JacksonIndex();
+                        ji.key = key;
+                        ji.store = store;
+                        yield transactionalEntityManager.save(ji);
+                    }
+                }
+            }));
+        });
+    }
+    delete(namespace, key) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.storeRepository.remove({
+                key: dbutils.key(namespace, key),
+            });
+        });
+    }
+}
+exports.default = {
+    new: (options) => __awaiter(void 0, void 0, void 0, function* () {
+        return yield new Sql(options).init();
+    }),
+};

package/dist/db/store.d.ts

@@ -0,0 +1,5 @@
+import { Storable } from '../typings';
+declare const _default: {
+    new: (namespace: string, db: any, ttl?: number) => Storable;
+};
+export default _default;

package/dist/db/store.js

@@ -0,0 +1,68 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (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 __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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const dbutils = __importStar(require("./utils"));
+class Store {
+    constructor(namespace, db, ttl = 0) {
+        this.namespace = namespace;
+        this.db = db;
+        this.ttl = ttl;
+    }
+    get(key) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.db.get(this.namespace, dbutils.keyDigest(key));
+        });
+    }
+    getByIndex(idx) {
+        return __awaiter(this, void 0, void 0, function* () {
+            idx.value = dbutils.keyDigest(idx.value);
+            return yield this.db.getByIndex(this.namespace, idx);
+        });
+    }
+    put(key, val, ...indexes) {
+        return __awaiter(this, void 0, void 0, function* () {
+            indexes = (indexes || []).map((idx) => {
+                idx.value = dbutils.keyDigest(idx.value);
+                return idx;
+            });
+            return yield this.db.put(this.namespace, dbutils.keyDigest(key), val, this.ttl, ...indexes);
+        });
+    }
+    delete(key) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.db.delete(this.namespace, dbutils.keyDigest(key));
+        });
+    }
+}
+exports.default = {
+    new: (namespace, db, ttl = 0) => {
+        return new Store(namespace, db, ttl);
+    },
+};

package/dist/db/utils.d.ts

@@ -0,0 +1,7 @@
+import { Index } from '../typings';
+export declare const key: (namespace: string, k: string) => string;
+export declare const keyForIndex: (namespace: string, idx: Index) => string;
+export declare const keyDigest: (k: string) => string;
+export declare const keyFromParts: (...parts: string[]) => string;
+export declare const sleep: (ms: number) => Promise<void>;
+export declare const indexPrefix = "_index";

package/dist/db/utils.js

@@ -0,0 +1,29 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.indexPrefix = exports.sleep = exports.keyFromParts = exports.keyDigest = exports.keyForIndex = exports.key = void 0;
+const ripemd160_1 = __importDefault(require("ripemd160"));
+const key = (namespace, k) => {
+    return namespace + ':' + k;
+};
+exports.key = key;
+const keyForIndex = (namespace, idx) => {
+    return (0, exports.key)((0, exports.key)(namespace, idx.name), idx.value);
+};
+exports.keyForIndex = keyForIndex;
+const keyDigest = (k) => {
+    return new ripemd160_1.default().update(k).digest('hex');
+};
+exports.keyDigest = keyDigest;
+const keyFromParts = (...parts) => {
+    // TODO: pick a better strategy, keys can collide now
+    return parts.join(':');
+};
+exports.keyFromParts = keyFromParts;
+const sleep = (ms) => {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+};
+exports.sleep = sleep;
+exports.indexPrefix = '_index';

package/dist/env.d.ts

@@ -0,0 +1,22 @@
+declare const env: {
+    hostUrl: string;
+    hostPort: number;
+    externalUrl: string;
+    samlPath: string;
+    samlAudience: string;
+    preLoadedConfig: string | undefined;
+    internalHostUrl: string;
+    internalHostPort: number;
+    apiKeys: string[];
+    idpEnabled: string | undefined;
+    db: {
+        engine: string | undefined;
+        url: string | undefined;
+        type: string | undefined;
+        ttl: string | undefined;
+        encryptionKey: string | undefined;
+        cleanupLimit: string | undefined;
+    };
+    useInternalServer: boolean;
+};
+export default env;

package/dist/env.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const hostUrl = process.env.HOST_URL || 'localhost';
+const hostPort = +(process.env.HOST_PORT || '5000');
+const externalUrl = process.env.EXTERNAL_URL || 'http://' + hostUrl + ':' + hostPort;
+const samlPath = process.env.SAML_PATH || '/oauth/saml';
+const internalHostUrl = process.env.INTERNAL_HOST_URL || 'localhost';
+const internalHostPort = +(process.env.INTERNAL_HOST_PORT || '6000');
+const apiKeys = (process.env.JACKSON_API_KEYS || '').split(',');
+const samlAudience = process.env.SAML_AUDIENCE || 'https://saml.boxyhq.com';
+const preLoadedConfig = process.env.PRE_LOADED_CONFIG;
+const idpEnabled = process.env.IDP_ENABLED;
+const db = {
+    engine: process.env.DB_ENGINE,
+    url: process.env.DB_URL,
+    type: process.env.DB_TYPE,
+    ttl: process.env.DB_TTL,
+    encryptionKey: process.env.DB_ENCRYPTION_KEY,
+    cleanupLimit: process.env.DB_CLEANUP_LIMIT,
+};
+const env = {
+    hostUrl,
+    hostPort,
+    externalUrl,
+    samlPath,
+    samlAudience,
+    preLoadedConfig,
+    internalHostUrl,
+    internalHostPort,
+    apiKeys,
+    idpEnabled,
+    db,
+    useInternalServer: !(hostUrl === internalHostUrl && hostPort === internalHostPort),
+};
+exports.default = env;

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+import { JacksonOption } from './typings';
+import { SAMLConfig } from './controller/api';
+import { OAuthController } from './controller/oauth';
+declare const controllers: (opts: JacksonOption) => Promise<{
+    apiController: SAMLConfig;
+    oauthController: OAuthController;
+}>;
+export default controllers;
+export * from './typings';

package/dist/index.js

@@ -0,0 +1,80 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const api_1 = require("./controller/api");
+const oauth_1 = require("./controller/oauth");
+const db_1 = __importDefault(require("./db/db"));
+const read_config_1 = __importDefault(require("./read-config"));
+const defaultOpts = (opts) => {
+    const newOpts = Object.assign({}, opts);
+    if (!newOpts.externalUrl) {
+        throw new Error('externalUrl is required');
+    }
+    if (!newOpts.samlPath) {
+        throw new Error('samlPath is required');
+    }
+    newOpts.samlAudience = newOpts.samlAudience || 'https://saml.boxyhq.com';
+    newOpts.preLoadedConfig = newOpts.preLoadedConfig || ''; // path to folder containing static SAML config that will be preloaded. This is useful for self-hosted deployments that only have to support a single tenant (or small number of known tenants).
+    newOpts.idpEnabled = newOpts.idpEnabled === true;
+    newOpts.db = newOpts.db || {};
+    newOpts.db.engine = newOpts.db.engine || 'sql';
+    newOpts.db.url =
+        newOpts.db.url || 'postgresql://postgres:postgres@localhost:5432/postgres';
+    newOpts.db.type = newOpts.db.type || 'postgres'; // Only needed if DB_ENGINE is sql.
+    newOpts.db.ttl = (newOpts.db.ttl || 300) * 1; // TTL for the code, session and token stores (in seconds)
+    newOpts.db.cleanupLimit = (newOpts.db.cleanupLimit || 1000) * 1; // Limit cleanup of TTL entries to this many items at a time
+    return newOpts;
+};
+const controllers = (opts) => __awaiter(void 0, void 0, void 0, function* () {
+    opts = defaultOpts(opts);
+    const db = yield db_1.default.new(opts.db);
+    const configStore = db.store('saml:config');
+    const sessionStore = db.store('oauth:session', opts.db.ttl);
+    const codeStore = db.store('oauth:code', opts.db.ttl);
+    const tokenStore = db.store('oauth:token', opts.db.ttl);
+    const apiController = new api_1.SAMLConfig({ configStore });
+    const oauthController = new oauth_1.OAuthController({
+        configStore,
+        sessionStore,
+        codeStore,
+        tokenStore,
+        opts,
+    });
+    // write pre-loaded config if present
+    if (opts.preLoadedConfig && opts.preLoadedConfig.length > 0) {
+        const configs = yield (0, read_config_1.default)(opts.preLoadedConfig);
+        for (const config of configs) {
+            yield apiController.config(config);
+            console.log(`loaded config for tenant "${config.tenant}" and product "${config.product}"`);
+        }
+    }
+    const type = opts.db.engine === 'sql' && opts.db.type ? ' Type: ' + opts.db.type : '';
+    console.log(`Using engine: ${opts.db.engine}.${type}`);
+    return {
+        apiController,
+        oauthController,
+    };
+});
+exports.default = controllers;
+__exportStar(require("./typings"), exports);

package/dist/jackson.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/jackson.js

@@ -0,0 +1,153 @@
+"use strict";
+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 });
+const cors_1 = __importDefault(require("cors"));
+const express_1 = __importDefault(require("express"));
+const utils_1 = require("./controller/utils");
+const env_1 = __importDefault(require("./env"));
+const index_1 = __importDefault(require("./index"));
+let apiController;
+let oauthController;
+const oauthPath = '/oauth';
+const apiPath = '/api/v1/saml';
+const app = (0, express_1.default)();
+app.use(express_1.default.json());
+app.use(express_1.default.urlencoded({ extended: true }));
+app.get(oauthPath + '/authorize', (req, res) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        // @ts-ignore
+        const { redirect_url } = yield oauthController.authorize(req.query);
+        res.redirect(redirect_url);
+    }
+    catch (err) {
+        const { message, statusCode = 500 } = err;
+        res.status(statusCode).send(message);
+    }
+}));
+app.post(env_1.default.samlPath, (req, res) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const { redirect_url } = yield oauthController.samlResponse(req.body);
+        res.redirect(redirect_url);
+    }
+    catch (err) {
+        const { message, statusCode = 500 } = err;
+        res.status(statusCode).send(message);
+    }
+}));
+app.post(oauthPath + '/token', (0, cors_1.default)(), (req, res) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const result = yield oauthController.token(req.body);
+        res.json(result);
+    }
+    catch (err) {
+        const { message, statusCode = 500 } = err;
+        res.status(statusCode).send(message);
+    }
+}));
+app.get(oauthPath + '/userinfo', (req, res) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        let token = (0, utils_1.extractAuthToken)(req);
+        // check for query param
+        if (!token) {
+            // @ts-ignore
+            token = req.query.access_token;
+        }
+        if (!token) {
+            return res.status(401).json({ message: 'Unauthorized' });
+        }
+        const profile = yield oauthController.userInfo(token);
+        res.json(profile);
+    }
+    catch (err) {
+        const { message, statusCode = 500 } = err;
+        res.status(statusCode).json({ message });
+    }
+}));
+const server = app.listen(env_1.default.hostPort, () => __awaiter(void 0, void 0, void 0, function* () {
+    console.log(`🚀 The path of the righteous server: http://${env_1.default.hostUrl}:${env_1.default.hostPort}`);
+    // @ts-ignore
+    const ctrlrModule = yield (0, index_1.default)(env_1.default);
+    apiController = ctrlrModule.apiController;
+    oauthController = ctrlrModule.oauthController;
+}));
+// Internal routes, recommended not to expose this to the public interface though it would be guarded by API key(s)
+let internalApp = app;
+if (env_1.default.useInternalServer) {
+    internalApp = (0, express_1.default)();
+    internalApp.use(express_1.default.json());
+    internalApp.use(express_1.default.urlencoded({ extended: true }));
+}
+const validateApiKey = (token) => {
+    return env_1.default.apiKeys.includes(token);
+};
+internalApp.post(apiPath + '/config', (req, res) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const apiKey = (0, utils_1.extractAuthToken)(req);
+        if (!validateApiKey(apiKey)) {
+            res.status(401).send('Unauthorized');
+            return;
+        }
+        res.json(yield apiController.config(req.body));
+    }
+    catch (err) {
+        const { message } = err;
+        res.status(500).json({
+            error: message,
+        });
+    }
+}));
+internalApp.get(apiPath + '/config', (req, res) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const apiKey = (0, utils_1.extractAuthToken)(req);
+        if (!validateApiKey(apiKey)) {
+            res.status(401).send('Unauthorized');
+            return;
+        }
+        // @ts-ignore
+        res.json(yield apiController.getConfig(req.query));
+    }
+    catch (err) {
+        const { message } = err;
+        res.status(500).json({
+            error: message,
+        });
+    }
+}));
+internalApp.delete(apiPath + '/config', (req, res) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const apiKey = (0, utils_1.extractAuthToken)(req);
+        if (!validateApiKey(apiKey)) {
+            res.status(401).send('Unauthorized');
+            return;
+        }
+        yield apiController.deleteConfig(req.body);
+        res.status(200).end();
+    }
+    catch (err) {
+        const { message } = err;
+        res.status(500).json({
+            error: message,
+        });
+    }
+}));
+let internalServer = server;
+if (env_1.default.useInternalServer) {
+    internalServer = internalApp.listen(env_1.default.internalHostPort, () => __awaiter(void 0, void 0, void 0, function* () {
+        console.log(`🚀 The path of the righteous internal server: http://${env_1.default.internalHostUrl}:${env_1.default.internalHostPort}`);
+    }));
+}
+module.exports = {
+    server,
+    internalServer,
+};

package/dist/read-config.d.ts

@@ -0,0 +1,3 @@
+import { IdPConfig } from './typings';
+declare const readConfig: (preLoadedConfig: string) => Promise<IdPConfig[]>;
+export default readConfig;

package/dist/read-config.js

@@ -0,0 +1,50 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (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 __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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const readConfig = (preLoadedConfig) => __awaiter(void 0, void 0, void 0, function* () {
+    if (preLoadedConfig.startsWith('./')) {
+        preLoadedConfig = path.resolve(process.cwd(), preLoadedConfig);
+    }
+    const files = yield fs.promises.readdir(preLoadedConfig);
+    const configs = [];
+    for (const idx in files) {
+        const file = files[idx];
+        if (file.endsWith('.js')) {
+            const config = require(path.join(preLoadedConfig, file));
+            const rawMetadata = yield fs.promises.readFile(path.join(preLoadedConfig, path.parse(file).name + '.xml'), 'utf8');
+            config.rawMetadata = rawMetadata;
+            configs.push(config);
+        }
+    }
+    return configs;
+});
+exports.default = readConfig;