jxp 3.0.0 → 4.1.0

package/dist/libs/schema.js

@@ -0,0 +1,98 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const mongoose_1 = __importDefault(require("mongoose"));
+const path_1 = __importDefault(require("path"));
+const JXPHelper = require("jxp-helper");
+const modeldir = require("./modeldir");
+const load_config_1 = require("./load-config");
+// Set some global types for JS model files using /* global ObjectId Mixed */
+global.ObjectId = mongoose_1.default.Schema.Types.ObjectId;
+global.Mixed = mongoose_1.default.Schema.Types.Mixed;
+function resolveModelDir(dir) {
+    if (path_1.default.isAbsolute(dir))
+        return dir;
+    return path_1.default.resolve(process.cwd(), dir);
+}
+function getModelDir() {
+    const fromEnv = (0, load_config_1.getModelDirFromEnv)();
+    if (fromEnv)
+        return resolveModelDir(fromEnv);
+    return modeldir.findModelDir(path_1.default.dirname(process.argv[1] ?? "."));
+}
+const getModelFileFromRef = (ref) => {
+    return path_1.default.join(getModelDir(), `${String(ref).toLowerCase()}_model`);
+};
+class JXPSchema extends mongoose_1.default.Schema {
+    constructor(definition, opts = {}) {
+        opts = Object.assign({
+            timestamps: true,
+            toJSON: { virtuals: true },
+            toObject: { virtuals: true },
+        }, opts);
+        definition = Object.assign({
+            _deleted: { type: Boolean, default: false, index: true },
+            _owner_id: { type: global.ObjectId, link: "User", map_to: "_owner", index: true },
+            _updated_by_id: { type: global.ObjectId, link: "User", map_to: "_updated_by", index: true },
+        }, definition);
+        if (!global.jxphelper) {
+            const jxp_settings = {};
+            if (global.apikey)
+                jxp_settings.apikey = global.apikey;
+            if (global.server)
+                jxp_settings.server = global.server;
+            if (jxp_settings.apikey && jxp_settings.server) {
+                global.jxphelper = new JXPHelper(jxp_settings);
+            }
+        }
+        super(definition, opts);
+        this.opts = opts;
+        this.definition = definition;
+        this.index({ createdAt: -1 });
+        this.index({ updatedAt: -1 });
+        this.setPerms();
+        this.generateLinks();
+    }
+    setPerms() {
+        // JXP stores permission strings on the schema for runtime auth checks
+        this.set("_perms", Object.assign({
+            admin: "",
+            owner: "",
+            user: "",
+            all: "",
+        }, this.opts.perms));
+    }
+    generateLinks() {
+        const loaded_files = [];
+        for (const key of Object.keys(this.definition)) {
+            let def = this.definition[key];
+            let is_array = false;
+            if (Array.isArray(def) && def[0]) {
+                def = def[0];
+                is_array = true;
+            }
+            if (!def || typeof def !== "object" || !("link" in def) || !def.link)
+                continue;
+            const virtual_name = def.map_to || def.virtual || String(def.link).toLowerCase();
+            if (!loaded_files.includes(def.link)) {
+                // eslint-disable-next-line @typescript-eslint/no-require-imports
+                const linked = require(getModelFileFromRef(def.link));
+                void (linked.default || linked);
+                loaded_files.push(def.link);
+            }
+            this.virtual(virtual_name, {
+                ref: def.link,
+                localField: key,
+                foreignField: "_id",
+                justOne: def.justOne ?? !is_array,
+                options: Object.assign({}, def.options),
+            });
+        }
+    }
+    static Types = mongoose_1.default.Schema.Types;
+    static model = mongoose_1.default.model.bind(mongoose_1.default);
+}
+exports.default = JXPSchema;
+//# sourceMappingURL=schema.js.map

package/dist/libs/schema.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.js","sourceRoot":"","sources":["../../src/libs/schema.ts"],"names":[],"mappings":";;;;;AAAA,wDAAuE;AACvE,gDAAwB;AACxB,wCAAyC;AACzC,uCAAwC;AACxC,+CAAmD;AAGnD,6EAA6E;AAC7E,MAAM,CAAC,QAAQ,GAAG,kBAAQ,CAAC,MAAM,CAAC,KAAK,CAAC,QAAQ,CAAC;AACjD,MAAM,CAAC,KAAK,GAAG,kBAAQ,CAAC,MAAM,CAAC,KAAK,CAAC,KAAK,CAAC;AAE3C,SAAS,eAAe,CAAC,GAAW;IACnC,IAAI,cAAI,CAAC,UAAU,CAAC,GAAG,CAAC;QAAE,OAAO,GAAG,CAAC;IACrC,OAAO,cAAI,CAAC,OAAO,CAAC,OAAO,CAAC,GAAG,EAAE,EAAE,GAAG,CAAC,CAAC;AACzC,CAAC;AAED,SAAS,WAAW;IACnB,MAAM,OAAO,GAAG,IAAA,gCAAkB,GAAE,CAAC;IACrC,IAAI,OAAO;QAAE,OAAO,eAAe,CAAC,OAAO,CAAC,CAAC;IAC7C,OAAO,QAAQ,CAAC,YAAY,CAAC,cAAI,CAAC,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,GAAG,CAAC,CAAC,CAAC;AACpE,CAAC;AAED,MAAM,mBAAmB,GAAG,CAAC,GAAW,EAAU,EAAE;IACnD,OAAO,cAAI,CAAC,IAAI,CAAC,WAAW,EAAE,EAAE,GAAG,MAAM,CAAC,GAAG,CAAC,CAAC,WAAW,EAAE,QAAQ,CAAC,CAAC;AACvE,CAAC,CAAC;AAWF,MAAM,SAAU,SAAQ,kBAAQ,CAAC,MAAM;IAItC,YAAY,UAAyB,EAAE,OAAyB,EAAE;QACjE,IAAI,GAAG,MAAM,CAAC,MAAM,CACnB;YACC,UAAU,EAAE,IAAI;YAChB,MAAM,EAAE,EAAE,QAAQ,EAAE,IAAI,EAAE;YAC1B,QAAQ,EAAE,EAAE,QAAQ,EAAE,IAAI,EAAE;SAC5B,EACD,IAAI,CACJ,CAAC;QACF,UAAU,GAAG,MAAM,CAAC,MAAM,CACzB;YACC,QAAQ,EAAE,EAAE,IAAI,EAAE,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE;YACxD,SAAS,EAAE,EAAE,IAAI,EAAE,MAAM,CAAC,QAAQ,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,KAAK,EAAE,IAAI,EAAE;YACjF,cAAc,EAAE,EAAE,IAAI,EAAE,MAAM,CAAC,QAAQ,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,aAAa,EAAE,KAAK,EAAE,IAAI,EAAE;SAC3F,EACD,UAAU,CACV,CAAC;QACF,IAAI,CAAC,MAAM,CAAC,SAAS,EAAE,CAAC;YACvB,MAAM,YAAY,GAAyC,EAAE,CAAC;YAC9D,IAAI,MAAM,CAAC,MAAM;gBAAE,YAAY,CAAC,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC;YACvD,IAAI,MAAM,CAAC,MAAM;gBAAE,YAAY,CAAC,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC;YACvD,IAAI,YAAY,CAAC,MAAM,IAAI,YAAY,CAAC,MAAM,EAAE,CAAC;gBAChD,MAAM,CAAC,SAAS,GAAG,IAAI,SAAS,CAAC,YAAY,CAAC,CAAC;YAChD,CAAC;QACF,CAAC;QACD,KAAK,CAAC,UAA8B,EAAE,IAAI,CAAC,CAAC;QAC5C,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;QACjB,IAAI,CAAC,UAAU,GAAG,UAAU,CAAC;QAC7B,IAAI,CAAC,KAAK,CAAC,EAAE,SAAS,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC;QAC9B,IAAI,CAAC,KAAK,CAAC,EAAE,SAAS,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC;QAC9B,IAAI,CAAC,QAAQ,EAAE,CAAC;QAChB,IAAI,CAAC,aAAa,EAAE,CAAC;IACtB,CAAC;IAED,QAAQ;QACP,sEAAsE;QACrE,IAA4D,CAAC,GAAG,CAChE,QAAQ,EACR,MAAM,CAAC,MAAM,CACZ;YACC,KAAK,EAAE,EAAE;YACT,KAAK,EAAE,EAAE;YACT,IAAI,EAAE,EAAE;YACR,GAAG,EAAE,EAAE;SACP,EACD,IAAI,CAAC,IAAI,CAAC,KAAK,CACf,CACD,CAAC;IACH,CAAC;IAED,aAAa;QACZ,MAAM,YAAY,GAAa,EAAE,CAAC;QAClC,KAAK,MAAM,GAAG,IAAI,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,EAAE,CAAC;YAChD,IAAI,GAAG,GAAG,IAAI,CAAC,UAAU,CAAC,GAAG,CAA0C,CAAC;YACxE,IAAI,QAAQ,GAAG,KAAK,CAAC;YACrB,IAAI,KAAK,CAAC,OAAO,CAAC,GAAG,CAAC,IAAI,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC;gBAClC,GAAG,GAAG,GAAG,CAAC,CAAC,CAAC,CAAC;gBACb,QAAQ,GAAG,IAAI,CAAC;YACjB,CAAC;YACD,IAAI,CAAC,GAAG,IAAI,OAAO,GAAG,KAAK,QAAQ,IAAI,CAAC,CAAC,MAAM,IAAI,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI;gBAAE,SAAS;YAC/E,MAAM,YAAY,GAAG,GAAG,CAAC,MAAM,IAAI,GAAG,CAAC,OAAO,IAAI,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,WAAW,EAAE,CAAC;YACjF,IAAI,CAAC,YAAY,CAAC,QAAQ,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC;gBACtC,iEAAiE;gBACjE,MAAM,MAAM,GAAG,OAAO,CAAC,mBAAmB,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC;gBACtD,KAAK,CAAC,MAAM,CAAC,OAAO,IAAI,MAAM,CAAC,CAAC;gBAChC,YAAY,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;YAC7B,CAAC;YACD,IAAI,CAAC,OAAO,CAAC,YAAY,EAAE;gBAC1B,GAAG,EAAE,GAAG,CAAC,IAAI;gBACb,UAAU,EAAE,GAAG;gBACf,YAAY,EAAE,KAAK;gBACnB,OAAO,EAAE,GAAG,CAAC,OAAO,IAAI,CAAC,QAAQ;gBACjC,OAAO,EAAE,MAAM,CAAC,MAAM,CAAC,EAAE,EAAE,GAAG,CAAC,OAAO,CAAC;aACvC,CAAC,CAAC;QACJ,CAAC;IACF,CAAC;IAED,MAAM,CAAC,KAAK,GAAG,kBAAQ,CAAC,MAAM,CAAC,KAAK,CAAC;IACrC,MAAM,CAAC,KAAK,GAAG,kBAAQ,CAAC,KAAK,CAAC,IAAI,CAAC,kBAAQ,CAI9B,CAAC;;AAIf,kBAAe,SAAS,CAAC"}

package/dist/libs/schema_description.d.ts

@@ -0,0 +1,3 @@
+declare const getModelFileContents: (model_dir: any) => Promise<unknown>;
+export = getModelFileContents;
+//# sourceMappingURL=schema_description.d.ts.map

package/dist/libs/schema_description.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema_description.d.ts","sourceRoot":"","sources":["../../src/libs/schema_description.ts"],"names":[],"mappings":"AAIA,QAAA,MAAM,oBAAoB,GAAI,cAAS,qBAmFtC,CAAA;AAED,SAAS,oBAAoB,CAAC"}

package/{libs → dist/libs}/schema_description.js

@@ -1,7 +1,7 @@
+"use strict";
 const fs = require("fs");
 const path = require("path");
 const mongoose = require("mongoose");
-
 const getModelFileContents = (model_dir) => {
     return new Promise((resolve, reject) => {
         try {
@@ -9,22 +9,16 @@ const getModelFileContents = (model_dir) => {
                 if (err) {
                     return reject(err);
                 }
-
                 // Filter for only model files first
-                const modelFiles = files.filter(file =>
-                    file.endsWith('_model.js') &&
-                    fs.statSync(path.join(model_dir, file)).isFile()
-                );
-
+                const modelFiles = files.filter(file => file.endsWith('_model.js') &&
+                    fs.statSync(path.join(model_dir, file)).isFile());
                 // Limit number of files processed at once
                 const MAX_FILES = 1000;
                 if (modelFiles.length > MAX_FILES) {
                     return reject(new Error(`Too many model files (${modelFiles.length}). Maximum allowed is ${MAX_FILES}`));
                 }
-
                 let models = [];
                 let errors = [];
-
                 for (const file of modelFiles) {
                     const modelname = path.basename(file, ".js").replace("_model", "");
                     try {
@@ -34,20 +28,19 @@ const getModelFileContents = (model_dir) => {
                             // Convert modelname to proper case for mongoose (first letter uppercase)
                             const modelKey = modelname.charAt(0).toUpperCase() + modelname.slice(1);
                             modelobj = mongoose.models[modelKey];
-
                             // If model doesn't exist in mongoose, try to load it from file
                             if (!modelobj) {
                                 const filePath = path.join(model_dir, file);
                                 delete require.cache[require.resolve(filePath)];
                                 modelobj = require(filePath);
                             }
-                        } catch (e) {
+                        }
+                        catch (e) {
                             // If getting from mongoose fails, try loading from file
                             const filePath = path.join(model_dir, file);
                             delete require.cache[require.resolve(filePath)];
                             modelobj = require(filePath);
                         }
-
                         // Check if we have a valid model with schema and permissions
                         if (modelobj && modelobj.schema) {
                             const perms = modelobj.schema.get("_perms");
@@ -60,11 +53,10 @@ const getModelFileContents = (model_dir) => {
                                 continue; // Skip error handling if successful
                             }
                         }
-
                         // If we get here, the model was loaded but didn't have proper schema/perms
                         errors.push(`Invalid model structure for ${modelname}`);
-
-                    } catch (error) {
+                    }
+                    catch (error) {
                         // Only add to errors if it's not an OverwriteModelError
                         if (!error.message.includes('Cannot overwrite')) {
                             errors.push(`Error with model ${modelname}: ${error.message}`);
@@ -72,19 +64,18 @@ const getModelFileContents = (model_dir) => {
                         }
                     }
                 }
-
                 // If we have errors but also some valid models, just log the errors
                 if (errors.length > 0 && models.length > 0) {
                     console.warn('Some models failed to load:', errors);
                 }
-
                 // Return empty array if no models found, but don't treat it as an error
                 return resolve(models);
             });
-        } catch (err) {
+        }
+        catch (err) {
             return reject(err);
         }
     });
-}
-
-module.exports = getModelFileContents;
+};
+module.exports = getModelFileContents;
+//# sourceMappingURL=schema_description.js.map

package/dist/libs/schema_description.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema_description.js","sourceRoot":"","sources":["../../src/libs/schema_description.ts"],"names":[],"mappings":"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"}

package/dist/libs/security.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=security.d.ts.map

package/dist/libs/security.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"security.d.ts","sourceRoot":"","sources":["../../src/libs/security.ts"],"names":[],"mappings":""}

package/dist/libs/security.js

@@ -0,0 +1,428 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const bcrypt = require("bcryptjs");
+const randToken = require("rand-token");
+const path = require("path");
+const errors = require("restify-errors");
+var APIKey = null;
+var Token = null;
+var Groups = null;
+var User = null;
+var RefreshToken = null;
+var provider = "";
+const loadModel = (modelDir, file) => {
+    const mod = require(path.join(modelDir, file));
+    return mod.default || mod;
+};
+const init = function (config) {
+    APIKey = loadModel(config.model_dir, "apikey_model");
+    Groups = loadModel(config.model_dir, "usergroups_model.js");
+    User = loadModel(config.model_dir, "user_model");
+    Token = loadModel(config.model_dir, "token_model");
+    RefreshToken = loadModel(config.model_dir, "refreshtoken_model");
+    if (config.url)
+        provider = config.url;
+};
+const basicAuthData = function (req) {
+    if (!req.headers.authorization) {
+        return false;
+    }
+    try {
+        const authorization = req.headers.authorization.split(" ")[1];
+        const decoded = Buffer.from(authorization, "base64").toString();
+        return decoded.split(":");
+    }
+    catch (err) {
+        return false;
+    }
+};
+const basicAuth = async (ba) => {
+    try {
+        if (!Array.isArray(ba) || ba.length !== 2) {
+            throw ("Basic Auth incorrectly formatted");
+        }
+        var email = ba[0];
+        var password = ba[1];
+        const user = await User.findOne({ email }).exec();
+        if (!user) {
+            throw (new Date(), `Incorrect username or password for ${email}`);
+        }
+        if (!await bcrypt.compare(password, user.password)) {
+            throw (`Incorrect username or password for ${email}`);
+        }
+        return user;
+    }
+    catch (err) {
+        console.error(new Date(), err);
+        throw err;
+    }
+};
+const bearerAuthData = req => {
+    if (!req.headers.authorization) {
+        return false;
+    }
+    try {
+        const token = req.headers.authorization.split(" ")[1];
+        return token;
+    }
+    catch (err) {
+        return false;
+    }
+};
+const bearerAuth = async (t) => {
+    try {
+        if (!t)
+            throw ("Token invalid");
+        const token = await Token.findOne({ access_token: t, provider }).exec();
+        if (!token) {
+            throw (`Token ${t} not found`);
+        }
+        if (!tokenIsValid(token)) {
+            throw (`Token is no loger valid`);
+        }
+        const user = await User.findOne({ _id: token.user_id }).exec();
+        if (!user) {
+            throw (`Could not find user`);
+        }
+        return user;
+    }
+    catch (err) {
+        console.error(err);
+        throw err;
+    }
+};
+const apiKeyAuth = async (apikey) => {
+    try {
+        if (!apikey)
+            throw ("Missing apikey");
+        const result = await APIKey.findOne({ apikey });
+        if (!result)
+            throw ("Could not find apikey");
+        const user = await User.findOne({ _id: result.user_id }).exec();
+        if (!user)
+            throw ("Could not find user associated to apikey");
+        return user;
+    }
+    catch (err) {
+        console.error(new Date(), err);
+        throw err;
+    }
+};
+const getGroups = async (user_id) => {
+    try {
+        const userGroup = await Groups.findOne({ user_id });
+        var groups = userGroup && userGroup.groups ? userGroup.groups : [];
+        return groups;
+    }
+    catch (err) {
+        console.error(new Date(), err);
+        throw err;
+    }
+};
+const encPassword = password => {
+    return bcrypt.hashSync(password, 4);
+};
+const generateApiKey = async (user_id) => {
+    try {
+        let existing = await APIKey.findOne({ user_id }).sort({ last_accessed: -1 }).exec();
+        if (existing) {
+            await existing.updateOne({ last_accessed: new Date() });
+            return existing;
+        }
+        var apikey = new APIKey();
+        apikey.user_id = user_id;
+        apikey.apikey = randToken.generate(16);
+        await apikey.save();
+        return apikey;
+    }
+    catch (err) {
+        console.error(new Date(), err);
+        throw err;
+    }
+};
+const tokenIsValid = token => {
+    if (!token)
+        return false;
+    const now = +new Date();
+    const expires_at = +new Date(token.createdAt) + (token.expires_in * 1000);
+    return (expires_at > now);
+};
+const tokenExpires = (token) => {
+    return new Date(new Date(token.createdAt).getTime() + token.expires_in * 1000);
+};
+const generateToken = async (user_id) => {
+    try {
+        var token = new Token();
+        token.user_id = user_id;
+        token.access_token = randToken.generate(16);
+        token.provider = provider;
+        await token.save();
+        return token;
+    }
+    catch (err) {
+        console.error(new Date(), err);
+        throw err;
+    }
+};
+const ensureToken = async (user_id) => {
+    try {
+        const token = await Token.findOne({ user_id, provider }).sort({ createdAt: -1 }).exec();
+        if (tokenIsValid(token)) {
+            return token;
+        }
+        return await generateToken(user_id);
+    }
+    catch (err) {
+        console.error(new Date(), err);
+        throw err;
+    }
+};
+const refreshToken = async (user_id) => {
+    await revokeToken(user_id);
+    return await ensureToken(user_id);
+};
+const revokeToken = async (user_id) => {
+    await Token.deleteOne({ user_id, provider });
+    return;
+};
+const generateRefreshToken = async (user_id) => {
+    try {
+        var refreshtoken = new RefreshToken();
+        refreshtoken.user_id = user_id;
+        refreshtoken.refresh_token = randToken.generate(16);
+        await refreshtoken.save();
+        return refreshtoken;
+    }
+    catch (err) {
+        console.error(new Date(), err);
+        throw err;
+    }
+};
+const ensureRefreshToken = async (user_id) => {
+    const refreshtoken = await RefreshToken.findOne({ user_id }).sort({ createdAt: -1 }).exec();
+    if (tokenIsValid(refreshtoken)) {
+        return refreshtoken;
+    }
+    return await generateRefreshToken(user_id);
+};
+const revokeRefreshToken = async (user_id) => {
+    await RefreshToken.deleteMany({ user_id });
+    return;
+};
+const refresh = async (req, res) => {
+    try {
+        if (req.headers.authorization && req.headers.authorization.trim().toLowerCase().indexOf("bearer") === 0) {
+            const refresh_token = await RefreshToken.findOne({ refresh_token: bearerAuthData(req) }).exec();
+            if (!refresh_token)
+                throw ("Refresh token not found");
+            if (!tokenIsValid(refresh_token))
+                throw ("Refresh token has expired");
+            const user_id = refresh_token.user_id;
+            const token = await refreshToken(user_id);
+            await revokeRefreshToken(user_id);
+            const new_refresh_token = await generateRefreshToken(user_id);
+            res.send({
+                user_id: user_id,
+                token: token.access_token,
+                token_expires: tokenExpires(token),
+                refresh_token: new_refresh_token.refresh_token,
+                refresh_token_expires: tokenExpires(new_refresh_token)
+            });
+        }
+        else {
+            throw ("Missing refresh token");
+        }
+    }
+    catch (err) {
+        console.error(err);
+        if (err.code)
+            throw err;
+        throw new errors.ForbiddenError(err.toString());
+    }
+};
+const login = async (req, res) => {
+    try {
+        const authenticate_result = await authenticate(req);
+        if (!authenticate_result) {
+            res.user = null;
+            res.groups = [];
+            return;
+        }
+        res = Object.assign(res, authenticate_result);
+    }
+    catch (err) {
+        console.error(err);
+        if (err.code)
+            throw err;
+        throw new errors.ForbiddenError(err.toString());
+    }
+};
+const authenticate = async (req) => {
+    let user = null;
+    if (!req.query.apikey && !req.headers.authorization && !(req.headers["X-API-Key"] || req.headers["x-api-key"])) {
+        return false;
+    }
+    if (req.headers.authorization && req.headers.authorization.trim().toLowerCase().indexOf("basic") === 0) {
+        // Basic Auth
+        user = await basicAuth(basicAuthData(req));
+    }
+    else if (req.headers.authorization && req.headers.authorization.trim().toLowerCase().indexOf("bearer") === 0) {
+        // Token Auth
+        user = await bearerAuth(bearerAuthData(req));
+    }
+    else if (req.query.apikey) {
+        user = await apiKeyAuth(req.query.apikey);
+    }
+    else if (req.headers["X-API-Key"] || req.headers["x-api-key"]) {
+        // API Key
+        user = await apiKeyAuth(req.headers["X-API-Key"] || req.headers["x-api-key"]);
+    }
+    else {
+        throw ("Could not find any way to authenticate");
+    }
+    if (!user) {
+        throw ("Could not find user");
+    }
+    return {
+        token: await ensureToken(user._id),
+        refresh_token: await ensureRefreshToken(user._id),
+        groups: await getGroups(user._id),
+        username: user.email,
+        user
+    };
+};
+const auth = async (req, res) => {
+    // Check against model as to whether we're allowed to edit this model
+    if (!req.Model) {
+        // console.error("Model missing");
+        throw new errors.BadRequestError("Model missing");
+    }
+    try {
+        var method = null;
+        // console.log("req.route.name", req.route.name);
+        if (req.method == "GET" || req.route.name === "postquerymodelname" || req.route.name === "postaggregatemodelname") {
+            method = "r";
+        }
+        else if (req.method == "POST") {
+            method = "c";
+        }
+        else if (req.method == "PUT") {
+            method = "u";
+        }
+        else if (req.method == "DELETE") {
+            method = "d";
+        }
+        else {
+            // console.error("Unsupported operation", req.method);
+            throw new errors.InternalServerError(`Unsupported operation: ${req.method}`);
+        }
+        return await check_perms(res.user, res.groups, req.Model, method, req.params.item_id);
+    }
+    catch (err) {
+        console.error(err);
+        if (err.code)
+            throw err;
+        throw new errors.ForbiddenError(err.toString());
+    }
+};
+// Bulk auth requires all CRUD permissions
+const bulkAuth = async (req, res) => {
+    try {
+        await check_perms(res.user, res.groups, req.Model, "c");
+        await check_perms(res.user, res.groups, req.Model, "r");
+        await check_perms(res.user, res.groups, req.Model, "u");
+        await check_perms(res.user, res.groups, req.Model, "d");
+    }
+    catch (err) {
+        console.error(err);
+        if (err.code)
+            throw err;
+        throw new errors.ForbiddenError(err.toString());
+    }
+};
+const check_perms = async (user, groups, model, method, item_id) => {
+    try {
+        const perms = model.schema.get("_perms");
+        //If no perms are set, then this isn't an available model
+        if (!perms.admin) {
+            console.error("Model permissions not set correctly - add an admin section");
+            throw new errors.InternalServerError("Model permissions not set correctly - add an admin section");
+        }
+        //First check if "all" is able to do this. If so, let's get on with it.
+        if (perms.all && perms.all.length) {
+            if (perms.all.indexOf(method) !== -1) {
+                return;
+            }
+        }
+        //This isn't an 'all' situation, so let's bail if the user isn't logged in
+        if (!user) {
+            throw new errors.ForbiddenError("User not logged in");
+        }
+        //Let's check perms in this order - admin, user, group, owner
+        //Admin check
+        if (user.admin && perms.admin && perms.admin.includes(method)) {
+            // console.log("Matched permission 'admin':" + method);
+            return;
+        }
+        //User check
+        if (perms.user && perms.user.includes(method)) {
+            // console.log("Matched permission 'user':" + method);
+            return;
+        }
+        //Group check
+        for (let group of groups) {
+            if (perms[group] && perms[group].includes(method)) {
+                // console.log("Matched permission '" + group + "':" + method);
+                return;
+            }
+        }
+        //Owner check
+        if (!item_id)
+            throw (`Authorization failed - ${method}`);
+        const item = await model.findById(item_id);
+        if (item && item._owner_id && item._owner_id.toString() == user._id.toString() && (perms.owner && perms.owner.includes(method)))
+            return;
+        throw ("Authorization failed");
+    }
+    catch (err) {
+        if (err.code)
+            throw err;
+        throw new errors.ForbiddenError(err.toString());
+    }
+};
+const admin_only = (req, res, next) => {
+    if (!res.user) {
+        return next(new errors.ForbiddenError("User not logged in"));
+    }
+    if (!res.user.admin) {
+        return next(new errors.ForbiddenError("User not admin"));
+    }
+    next();
+};
+const Security = {
+    init,
+    basicAuthData,
+    basicAuth,
+    encPassword,
+    generateApiKey,
+    generateToken,
+    ensureToken,
+    refreshToken,
+    revokeToken,
+    tokenExpires,
+    generateRefreshToken,
+    ensureRefreshToken,
+    revokeRefreshToken,
+    login,
+    refresh,
+    authenticate,
+    auth,
+    admin_only,
+    check_perms,
+    getGroups,
+    apiKeyAuth,
+    bearerAuth,
+    bulkAuth
+};
+module.exports = Security;
+//# sourceMappingURL=security.js.map