@terreno/api 0.0.1

package/dist/auth.d.ts

@@ -0,0 +1,50 @@
+import express from "express";
+import type { Model, ObjectId } from "mongoose";
+import type { AuthOptions } from "./expressServer";
+export interface User {
+    _id: ObjectId | string;
+    id: string;
+    admin: boolean;
+    /**
+     * We support anonymous users, which do not yet have login information.
+     * This can be helpful for pre-signup users.
+     */
+    isAnonymous?: boolean;
+}
+export interface UserModel extends Model<User> {
+    createAnonymousUser?: (id?: string) => Promise<User>;
+    postCreate?: (body: any) => Promise<void>;
+    createStrategy(): any;
+    serializeUser(): any;
+    deserializeUser(): any;
+    findByUsername(username: string, findOpts: any): any;
+}
+export declare function authenticateMiddleware(anonymous?: boolean): any;
+export declare function signupUser(userModel: UserModel, email: string, password: string, body?: any): Promise<any>;
+/**
+ * Generates both an access token (JWT) and a refresh token for a given user.
+ *
+ * This function:
+ * - Signs the user's `_id` into a short-lived JWT (`token`)
+ *   and a long-lived refresh token (`refreshToken`).
+ * - Supports custom expiration logic
+ *   and payload customization via `AuthOptions`.
+ * - Reads token secrets, issuer,
+ *   and default expirations from environment variables.
+ * - Returns `{ token, refreshToken }`,
+ *   or `{ token: null, refreshToken: null }` if the user is missing.
+ *
+ * It is exported to allow external implementations (such as OAuth integrations or other
+ * authentication providers) to reuse and customize the same token generation logic.
+ * This ensures consistent and secure token issuance across different authentication flows.
+ */
+export declare const generateTokens: (user: any, authOptions?: AuthOptions) => Promise<{
+    refreshToken: null;
+    token: null;
+} | {
+    refreshToken: any;
+    token: string;
+}>;
+export declare function setupAuth(app: express.Application, userModel: UserModel): void;
+export declare function addAuthRoutes(app: express.Application, userModel: UserModel, authOptions?: AuthOptions): void;
+export declare function addMeRoutes(app: express.Application, userModel: UserModel, _authOptions?: AuthOptions): void;

package/dist/auth.js

@@ -0,0 +1,512 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+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 __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateTokens = void 0;
+exports.authenticateMiddleware = authenticateMiddleware;
+exports.signupUser = signupUser;
+exports.setupAuth = setupAuth;
+exports.addAuthRoutes = addAuthRoutes;
+exports.addMeRoutes = addMeRoutes;
+var express_1 = __importDefault(require("express"));
+var jsonwebtoken_1 = __importDefault(require("jsonwebtoken"));
+var ms_1 = __importDefault(require("ms"));
+var passport_1 = __importDefault(require("passport"));
+var passport_anonymous_1 = require("passport-anonymous");
+var passport_jwt_1 = require("passport-jwt");
+var passport_local_1 = require("passport-local");
+var errors_1 = require("./errors");
+var logger_1 = require("./logger");
+function authenticateMiddleware(anonymous) {
+    if (anonymous === void 0) { anonymous = false; }
+    var strategies = ["jwt"];
+    if (anonymous) {
+        strategies.push("anonymous");
+    }
+    return passport_1.default.authenticate(strategies, {
+        failureMessage: false, // this is just avoiding storing the message in the session
+        failWithError: true,
+        session: false,
+    });
+}
+function signupUser(userModel, email, password, body) {
+    return __awaiter(this, void 0, void 0, function () {
+        var _email, _password, bodyRest, user, error_1, error_2;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    _email = body.email, _password = body.password, bodyRest = __rest(body, ["email", "password"]);
+                    _a.label = 1;
+                case 1:
+                    _a.trys.push([1, 8, , 9]);
+                    return [4 /*yield*/, userModel.register(__assign({ email: email }, bodyRest), password)];
+                case 2:
+                    user = _a.sent();
+                    if (!user.postCreate) return [3 /*break*/, 6];
+                    _a.label = 3;
+                case 3:
+                    _a.trys.push([3, 5, , 6]);
+                    return [4 /*yield*/, user.postCreate(bodyRest)];
+                case 4:
+                    _a.sent();
+                    return [3 /*break*/, 6];
+                case 5:
+                    error_1 = _a.sent();
+                    logger_1.logger.error("Error in user.postCreate: ".concat(error_1));
+                    throw error_1;
+                case 6: return [4 /*yield*/, user.save()];
+                case 7:
+                    _a.sent();
+                    return [2 /*return*/, user];
+                case 8:
+                    error_2 = _a.sent();
+                    throw new errors_1.APIError({ title: error_2.message });
+                case 9: return [2 /*return*/];
+            }
+        });
+    });
+}
+/**
+ * Generates both an access token (JWT) and a refresh token for a given user.
+ *
+ * This function:
+ * - Signs the user's `_id` into a short-lived JWT (`token`)
+ *   and a long-lived refresh token (`refreshToken`).
+ * - Supports custom expiration logic
+ *   and payload customization via `AuthOptions`.
+ * - Reads token secrets, issuer,
+ *   and default expirations from environment variables.
+ * - Returns `{ token, refreshToken }`,
+ *   or `{ token: null, refreshToken: null }` if the user is missing.
+ *
+ * It is exported to allow external implementations (such as OAuth integrations or other
+ * authentication providers) to reuse and customize the same token generation logic.
+ * This ensures consistent and secure token issuance across different authentication flows.
+ */
+var generateTokens = function (user, authOptions) { return __awaiter(void 0, void 0, void 0, function () {
+    var tokenSecretOrKey, payload, tokenOptions, token, refreshTokenSecretOrKey, refreshToken, refreshTokenOptions;
+    return __generator(this, function (_a) {
+        tokenSecretOrKey = process.env.TOKEN_SECRET;
+        if (!tokenSecretOrKey) {
+            throw new Error("TOKEN_SECRET must be set in env.");
+        }
+        if (!(user === null || user === void 0 ? void 0 : user._id)) {
+            logger_1.logger.warn("No user found for token generation");
+            return [2 /*return*/, { refreshToken: null, token: null }];
+        }
+        payload = { id: user._id.toString() };
+        if (authOptions === null || authOptions === void 0 ? void 0 : authOptions.generateJWTPayload) {
+            payload = __assign(__assign({}, authOptions.generateJWTPayload(user)), payload);
+        }
+        tokenOptions = {
+            expiresIn: "15m",
+        };
+        if (authOptions === null || authOptions === void 0 ? void 0 : authOptions.generateTokenExpiration) {
+            tokenOptions.expiresIn = authOptions.generateTokenExpiration(user);
+        }
+        else if (process.env.TOKEN_EXPIRES_IN) {
+            try {
+                // this call to ms is purely for validation of the env variable. If it is invalid,
+                // we want to be able to log the error and use the default.
+                (0, ms_1.default)(process.env.TOKEN_EXPIRES_IN);
+                tokenOptions.expiresIn = process.env.TOKEN_EXPIRES_IN;
+            }
+            catch (error) {
+                // This error will result in using the default value above of 15m.
+                logger_1.logger.error(error);
+            }
+        }
+        if (process.env.TOKEN_ISSUER) {
+            tokenOptions.issuer = process.env.TOKEN_ISSUER;
+        }
+        token = jsonwebtoken_1.default.sign(payload, tokenSecretOrKey, tokenOptions);
+        refreshTokenSecretOrKey = process.env.REFRESH_TOKEN_SECRET;
+        if (refreshTokenSecretOrKey) {
+            refreshTokenOptions = {
+                expiresIn: "30d",
+            };
+            if (authOptions === null || authOptions === void 0 ? void 0 : authOptions.generateRefreshTokenExpiration) {
+                refreshTokenOptions.expiresIn = authOptions.generateRefreshTokenExpiration(user);
+            }
+            else if (process.env.REFRESH_TOKEN_EXPIRES_IN) {
+                try {
+                    // this call to ms is purely for validation of the env variable. If it is invalid,
+                    // we want to be able to log the error and use the default.
+                    (0, ms_1.default)(process.env.REFRESH_TOKEN_EXPIRES_IN);
+                    refreshTokenOptions.expiresIn = process.env.REFRESH_TOKEN_EXPIRES_IN;
+                }
+                catch (error) {
+                    // This error will result in using the default value above of 30d.
+                    logger_1.logger.error(error);
+                }
+            }
+            refreshToken = jsonwebtoken_1.default.sign(payload, refreshTokenSecretOrKey, refreshTokenOptions);
+        }
+        else {
+            logger_1.logger.info("REFRESH_TOKEN_SECRET not set so refresh tokens will not be issued");
+        }
+        return [2 /*return*/, { refreshToken: refreshToken, token: token }];
+    });
+}); };
+exports.generateTokens = generateTokens;
+// TODO allow customization
+function setupAuth(app, userModel) {
+    var _this = this;
+    passport_1.default.use(new passport_anonymous_1.Strategy());
+    passport_1.default.use(userModel.createStrategy());
+    passport_1.default.use("signup", new passport_local_1.Strategy({
+        passReqToCallback: true,
+        passwordField: "password",
+        usernameField: "email",
+    }, function (req, email, password, done) { return __awaiter(_this, void 0, void 0, function () {
+        var _a, _b, error_3;
+        return __generator(this, function (_c) {
+            switch (_c.label) {
+                case 0:
+                    _c.trys.push([0, 2, , 3]);
+                    _a = done;
+                    _b = [undefined];
+                    return [4 /*yield*/, signupUser(userModel, email, password, req.body)];
+                case 1:
+                    _a.apply(void 0, _b.concat([_c.sent()]));
+                    return [3 /*break*/, 3];
+                case 2:
+                    error_3 = _c.sent();
+                    return [2 /*return*/, done(error_3)];
+                case 3: return [2 /*return*/];
+            }
+        });
+    }); }));
+    if (!userModel.createStrategy) {
+        throw new Error("setupAuth userModel must have .createStrategy()");
+    }
+    var customTokenExtractor = function (req) {
+        var _a, _b, _c;
+        var token = null;
+        if ((_a = req === null || req === void 0 ? void 0 : req.cookies) === null || _a === void 0 ? void 0 : _a.jwt) {
+            token = req.cookies.jwt;
+        }
+        else if ((_b = req === null || req === void 0 ? void 0 : req.headers) === null || _b === void 0 ? void 0 : _b.authorization) {
+            token = (_c = req === null || req === void 0 ? void 0 : req.headers) === null || _c === void 0 ? void 0 : _c.authorization.split(" ")[1];
+        }
+        return token;
+    };
+    if (process.env.TOKEN_SECRET) {
+        if (process.env.NODE_ENV !== "test") {
+            logger_1.logger.debug("Setting up JWT Authentication");
+        }
+        var secretOrKey = process.env.TOKEN_SECRET;
+        if (!secretOrKey) {
+            throw new Error("TOKEN_SECRET must be set in env.");
+        }
+        var jwtOpts = {
+            issuer: process.env.TOKEN_ISSUER,
+            jwtFromRequest: customTokenExtractor,
+            secretOrKey: secretOrKey,
+        };
+        passport_1.default.use("jwt", new passport_jwt_1.Strategy(jwtOpts, function (jwtPayload, done) { return __awaiter(_this, void 0, void 0, function () {
+            var user, error_4;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!jwtPayload) {
+                            return [2 /*return*/, done(null, false)];
+                        }
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, 3, , 4]);
+                        return [4 /*yield*/, userModel.findById(jwtPayload.id)];
+                    case 2:
+                        user = _a.sent();
+                        return [3 /*break*/, 4];
+                    case 3:
+                        error_4 = _a.sent();
+                        logger_1.logger.warn("[jwt] Error finding user from id: ".concat(error_4));
+                        return [2 /*return*/, done(error_4, false)];
+                    case 4:
+                        if (user) {
+                            return [2 /*return*/, done(null, user)];
+                        }
+                        if (!userModel.createAnonymousUser) return [3 /*break*/, 6];
+                        logger_1.logger.info("[jwt] Creating anonymous user");
+                        return [4 /*yield*/, userModel.createAnonymousUser()];
+                    case 5:
+                        user = _a.sent();
+                        return [2 /*return*/, done(null, user)];
+                    case 6:
+                        logger_1.logger.info("[jwt] No user found from token");
+                        return [2 /*return*/, done(null, false)];
+                }
+            });
+        }); }));
+    }
+    // Adds req.user to the request. This may wind up duplicating requests with passport,
+    // but passport doesn't give us req.user early enough.
+    function decodeJWTMiddleware(req, res, next) {
+        return __awaiter(this, void 0, void 0, function () {
+            var token, decoded, userText, details, _a, error_5;
+            var _b, _c, _d, _e;
+            return __generator(this, function (_f) {
+                switch (_f.label) {
+                    case 0:
+                        if (!process.env.TOKEN_SECRET) {
+                            return [2 /*return*/, next()];
+                        }
+                        // Allow requests with a "Secret" prefix to pass through since this is a string value,
+                        // not a jwt that needs to be decoded
+                        if (((_c = (_b = req === null || req === void 0 ? void 0 : req.headers) === null || _b === void 0 ? void 0 : _b.authorization) === null || _c === void 0 ? void 0 : _c.split(" ")[0]) === "Secret") {
+                            return [2 /*return*/, next()];
+                        }
+                        token = customTokenExtractor(req);
+                        // For some reason, our app will happily put null into the authorization header when logging
+                        // out then back in.
+                        if (!token || token === "null" || token === "undefined") {
+                            return [2 /*return*/, next()];
+                        }
+                        try {
+                            decoded = jsonwebtoken_1.default.verify(token, process.env.TOKEN_SECRET, {
+                                issuer: process.env.TOKEN_ISSUER,
+                            });
+                        }
+                        catch (error) {
+                            userText = ((_d = req.user) === null || _d === void 0 ? void 0 : _d._id) ? " for user ".concat(req.user._id, " ") : "";
+                            details = "[jwt] Error decoding token".concat(userText, ": ").concat(error, ", expired at ").concat(error === null || error === void 0 ? void 0 : error.expiredAt, ", current time: ").concat(Date.now());
+                            logger_1.logger.debug(details);
+                            return [2 /*return*/, res.status(401).json({ details: details, message: error === null || error === void 0 ? void 0 : error.message })];
+                        }
+                        if (!decoded.id) return [3 /*break*/, 4];
+                        _f.label = 1;
+                    case 1:
+                        _f.trys.push([1, 3, , 4]);
+                        _a = req;
+                        return [4 /*yield*/, userModel.findById(decoded.id)];
+                    case 2:
+                        _a.user = _f.sent();
+                        if ((_e = req.user) === null || _e === void 0 ? void 0 : _e.disabled) {
+                            logger_1.logger.warn("[jwt] User ".concat(req.user.id, " is disabled"));
+                            return [2 /*return*/, res.status(401).json({ status: 401, title: "User is disabled" })];
+                        }
+                        return [3 /*break*/, 4];
+                    case 3:
+                        error_5 = _f.sent();
+                        logger_1.logger.warn("[jwt] Error finding user from id: ".concat(error_5));
+                        return [3 /*break*/, 4];
+                    case 4: return [2 /*return*/, next()];
+                }
+            });
+        });
+    }
+    app.use(decodeJWTMiddleware);
+    app.use(express_1.default.urlencoded({ extended: false }));
+}
+function addAuthRoutes(app, userModel, authOptions) {
+    var _this = this;
+    var router = express_1.default.Router();
+    router.post("/login", function (req, res, next) { return __awaiter(_this, void 0, void 0, function () {
+        var _this = this;
+        return __generator(this, function (_a) {
+            passport_1.default.authenticate("local", { session: false }, function (err, user, info) { return __awaiter(_this, void 0, void 0, function () {
+                var tokens;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0:
+                            if (err) {
+                                logger_1.logger.error("Error logging in: ".concat(err));
+                                return [2 /*return*/, next(err)];
+                            }
+                            if (!user) {
+                                logger_1.logger.warn("Invalid login: ".concat(info));
+                                return [2 /*return*/, res.status(401).json({ message: info === null || info === void 0 ? void 0 : info.message })];
+                            }
+                            logger_1.logger.info("User logged in: ".concat(user._id, ", type: ").concat(user.type || "N/A"));
+                            return [4 /*yield*/, (0, exports.generateTokens)(user, authOptions)];
+                        case 1:
+                            tokens = _a.sent();
+                            return [2 /*return*/, res.json({
+                                    data: { refreshToken: tokens.refreshToken, token: tokens.token, userId: user === null || user === void 0 ? void 0 : user._id },
+                                })];
+                    }
+                });
+            }); })(req, res, next);
+            return [2 /*return*/];
+        });
+    }); });
+    router.post("/refresh_token", function (req, res) { return __awaiter(_this, void 0, void 0, function () {
+        var refreshTokenSecretOrKey, decoded, user, tokens;
+        var _a, _b, _c, _d;
+        return __generator(this, function (_e) {
+            switch (_e.label) {
+                case 0:
+                    if (!req.body.refreshToken) {
+                        logger_1.logger.error("No refresh token provided, must provide refreshToken in body, user id: ".concat((_a = req.user) === null || _a === void 0 ? void 0 : _a.id));
+                        return [2 /*return*/, res
+                                .status(401)
+                                .json({ message: "No refresh token provided, must provide refreshToken in body" })];
+                    }
+                    if (!process.env.REFRESH_TOKEN_SECRET) {
+                        logger_1.logger.error("No REFRESH_TOKEN_SECRET set, cannot refresh token, user id: ".concat((_b = req.user) === null || _b === void 0 ? void 0 : _b.id));
+                        return [2 /*return*/, res.status(401).json({ message: "No REFRESH_TOKEN_SECRET set, cannot refresh token" })];
+                    }
+                    refreshTokenSecretOrKey = process.env.REFRESH_TOKEN_SECRET;
+                    try {
+                        decoded = jsonwebtoken_1.default.verify(req.body.refreshToken, refreshTokenSecretOrKey);
+                    }
+                    catch (error) {
+                        logger_1.logger.error("Error refreshing token for user ".concat((_c = req.user) === null || _c === void 0 ? void 0 : _c.id, ": ").concat(error));
+                        return [2 /*return*/, res.status(401).json({ message: error === null || error === void 0 ? void 0 : error.message })];
+                    }
+                    if (!(decoded === null || decoded === void 0 ? void 0 : decoded.id)) return [3 /*break*/, 3];
+                    return [4 /*yield*/, userModel.findById(decoded.id)];
+                case 1:
+                    user = _e.sent();
+                    return [4 /*yield*/, (0, exports.generateTokens)(user, authOptions)];
+                case 2:
+                    tokens = _e.sent();
+                    logger_1.logger.debug("Refreshed token for ".concat(user === null || user === void 0 ? void 0 : user.id));
+                    return [2 /*return*/, res.json({ data: { refreshToken: tokens.refreshToken, token: tokens.token } })];
+                case 3:
+                    logger_1.logger.error("Invalid refresh token, user id: ".concat((_d = req.user) === null || _d === void 0 ? void 0 : _d.id));
+                    return [2 /*return*/, res.status(401).json({ message: "Invalid refresh token" })];
+            }
+        });
+    }); });
+    var signupDisabled = process.env.SIGNUP_DISABLED === "true";
+    if (!signupDisabled) {
+        router.post("/signup", passport_1.default.authenticate("signup", { failWithError: true, session: false }), function (req, res) { return __awaiter(_this, void 0, void 0, function () {
+            var tokens;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, (0, exports.generateTokens)(req.user, authOptions)];
+                    case 1:
+                        tokens = _a.sent();
+                        return [2 /*return*/, res.json({
+                                data: { refreshToken: tokens.refreshToken, token: tokens.token, userId: req.user._id },
+                            })];
+                }
+            });
+        }); });
+    }
+    app.set("etag", false);
+    app.use("/auth", router);
+}
+function addMeRoutes(app, userModel, _authOptions) {
+    var _this = this;
+    var router = express_1.default.Router();
+    router.get("/me", authenticateMiddleware(), function (req, res) { return __awaiter(_this, void 0, void 0, function () {
+        var data, dataObject;
+        var _a;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    if (!((_a = req.user) === null || _a === void 0 ? void 0 : _a.id)) {
+                        logger_1.logger.debug("Not user found for /me");
+                        return [2 /*return*/, res.sendStatus(401)];
+                    }
+                    return [4 /*yield*/, userModel.findById(req.user.id)];
+                case 1:
+                    data = _b.sent();
+                    if (!data) {
+                        logger_1.logger.debug("Not user data found for /me");
+                        return [2 /*return*/, res.sendStatus(404)];
+                    }
+                    dataObject = data.toObject();
+                    dataObject.id = data._id;
+                    return [2 /*return*/, res.json({ data: dataObject })];
+            }
+        });
+    }); });
+    router.patch("/me", authenticateMiddleware(), function (req, res) { return __awaiter(_this, void 0, void 0, function () {
+        var doc, dataObject, error_6;
+        var _a;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    if (!((_a = req.user) === null || _a === void 0 ? void 0 : _a.id)) {
+                        return [2 /*return*/, res.sendStatus(401)];
+                    }
+                    return [4 /*yield*/, userModel.findById(req.user.id)];
+                case 1:
+                    doc = _b.sent();
+                    if (!doc) {
+                        return [2 /*return*/, res.sendStatus(404)];
+                    }
+                    _b.label = 2;
+                case 2:
+                    _b.trys.push([2, 4, , 5]);
+                    Object.assign(doc, req.body);
+                    return [4 /*yield*/, doc.save()];
+                case 3:
+                    _b.sent();
+                    dataObject = doc.toObject();
+                    dataObject.id = doc._id;
+                    return [2 /*return*/, res.json({ data: dataObject })];
+                case 4:
+                    error_6 = _b.sent();
+                    return [2 /*return*/, res.status(403).send({ message: error_6.message })];
+                case 5: return [2 /*return*/];
+            }
+        });
+    }); });
+    app.set("etag", false);
+    app.use("/auth", router);
+    app.use(errors_1.apiErrorMiddleware);
+}

package/dist/auth.test.d.ts

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