@boxyhq/saml-jackson 0.4.3 → 1.0.0

package/dist/controller/signout.js

@@ -0,0 +1,231 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LogoutController = void 0;
+const xmldom_1 = require("@xmldom/xmldom");
+const crypto_1 = __importDefault(require("crypto"));
+const thumbprint_1 = __importDefault(require("thumbprint"));
+const util_1 = require("util");
+const xml_crypto_1 = require("xml-crypto");
+const xml2js_1 = __importDefault(require("xml2js"));
+const xmlbuilder_1 = __importDefault(require("xmlbuilder"));
+const zlib_1 = require("zlib");
+const dbutils = __importStar(require("../db/utils"));
+const saml_1 = __importDefault(require("../saml/saml"));
+const error_1 = require("./error");
+const redirect = __importStar(require("./oauth/redirect"));
+const utils_1 = require("./utils");
+const deflateRawAsync = (0, util_1.promisify)(zlib_1.deflateRaw);
+const relayStatePrefix = 'boxyhq_jackson_';
+class LogoutController {
+    constructor({ configStore, sessionStore, opts }) {
+        this.opts = opts;
+        this.configStore = configStore;
+        this.sessionStore = sessionStore;
+    }
+    // Create SLO Request
+    createRequest({ nameId, tenant, product, redirectUrl }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let samlConfig = null;
+            if (tenant && product) {
+                const samlConfigs = yield this.configStore.getByIndex({
+                    name: utils_1.IndexNames.TenantProduct,
+                    value: dbutils.keyFromParts(tenant, product),
+                });
+                if (!samlConfigs || samlConfigs.length === 0) {
+                    throw new error_1.JacksonError('SAML configuration not found.', 403);
+                }
+                samlConfig = samlConfigs[0];
+            }
+            if (!samlConfig) {
+                throw new error_1.JacksonError('SAML configuration not found.', 403);
+            }
+            const { idpMetadata: { slo, provider }, certs: { privateKey, publicKey }, } = samlConfig;
+            if ('redirectUrl' in slo === false && 'postUrl' in slo === false) {
+                throw new error_1.JacksonError(`${provider} doesn't support SLO or disabled by IdP.`, 400);
+            }
+            const { id, xml } = buildRequestXML(nameId, this.opts.samlAudience, slo.redirectUrl);
+            const sessionId = crypto_1.default.randomBytes(16).toString('hex');
+            let logoutUrl = null;
+            let logoutForm = null;
+            const relayState = relayStatePrefix + sessionId;
+            const signedXML = yield signXML(xml, privateKey, publicKey);
+            yield this.sessionStore.put(sessionId, {
+                id,
+                redirectUrl,
+            });
+            // HTTP-Redirect binding
+            if ('redirectUrl' in slo) {
+                logoutUrl = redirect.success(slo.redirectUrl, {
+                    SAMLRequest: Buffer.from(yield deflateRawAsync(signedXML)).toString('base64'),
+                    RelayState: relayState,
+                });
+            }
+            // HTTP-POST binding
+            if ('postUrl' in slo) {
+                logoutForm = (0, utils_1.createRequestForm)(relayState, encodeURI(Buffer.from(signedXML).toString('base64')), slo.postUrl);
+            }
+            return { logoutUrl, logoutForm };
+        });
+    }
+    // Handle SLO Response
+    handleResponse({ SAMLResponse, RelayState }) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            const rawResponse = Buffer.from(SAMLResponse, 'base64').toString();
+            const sessionId = RelayState.replace(relayStatePrefix, '');
+            const session = yield this.sessionStore.get(sessionId);
+            if (!session) {
+                throw new error_1.JacksonError('Unable to validate state from the origin request.', 403);
+            }
+            const parsedResponse = yield parseSAMLResponse(rawResponse);
+            if (parsedResponse.status !== 'urn:oasis:names:tc:SAML:2.0:status:Success') {
+                throw new error_1.JacksonError(`SLO failed with status ${parsedResponse.status}.`, 400);
+            }
+            if (parsedResponse.inResponseTo !== session.id) {
+                throw new error_1.JacksonError(`SLO failed with mismatched request ID.`, 400);
+            }
+            const samlConfigs = yield this.configStore.getByIndex({
+                name: utils_1.IndexNames.EntityID,
+                value: parsedResponse.issuer,
+            });
+            if (!samlConfigs || samlConfigs.length === 0) {
+                throw new error_1.JacksonError('SAML configuration not found.', 403);
+            }
+            const { idpMetadata, defaultRedirectUrl } = samlConfigs[0];
+            if (!(yield hasValidSignature(rawResponse, idpMetadata.thumbprint))) {
+                throw new error_1.JacksonError('Invalid signature.', 403);
+            }
+            try {
+                yield this.sessionStore.delete(sessionId);
+            }
+            catch (_err) {
+                // Ignore
+            }
+            return {
+                redirectUrl: (_a = session.redirectUrl) !== null && _a !== void 0 ? _a : defaultRedirectUrl,
+            };
+        });
+    }
+}
+exports.LogoutController = LogoutController;
+// Create the XML for the SLO Request
+const buildRequestXML = (nameId, providerName, sloUrl) => {
+    const id = '_' + crypto_1.default.randomBytes(10).toString('hex');
+    const xml = {
+        'samlp:LogoutRequest': {
+            '@xmlns:samlp': 'urn:oasis:names:tc:SAML:2.0:protocol',
+            '@xmlns:saml': 'urn:oasis:names:tc:SAML:2.0:assertion',
+            '@ID': id,
+            '@Version': '2.0',
+            '@IssueInstant': new Date().toISOString(),
+            '@Destination': sloUrl,
+            'saml:Issuer': {
+                '#text': providerName,
+            },
+            'saml:NameID': {
+                '@Format': 'urn:oasis:names:tc:SAML:1.1:nameid-format:unspecified',
+                '#text': nameId,
+            },
+        },
+    };
+    return {
+        id,
+        xml: xmlbuilder_1.default.create(xml).end({}),
+    };
+};
+// Parse SAMLResponse
+const parseSAMLResponse = (rawResponse) => __awaiter(void 0, void 0, void 0, function* () {
+    return new Promise((resolve, reject) => {
+        xml2js_1.default.parseString(rawResponse, { tagNameProcessors: [xml2js_1.default.processors.stripPrefix] }, (err, { LogoutResponse }) => {
+            if (err) {
+                reject(err);
+                return;
+            }
+            resolve({
+                issuer: LogoutResponse.Issuer[0]._,
+                id: LogoutResponse.$.ID,
+                status: LogoutResponse.Status[0].StatusCode[0].$.Value,
+                destination: LogoutResponse.$.Destination,
+                inResponseTo: LogoutResponse.$.InResponseTo,
+            });
+        });
+    });
+});
+// Sign the XML
+const signXML = (xml, signingKey, publicKey) => __awaiter(void 0, void 0, void 0, function* () {
+    const sig = new xml_crypto_1.SignedXml();
+    sig.signatureAlgorithm = 'http://www.w3.org/2001/04/xmldsig-more#rsa-sha256';
+    sig.keyInfoProvider = new saml_1.default.PubKeyInfo(publicKey);
+    sig.signingKey = signingKey;
+    sig.addReference("/*[local-name(.)='LogoutRequest']", ['http://www.w3.org/2000/09/xmldsig#enveloped-signature', 'http://www.w3.org/2001/10/xml-exc-c14n#'], 'http://www.w3.org/2001/04/xmlenc#sha256');
+    sig.computeSignature(xml);
+    return sig.getSignedXml();
+});
+// Validate signature
+const hasValidSignature = (xml, certThumbprint) => __awaiter(void 0, void 0, void 0, function* () {
+    return new Promise((resolve, reject) => {
+        const doc = new xmldom_1.DOMParser().parseFromString(xml);
+        const signed = new xml_crypto_1.SignedXml();
+        let calculatedThumbprint;
+        const signature = (0, xml_crypto_1.xpath)(doc, "/*/*/*[local-name(.)='Signature' and namespace-uri(.)='http://www.w3.org/2000/09/xmldsig#']")[0] ||
+            (0, xml_crypto_1.xpath)(doc, "/*/*[local-name(.)='Signature' and namespace-uri(.)='http://www.w3.org/2000/09/xmldsig#']")[0] ||
+            (0, xml_crypto_1.xpath)(doc, "/*/*/*/*[local-name(.)='Signature' and namespace-uri(.)='http://www.w3.org/2000/09/xmldsig#']")[0];
+        signed.keyInfoProvider = {
+            getKey: function getKey(keyInfo) {
+                if (certThumbprint) {
+                    const embeddedSignature = keyInfo[0].getElementsByTagNameNS('http://www.w3.org/2000/09/xmldsig#', 'X509Certificate');
+                    if (embeddedSignature.length > 0) {
+                        const base64cer = embeddedSignature[0].firstChild.toString();
+                        calculatedThumbprint = thumbprint_1.default.calculate(base64cer);
+                        return saml_1.default.certToPEM(base64cer);
+                    }
+                }
+            },
+            getKeyInfo: function getKeyInfo() {
+                return '<X509Data></X509Data>';
+            },
+        };
+        signed.loadSignature(signature.toString());
+        try {
+            return resolve(signed.checkSignature(xml) && calculatedThumbprint.toUpperCase() === certThumbprint.toUpperCase());
+        }
+        catch (err) {
+            return reject(err);
+        }
+    });
+});

package/dist/controller/utils.d.ts

@@ -2,4 +2,5 @@ export declare enum IndexNames {
     EntityID = "entityID",
     TenantProduct = "tenantProduct"
 }
-export declare const createAuthorizeForm: (relayState: string, samlReqEnc: string, postUrl: string) => string;
+export declare const createRequestForm: (relayState: string, samlReqEnc: string, postUrl: string) => string;
+export declare const validateAbsoluteUrl: (url: any, message: any) => void;

package/dist/controller/utils.js

@@ -1,12 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createAuthorizeForm = exports.IndexNames = void 0;
+exports.validateAbsoluteUrl = exports.createRequestForm = exports.IndexNames = void 0;
+const error_1 = require("./error");
 var IndexNames;
 (function (IndexNames) {
     IndexNames["EntityID"] = "entityID";
     IndexNames["TenantProduct"] = "tenantProduct";
 })(IndexNames = exports.IndexNames || (exports.IndexNames = {}));
-const createAuthorizeForm = (relayState, samlReqEnc, postUrl) => {
+const createRequestForm = (relayState, samlReqEnc, postUrl) => {
     const formElements = [
         '<!DOCTYPE html>',
         '<html>',
@@ -29,4 +30,13 @@ const createAuthorizeForm = (relayState, samlReqEnc, postUrl) => {
     ];
     return formElements.join('');
 };
-exports.createAuthorizeForm = createAuthorizeForm;
+exports.createRequestForm = createRequestForm;
+const validateAbsoluteUrl = (url, message) => {
+    try {
+        new URL(url);
+    }
+    catch (err) {
+        throw new error_1.JacksonError(message ? message : 'Invalid url', 400);
+    }
+};
+exports.validateAbsoluteUrl = validateAbsoluteUrl;

package/dist/db/db.d.ts

@@ -4,7 +4,7 @@ declare class DB implements DatabaseDriver {
     private encryptionKey;
     constructor(db: DatabaseDriver, encryptionKey: EncryptionKey);
     get(namespace: string, key: string): Promise<unknown>;
-    getAll(namespace: any): Promise<unknown[]>;
+    getAll(namespace: any, pageOffset: any, pageLimit: any): Promise<unknown[]>;
     getByIndex(namespace: string, idx: Index): Promise<unknown[]>;
     put(namespace: string, key: string, val: unknown, ttl?: number, ...indexes: Index[]): Promise<unknown>;
     delete(namespace: string, key: string): Promise<unknown>;

package/dist/db/db.js

@@ -1,7 +1,11 @@
 "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]; } });
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
 }) : (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     o[k2] = m[k];
@@ -57,9 +61,9 @@ class DB {
             return decrypt(res, this.encryptionKey);
         });
     }
-    getAll(namespace) {
+    getAll(namespace, pageOffset, pageLimit) {
         return __awaiter(this, void 0, void 0, function* () {
-            const res = (yield this.db.getAll(namespace));
+            const res = (yield this.db.getAll(namespace, pageOffset, pageLimit));
             const encryptionKey = this.encryptionKey;
             return res.map((r) => {
                 return decrypt(r, encryptionKey);

package/dist/db/defaultDb.d.ts

@@ -0,0 +1,2 @@
+import { JacksonOption } from '../typings';
+export default function defaultDb(opts: JacksonOption): JacksonOption;

package/dist/db/defaultDb.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function defaultDb(opts) {
+    opts.db = opts.db || {};
+    opts.db.engine = opts.db.engine || 'sql';
+    opts.db.url = opts.db.url || 'postgresql://postgres:postgres@localhost:5432/postgres';
+    opts.db.type = opts.db.type || 'postgres'; // Only needed if DB_ENGINE is sql.
+    opts.db.ttl = (opts.db.ttl || 300) * 1; // TTL for the code, session and token stores (in seconds)
+    opts.db.cleanupLimit = (opts.db.cleanupLimit || 1000) * 1; // Limit cleanup of TTL entries to this many items at a time
+    return opts;
+}
+exports.default = defaultDb;

package/dist/db/mem.d.ts

@@ -10,7 +10,7 @@ declare class Mem implements DatabaseDriver {
     constructor(options: DatabaseOption);
     init(): Promise<Mem>;
     get(namespace: string, key: string): Promise<any>;
-    getAll(namespace: string): Promise<unknown[]>;
+    getAll(namespace: string, pageOffset: number, pageLimit: number): Promise<unknown[]>;
     getByIndex(namespace: string, idx: Index): Promise<any>;
     put(namespace: string, key: string, val: Encrypted, ttl?: number, ...indexes: any[]): Promise<any>;
     delete(namespace: string, key: string): Promise<any>;

package/dist/db/mem.js

@@ -2,7 +2,11 @@
 // This is an in-memory implementation to be used with testing and prototyping only
 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]; } });
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
 }) : (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     o[k2] = m[k];
@@ -66,19 +70,28 @@ class Mem {
             return null;
         });
     }
-    getAll(namespace) {
+    getAll(namespace, pageOffset, pageLimit) {
         return __awaiter(this, void 0, void 0, function* () {
+            const offsetAndLimitValueCheck = !dbutils.isNumeric(pageOffset) && !dbutils.isNumeric(pageLimit);
+            let take = Number(offsetAndLimitValueCheck ? this.options.pageLimit : pageLimit);
+            const skip = Number(offsetAndLimitValueCheck ? 0 : pageOffset);
+            let count = 0;
+            take += skip;
             const returnValue = [];
             if (namespace) {
-                for (const key in this.store) {
-                    if (key.startsWith(namespace)) {
-                        returnValue.push(this.store[key]);
+                const val = Array.from(this.indexes[dbutils.keyFromParts(dbutils.createdAtPrefix, namespace)]);
+                const iterator = val.reverse().values();
+                for (const value of iterator) {
+                    if (count >= take) {
+                        break;
+                    }
+                    if (count >= skip) {
+                        returnValue.push(this.store[dbutils.keyFromParts(namespace, value)]);
                     }
+                    count++;
                 }
             }
-            if (returnValue)
-                return returnValue;
-            return [];
+            return returnValue || [];
         });
     }
     getByIndex(namespace, idx) {
@@ -95,9 +108,6 @@ class Mem {
         return __awaiter(this, void 0, void 0, function* () {
             const k = dbutils.key(namespace, key);
             this.store[k] = val;
-            if (!Date.parse(this.store['createdAt']))
-                this.store['createdAt'] = new Date().toISOString();
-            this.store['modifiedAt'] = new Date().toISOString();
             // console.log(this.store)
             if (ttl) {
                 this.ttlStore[k] = {
@@ -123,6 +133,26 @@ class Mem {
                 }
                 cleanup.add(idxKey);
             }
+            let createdAtSet = this.indexes[dbutils.keyFromParts(dbutils.createdAtPrefix, namespace)];
+            if (!createdAtSet) {
+                createdAtSet = new Set();
+                this.indexes[dbutils.keyFromParts(dbutils.createdAtPrefix, namespace)] = createdAtSet;
+                this.store['createdAt'] = new Date().toISOString();
+                createdAtSet.add(key);
+            }
+            else {
+                if (!this.indexes[dbutils.keyFromParts(dbutils.createdAtPrefix, namespace)].has(key)) {
+                    createdAtSet.add(key);
+                    this.store['createdAt'] = new Date().toISOString();
+                }
+            }
+            let modifiedAtSet = this.indexes[dbutils.keyFromParts(dbutils.modifiedAtPrefix, namespace)];
+            if (!modifiedAtSet) {
+                modifiedAtSet = new Set();
+                this.indexes[dbutils.keyFromParts(dbutils.modifiedAtPrefix, namespace)] = modifiedAtSet;
+            }
+            modifiedAtSet.add(key);
+            this.store['modifiedAt'] = new Date().toISOString();
         });
     }
     delete(namespace, key) {
@@ -135,6 +165,8 @@ class Mem {
             for (const dbKey of dbKeys || []) {
                 this.indexes[dbKey] && this.indexes[dbKey].delete(key);
             }
+            this.indexes[dbutils.keyFromParts(dbutils.createdAtPrefix, namespace)].delete(key);
+            this.indexes[dbutils.keyFromParts(dbutils.modifiedAtPrefix, namespace)].delete(key);
             delete this.cleanup[idxKey];
             delete this.ttlStore[k];
         });

package/dist/db/mongo.d.ts

@@ -7,7 +7,7 @@ declare class Mongo implements DatabaseDriver {
     constructor(options: DatabaseOption);
     init(): Promise<Mongo>;
     get(namespace: string, key: string): Promise<any>;
-    getAll(namespace: string): Promise<unknown[]>;
+    getAll(namespace: string, offset: number, limit: number): Promise<unknown[]>;
     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>;

package/dist/db/mongo.js

@@ -1,7 +1,11 @@
 "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]; } });
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
 }) : (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     o[k2] = m[k];
@@ -36,16 +40,9 @@ class Mongo {
     }
     init() {
         return __awaiter(this, void 0, void 0, function* () {
-            try {
-                if (!this.options.url) {
-                    throw Error('Please specify a db url');
-                }
-                this.client = new mongodb_1.MongoClient(this.options.url);
-                yield this.client.connect();
-            }
-            catch (err) {
-                console.error(`error connecting to ${this.options.type} db: ${err}`);
-            }
+            const dbUrl = this.options.url;
+            this.client = new mongodb_1.MongoClient(dbUrl);
+            yield this.client.connect();
             this.db = this.client.db();
             this.collection = this.db.collection('jacksonStore');
             yield this.collection.createIndex({ indexes: 1 });
@@ -64,10 +61,12 @@ class Mongo {
             return null;
         });
     }
-    getAll(namespace) {
+    getAll(namespace, offset, limit) {
         return __awaiter(this, void 0, void 0, function* () {
             const _namespaceMatch = new RegExp(`^${namespace}:.*`);
-            const docs = yield this.collection.find({ _id: _namespaceMatch }).toArray();
+            const docs = yield this.collection
+                .find({ _id: _namespaceMatch }, { sort: { createdAt: -1 }, skip: offset, limit: limit })
+                .toArray();
             if (docs)
                 return docs.map(({ value }) => value);
             return [];

package/dist/db/redis.d.ts

@@ -5,7 +5,7 @@ declare class Redis implements DatabaseDriver {
     constructor(options: DatabaseOption);
     init(): Promise<Redis>;
     get(namespace: string, key: string): Promise<any>;
-    getAll(namespace: string): Promise<unknown[]>;
+    getAll(namespace: string, pageOffset: number, pageLimit: number): Promise<unknown[]>;
     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>;

package/dist/db/redis.js

@@ -1,7 +1,11 @@
 "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]; } });
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
 }) : (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     o[k2] = m[k];
@@ -27,6 +31,13 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
+var __asyncValues = (this && this.__asyncValues) || function (o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 const redis = __importStar(require("redis"));
 const dbutils = __importStar(require("./utils"));
@@ -57,29 +68,51 @@ class Redis {
             return null;
         });
     }
-    getAll(namespace) {
+    getAll(namespace, pageOffset, pageLimit) {
+        var e_1, _a;
         return __awaiter(this, void 0, void 0, function* () {
-            const keys = yield this.client.sendCommand(['keys', namespace + ':*']);
+            const offsetAndLimitValueCheck = !dbutils.isNumeric(pageOffset) && !dbutils.isNumeric(pageLimit);
+            let take = Number(offsetAndLimitValueCheck ? this.options.pageLimit : pageLimit);
+            const skip = Number(offsetAndLimitValueCheck ? 0 : pageOffset);
             const returnValue = [];
-            for (let i = 0; i < keys.length; i++) {
-                try {
-                    if (this.client.get(keys[i])) {
-                        const value = yield this.client.get(keys[i]);
-                        returnValue.push(JSON.parse(value));
+            const keyArray = [];
+            let count = 0;
+            take += skip;
+            try {
+                for (var _b = __asyncValues(this.client.zScanIterator(dbutils.keyFromParts(dbutils.createdAtPrefix, namespace), Math.min(take, 1000))), _c; _c = yield _b.next(), !_c.done;) {
+                    const { score, value } = _c.value;
+                    if (count >= take) {
+                        break;
                     }
+                    if (count >= skip) {
+                        keyArray.push(dbutils.keyFromParts(namespace, value));
+                    }
+                    count++;
+                }
+            }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
+                try {
+                    if (_c && !_c.done && (_a = _b.return)) yield _a.call(_b);
                 }
-                catch (error) {
-                    console.error(error);
+                finally { if (e_1) throw e_1.error; }
+            }
+            if (keyArray.length > 0) {
+                const value = yield this.client.MGET(keyArray);
+                for (let i = 0; i < value.length; i++) {
+                    const valueObject = JSON.parse(value[i].toString());
+                    if (valueObject !== null && valueObject !== '') {
+                        returnValue.push(valueObject);
+                    }
                 }
             }
-            if (returnValue)
-                return returnValue;
-            return [];
+            return returnValue || [];
         });
     }
     getByIndex(namespace, idx) {
         return __awaiter(this, void 0, void 0, function* () {
-            const dbKeys = yield this.client.sMembers(dbutils.keyForIndex(namespace, idx));
+            const idxKey = dbutils.keyForIndex(namespace, idx);
+            const dbKeys = yield this.client.sMembers(dbutils.keyFromParts(dbutils.indexPrefix, idxKey));
             const ret = [];
             for (const dbKey of dbKeys || []) {
                 ret.push(yield this.get(namespace, dbKey));
@@ -98,9 +131,21 @@ class Redis {
             // no ttl support for secondary indexes
             for (const idx of indexes || []) {
                 const idxKey = dbutils.keyForIndex(namespace, idx);
-                tx = tx.sAdd(idxKey, key);
+                tx = tx.sAdd(dbutils.keyFromParts(dbutils.indexPrefix, idxKey), key);
                 tx = tx.sAdd(dbutils.keyFromParts(dbutils.indexPrefix, k), idxKey);
             }
+            const timestamp = Number(Date.now());
+            //Converting Timestamp in negative so that when we get the value, it will be found in reverse order (descending order).
+            const negativeTimestamp = -Math.abs(timestamp);
+            const value = yield this.client.get(k);
+            if (!value) {
+                tx = tx.zAdd(dbutils.keyFromParts(dbutils.createdAtPrefix, namespace), [
+                    { score: negativeTimestamp, value: key },
+                ]);
+            }
+            tx = tx.zAdd(dbutils.keyFromParts(dbutils.modifiedAtPrefix, namespace), [
+                { score: negativeTimestamp, value: key },
+            ]);
             yield tx.exec();
         });
     }
@@ -113,8 +158,10 @@ class Redis {
             // delete secondary indexes and then the mapping of the seconary indexes
             const dbKeys = yield this.client.sMembers(idxKey);
             for (const dbKey of dbKeys || []) {
-                tx.sRem(dbKey, key);
+                tx.sRem(dbutils.keyFromParts(dbutils.indexPrefix, dbKey), key);
             }
+            tx.ZREM(dbutils.keyFromParts(dbutils.createdAtPrefix, namespace), key);
+            tx.ZREM(dbutils.keyFromParts(dbutils.modifiedAtPrefix, namespace), key);
             tx.del(idxKey);
             return yield tx.exec();
         });

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

@@ -1,7 +1,7 @@
 import { DatabaseDriver, DatabaseOption, Index, Encrypted } from '../../typings';
 declare class Sql implements DatabaseDriver {
     private options;
-    private connection;
+    private dataSource;
     private storeRepository;
     private indexRepository;
     private ttlRepository;
@@ -10,7 +10,7 @@ declare class Sql implements DatabaseDriver {
     constructor(options: DatabaseOption);
     init(): Promise<Sql>;
     get(namespace: string, key: string): Promise<any>;
-    getAll(namespace: string): Promise<unknown[]>;
+    getAll(namespace: string, pageOffset: number, pageLimit: number): Promise<unknown[]>;
     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>;