@terreno/api 0.10.0 → 0.11.0

package/dist/plugins.js

@@ -95,23 +95,18 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
     }
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DateOnly = void 0;
-exports.baseUserPlugin = baseUserPlugin;
-exports.isDeletedPlugin = isDeletedPlugin;
-exports.isDisabledPlugin = isDisabledPlugin;
-exports.createdUpdatedPlugin = createdUpdatedPlugin;
-exports.firebaseJWTPlugin = firebaseJWTPlugin;
-exports.findOneOrNone = findOneOrNone;
-exports.findExactlyOne = findExactlyOne;
-exports.upsertPlugin = upsertPlugin;
+exports.DateOnly = exports.upsertPlugin = exports.findExactlyOne = exports.findOneOrNone = exports.firebaseJWTPlugin = exports.createdUpdatedPlugin = exports.isDisabledPlugin = exports.isDeletedPlugin = exports.baseUserPlugin = void 0;
 var luxon_1 = require("luxon");
 var mongoose_1 = __importStar(require("mongoose"));
 var errors_1 = require("./errors");
-function baseUserPlugin(schema) {
-    schema.add({ admin: { default: false, type: Boolean } });
-    schema.add({ email: { index: true, type: String } });
-}
-function isDeletedPlugin(schema, defaultValue) {
+var baseUserPlugin = function (schema) {
+    schema.add({
+        admin: { default: false, description: "Whether the user has admin privileges", type: Boolean },
+    });
+    schema.add({ email: { description: "The user's email address", index: true, type: String } });
+};
+exports.baseUserPlugin = baseUserPlugin;
+var isDeletedPlugin = function (schema, defaultValue) {
     if (defaultValue === void 0) { defaultValue = false; }
     schema.add({
         deleted: {
@@ -122,20 +117,21 @@ function isDeletedPlugin(schema, defaultValue) {
             type: Boolean,
         },
     });
-    function applyDeleteFilter(q) {
+    var applyDeleteFilter = function (q) {
         var query = q.getQuery();
         if (query && query.deleted === undefined) {
             void q.where({ deleted: { $ne: true } });
         }
-    }
+    };
     schema.pre("find", function () {
         applyDeleteFilter(this);
     });
     schema.pre("findOne", function () {
         applyDeleteFilter(this);
     });
-}
-function isDisabledPlugin(schema, defaultValue) {
+};
+exports.isDeletedPlugin = isDeletedPlugin;
+var isDisabledPlugin = function (schema, defaultValue) {
     if (defaultValue === void 0) { defaultValue = false; }
     schema.add({
         disabled: {
@@ -145,10 +141,13 @@ function isDisabledPlugin(schema, defaultValue) {
             type: Boolean,
         },
     });
-}
-function createdUpdatedPlugin(schema) {
-    schema.add({ updated: { index: true, type: Date } });
-    schema.add({ created: { index: true, type: Date } });
+};
+exports.isDisabledPlugin = isDisabledPlugin;
+var createdUpdatedPlugin = function (schema) {
+    schema.add({
+        updated: { description: "When this document was last updated", index: true, type: Date },
+    });
+    schema.add({ created: { description: "When this document was created", index: true, type: Date } });
     schema.pre("save", function () {
         if (this.disableCreatedUpdatedPlugin === true) {
             return;
@@ -163,10 +162,14 @@ function createdUpdatedPlugin(schema) {
     schema.pre(/save|updateOne|insertMany/, function () {
         void this.updateOne({}, { $set: { updated: new Date() } });
     });
-}
-function firebaseJWTPlugin(schema) {
-    schema.add({ firebaseId: { index: true, type: String } });
-}
+};
+exports.createdUpdatedPlugin = createdUpdatedPlugin;
+var firebaseJWTPlugin = function (schema) {
+    schema.add({
+        firebaseId: { description: "The user's Firebase authentication ID", index: true, type: String },
+    });
+};
+exports.firebaseJWTPlugin = firebaseJWTPlugin;
 /**
  * This adds a static method `Model.findOneOrNone` to the schema. This should replace `Model.findOne` in most instances.
  * `Model.findOne` should only be used with a unique index, but that's not apparent from the docs. Otherwise you can wind
@@ -174,7 +177,7 @@ function firebaseJWTPlugin(schema) {
  * document, or throws an exception if multiple are found.
  * @param schema Mongoose Schema
  */
-function findOneOrNone(schema) {
+var findOneOrNone = function (schema) {
     schema.statics.findOneOrNone = function (query, errorArgs) {
         return __awaiter(this, void 0, void 0, function () {
             var results;
@@ -194,7 +197,8 @@ function findOneOrNone(schema) {
             });
         });
     };
-}
+};
+exports.findOneOrNone = findOneOrNone;
 /**
  * This adds a static method `Model.findExactlyOne` to the schema. This or findOneOrNone should replace `Model.findOne`
  * in most instances.
@@ -203,7 +207,7 @@ function findOneOrNone(schema) {
  * multiple or none are found.
  * @param schema Mongoose Schema
  */
-function findExactlyOne(schema) {
+var findExactlyOne = function (schema) {
     schema.statics.findExactlyOne = function (query, errorArgs) {
         return __awaiter(this, void 0, void 0, function () {
             var results;
@@ -223,14 +227,15 @@ function findExactlyOne(schema) {
             });
         });
     };
-}
+};
+exports.findExactlyOne = findExactlyOne;
 /**
  * This adds a static method `Model.upsert` to the schema. This method will either update an existing document
  * that matches the conditions or create a new document if none exists. It throws an error if multiple documents
  * match the conditions to prevent ambiguous updates.
  * @param schema Mongoose Schema
  */
-function upsertPlugin(schema) {
+var upsertPlugin = function (schema) {
     schema.statics.upsert = function (conditions, update) {
         return __awaiter(this, void 0, void 0, function () {
             var docs, doc, combinedData, newDoc;
@@ -259,7 +264,8 @@ function upsertPlugin(schema) {
             });
         });
     };
-}
+};
+exports.upsertPlugin = upsertPlugin;
 var DateOnly = /** @class */ (function (_super) {
     __extends(DateOnly, _super);
     function DateOnly(key, options) {

package/dist/populate.test.js

@@ -1,4 +1,37 @@
 "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) {
@@ -53,6 +86,7 @@ var __read = (this && this.__read) || function (o, n) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 var bun_test_1 = require("bun:test");
+var mongoose_1 = __importStar(require("mongoose"));
 var populate_1 = require("./populate");
 var tests_1 = require("./tests");
 (0, bun_test_1.describe)("populate functions", function () {
@@ -183,3 +217,68 @@ var tests_1 = require("./tests");
         (0, bun_test_1.expect)(result.containers[1].items).toEqual(["item-3", "item-4"]);
     });
 });
+(0, bun_test_1.describe)("fixMixedFields", function () {
+    (0, bun_test_1.it)("returns early when schema is missing", function () {
+        var properties = { foo: { type: "object" } };
+        (0, bun_test_1.expect)(function () { return (0, populate_1.fixMixedFields)(null, properties); }).not.toThrow();
+    });
+    (0, bun_test_1.it)("returns early when properties is missing", function () {
+        var schema = new mongoose_1.Schema({});
+        (0, bun_test_1.expect)(function () { return (0, populate_1.fixMixedFields)(schema, null); }).not.toThrow();
+    });
+    (0, bun_test_1.it)("replaces Mixed fields with only description", function () {
+        var schema = new mongoose_1.Schema({ data: { description: "any data", type: mongoose_1.Schema.Types.Mixed } });
+        var properties = { data: { description: "any data", type: "object" } };
+        (0, populate_1.fixMixedFields)(schema, properties);
+        (0, bun_test_1.expect)(properties.data).toEqual({ description: "any data" });
+    });
+    (0, bun_test_1.it)("recurses into arrays of sub-documents", function () {
+        var subSchema = new mongoose_1.Schema({ meta: { type: mongoose_1.Schema.Types.Mixed } });
+        var schema = new mongoose_1.Schema({ items: [subSchema] });
+        var properties = {
+            items: {
+                items: {
+                    properties: {
+                        meta: { type: "object" },
+                    },
+                },
+                type: "array",
+            },
+        };
+        (0, populate_1.fixMixedFields)(schema, properties);
+        (0, bun_test_1.expect)(properties.items.items.properties.meta).toEqual({ description: undefined });
+    });
+    (0, bun_test_1.it)("skips unknown paths", function () {
+        var schema = new mongoose_1.Schema({ foo: String });
+        var properties = { unknownKey: { type: "string" } };
+        (0, bun_test_1.expect)(function () { return (0, populate_1.fixMixedFields)(schema, properties); }).not.toThrow();
+    });
+});
+(0, bun_test_1.describe)("getOpenApiSpecForModel edge cases", function () {
+    (0, bun_test_1.it)("returns model properties without populatePaths", function () {
+        var result = (0, populate_1.getOpenApiSpecForModel)(tests_1.UserModel);
+        (0, bun_test_1.expect)(result.properties).toBeDefined();
+    });
+    (0, bun_test_1.it)("returns with extraModelProperties merged", function () {
+        var result = (0, populate_1.getOpenApiSpecForModel)(tests_1.UserModel, {
+            extraModelProperties: { customField: { type: "string" } },
+        });
+        (0, bun_test_1.expect)(result.properties.customField).toEqual({ type: "string" });
+    });
+    (0, bun_test_1.it)("skips populate paths without ref", function () {
+        // Create a schema with a non-referenced ObjectId field
+        var testSchema = new mongoose_1.Schema({ name: String, simpleId: mongoose_1.Schema.Types.ObjectId });
+        var TestModelNoRef = mongoose_1.default.models.TestModelNoRef || mongoose_1.default.model("TestModelNoRef", testSchema);
+        var result = (0, populate_1.getOpenApiSpecForModel)(TestModelNoRef, {
+            populatePaths: [{ path: "simpleId" }],
+        });
+        // Should not throw, simpleId stays as-is
+        (0, bun_test_1.expect)(result.properties).toBeDefined();
+    });
+    (0, bun_test_1.it)("populates with fields allowlist", function () {
+        var result = (0, populate_1.getOpenApiSpecForModel)(tests_1.FoodModel, {
+            populatePaths: [{ fields: ["name"], path: "ownerId" }],
+        });
+        (0, bun_test_1.expect)(result.properties).toBeDefined();
+    });
+});

package/dist/syncConsents.test.js

@@ -246,4 +246,277 @@ var baseDef = {
             }
         });
     }); });
+    (0, bun_test_1.it)("publishes new version when type changes", function () { return __awaiter(void 0, void 0, void 0, function () {
+        var updated, result;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, (0, syncConsents_1.syncConsents)({ terms: baseDef })];
+                case 1:
+                    _a.sent();
+                    updated = __assign(__assign({}, baseDef), { type: "privacy" });
+                    return [4 /*yield*/, (0, syncConsents_1.syncConsents)({ terms: updated })];
+                case 2:
+                    result = _a.sent();
+                    (0, bun_test_1.expect)(result.updated).toEqual(["terms"]);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    (0, bun_test_1.it)("publishes new version when order changes", function () { return __awaiter(void 0, void 0, void 0, function () {
+        var updated, result;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, (0, syncConsents_1.syncConsents)({ terms: baseDef })];
+                case 1:
+                    _a.sent();
+                    updated = __assign(__assign({}, baseDef), { order: 99 });
+                    return [4 /*yield*/, (0, syncConsents_1.syncConsents)({ terms: updated })];
+                case 2:
+                    result = _a.sent();
+                    (0, bun_test_1.expect)(result.updated).toEqual(["terms"]);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    (0, bun_test_1.it)("publishes new version when required changes", function () { return __awaiter(void 0, void 0, void 0, function () {
+        var updated, result;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, (0, syncConsents_1.syncConsents)({ terms: baseDef })];
+                case 1:
+                    _a.sent();
+                    updated = __assign(__assign({}, baseDef), { required: false });
+                    return [4 /*yield*/, (0, syncConsents_1.syncConsents)({ terms: updated })];
+                case 2:
+                    result = _a.sent();
+                    (0, bun_test_1.expect)(result.updated).toEqual(["terms"]);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    (0, bun_test_1.it)("publishes new version when requireScrollToBottom changes", function () { return __awaiter(void 0, void 0, void 0, function () {
+        var updated, result;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, (0, syncConsents_1.syncConsents)({ terms: baseDef })];
+                case 1:
+                    _a.sent();
+                    updated = __assign(__assign({}, baseDef), { requireScrollToBottom: true });
+                    return [4 /*yield*/, (0, syncConsents_1.syncConsents)({ terms: updated })];
+                case 2:
+                    result = _a.sent();
+                    (0, bun_test_1.expect)(result.updated).toEqual(["terms"]);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    (0, bun_test_1.it)("publishes new version when captureSignature changes", function () { return __awaiter(void 0, void 0, void 0, function () {
+        var updated, result;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, (0, syncConsents_1.syncConsents)({ terms: baseDef })];
+                case 1:
+                    _a.sent();
+                    updated = __assign(__assign({}, baseDef), { captureSignature: true });
+                    return [4 /*yield*/, (0, syncConsents_1.syncConsents)({ terms: updated })];
+                case 2:
+                    result = _a.sent();
+                    (0, bun_test_1.expect)(result.updated).toEqual(["terms"]);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    (0, bun_test_1.it)("publishes new version when agreeButtonText changes", function () { return __awaiter(void 0, void 0, void 0, function () {
+        var updated, result;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, (0, syncConsents_1.syncConsents)({ terms: baseDef })];
+                case 1:
+                    _a.sent();
+                    updated = __assign(__assign({}, baseDef), { agreeButtonText: "Consent" });
+                    return [4 /*yield*/, (0, syncConsents_1.syncConsents)({ terms: updated })];
+                case 2:
+                    result = _a.sent();
+                    (0, bun_test_1.expect)(result.updated).toEqual(["terms"]);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    (0, bun_test_1.it)("publishes new version when allowDecline changes", function () { return __awaiter(void 0, void 0, void 0, function () {
+        var updated, result;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, (0, syncConsents_1.syncConsents)({ terms: baseDef })];
+                case 1:
+                    _a.sent();
+                    updated = __assign(__assign({}, baseDef), { allowDecline: true });
+                    return [4 /*yield*/, (0, syncConsents_1.syncConsents)({ terms: updated })];
+                case 2:
+                    result = _a.sent();
+                    (0, bun_test_1.expect)(result.updated).toEqual(["terms"]);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    (0, bun_test_1.it)("publishes new version when declineButtonText changes", function () { return __awaiter(void 0, void 0, void 0, function () {
+        var updated, result;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, (0, syncConsents_1.syncConsents)({ terms: baseDef })];
+                case 1:
+                    _a.sent();
+                    updated = __assign(__assign({}, baseDef), { allowDecline: true, declineButtonText: "No Thanks" });
+                    return [4 /*yield*/, (0, syncConsents_1.syncConsents)({ terms: updated })];
+                case 2:
+                    result = _a.sent();
+                    (0, bun_test_1.expect)(result.updated).toEqual(["terms"]);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    (0, bun_test_1.it)("publishes new version when defaultLocale changes", function () { return __awaiter(void 0, void 0, void 0, function () {
+        var updated, result;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, (0, syncConsents_1.syncConsents)({ terms: baseDef })];
+                case 1:
+                    _a.sent();
+                    updated = __assign(__assign({}, baseDef), { defaultLocale: "es" });
+                    return [4 /*yield*/, (0, syncConsents_1.syncConsents)({ terms: updated })];
+                case 2:
+                    result = _a.sent();
+                    (0, bun_test_1.expect)(result.updated).toEqual(["terms"]);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    (0, bun_test_1.it)("publishes new version when content locale count changes", function () { return __awaiter(void 0, void 0, void 0, function () {
+        var updated, result;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, (0, syncConsents_1.syncConsents)({ terms: baseDef })];
+                case 1:
+                    _a.sent();
+                    updated = __assign(__assign({}, baseDef), { content: { en: baseDef.content.en, es: "# Términos" } });
+                    return [4 /*yield*/, (0, syncConsents_1.syncConsents)({ terms: updated })];
+                case 2:
+                    result = _a.sent();
+                    (0, bun_test_1.expect)(result.updated).toEqual(["terms"]);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    (0, bun_test_1.it)("publishes new version when checkbox count changes", function () { return __awaiter(void 0, void 0, void 0, function () {
+        var updated, result;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, (0, syncConsents_1.syncConsents)({
+                        terms: __assign(__assign({}, baseDef), { checkboxes: [{ label: "Agree", required: true }] }),
+                    })];
+                case 1:
+                    _a.sent();
+                    updated = __assign(__assign({}, baseDef), { checkboxes: [
+                            { label: "Agree", required: true },
+                            { label: "Also agree", required: false },
+                        ] });
+                    return [4 /*yield*/, (0, syncConsents_1.syncConsents)({ terms: updated })];
+                case 2:
+                    result = _a.sent();
+                    (0, bun_test_1.expect)(result.updated).toEqual(["terms"]);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    (0, bun_test_1.it)("publishes new version when checkbox label changes", function () { return __awaiter(void 0, void 0, void 0, function () {
+        var updated, result;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, (0, syncConsents_1.syncConsents)({
+                        terms: __assign(__assign({}, baseDef), { checkboxes: [{ label: "Agree", required: true }] }),
+                    })];
+                case 1:
+                    _a.sent();
+                    updated = __assign(__assign({}, baseDef), { checkboxes: [{ label: "I Agree", required: true }] });
+                    return [4 /*yield*/, (0, syncConsents_1.syncConsents)({ terms: updated })];
+                case 2:
+                    result = _a.sent();
+                    (0, bun_test_1.expect)(result.updated).toEqual(["terms"]);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    (0, bun_test_1.it)("publishes new version when checkbox confirmationPrompt changes", function () { return __awaiter(void 0, void 0, void 0, function () {
+        var updated, result;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, (0, syncConsents_1.syncConsents)({
+                        terms: __assign(__assign({}, baseDef), { checkboxes: [{ confirmationPrompt: "Sure?", label: "Agree", required: true }] }),
+                    })];
+                case 1:
+                    _a.sent();
+                    updated = __assign(__assign({}, baseDef), { checkboxes: [{ confirmationPrompt: "Are you sure?", label: "Agree", required: true }] });
+                    return [4 /*yield*/, (0, syncConsents_1.syncConsents)({ terms: updated })];
+                case 2:
+                    result = _a.sent();
+                    (0, bun_test_1.expect)(result.updated).toEqual(["terms"]);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    (0, bun_test_1.it)("leaves unchanged forms alone with checkboxes present", function () { return __awaiter(void 0, void 0, void 0, function () {
+        var withCheckboxes, result;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    withCheckboxes = __assign(__assign({}, baseDef), { checkboxes: [{ confirmationPrompt: "Sure?", label: "Agree", required: true }] });
+                    return [4 /*yield*/, (0, syncConsents_1.syncConsents)({ terms: withCheckboxes })];
+                case 1:
+                    _a.sent();
+                    return [4 /*yield*/, (0, syncConsents_1.syncConsents)({ terms: withCheckboxes })];
+                case 2:
+                    result = _a.sent();
+                    (0, bun_test_1.expect)(result.unchanged).toEqual(["terms"]);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    (0, bun_test_1.it)("dry run does not create new versions", function () { return __awaiter(void 0, void 0, void 0, function () {
+        var updated, result, forms;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, (0, syncConsents_1.syncConsents)({ terms: baseDef })];
+                case 1:
+                    _a.sent();
+                    updated = __assign(__assign({}, baseDef), { title: "Updated" });
+                    return [4 /*yield*/, (0, syncConsents_1.syncConsents)({ terms: updated }, { dryRun: true })];
+                case 2:
+                    result = _a.sent();
+                    (0, bun_test_1.expect)(result.updated).toEqual(["terms"]);
+                    return [4 /*yield*/, consentForm_1.ConsentForm.find({ slug: "terms" })];
+                case 3:
+                    forms = _a.sent();
+                    (0, bun_test_1.expect)(forms).toHaveLength(1); // No new version created
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    (0, bun_test_1.it)("dry run does not deactivate forms", function () { return __awaiter(void 0, void 0, void 0, function () {
+        var result, privacy;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, (0, syncConsents_1.syncConsents)({ privacy: __assign(__assign({}, baseDef), { title: "Privacy", type: "privacy" }), terms: baseDef })];
+                case 1:
+                    _a.sent();
+                    return [4 /*yield*/, (0, syncConsents_1.syncConsents)({ terms: baseDef }, { deactivateRemoved: true, dryRun: true })];
+                case 2:
+                    result = _a.sent();
+                    (0, bun_test_1.expect)(result.deactivated).toEqual(["privacy"]);
+                    return [4 /*yield*/, consentForm_1.ConsentForm.findOne({ slug: "privacy" })];
+                case 3:
+                    privacy = _a.sent();
+                    (0, bun_test_1.expect)(privacy === null || privacy === void 0 ? void 0 : privacy.active).toBe(true); // Still active
+                    return [2 /*return*/];
+            }
+        });
+    }); });
 });

package/dist/tests.d.ts

@@ -71,9 +71,9 @@ export declare const RequiredModel: mongoose.Model<RequiredField, {}, {}, {}, mo
 } & {
     __v: number;
 }, any>;
-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, {}, {}> & User & {
+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;