@terreno/api 0.21.0 → 0.22.0

package/dist/tests/createTestData.js

@@ -0,0 +1,272 @@
+"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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadTestDataFromDocuments = exports.toCachedTestData = exports.createTestData = exports.createRequiredFixtures = exports.createStandardFoods = exports.createTestUsers = exports.clearTestCollections = void 0;
+var logger_1 = require("../logger");
+var models_1 = require("./models");
+var setPassword = function (user, password) { return __awaiter(void 0, void 0, void 0, function () {
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4 /*yield*/, user.setPassword(password)];
+            case 1:
+                _a.sent();
+                return [4 /*yield*/, user.save()];
+            case 2:
+                _a.sent();
+                return [2 /*return*/];
+        }
+    });
+}); };
+var clearTestCollections = function () { return __awaiter(void 0, void 0, void 0, function () {
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4 /*yield*/, Promise.all([
+                    models_1.UserModel.deleteMany({}),
+                    models_1.FoodModel.deleteMany({}),
+                    models_1.RequiredModel.deleteMany({}),
+                ]).catch(logger_1.logger.catch)];
+            case 1:
+                _a.sent();
+                return [2 /*return*/];
+        }
+    });
+}); };
+exports.clearTestCollections = clearTestCollections;
+var createTestUsers = function () { return __awaiter(void 0, void 0, void 0, function () {
+    var _a, notAdmin, admin, adminOther;
+    return __generator(this, function (_b) {
+        switch (_b.label) {
+            case 0: return [4 /*yield*/, Promise.all([
+                    models_1.UserModel.create({ email: "notAdmin@example.com", name: "Not Admin" }),
+                    models_1.UserModel.create({ admin: true, email: "admin@example.com", name: "Admin" }),
+                    models_1.UserModel.create({ admin: true, email: "admin+other@example.com", name: "Admin Other" }),
+                ])];
+            case 1:
+                _a = __read.apply(void 0, [_b.sent(), 3]), notAdmin = _a[0], admin = _a[1], adminOther = _a[2];
+                return [4 /*yield*/, Promise.all([
+                        setPassword(notAdmin, "password"),
+                        setPassword(admin, "securePassword"),
+                        setPassword(adminOther, "otherPassword"),
+                    ])];
+            case 2:
+                _b.sent();
+                return [2 /*return*/, { admin: admin, adminOther: adminOther, notAdmin: notAdmin }];
+        }
+    });
+}); };
+exports.createTestUsers = createTestUsers;
+var createStandardFoods = function (users) { return __awaiter(void 0, void 0, void 0, function () {
+    var admin, adminOther, notAdmin, _a, spinach, apple, carrots, pizza;
+    return __generator(this, function (_b) {
+        switch (_b.label) {
+            case 0:
+                admin = users.admin, adminOther = users.adminOther, notAdmin = users.notAdmin;
+                return [4 /*yield*/, Promise.all([
+                        models_1.FoodModel.create({
+                            calories: 1,
+                            categories: [{ name: "Vegetables", show: true }],
+                            created: new Date("2021-12-03T00:00:20.000Z"),
+                            eatenBy: [admin._id],
+                            expiration: "2026-12-31",
+                            hidden: false,
+                            lastEatenWith: {
+                                dressing: new Date("2021-12-03T19:00:30.000Z"),
+                            },
+                            likesIds: [
+                                { likes: true, userId: admin._id },
+                                { likes: false, userId: notAdmin._id },
+                            ],
+                            name: "Spinach",
+                            ownerId: notAdmin._id,
+                            source: {
+                                dateAdded: "2023-12-13T12:30:00.000Z",
+                                href: "https://www.example.com/spinach",
+                                name: "Brand",
+                            },
+                            tags: ["healthy"],
+                        }),
+                        models_1.FoodModel.create({
+                            calories: 100,
+                            created: new Date("2021-12-03T00:00:30.000Z"),
+                            expiration: "2026-12-31",
+                            hidden: true,
+                            likesIds: [{ likes: true, userId: admin._id }],
+                            name: "Apple",
+                            ownerId: admin._id,
+                            source: { name: "Orchard" },
+                            tags: ["healthy"],
+                        }),
+                        models_1.FoodModel.create({
+                            calories: 100,
+                            created: new Date("2021-12-03T00:00:00.000Z"),
+                            eatenBy: [admin._id, notAdmin._id],
+                            expiration: "2026-12-31",
+                            hidden: false,
+                            likesIds: [{ likes: false, userId: notAdmin._id }],
+                            name: "Carrots",
+                            ownerId: admin._id,
+                            source: { name: "Farm" },
+                            tags: ["vegetable"],
+                        }),
+                        models_1.FoodModel.create({
+                            calories: 800,
+                            created: new Date("2022-01-01T00:00:00.000Z"),
+                            expiration: "2026-12-31",
+                            hidden: false,
+                            likesIds: [{ likes: true, userId: adminOther._id }],
+                            name: "Pizza",
+                            ownerId: adminOther._id,
+                            source: { name: "Pizzeria" },
+                            tags: ["comfort"],
+                        }),
+                    ])];
+            case 1:
+                _a = __read.apply(void 0, [_b.sent(), 4]), spinach = _a[0], apple = _a[1], carrots = _a[2], pizza = _a[3];
+                return [2 /*return*/, { apple: apple, carrots: carrots, pizza: pizza, spinach: spinach }];
+        }
+    });
+}); };
+exports.createStandardFoods = createStandardFoods;
+var createRequiredFixtures = function () { return __awaiter(void 0, void 0, void 0, function () {
+    var _a, sample, withAbout;
+    return __generator(this, function (_b) {
+        switch (_b.label) {
+            case 0: return [4 /*yield*/, Promise.all([
+                    models_1.RequiredModel.create({ name: "Sample Required" }),
+                    models_1.RequiredModel.create({ about: "Optional about text", name: "Required With About" }),
+                ])];
+            case 1:
+                _a = __read.apply(void 0, [_b.sent(), 2]), sample = _a[0], withAbout = _a[1];
+                return [2 /*return*/, { sample: sample, withAbout: withAbout }];
+        }
+    });
+}); };
+exports.createRequiredFixtures = createRequiredFixtures;
+/** Builds the standard Terreno API test database (users, foods, required docs). */
+var createTestData = function () { return __awaiter(void 0, void 0, void 0, function () {
+    var users, _a, foods, required;
+    return __generator(this, function (_b) {
+        switch (_b.label) {
+            case 0: return [4 /*yield*/, (0, exports.clearTestCollections)()];
+            case 1:
+                _b.sent();
+                return [4 /*yield*/, (0, exports.createTestUsers)()];
+            case 2:
+                users = _b.sent();
+                return [4 /*yield*/, Promise.all([
+                        (0, exports.createStandardFoods)(users),
+                        (0, exports.createRequiredFixtures)(),
+                    ])];
+            case 3:
+                _a = __read.apply(void 0, [_b.sent(), 2]), foods = _a[0], required = _a[1];
+                return [2 /*return*/, { foods: foods, required: required, users: users }];
+        }
+    });
+}); };
+exports.createTestData = createTestData;
+var toCachedTestData = function (testData) { return ({
+    foods: {
+        apple: testData.foods.apple.id,
+        carrots: testData.foods.carrots.id,
+        pizza: testData.foods.pizza.id,
+        spinach: testData.foods.spinach.id,
+    },
+    required: {
+        sample: testData.required.sample.id,
+        withAbout: testData.required.withAbout.id,
+    },
+    users: {
+        admin: testData.users.admin.id,
+        adminOther: testData.users.adminOther.id,
+        notAdmin: testData.users.notAdmin.id,
+    },
+}); };
+exports.toCachedTestData = toCachedTestData;
+var loadTestDataFromDocuments = function (cached) { return __awaiter(void 0, void 0, void 0, function () {
+    var _a, admin, notAdmin, adminOther, spinach, apple, carrots, pizza, sample, withAbout;
+    return __generator(this, function (_b) {
+        switch (_b.label) {
+            case 0: return [4 /*yield*/, Promise.all([
+                    models_1.UserModel.findById(cached.users.admin),
+                    models_1.UserModel.findById(cached.users.notAdmin),
+                    models_1.UserModel.findById(cached.users.adminOther),
+                    models_1.FoodModel.findById(cached.foods.spinach),
+                    models_1.FoodModel.findById(cached.foods.apple),
+                    models_1.FoodModel.findById(cached.foods.carrots),
+                    models_1.FoodModel.findById(cached.foods.pizza),
+                    models_1.RequiredModel.findById(cached.required.sample),
+                    models_1.RequiredModel.findById(cached.required.withAbout),
+                ])];
+            case 1:
+                _a = __read.apply(void 0, [_b.sent(), 9]), admin = _a[0], notAdmin = _a[1], adminOther = _a[2], spinach = _a[3], apple = _a[4], carrots = _a[5], pizza = _a[6], sample = _a[7], withAbout = _a[8];
+                if (!admin ||
+                    !notAdmin ||
+                    !adminOther ||
+                    !spinach ||
+                    !apple ||
+                    !carrots ||
+                    !pizza ||
+                    !sample ||
+                    !withAbout) {
+                    throw new Error("[createTestData] Cached test data references missing documents");
+                }
+                return [2 /*return*/, {
+                        foods: { apple: apple, carrots: carrots, pizza: pizza, spinach: spinach },
+                        required: { sample: sample, withAbout: withAbout },
+                        users: { admin: admin, adminOther: adminOther, notAdmin: notAdmin },
+                    }];
+        }
+    });
+}); };
+exports.loadTestDataFromDocuments = loadTestDataFromDocuments;

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";