@terreno/api 0.0.1

package/dist/tests/bunSetup.js

@@ -0,0 +1,297 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __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 });
+var bun_test_1 = require("bun:test");
+var node_stream_1 = require("node:stream");
+var mongoose_1 = __importDefault(require("mongoose"));
+var winston_1 = __importDefault(require("winston"));
+var expressServer_1 = require("../expressServer");
+var logger_1 = require("../logger");
+// Connect to MongoDB once for all tests
+(0, bun_test_1.beforeAll)(function () { return __awaiter(void 0, void 0, void 0, function () {
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4 /*yield*/, mongoose_1.default
+                    .connect("mongodb://127.0.0.1/terreno?&connectTimeoutMS=360000")
+                    .catch(logger_1.logger.catch)];
+            case 1:
+                _a.sent();
+                return [2 /*return*/];
+        }
+    });
+}); });
+// Close MongoDB connection after all tests
+(0, bun_test_1.afterAll)(function () { return __awaiter(void 0, void 0, void 0, function () {
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4 /*yield*/, mongoose_1.default.connection.close()];
+            case 1:
+                _a.sent();
+                return [2 /*return*/];
+        }
+    });
+}); });
+var logs = [];
+var SHOW_ALL_LOGS = process.env.SHOW_ALL_TEST_LOGS === "true";
+// Create a custom stream that captures logs
+var logStream = new node_stream_1.Writable({
+    write: function (chunk, _encoding, callback) {
+        logs.push(chunk.toString());
+        if (SHOW_ALL_LOGS) {
+            process.stdout.write(chunk);
+        }
+        callback();
+    },
+});
+// Silence both winston loggers by replacing all transports with our capturing stream
+var silentTransport = new winston_1.default.transports.Stream({
+    format: winston_1.default.format.simple(),
+    stream: logStream,
+});
+// Clear and silence the default winston logger
+winston_1.default.clear();
+winston_1.default.add(silentTransport);
+// Clear and silence the custom winstonLogger
+logger_1.winstonLogger.clear();
+logger_1.winstonLogger.add(silentTransport);
+// Capture and silence console methods
+var originalConsole = {
+    debug: console.debug,
+    error: console.error,
+    info: console.info,
+    // biome-ignore lint/suspicious/noConsole: We keep the original reference.
+    log: console.log,
+    warn: console.warn,
+};
+var captureConsoleMethod = function (method) {
+    console[method] = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        var logMessage = "[console.".concat(method, "] ").concat(args.map(function (arg) { return (typeof arg === "object" ? JSON.stringify(arg) : String(arg)); }).join(" "));
+        logs.push(logMessage);
+        if (SHOW_ALL_LOGS) {
+            originalConsole[method].apply(originalConsole, __spreadArray([], __read(args), false));
+        }
+    };
+};
+captureConsoleMethod("log");
+captureConsoleMethod("info");
+captureConsoleMethod("warn");
+captureConsoleMethod("error");
+captureConsoleMethod("debug");
+// Setup before each test
+(0, bun_test_1.beforeEach)(function () {
+    process.env.TOKEN_SECRET = "secret";
+    process.env.TOKEN_ISSUER = "terreno-api.test";
+    process.env.SESSION_SECRET = "sessionSecret";
+    process.env.REFRESH_TOKEN_SECRET = "refreshTokenSecret";
+    (0, expressServer_1.setupEnvironment)();
+    // Re-silence loggers after setupEnvironment which may reconfigure them
+    winston_1.default.clear();
+    winston_1.default.add(silentTransport);
+    logger_1.winstonLogger.clear();
+    logger_1.winstonLogger.add(silentTransport);
+    logs = [];
+});
+// Clear logs after each test
+(0, bun_test_1.afterEach)(function () {
+    logs = [];
+});
+// Mock @sentry/node module
+bun_test_1.mock.module("@sentry/node", function () {
+    var mockFn = function () { return (0, bun_test_1.mock)(function () { }); };
+    // Mock Scope
+    var mockScope = {
+        addBreadcrumb: mockFn(),
+        clear: mockFn(),
+        getSpan: mockFn(),
+        setContext: mockFn(),
+        setFingerprint: mockFn(),
+        setLevel: mockFn(),
+        setSpan: mockFn(),
+        setTag: mockFn(),
+        setTags: mockFn(),
+        setTransactionName: mockFn(),
+        setUser: mockFn(),
+    };
+    // Mock Hub
+    var mockClient = {
+        captureException: mockFn(),
+        captureMessage: mockFn(),
+        close: (0, bun_test_1.mock)(function () { return Promise.resolve(true); }),
+        flush: (0, bun_test_1.mock)(function () { return Promise.resolve(true); }),
+        getOptions: (0, bun_test_1.mock)(function () { return ({}); }),
+    };
+    var mockHub = {
+        addBreadcrumb: mockFn(),
+        captureException: mockFn(),
+        captureMessage: mockFn(),
+        configureScope: mockFn(),
+        getClient: (0, bun_test_1.mock)(function () { return mockClient; }),
+        getScope: (0, bun_test_1.mock)(function () { return mockScope; }),
+        popScope: mockFn(),
+        pushScope: mockFn(),
+        setContext: mockFn(),
+        setTag: mockFn(),
+        setTags: mockFn(),
+        setUser: mockFn(),
+        withScope: mockFn(),
+    };
+    var mockSpan = {
+        finish: mockFn(),
+        setData: mockFn(),
+        setStatus: mockFn(),
+        setTag: mockFn(),
+        startChild: mockFn(),
+        toTraceparent: (0, bun_test_1.mock)(function () { return "mock-trace-parent"; }),
+    };
+    mockSpan.startChild = (0, bun_test_1.mock)(function () { return mockSpan; });
+    var mockTransaction = {
+        finish: mockFn(),
+        setData: mockFn(),
+        setName: mockFn(),
+        setStatus: mockFn(),
+        setTag: mockFn(),
+        startChild: (0, bun_test_1.mock)(function () { return mockSpan; }),
+        toTraceparent: (0, bun_test_1.mock)(function () { return "mock-trace-parent"; }),
+    };
+    return {
+        addBreadcrumb: mockFn(),
+        captureException: mockFn(),
+        captureMessage: mockFn(),
+        clearScope: mockFn(),
+        close: (0, bun_test_1.mock)(function () { return Promise.resolve(true); }),
+        configureScope: mockFn(),
+        default: {
+            addBreadcrumb: mockFn(),
+            captureException: mockFn(),
+            captureMessage: mockFn(),
+            clearScope: mockFn(),
+            close: (0, bun_test_1.mock)(function () { return Promise.resolve(true); }),
+            configureScope: mockFn(),
+            flush: (0, bun_test_1.mock)(function () { return Promise.resolve(true); }),
+            getClient: (0, bun_test_1.mock)(function () { return mockClient; }),
+            getCurrentHub: (0, bun_test_1.mock)(function () { return mockHub; }),
+            getCurrentScope: (0, bun_test_1.mock)(function () { return mockScope; }),
+            Handlers: {
+                errorHandler: (0, bun_test_1.mock)(function () { return function (err, _req, _res, next) { return next(err); }; }),
+                requestHandler: (0, bun_test_1.mock)(function () { return function (_req, _res, next) { return next(); }; }),
+                tracingHandler: (0, bun_test_1.mock)(function () { return function (_req, _res, next) { return next(); }; }),
+            },
+            init: mockFn(),
+            isInitialized: (0, bun_test_1.mock)(function () { return true; }),
+            popScope: mockFn(),
+            pushScope: mockFn(),
+            Severity: {
+                Debug: "debug",
+                Error: "error",
+                Fatal: "fatal",
+                Info: "info",
+                Warning: "warning",
+            },
+            setContext: mockFn(),
+            setFingerprint: mockFn(),
+            setLevel: mockFn(),
+            setTag: mockFn(),
+            setTags: mockFn(),
+            setUser: mockFn(),
+            setupExpressErrorHandler: mockFn(),
+            startTransaction: (0, bun_test_1.mock)(function () { return mockTransaction; }),
+            withScope: (0, bun_test_1.mock)(function (callback) { return callback(mockScope); }),
+        },
+        flush: (0, bun_test_1.mock)(function () { return Promise.resolve(true); }),
+        getClient: (0, bun_test_1.mock)(function () { return mockClient; }),
+        getCurrentHub: (0, bun_test_1.mock)(function () { return mockHub; }),
+        getCurrentScope: (0, bun_test_1.mock)(function () { return mockScope; }),
+        Handlers: {
+            errorHandler: (0, bun_test_1.mock)(function () { return function (err, _req, _res, next) { return next(err); }; }),
+            requestHandler: (0, bun_test_1.mock)(function () { return function (_req, _res, next) { return next(); }; }),
+            tracingHandler: (0, bun_test_1.mock)(function () { return function (_req, _res, next) { return next(); }; }),
+        },
+        init: mockFn(),
+        isInitialized: (0, bun_test_1.mock)(function () { return true; }),
+        popScope: mockFn(),
+        pushScope: mockFn(),
+        Severity: {
+            Debug: "debug",
+            Error: "error",
+            Fatal: "fatal",
+            Info: "info",
+            Warning: "warning",
+        },
+        setContext: mockFn(),
+        setFingerprint: mockFn(),
+        setLevel: mockFn(),
+        setTag: mockFn(),
+        setTags: mockFn(),
+        setUser: mockFn(),
+        setupExpressErrorHandler: mockFn(),
+        startTransaction: (0, bun_test_1.mock)(function () { return mockTransaction; }),
+        withScope: (0, bun_test_1.mock)(function (callback) { return callback(mockScope); }),
+    };
+});

package/dist/tests/index.d.ts

@@ -0,0 +1 @@
+export * from "./bunSetup";

package/dist/tests/index.js

@@ -0,0 +1,17 @@
+"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("./bunSetup"), exports);

package/dist/tests.d.ts

@@ -0,0 +1,99 @@
+import express, { type Express } from "express";
+import mongoose, { type Model, Schema } from "mongoose";
+import type TestAgent from "supertest/lib/agent";
+export interface User {
+    admin: boolean;
+    name?: string;
+    username: string;
+    email: string;
+    age?: number;
+    disabled?: boolean;
+}
+export interface SuperUser extends User {
+    superTitle: string;
+}
+export interface StaffUser extends User {
+    department: string;
+}
+export interface FoodCategory {
+    _id?: string;
+    name: string;
+    show: boolean;
+    created: Date;
+    updated: Date;
+}
+export interface Food {
+    _id: string;
+    name: string;
+    calories: number;
+    created: Date;
+    ownerId: mongoose.Types.ObjectId | User;
+    hidden?: boolean;
+    source: {
+        name: string;
+        href?: string;
+        dateAdded?: string;
+    };
+    tags: string[];
+    eatenBy: [Schema.Types.ObjectId | User];
+    lastEatenWith: {
+        [name: string]: Date;
+    };
+    categories: FoodCategory[];
+    expiration: string;
+    likesIds: {
+        userId: string;
+        likes: boolean;
+    }[];
+}
+export declare const UserModel: mongoose.Model<User, {}, {}, {}, mongoose.Document<unknown, {}, User, {}, mongoose.DefaultSchemaOptions> & User & {
+    _id: mongoose.Types.ObjectId;
+} & {
+    __v: number;
+} & {
+    id: string;
+}, any, User>;
+export declare const SuperUserModel: mongoose.Model<User & SuperUser, {}, {}, {
+    id: string;
+}, mongoose.Document<unknown, {}, User & SuperUser, {
+    id: string;
+}, mongoose.DefaultSchemaOptions> & Omit<User & SuperUser & {
+    _id: mongoose.Types.ObjectId;
+} & {
+    __v: number;
+}, "id"> & {
+    id: string;
+}, any, User & SuperUser>;
+export declare const StaffUserModel: mongoose.Model<User & StaffUser, {}, {}, {
+    id: string;
+}, mongoose.Document<unknown, {}, User & StaffUser, {
+    id: string;
+}, mongoose.DefaultSchemaOptions> & Omit<User & StaffUser & {
+    _id: mongoose.Types.ObjectId;
+} & {
+    __v: number;
+}, "id"> & {
+    id: string;
+}, any, User & StaffUser>;
+export declare const FoodModel: Model<Food>;
+interface RequiredField {
+    name: string;
+    about?: string;
+}
+export declare const RequiredModel: mongoose.Model<RequiredField, {}, {}, {}, mongoose.Document<unknown, {}, RequiredField, {}, mongoose.DefaultSchemaOptions> & RequiredField & {
+    _id: mongoose.Types.ObjectId;
+} & {
+    __v: number;
+} & {
+    id: string;
+}, any, RequiredField>;
+export declare function getBaseServer(): Express;
+export declare function authAsUser(app: express.Application, type: "admin" | "notAdmin"): Promise<TestAgent>;
+export declare function setupDb(): Promise<(mongoose.Document<unknown, {}, User, {}, mongoose.DefaultSchemaOptions> & User & {
+    _id: mongoose.Types.ObjectId;
+} & {
+    __v: number;
+} & {
+    id: string;
+})[]>;
+export {};

package/dist/tests.js

@@ -0,0 +1,273 @@
+"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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RequiredModel = exports.FoodModel = exports.StaffUserModel = exports.SuperUserModel = exports.UserModel = void 0;
+exports.getBaseServer = getBaseServer;
+exports.authAsUser = authAsUser;
+exports.setupDb = setupDb;
+var express_1 = __importDefault(require("express"));
+var mongoose_1 = __importStar(require("mongoose"));
+var passport_local_mongoose_1 = __importDefault(require("passport-local-mongoose"));
+var supertest_1 = __importDefault(require("supertest"));
+var logger_1 = require("./logger");
+var plugins_1 = require("./plugins");
+var userSchema = new mongoose_1.Schema({
+    admin: { default: false, type: Boolean },
+    age: Number,
+    name: String,
+    username: String,
+});
+userSchema.plugin(passport_local_mongoose_1.default, {
+    attemptsField: "attempts",
+    interval: process.env.NODE_ENV === "test" ? 1 : 100,
+    limitAttempts: true,
+    maxAttempts: 3,
+    maxInterval: process.env.NODE_ENV === "test" ? 1 : 300000,
+    usernameCaseInsensitive: true,
+    usernameField: "email",
+});
+// userSchema.plugin(tokenPlugin);
+userSchema.plugin(plugins_1.createdUpdatedPlugin);
+userSchema.plugin(plugins_1.isDisabledPlugin);
+userSchema.methods.postCreate = function (body) {
+    return __awaiter(this, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            this.age = body.age;
+            return [2 /*return*/, this.save()];
+        });
+    });
+};
+exports.UserModel = (0, mongoose_1.model)("User", userSchema);
+var superUserSchema = new mongoose_1.Schema({
+    superTitle: { required: true, type: String },
+});
+exports.SuperUserModel = exports.UserModel.discriminator("SuperUser", superUserSchema);
+var staffUserSchema = new mongoose_1.Schema({
+    department: { required: true, type: String },
+});
+exports.StaffUserModel = exports.UserModel.discriminator("Staff", staffUserSchema);
+var foodCategorySchema = new mongoose_1.Schema({
+    name: String,
+    show: Boolean,
+}, { timestamps: { createdAt: "created", updatedAt: "updated" } });
+var likesSchema = new mongoose_1.Schema({
+    likes: Boolean,
+    userId: { ref: "User", type: "ObjectId" },
+});
+var foodSchema = new mongoose_1.Schema({
+    calories: Number,
+    categories: [foodCategorySchema],
+    created: Date,
+    eatenBy: [
+        {
+            ref: "User",
+            required: true,
+            type: mongoose_1.Schema.Types.ObjectId,
+        },
+    ],
+    expiration: plugins_1.DateOnly,
+    hidden: { default: false, type: Boolean },
+    lastEatenWith: {
+        of: Date,
+        type: Map,
+    },
+    likesIds: { required: true, type: [likesSchema] },
+    name: String,
+    ownerId: { ref: "User", type: "ObjectId" },
+    source: {
+        dateAdded: String,
+        href: String,
+        name: String,
+    },
+    tags: [String],
+}, { strict: "throw", toJSON: { virtuals: true }, toObject: { virtuals: true } });
+foodSchema.virtual("description").get(function () {
+    return "".concat(this.name, " has ").concat(this.calories, " calories");
+});
+exports.FoodModel = (0, mongoose_1.model)("Food", foodSchema);
+var requiredSchema = new mongoose_1.Schema({
+    about: String,
+    name: { required: true, type: String },
+});
+exports.RequiredModel = (0, mongoose_1.model)("Required", requiredSchema);
+function getBaseServer() {
+    var app = (0, express_1.default)();
+    app.all("/*", function (req, res, next) {
+        res.header("Access-Control-Allow-Origin", "*");
+        res.header("Access-Control-Allow-Headers", "*");
+        // intercepts OPTIONS method
+        if (req.method === "OPTIONS") {
+            res.send(200);
+        }
+        else {
+            next();
+        }
+    });
+    app.use(express_1.default.json());
+    return app;
+}
+function authAsUser(app, type) {
+    return __awaiter(this, void 0, void 0, function () {
+        var email, password, agent, res;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    email = type === "admin" ? "admin@example.com" : "notAdmin@example.com";
+                    password = type === "admin" ? "securePassword" : "password";
+                    agent = supertest_1.default.agent(app);
+                    return [4 /*yield*/, agent.post("/auth/login").send({ email: email, password: password }).expect(200)];
+                case 1:
+                    res = _a.sent();
+                    return [4 /*yield*/, agent.set("authorization", "Bearer ".concat(res.body.data.token))];
+                case 2:
+                    _a.sent();
+                    return [2 /*return*/, agent];
+            }
+        });
+    });
+}
+function setupDb() {
+    return __awaiter(this, void 0, void 0, function () {
+        var _a, notAdmin, admin, adminOther, error_1;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0: return [4 /*yield*/, mongoose_1.default
+                        .connect("mongodb://127.0.0.1/terreno?&connectTimeoutMS=360000")
+                        .catch(logger_1.logger.catch)];
+                case 1:
+                    _b.sent();
+                    process.env.REFRESH_TOKEN_SECRET = "refresh_secret";
+                    process.env.TOKEN_SECRET = "secret";
+                    process.env.TOKEN_EXPIRES_IN = "30m";
+                    process.env.TOKEN_ISSUER = "example.com";
+                    process.env.SESSION_SECRET = "session";
+                    // Broken out of the try/catch below so you can test the catch logger by shutting down mongo.
+                    return [4 /*yield*/, Promise.all([exports.UserModel.deleteMany({}), exports.FoodModel.deleteMany({})]).catch(logger_1.logger.catch)];
+                case 2:
+                    // Broken out of the try/catch below so you can test the catch logger by shutting down mongo.
+                    _b.sent();
+                    _b.label = 3;
+                case 3:
+                    _b.trys.push([3, 11, , 12]);
+                    return [4 /*yield*/, Promise.all([
+                            exports.UserModel.create({ email: "notAdmin@example.com", name: "Not Admin" }),
+                            exports.UserModel.create({ admin: true, email: "admin@example.com", name: "Admin" }),
+                            exports.UserModel.create({ admin: true, email: "admin+other@example.com", name: "Admin Other" }),
+                        ])];
+                case 4:
+                    _a = __read.apply(void 0, [_b.sent(), 3]), notAdmin = _a[0], admin = _a[1], adminOther = _a[2];
+                    return [4 /*yield*/, notAdmin.setPassword("password")];
+                case 5:
+                    _b.sent();
+                    return [4 /*yield*/, notAdmin.save()];
+                case 6:
+                    _b.sent();
+                    return [4 /*yield*/, admin.setPassword("securePassword")];
+                case 7:
+                    _b.sent();
+                    return [4 /*yield*/, admin.save()];
+                case 8:
+                    _b.sent();
+                    return [4 /*yield*/, adminOther.setPassword("otherPassword")];
+                case 9:
+                    _b.sent();
+                    return [4 /*yield*/, adminOther.save()];
+                case 10:
+                    _b.sent();
+                    return [2 /*return*/, [admin, notAdmin, adminOther]];
+                case 11:
+                    error_1 = _b.sent();
+                    console.error("Error setting up DB", error_1);
+                    throw error_1;
+                case 12: return [2 /*return*/];
+            }
+        });
+    });
+}