@terreno/api 0.20.2 → 0.22.0

package/dist/tests/models.d.ts

@@ -0,0 +1,71 @@
+import mongoose, { type Model, Schema } from "mongoose";
+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 interface RequiredField {
+    name: string;
+    about?: string;
+}
+export declare const UserModel: mongoose.Model<User, {}, {}, {}, mongoose.Document<unknown, {}, User, {}, {}> & User & {
+    _id: mongoose.Types.ObjectId;
+} & {
+    __v: number;
+}, any>;
+export declare const SuperUserModel: mongoose.Model<User & SuperUser, {}, {}, {}, mongoose.Document<unknown, {}, User & SuperUser, {}, {}> & User & SuperUser & {
+    _id: mongoose.Types.ObjectId;
+} & {
+    __v: number;
+}, any>;
+export declare const StaffUserModel: mongoose.Model<User & StaffUser, {}, {}, {}, mongoose.Document<unknown, {}, User & StaffUser, {}, {}> & User & StaffUser & {
+    _id: mongoose.Types.ObjectId;
+} & {
+    __v: number;
+}, any>;
+export declare const FoodModel: Model<Food>;
+export declare const RequiredModel: mongoose.Model<RequiredField, {}, {}, {}, mongoose.Document<unknown, {}, RequiredField, {}, {}> & RequiredField & {
+    _id: mongoose.Types.ObjectId;
+} & {
+    __v: number;
+}, any>;

package/dist/tests/models.js

@@ -0,0 +1,134 @@
+"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 __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;
+var mongoose_1 = require("mongoose");
+var passport_local_mongoose_1 = __importDefault(require("passport-local-mongoose"));
+var plugins_1 = require("../plugins");
+var userSchema = new mongoose_1.Schema({
+    admin: { default: false, description: "Whether the user has admin privileges", type: Boolean },
+    age: { description: "The user's age", type: Number },
+    name: { description: "The user's display name", type: String },
+    username: { description: "The user's username", type: 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(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: { description: "The super user's title", required: true, type: String },
+});
+exports.SuperUserModel = exports.UserModel.discriminator("SuperUser", superUserSchema);
+var staffUserSchema = new mongoose_1.Schema({
+    department: {
+        description: "The department the staff member belongs to",
+        required: true,
+        type: String,
+    },
+});
+exports.StaffUserModel = exports.UserModel.discriminator("Staff", staffUserSchema);
+var foodCategorySchema = new mongoose_1.Schema({
+    name: { description: "The name of the food category", type: String },
+    show: { description: "Whether this category is visible", type: Boolean },
+}, { timestamps: { createdAt: "created", updatedAt: "updated" } });
+var likesSchema = new mongoose_1.Schema({
+    likes: { description: "Whether the user liked the item", type: Boolean },
+    userId: { description: "The user who liked the item", ref: "User", type: "ObjectId" },
+});
+var foodSchema = new mongoose_1.Schema({
+    calories: { description: "Number of calories in the food", type: Number },
+    categories: { description: "Categories this food belongs to", type: [foodCategorySchema] },
+    created: { description: "When this food was created", type: Date },
+    eatenBy: [
+        {
+            description: "Users who have eaten this food",
+            ref: "User",
+            required: true,
+            type: mongoose_1.Schema.Types.ObjectId,
+        },
+    ],
+    // biome-ignore lint/suspicious/noExplicitAny: DateOnly is a custom SchemaType not recognized by Mongoose's built-in type definitions
+    expiration: { description: "Expiration date of the food", type: plugins_1.DateOnly },
+    hidden: {
+        default: false,
+        description: "Whether this food is hidden from listings",
+        type: Boolean,
+    },
+    lastEatenWith: {
+        description: "Map of user names to dates they last ate this food with",
+        of: Date,
+        type: Map,
+    },
+    likesIds: { description: "User likes for this food", required: true, type: [likesSchema] },
+    name: { description: "The name of the food", type: String },
+    ownerId: { description: "The user who owns this food entry", ref: "User", type: "ObjectId" },
+    source: {
+        dateAdded: { description: "When the source was added", type: String },
+        href: { description: "URL of the source", type: String },
+        name: { description: "Name of the source", type: String },
+    },
+    tags: { description: "Tags associated with this food", type: [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: { description: "Information about the item", type: String },
+    name: { description: "The name of the item", required: true, type: String },
+});
+exports.RequiredModel = (0, mongoose_1.model)("Required", requiredSchema);

package/dist/tests/mongoTestSetup.d.ts

@@ -0,0 +1,7 @@
+import type { TestData } from "./types";
+export declare const cacheFilesExist: () => boolean, cleanCache: () => void, loadTestDataFromCache: () => Promise<void>, setupTestCache: (options?: {
+    force?: boolean;
+}) => Promise<void>;
+/** Loads fixture documents after the collection cache has been restored. */
+export declare const loadTestData: () => Promise<TestData>;
+export declare const resetCachedTestData: () => void;

package/dist/tests/mongoTestSetup.js

@@ -0,0 +1,150 @@
+"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 _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resetCachedTestData = exports.loadTestData = exports.setupTestCache = exports.loadTestDataFromCache = exports.cleanCache = exports.cacheFilesExist = void 0;
+var fs = __importStar(require("node:fs"));
+var path = __importStar(require("node:path"));
+var test_1 = require("@terreno/test");
+var createTestData_1 = require("./createTestData");
+var moduleDir = __dirname;
+var defaultCacheDir = process.env.TERRENO_TEST_CACHE_DIR || path.join("/tmp", "terreno-api-test-cache");
+var apiTestCache = (0, test_1.createMongoTestCache)({
+    baseDatabaseName: "terrenoTest_base",
+    cacheDir: defaultCacheDir,
+    createTestData: function () { return __awaiter(void 0, void 0, void 0, function () {
+        var testData;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, (0, createTestData_1.createTestData)()];
+                case 1:
+                    testData = _a.sent();
+                    return [2 /*return*/, (0, createTestData_1.toCachedTestData)(testData)];
+            }
+        });
+    }); },
+    sourceDirs: [path.resolve(moduleDir, "..")],
+});
+exports.cacheFilesExist = apiTestCache.cacheFilesExist, exports.cleanCache = apiTestCache.cleanCache, exports.loadTestDataFromCache = apiTestCache.loadTestDataFromCache, exports.setupTestCache = apiTestCache.setupTestCache;
+var cachedTestData;
+/** Loads fixture documents after the collection cache has been restored. */
+var loadTestData = function () { return __awaiter(void 0, void 0, void 0, function () {
+    var cachedFilePath, cached;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                if (cachedTestData) {
+                    return [2 /*return*/, cachedTestData];
+                }
+                cachedFilePath = path.join(defaultCacheDir, "cached-data.json");
+                cached = JSON.parse(fs.readFileSync(cachedFilePath, "utf-8"));
+                return [4 /*yield*/, (0, createTestData_1.loadTestDataFromDocuments)(cached)];
+            case 1:
+                cachedTestData = _a.sent();
+                return [2 /*return*/, cachedTestData];
+        }
+    });
+}); };
+exports.loadTestData = loadTestData;
+var resetCachedTestData = function () {
+    cachedTestData = undefined;
+};
+exports.resetCachedTestData = resetCachedTestData;
+if ((_a = process.argv[1]) === null || _a === void 0 ? void 0 : _a.includes("mongoTestSetup")) {
+    var command_1 = process.argv[2];
+    var force_1 = process.argv.includes("--force");
+    void (function () { return __awaiter(void 0, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    if (!(command_1 === "setup")) return [3 /*break*/, 2];
+                    return [4 /*yield*/, (0, exports.setupTestCache)({ force: force_1 })];
+                case 1:
+                    _a.sent();
+                    process.exit(0);
+                    _a.label = 2;
+                case 2:
+                    if (command_1 === "clean") {
+                        (0, exports.cleanCache)();
+                        (0, exports.resetCachedTestData)();
+                        process.exit(0);
+                    }
+                    if (command_1 === "status") {
+                        console.info("[mongoTestSetup] cache exists: ".concat((0, exports.cacheFilesExist)()));
+                        process.exit(0);
+                    }
+                    console.error("[mongoTestSetup] Unknown command: ".concat(command_1 !== null && command_1 !== void 0 ? command_1 : "(none)", ". Usage: setup | clean | status"));
+                    process.exit(1);
+                    return [2 /*return*/];
+            }
+        });
+    }); })();
+}

package/dist/tests/testEnv.js

@@ -0,0 +1,6 @@
+"use strict";
+var _a;
+/** Use in-memory MongoDB when no external test URI is configured (local / CI without mongod). */
+if (!((_a = process.env.TERRENO_TEST_MONGODB_URI) === null || _a === void 0 ? void 0 : _a.trim())) {
+    process.env.TERRENO_TEST_USE_MEMORY_MONGO = "true";
+}

package/dist/tests/testHelper.d.ts

@@ -0,0 +1,22 @@
+import type { TestData } from "./types";
+export declare const applyTestAuthEnv: () => void;
+/** Seeds only the standard users (legacy helper). */
+export declare const setupDb: () => Promise<readonly [import("mongoose").Document<unknown, {}, import("./models").User, {}, {}> & import("./models").User & {
+    _id: import("mongoose").Types.ObjectId;
+} & {
+    __v: number;
+}, import("mongoose").Document<unknown, {}, import("./models").User, {}, {}> & import("./models").User & {
+    _id: import("mongoose").Types.ObjectId;
+} & {
+    __v: number;
+}, import("mongoose").Document<unknown, {}, import("./models").User, {}, {}> & import("./models").User & {
+    _id: import("mongoose").Types.ObjectId;
+} & {
+    __v: number;
+}]>;
+/** Seeds users, foods, and required docs — the recommended API test baseline. */
+export declare const setupTestData: () => Promise<TestData>;
+/** Clears all API test collections without re-seeding. */
+export declare const resetTestCollections: () => Promise<void>;
+export { createTestData } from "./createTestData";
+export { loadTestData } from "./mongoTestSetup";

package/dist/tests/testHelper.js

@@ -0,0 +1,115 @@
+"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 };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadTestData = exports.createTestData = exports.resetTestCollections = exports.setupTestData = exports.setupDb = exports.applyTestAuthEnv = void 0;
+var test_1 = require("@terreno/test");
+var logger_1 = require("../logger");
+var createTestData_1 = require("./createTestData");
+var models_1 = require("./models");
+var mongoTestSetup_1 = require("./mongoTestSetup");
+var defaultTestMongoUri = "mongodb://127.0.0.1/terreno?&connectTimeoutMS=360000";
+var applyTestAuthEnv = function () {
+    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";
+};
+exports.applyTestAuthEnv = applyTestAuthEnv;
+var ensureConnected = function () { return __awaiter(void 0, void 0, void 0, function () {
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4 /*yield*/, (0, test_1.ensureTestMongooseConnected)({
+                    defaultUri: defaultTestMongoUri,
+                    onConnectError: logger_1.logger.catch,
+                })];
+            case 1:
+                _a.sent();
+                (0, exports.applyTestAuthEnv)();
+                return [2 /*return*/];
+        }
+    });
+}); };
+/** Seeds only the standard users (legacy helper). */
+var setupDb = function () { return __awaiter(void 0, void 0, void 0, function () {
+    var users, error_1;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4 /*yield*/, ensureConnected()];
+            case 1:
+                _a.sent();
+                return [4 /*yield*/, Promise.all([models_1.UserModel.deleteMany({}), models_1.FoodModel.deleteMany({})]).catch(logger_1.logger.catch)];
+            case 2:
+                _a.sent();
+                _a.label = 3;
+            case 3:
+                _a.trys.push([3, 5, , 6]);
+                return [4 /*yield*/, (0, createTestData_1.createTestUsers)()];
+            case 4:
+                users = _a.sent();
+                return [2 /*return*/, [users.admin, users.notAdmin, users.adminOther]];
+            case 5:
+                error_1 = _a.sent();
+                logger_1.logger.error("Error setting up DB", error_1);
+                throw error_1;
+            case 6: return [2 /*return*/];
+        }
+    });
+}); };
+exports.setupDb = setupDb;
+/** Seeds users, foods, and required docs — the recommended API test baseline. */
+var setupTestData = function () { return __awaiter(void 0, void 0, void 0, function () {
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4 /*yield*/, ensureConnected()];
+            case 1:
+                _a.sent();
+                if (process.env.TERRENO_TEST_USE_FIXTURE_CACHE === "true") {
+                    return [2 /*return*/, (0, mongoTestSetup_1.loadTestData)()];
+                }
+                return [2 /*return*/, (0, createTestData_1.createTestData)()];
+        }
+    });
+}); };
+exports.setupTestData = setupTestData;
+/** Clears all API test collections without re-seeding. */
+exports.resetTestCollections = createTestData_1.clearTestCollections;
+var createTestData_2 = require("./createTestData");
+Object.defineProperty(exports, "createTestData", { enumerable: true, get: function () { return createTestData_2.createTestData; } });
+var mongoTestSetup_2 = require("./mongoTestSetup");
+Object.defineProperty(exports, "loadTestData", { enumerable: true, get: function () { return mongoTestSetup_2.loadTestData; } });

package/dist/tests/types.d.ts

@@ -0,0 +1,29 @@
+import type { HydratedDocument } from "mongoose";
+import type { Food, RequiredField, User } from "./models";
+export interface TestUsers {
+    admin: HydratedDocument<User>;
+    adminOther: HydratedDocument<User>;
+    notAdmin: HydratedDocument<User>;
+}
+export interface TestFoods {
+    apple: HydratedDocument<Food>;
+    carrots: HydratedDocument<Food>;
+    pizza: HydratedDocument<Food>;
+    spinach: HydratedDocument<Food>;
+}
+export interface TestRequired {
+    sample: HydratedDocument<RequiredField>;
+    withAbout: HydratedDocument<RequiredField>;
+}
+/** Canonical API integration-test fixture graph. */
+export interface TestData {
+    foods: TestFoods;
+    required: TestRequired;
+    users: TestUsers;
+}
+/** JSON-serializable snapshot stored alongside collection cache files. */
+export interface CachedTestData {
+    foods: Record<keyof TestFoods, string>;
+    required: Record<keyof TestRequired, string>;
+    users: Record<keyof TestUsers, string>;
+}

package/dist/tests/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/tests.d.ts

@@ -1,81 +1,13 @@
-import express, { type Express } from "express";
-import mongoose, { type Model, Schema } from "mongoose";
+import type express from "express";
+import type { Express } from "express";
 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, {}, {}> & User & {
-    _id: mongoose.Types.ObjectId;
-} & {
-    __v: number;
-}, any>;
-export declare const SuperUserModel: mongoose.Model<User & SuperUser, {}, {}, {}, mongoose.Document<unknown, {}, User & SuperUser, {}, {}> & User & SuperUser & {
-    _id: mongoose.Types.ObjectId;
-} & {
-    __v: number;
-}, any>;
-export declare const StaffUserModel: mongoose.Model<User & StaffUser, {}, {}, {}, mongoose.Document<unknown, {}, User & StaffUser, {}, {}> & User & StaffUser & {
-    _id: mongoose.Types.ObjectId;
-} & {
-    __v: number;
-}, any>;
-export declare const FoodModel: Model<Food>;
-interface RequiredField {
-    name: string;
-    about?: string;
-}
-export declare const RequiredModel: mongoose.Model<RequiredField, {}, {}, {}, mongoose.Document<unknown, {}, RequiredField, {}, {}> & RequiredField & {
-    _id: mongoose.Types.ObjectId;
-} & {
-    __v: number;
-}, any>;
+import { createTestData } from "./tests/createTestData";
+import { type Food, type FoodCategory, FoodModel, type RequiredField, RequiredModel, type StaffUser, StaffUserModel, type SuperUser, SuperUserModel, type User, UserModel } from "./tests/models";
+import { loadTestDataFromCache, setupTestCache } from "./tests/mongoTestSetup";
+import { setupDb, setupTestData } from "./tests/testHelper";
+import type { TestData } from "./tests/types";
+export type { Food, FoodCategory, RequiredField, StaffUser, SuperUser, TestData, User };
+export { createTestData, FoodModel, loadTestDataFromCache, RequiredModel, StaffUserModel, SuperUserModel, setupDb, setupTestCache, setupTestData, UserModel, };
 export declare const getBaseServer: () => Express;
 export declare const authAsUser: (app: express.Application, type: "admin" | "notAdmin") => Promise<TestAgent>;
-export declare const setupDb: () => Promise<(mongoose.Document<unknown, {}, User, {}, {}> & User & {
-    _id: mongoose.Types.ObjectId;
-} & {
-    __v: number;
-})[]>;
-export {};
+export { loadTestData } from "./tests/mongoTestSetup";