@terreno/api 0.0.1

package/dist/expressServer.js

@@ -0,0 +1,436 @@
+"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 () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __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 __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setupEnvironment = setupEnvironment;
+exports.logRequests = logRequests;
+exports.createRouter = createRouter;
+exports.createRouterWithAuth = createRouterWithAuth;
+exports.setupServer = setupServer;
+exports.cronjob = cronjob;
+exports.wrapScript = wrapScript;
+var Sentry = __importStar(require("@sentry/node"));
+var openapi_1 = __importDefault(require("@wesleytodd/openapi"));
+var cors_1 = __importDefault(require("cors"));
+var cron_1 = __importDefault(require("cron"));
+var express_1 = __importDefault(require("express"));
+var cloneDeep_1 = __importDefault(require("lodash/cloneDeep"));
+var on_finished_1 = __importDefault(require("on-finished"));
+var passport_1 = __importDefault(require("passport"));
+var qs_1 = __importDefault(require("qs"));
+var auth_1 = require("./auth");
+var errors_1 = require("./errors");
+var logger_1 = require("./logger");
+var notifiers_1 = require("./notifiers");
+var openApiEtag_1 = require("./openApiEtag");
+var SLOW_READ_MAX = 200;
+var SLOW_WRITE_MAX = 500;
+var IS_JEST = process.env.JEST_WORKER_ID !== undefined;
+function setupEnvironment() {
+    if (!process.env.TOKEN_ISSUER) {
+        throw new Error("TOKEN_ISSUER must be set in env.");
+    }
+    if (!process.env.TOKEN_SECRET) {
+        throw new Error("TOKEN_SECRET must be set.");
+    }
+    if (!process.env.REFRESH_TOKEN_SECRET) {
+        throw new Error("REFRESH_TOKEN_SECRET must be set.");
+    }
+    if (!process.env.SESSION_SECRET) {
+        throw new Error("SESSION_SECRET must be set.");
+    }
+    if (!process.env.TOKEN_EXPIRES_IN && !IS_JEST) {
+        logger_1.logger.warn("TOKEN_EXPIRES_IN is not set so using default.");
+    }
+    if (!process.env.REFRESH_TOKEN_EXPIRES_IN && !IS_JEST) {
+        logger_1.logger.warn("REFRESH_TOKEN_EXPIRES_IN not set so using default.");
+    }
+}
+var logRequestsFinished = function (req, res, startTime) {
+    var _a, _b, _c;
+    var options = ((_a = res.locals.loggingOptions) !== null && _a !== void 0 ? _a : {});
+    var slowReadMs = (_b = options.logSlowRequestsReadMs) !== null && _b !== void 0 ? _b : SLOW_READ_MAX;
+    var slowWriteMs = (_c = options.logSlowRequestsWriteMs) !== null && _c !== void 0 ? _c : SLOW_WRITE_MAX;
+    var diff = process.hrtime.bigint() - startTime;
+    var diffInMs = Number(diff) / 1000000;
+    var pathName = "unknown";
+    if (req.route && req.routeMount) {
+        pathName = "".concat(req.routeMount).concat(req.route.path);
+    }
+    else if (req.route) {
+        pathName = req.route.path;
+    }
+    else if (res.statusCode < 400) {
+        logger_1.logger.warn("Request without route: ".concat(req.originalUrl));
+    }
+    if (process.env.DISABLE_LOG_ALL_REQUESTS !== "true") {
+        logger_1.logger.debug("".concat(req.method, " -> ").concat(req.originalUrl, " ").concat(res.statusCode, " ").concat("".concat(diffInMs, "ms")));
+    }
+    if (options.logSlowRequests) {
+        if (diffInMs > slowReadMs && req.method === "GET") {
+            logger_1.logger.warn("Slow GET request, ".concat(JSON.stringify({
+                pathName: pathName,
+                requestTime: diffInMs,
+                url: req.originalUrl,
+            })));
+        }
+        else if (diffInMs > slowWriteMs) {
+            logger_1.logger.warn("Slow write request ".concat(JSON.stringify({
+                pathName: pathName,
+                requestTime: diffInMs,
+                url: req.originalUrl,
+            })));
+        }
+    }
+};
+function logRequests(req, res, next) {
+    var _a, _b, _c, _d;
+    var startTime = process.hrtime.bigint();
+    var userString = "";
+    if (req.user) {
+        var type = "User";
+        if ((_a = req.user) === null || _a === void 0 ? void 0 : _a.admin) {
+            type = "Admin";
+        }
+        else if ((_b = req.user) === null || _b === void 0 ? void 0 : _b.testUser) {
+            type = "Test User";
+        }
+        else if ((_c = req.user) === null || _c === void 0 ? void 0 : _c.type) {
+            type = (_d = req.user) === null || _d === void 0 ? void 0 : _d.type;
+        }
+        userString = " <".concat(type, ":").concat(req.user.id, ">");
+    }
+    var body = "";
+    if (req.body && Object.keys(req.body).length > 0) {
+        var bodyCopy = (0, cloneDeep_1.default)(req.body);
+        if (bodyCopy.password) {
+            bodyCopy.password = "<PASSWORD>";
+        }
+        body = " Body: ".concat(JSON.stringify(bodyCopy));
+    }
+    if (process.env.DISABLE_LOG_ALL_REQUESTS !== "true") {
+        logger_1.logger.debug("".concat(req.method, " <- ").concat(req.url).concat(userString).concat(body));
+    }
+    (0, on_finished_1.default)(res, function () { return logRequestsFinished(req, res, startTime); });
+    next();
+}
+function createRouter(rootPath, addRoutes, middleware) {
+    if (middleware === void 0) { middleware = []; }
+    function routePathMiddleware(req, _res, next) {
+        if (!req.routeMount) {
+            req.routeMount = [];
+        }
+        req.routeMount.push(rootPath);
+        next();
+    }
+    var router = express_1.default.Router();
+    router.use(routePathMiddleware);
+    addRoutes(router);
+    return __spreadArray(__spreadArray([rootPath], __read(middleware), false), [router], false);
+}
+function createRouterWithAuth(rootPath, addRoutes, middleware) {
+    if (middleware === void 0) { middleware = []; }
+    return createRouter(rootPath, addRoutes, __spreadArray([
+        passport_1.default.authenticate("firebase-jwt", { session: false })
+    ], __read(middleware), false));
+}
+function initializeRoutes(UserModel, addRoutes, options) {
+    var _a;
+    if (options === void 0) { options = {}; }
+    var app = (0, express_1.default)();
+    // TODO: Log a warning when we hit the array limit.
+    app.set("query parser", function (str) { var _a; return qs_1.default.parse(str, { arrayLimit: (_a = options.arrayLimit) !== null && _a !== void 0 ? _a : 200 }); });
+    app.use((0, cors_1.default)({
+        origin: (_a = options.corsOrigin) !== null && _a !== void 0 ? _a : "*",
+    }));
+    if (options.addMiddleware) {
+        options.addMiddleware(app);
+    }
+    app.use(express_1.default.json());
+    // Add login/signup/refresh_token before the JWT/auth middlewares
+    (0, auth_1.addAuthRoutes)(app, UserModel, options === null || options === void 0 ? void 0 : options.authOptions);
+    (0, auth_1.setupAuth)(app, UserModel);
+    if (options.logRequests !== false) {
+        app.use(logRequests);
+    }
+    // Store the logging options on the request so we can access them later.
+    app.use(function (_req, res, next) {
+        res.locals.loggingOptions = options.loggingOptions;
+        next();
+    });
+    // Add Sentry scopes for session, transaction, and userId if any are set
+    app.all("*", function (req, _res, next) {
+        var _a;
+        var transactionId = req.header("X-Transaction-ID");
+        var sessionId = req.header("X-Session-ID");
+        if (transactionId) {
+            Sentry.getCurrentScope().setTag("transaction_id", transactionId);
+        }
+        if (sessionId) {
+            Sentry.getCurrentScope().setTag("session_id", sessionId);
+        }
+        if ((_a = req.user) === null || _a === void 0 ? void 0 : _a._id) {
+            Sentry.getCurrentScope().setTag("user", req.user._id);
+        }
+        next();
+    });
+    // Add ETag middleware for OpenAPI JSON endpoint before the openapi middleware
+    app.use(openApiEtag_1.openApiEtagMiddleware);
+    var oapi = (0, openapi_1.default)({
+        info: {
+            description: "Generated docs from an Express api",
+            title: "Express Application",
+            version: "1.0.0",
+        },
+        openapi: "3.0.0",
+    });
+    app.use(oapi);
+    if (process.env.ENABLE_SWAGGER === "true") {
+        app.use("/swagger", oapi.swaggerui());
+    }
+    (0, auth_1.addMeRoutes)(app, UserModel, options === null || options === void 0 ? void 0 : options.authOptions);
+    addRoutes(app, { openApi: oapi });
+    Sentry.setupExpressErrorHandler(app);
+    // Catch any thrown APIErrors and return them in an OpenAPI compatible format
+    app.use(errors_1.apiUnauthorizedMiddleware);
+    app.use(errors_1.apiErrorMiddleware);
+    app.use(function onError(err, _req, res, _next) {
+        logger_1.logger.error("Fallthrough error: ".concat(err).concat((err === null || err === void 0 ? void 0 : err.stack) ? "\n".concat(err.stack) : "", "}"));
+        Sentry.captureException(err);
+        res.statusCode = 500;
+        res.end("".concat(res.sentry, "\n"));
+    });
+    return app;
+}
+// Sets up the routes and returns a function to launch the API.
+function setupServer(options) {
+    var UserModel = options.userModel;
+    var addRoutes = options.addRoutes;
+    (0, logger_1.setupLogging)(options.loggingOptions);
+    var app;
+    try {
+        app = initializeRoutes(UserModel, addRoutes, {
+            addMiddleware: options.addMiddleware,
+            authOptions: options.authOptions,
+            corsOrigin: options.corsOrigin,
+        });
+    }
+    catch (error) {
+        logger_1.logger.error("Error initializing routes: ".concat(error.stack));
+        throw error;
+    }
+    if (!options.skipListen) {
+        var port_1 = process.env.PORT || "9000";
+        try {
+            app.listen(port_1, function () {
+                logger_1.logger.info("Listening on port ".concat(port_1));
+            });
+        }
+        catch (error) {
+            logger_1.logger.error("Error trying to start HTTP server: ".concat(error, "\n").concat(error.stack));
+            process.exit(1);
+        }
+    }
+    return app;
+}
+// Convenience method to execute cronjobs with an always-running server.
+function cronjob(name, schedule, callback) {
+    var _cronSchedule = schedule;
+    if (schedule === "hourly") {
+        _cronSchedule = "0 * * * *";
+    }
+    else if (schedule === "minutely") {
+        _cronSchedule = "* * * * *";
+    }
+    logger_1.logger.info("Adding cronjob ".concat(name, ", running at: ").concat(schedule));
+    try {
+        new cron_1.default.CronJob(schedule, callback, null, true, "America/Chicago");
+    }
+    catch (error) {
+        throw new Error("Failed to create cronjob: ".concat(error));
+    }
+}
+// Wrap up a script with some helpers, such as catching errors, reporting them to sentry, notifying
+// Slack of runs, etc. Also supports timeouts.
+function wrapScript(func_1) {
+    return __awaiter(this, arguments, void 0, function (func, options) {
+        var name, warnTime_1, closeTime, result, error_1;
+        var _this = this;
+        var _a, _b, _c;
+        if (options === void 0) { options = {}; }
+        return __generator(this, function (_d) {
+            switch (_d.label) {
+                case 0:
+                    name = (_a = require.main) === null || _a === void 0 ? void 0 : _a.filename.split("/").slice(-1)[0].replace(".ts", "");
+                    logger_1.logger.info("Running script ".concat(name));
+                    return [4 /*yield*/, (0, notifiers_1.sendToSlack)("Running script ".concat(name), {
+                            slackChannel: options.slackChannel,
+                        })];
+                case 1:
+                    _d.sent();
+                    if (options.terminateTimeout !== 0) {
+                        warnTime_1 = (((_b = options.terminateTimeout) !== null && _b !== void 0 ? _b : 300) / 2) * 1000;
+                        closeTime = ((_c = options.terminateTimeout) !== null && _c !== void 0 ? _c : 300) * 1000;
+                        setTimeout(function () { return __awaiter(_this, void 0, void 0, function () {
+                            var msg;
+                            return __generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0:
+                                        msg = "Script ".concat(name, " is taking a while, currently ").concat(warnTime_1 / 1000, " seconds");
+                                        return [4 /*yield*/, (0, notifiers_1.sendToSlack)(msg)];
+                                    case 1:
+                                        _a.sent();
+                                        logger_1.logger.warn(msg);
+                                        return [2 /*return*/];
+                                }
+                            });
+                        }); }, warnTime_1);
+                        setTimeout(function () { return __awaiter(_this, void 0, void 0, function () {
+                            var msg;
+                            return __generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0:
+                                        msg = "Script ".concat(name, " took too long, exiting");
+                                        return [4 /*yield*/, (0, notifiers_1.sendToSlack)(msg)];
+                                    case 1:
+                                        _a.sent();
+                                        logger_1.logger.error(msg);
+                                        Sentry.captureException(new Error("Script ".concat(name, " took too long, exiting")));
+                                        return [4 /*yield*/, Sentry.flush()];
+                                    case 2:
+                                        _a.sent();
+                                        process.exit(2);
+                                        return [2 /*return*/];
+                                }
+                            });
+                        }); }, closeTime);
+                    }
+                    _d.label = 2;
+                case 2:
+                    _d.trys.push([2, 6, , 9]);
+                    return [4 /*yield*/, func()];
+                case 3:
+                    result = _d.sent();
+                    if (!options.onFinish) return [3 /*break*/, 5];
+                    return [4 /*yield*/, options.onFinish(result)];
+                case 4:
+                    _d.sent();
+                    _d.label = 5;
+                case 5: return [3 /*break*/, 9];
+                case 6:
+                    error_1 = _d.sent();
+                    Sentry.captureException(error_1);
+                    logger_1.logger.error("Error running script ".concat(name, ": ").concat(error_1, "\n").concat(error_1.stack));
+                    return [4 /*yield*/, (0, notifiers_1.sendToSlack)("Error running script ".concat(name, ": ").concat(error_1, "\n").concat(error_1.stack))];
+                case 7:
+                    _d.sent();
+                    return [4 /*yield*/, Sentry.flush()];
+                case 8:
+                    _d.sent();
+                    process.exit(1);
+                    return [3 /*break*/, 9];
+                case 9: return [4 /*yield*/, (0, notifiers_1.sendToSlack)("Success running script ".concat(name, ": ").concat(result))];
+                case 10:
+                    _d.sent();
+                    // Unclear why we have to exit here to prevent the script for continuing to run.
+                    process.exit(0);
+                    return [2 /*return*/];
+            }
+        });
+    });
+}

package/dist/index.d.ts

@@ -0,0 +1,14 @@
+export * from "./api";
+export * from "./auth";
+export * from "./errors";
+export * from "./expressServer";
+export * from "./logger";
+export * from "./middleware";
+export * from "./notifiers";
+export * from "./openApiBuilder";
+export * from "./openApiEtag";
+export * from "./permissions";
+export * from "./plugins";
+export * from "./populate";
+export * from "./transformers";
+export * from "./utils";

package/dist/index.js

@@ -0,0 +1,30 @@
+"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 __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);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./api"), exports);
+__exportStar(require("./auth"), exports);
+__exportStar(require("./errors"), exports);
+__exportStar(require("./expressServer"), exports);
+__exportStar(require("./logger"), exports);
+__exportStar(require("./middleware"), exports);
+__exportStar(require("./notifiers"), exports);
+__exportStar(require("./openApiBuilder"), exports);
+__exportStar(require("./openApiEtag"), exports);
+__exportStar(require("./permissions"), exports);
+__exportStar(require("./plugins"), exports);
+__exportStar(require("./populate"), exports);
+__exportStar(require("./transformers"), exports);
+__exportStar(require("./utils"), exports);

package/dist/logger.d.ts

@@ -0,0 +1,23 @@
+import winston from "winston";
+export declare const winstonLogger: winston.Logger;
+export declare const logger: {
+    catch: (e: unknown) => void;
+    debug: (msg: string, ...args: unknown[]) => void;
+    error: (msg: string, ...args: unknown[]) => void;
+    info: (msg: string, ...args: unknown[]) => void;
+    warn: (msg: string, ...args: unknown[]) => void;
+};
+export interface LoggingOptions {
+    level?: "debug" | "info" | "warn" | "error";
+    transports?: winston.transport[];
+    disableFileLogging?: boolean;
+    disableConsoleLogging?: boolean;
+    disableConsoleColors?: boolean;
+    showConsoleTimestamps?: boolean;
+    logDirectory?: string;
+    logRequests?: boolean;
+    logSlowRequests?: boolean;
+    logSlowRequestsReadMs?: number;
+    logSlowRequestsWriteMs?: number;
+}
+export declare function setupLogging(options?: LoggingOptions): void;