@terreno/api 0.9.3 → 0.11.0

package/src/plugins.ts

@@ -15,10 +15,12 @@ export interface BaseUser {
   email: string;
 }
 
-export function baseUserPlugin(schema: Schema<any, any, any, any>) {
-  schema.add({admin: {default: false, type: Boolean}});
-  schema.add({email: {index: true, type: String}});
-}
+export const baseUserPlugin = (schema: Schema<any, any, any, any>): void => {
+  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}});
+};
 
 /** For models with the isDeletedPlugin, extend this interface to add the appropriate fields. */
 export interface IsDeleted {
@@ -26,7 +28,7 @@ export interface IsDeleted {
   deleted: boolean;
 }
 
-export function isDeletedPlugin(schema: Schema<any, any, any, any>, defaultValue = false) {
+export const isDeletedPlugin = (schema: Schema<any, any, any, any>, defaultValue = false): void => {
   schema.add({
     deleted: {
       default: defaultValue,
@@ -37,21 +39,24 @@ export function isDeletedPlugin(schema: Schema<any, any, any, any>, defaultValue
       type: Boolean,
     },
   });
-  function applyDeleteFilter(q: Query<any, any>) {
+  const applyDeleteFilter = (q: Query<any, any>): void => {
     const 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);
   });
-}
+};
 
-export function isDisabledPlugin(schema: Schema<any, any, any, any>, defaultValue = false) {
+export const isDisabledPlugin = (
+  schema: Schema<any, any, any, any>,
+  defaultValue = false
+): void => {
   schema.add({
     disabled: {
       default: defaultValue,
@@ -60,16 +65,18 @@ export function isDisabledPlugin(schema: Schema<any, any, any, any>, defaultValu
       type: Boolean,
     },
   });
-}
+};
 
 export interface CreatedDeleted {
   updated: {type: Date; required: true};
   created: {type: Date; required: true};
 }
 
-export function createdUpdatedPlugin(schema: Schema<any, any, any, any>) {
-  schema.add({updated: {index: true, type: Date}});
-  schema.add({created: {index: true, type: Date}});
+export const createdUpdatedPlugin = (schema: Schema<any, any, any, any>): void => {
+  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) {
@@ -86,11 +93,13 @@ export function createdUpdatedPlugin(schema: Schema<any, any, any, any>) {
   schema.pre(/save|updateOne|insertMany/, function () {
     void this.updateOne({}, {$set: {updated: new Date()}});
   });
-}
+};
 
-export function firebaseJWTPlugin(schema: Schema) {
-  schema.add({firebaseId: {index: true, type: String}});
-}
+export const firebaseJWTPlugin = (schema: Schema): void => {
+  schema.add({
+    firebaseId: {description: "The user's Firebase authentication ID", index: true, type: String},
+  });
+};
 
 /**
  * This adds a static method `Model.findOneOrNone` to the schema. This should replace `Model.findOne` in most instances.
@@ -99,7 +108,7 @@ export function firebaseJWTPlugin(schema: Schema) {
  * document, or throws an exception if multiple are found.
  * @param schema Mongoose Schema
  */
-export function findOneOrNone<T>(schema: Schema<T>) {
+export const findOneOrNone = <T>(schema: Schema<T>): void => {
   schema.statics.findOneOrNone = async function (
     query: Record<string, any>,
     errorArgs?: Partial<APIErrorConstructor>
@@ -118,7 +127,7 @@ export function findOneOrNone<T>(schema: Schema<T>) {
     }
     return results[0];
   };
-}
+};
 
 /**
  * This adds a static method `Model.findExactlyOne` to the schema. This or findOneOrNone should replace `Model.findOne`
@@ -128,7 +137,7 @@ export function findOneOrNone<T>(schema: Schema<T>) {
  * multiple or none are found.
  * @param schema Mongoose Schema
  */
-export function findExactlyOne<T>(schema: Schema<T>) {
+export const findExactlyOne = <T>(schema: Schema<T>): void => {
   schema.statics.findExactlyOne = async function (
     query: Record<string, any>,
     errorArgs?: Partial<APIErrorConstructor>
@@ -152,7 +161,7 @@ export function findExactlyOne<T>(schema: Schema<T>) {
     }
     return results[0];
   };
-}
+};
 
 /**
  * This adds a static method `Model.upsert` to the schema. This method will either update an existing document
@@ -160,7 +169,7 @@ export function findExactlyOne<T>(schema: Schema<T>) {
  * match the conditions to prevent ambiguous updates.
  * @param schema Mongoose Schema
  */
-export function upsertPlugin<T>(schema: Schema<any, any, any, any>) {
+export const upsertPlugin = <T>(schema: Schema<any, any, any, any>): void => {
   schema.statics.upsert = async function (
     conditions: Record<string, any>,
     update: Record<string, any>
@@ -187,7 +196,7 @@ export function upsertPlugin<T>(schema: Schema<any, any, any, any>) {
     const newDoc = new this(combinedData);
     return newDoc.save();
   };
-}
+};
 
 /** For models with the upsertPlugin, extend this interface to add the upsert static method. */
 export interface HasUpsert<T> {

package/src/populate.test.ts

@@ -1,7 +1,8 @@
 import {beforeEach, describe, expect, it} from "bun:test";
+import mongoose, {Schema} from "mongoose";
 
-import {unpopulate} from "./populate";
-import {FoodModel, setupDb} from "./tests";
+import {fixMixedFields, getOpenApiSpecForModel, unpopulate} from "./populate";
+import {FoodModel, setupDb, UserModel} from "./tests";
 
 describe("populate functions", () => {
   let admin: any;
@@ -121,3 +122,78 @@ describe("unpopulate edge cases", () => {
     expect(result.containers[1].items).toEqual(["item-3", "item-4"]);
   });
 });
+
+describe("fixMixedFields", () => {
+  it("returns early when schema is missing", () => {
+    const properties = {foo: {type: "object"}};
+    expect(() => fixMixedFields(null, properties)).not.toThrow();
+  });
+
+  it("returns early when properties is missing", () => {
+    const schema = new Schema({});
+    expect(() => fixMixedFields(schema, null as any)).not.toThrow();
+  });
+
+  it("replaces Mixed fields with only description", () => {
+    const schema = new Schema({data: {description: "any data", type: Schema.Types.Mixed}});
+    const properties: any = {data: {description: "any data", type: "object"}};
+    fixMixedFields(schema, properties);
+    expect(properties.data).toEqual({description: "any data"});
+  });
+
+  it("recurses into arrays of sub-documents", () => {
+    const subSchema = new Schema({meta: {type: Schema.Types.Mixed}});
+    const schema = new Schema({items: [subSchema]});
+    const properties: any = {
+      items: {
+        items: {
+          properties: {
+            meta: {type: "object"},
+          },
+        },
+        type: "array",
+      },
+    };
+    fixMixedFields(schema, properties);
+    expect(properties.items.items.properties.meta).toEqual({description: undefined});
+  });
+
+  it("skips unknown paths", () => {
+    const schema = new Schema({foo: String});
+    const properties = {unknownKey: {type: "string"}};
+    expect(() => fixMixedFields(schema, properties)).not.toThrow();
+  });
+});
+
+describe("getOpenApiSpecForModel edge cases", () => {
+  it("returns model properties without populatePaths", () => {
+    const result = getOpenApiSpecForModel(UserModel);
+    expect(result.properties).toBeDefined();
+  });
+
+  it("returns with extraModelProperties merged", () => {
+    const result = getOpenApiSpecForModel(UserModel, {
+      extraModelProperties: {customField: {type: "string"}},
+    });
+    expect(result.properties.customField).toEqual({type: "string"});
+  });
+
+  it("skips populate paths without ref", () => {
+    // Create a schema with a non-referenced ObjectId field
+    const testSchema = new Schema({name: String, simpleId: Schema.Types.ObjectId});
+    const TestModelNoRef =
+      mongoose.models.TestModelNoRef || mongoose.model("TestModelNoRef", testSchema);
+    const result = getOpenApiSpecForModel(TestModelNoRef, {
+      populatePaths: [{path: "simpleId"}],
+    });
+    // Should not throw, simpleId stays as-is
+    expect(result.properties).toBeDefined();
+  });
+
+  it("populates with fields allowlist", () => {
+    const result = getOpenApiSpecForModel(FoodModel, {
+      populatePaths: [{fields: ["name"], path: "ownerId"}],
+    });
+    expect(result.properties).toBeDefined();
+  });
+});

package/src/syncConsents.test.ts

@@ -121,4 +121,149 @@ describe("syncConsents", () => {
     expect(forms[0].slug).toBe("terms");
     expect(forms[1].slug).toBe("privacy");
   });
+
+  it("publishes new version when type changes", async () => {
+    await syncConsents({terms: baseDef});
+    const updated: ConsentFormDefinition = {...baseDef, type: "privacy"};
+    const result = await syncConsents({terms: updated});
+    expect(result.updated).toEqual(["terms"]);
+  });
+
+  it("publishes new version when order changes", async () => {
+    await syncConsents({terms: baseDef});
+    const updated = {...baseDef, order: 99};
+    const result = await syncConsents({terms: updated});
+    expect(result.updated).toEqual(["terms"]);
+  });
+
+  it("publishes new version when required changes", async () => {
+    await syncConsents({terms: baseDef});
+    const updated = {...baseDef, required: false};
+    const result = await syncConsents({terms: updated});
+    expect(result.updated).toEqual(["terms"]);
+  });
+
+  it("publishes new version when requireScrollToBottom changes", async () => {
+    await syncConsents({terms: baseDef});
+    const updated = {...baseDef, requireScrollToBottom: true};
+    const result = await syncConsents({terms: updated});
+    expect(result.updated).toEqual(["terms"]);
+  });
+
+  it("publishes new version when captureSignature changes", async () => {
+    await syncConsents({terms: baseDef});
+    const updated = {...baseDef, captureSignature: true};
+    const result = await syncConsents({terms: updated});
+    expect(result.updated).toEqual(["terms"]);
+  });
+
+  it("publishes new version when agreeButtonText changes", async () => {
+    await syncConsents({terms: baseDef});
+    const updated = {...baseDef, agreeButtonText: "Consent"};
+    const result = await syncConsents({terms: updated});
+    expect(result.updated).toEqual(["terms"]);
+  });
+
+  it("publishes new version when allowDecline changes", async () => {
+    await syncConsents({terms: baseDef});
+    const updated = {...baseDef, allowDecline: true};
+    const result = await syncConsents({terms: updated});
+    expect(result.updated).toEqual(["terms"]);
+  });
+
+  it("publishes new version when declineButtonText changes", async () => {
+    await syncConsents({terms: baseDef});
+    const updated = {...baseDef, allowDecline: true, declineButtonText: "No Thanks"};
+    const result = await syncConsents({terms: updated});
+    expect(result.updated).toEqual(["terms"]);
+  });
+
+  it("publishes new version when defaultLocale changes", async () => {
+    await syncConsents({terms: baseDef});
+    const updated = {...baseDef, defaultLocale: "es"};
+    const result = await syncConsents({terms: updated});
+    expect(result.updated).toEqual(["terms"]);
+  });
+
+  it("publishes new version when content locale count changes", async () => {
+    await syncConsents({terms: baseDef});
+    const updated = {...baseDef, content: {en: baseDef.content.en, es: "# Términos"}};
+    const result = await syncConsents({terms: updated});
+    expect(result.updated).toEqual(["terms"]);
+  });
+
+  it("publishes new version when checkbox count changes", async () => {
+    await syncConsents({
+      terms: {
+        ...baseDef,
+        checkboxes: [{label: "Agree", required: true}],
+      },
+    });
+    const updated = {
+      ...baseDef,
+      checkboxes: [
+        {label: "Agree", required: true},
+        {label: "Also agree", required: false},
+      ],
+    };
+    const result = await syncConsents({terms: updated});
+    expect(result.updated).toEqual(["terms"]);
+  });
+
+  it("publishes new version when checkbox label changes", async () => {
+    await syncConsents({
+      terms: {
+        ...baseDef,
+        checkboxes: [{label: "Agree", required: true}],
+      },
+    });
+    const updated = {
+      ...baseDef,
+      checkboxes: [{label: "I Agree", required: true}],
+    };
+    const result = await syncConsents({terms: updated});
+    expect(result.updated).toEqual(["terms"]);
+  });
+
+  it("publishes new version when checkbox confirmationPrompt changes", async () => {
+    await syncConsents({
+      terms: {
+        ...baseDef,
+        checkboxes: [{confirmationPrompt: "Sure?", label: "Agree", required: true}],
+      },
+    });
+    const updated = {
+      ...baseDef,
+      checkboxes: [{confirmationPrompt: "Are you sure?", label: "Agree", required: true}],
+    };
+    const result = await syncConsents({terms: updated});
+    expect(result.updated).toEqual(["terms"]);
+  });
+
+  it("leaves unchanged forms alone with checkboxes present", async () => {
+    const withCheckboxes = {
+      ...baseDef,
+      checkboxes: [{confirmationPrompt: "Sure?", label: "Agree", required: true}],
+    };
+    await syncConsents({terms: withCheckboxes});
+    const result = await syncConsents({terms: withCheckboxes});
+    expect(result.unchanged).toEqual(["terms"]);
+  });
+
+  it("dry run does not create new versions", async () => {
+    await syncConsents({terms: baseDef});
+    const updated = {...baseDef, title: "Updated"};
+    const result = await syncConsents({terms: updated}, {dryRun: true});
+    expect(result.updated).toEqual(["terms"]);
+    const forms = await ConsentForm.find({slug: "terms"});
+    expect(forms).toHaveLength(1); // No new version created
+  });
+
+  it("dry run does not deactivate forms", async () => {
+    await syncConsents({privacy: {...baseDef, title: "Privacy", type: "privacy"}, terms: baseDef});
+    const result = await syncConsents({terms: baseDef}, {deactivateRemoved: true, dryRun: true});
+    expect(result.deactivated).toEqual(["privacy"]);
+    const privacy = await ConsentForm.findOne({slug: "privacy"});
+    expect(privacy?.active).toBe(true); // Still active
+  });
 });

package/src/syncConsents.ts

@@ -237,7 +237,7 @@ export const syncConsents = async (
 
   // Deactivate forms that are no longer in definitions
   if (deactivateRemoved) {
-    for (const [slug, form] of activeBySlug) {
+    for (const [slug] of activeBySlug) {
       if (!definitions[slug]) {
         logger.info(`syncConsents: deactivating "${slug}"`, {dryRun});
         if (!dryRun) {

package/src/tests/bunSetup.ts

@@ -6,17 +6,23 @@ import winston from "winston";
 import {setupEnvironment} from "../expressServer";
 import {logger, winstonLogger} from "../logger";
 
+const shouldConnectToTestDb = process.env.BUN_TEST_DISABLE_DB !== "true";
+
 // Connect to MongoDB once for all tests
-beforeAll(async () => {
-  await mongoose
-    .connect("mongodb://127.0.0.1/terreno?&connectTimeoutMS=360000")
-    .catch(logger.catch);
-});
+if (shouldConnectToTestDb) {
+  beforeAll(async () => {
+    await mongoose
+      .connect("mongodb://127.0.0.1/terreno?&connectTimeoutMS=360000")
+      .catch(logger.catch);
+  });
+}
 
 // Close MongoDB connection after all tests
-afterAll(async () => {
-  await mongoose.connection.close();
-});
+if (shouldConnectToTestDb) {
+  afterAll(async () => {
+    await mongoose.connection.close();
+  });
+}
 
 let logs: string[] = [];
 

package/src/tests.ts

@@ -162,7 +162,7 @@ const requiredSchema = new Schema<RequiredField>({
 });
 export const RequiredModel = model<RequiredField>("Required", requiredSchema);
 
-export function getBaseServer(): Express {
+export const getBaseServer = (): Express => {
   const app = express();
   app.set("query parser", (str: string) => qs.parse(str, {arrayLimit: 200}));
 
@@ -186,12 +186,12 @@ export function getBaseServer(): Express {
   });
   app.use(express.json());
   return app;
-}
+};
 
-export async function authAsUser(
+export const authAsUser = async (
   app: express.Application,
   type: "admin" | "notAdmin"
-): Promise<TestAgent> {
+): Promise<TestAgent> => {
   const email = type === "admin" ? "admin@example.com" : "notAdmin@example.com";
   const password = type === "admin" ? "securePassword" : "password";
 
@@ -199,9 +199,9 @@ export async function authAsUser(
   const res = await agent.post("/auth/login").send({email, password}).expect(200);
   await agent.set("authorization", `Bearer ${res.body.data.token}`);
   return agent;
-}
+};
 
-export async function setupDb() {
+export const setupDb = async () => {
   await mongoose
     .connect("mongodb://127.0.0.1/terreno?&connectTimeoutMS=360000")
     .catch(logger.catch);
@@ -233,7 +233,7 @@ export async function setupDb() {
 
     return [admin, notAdmin, adminOther];
   } catch (error) {
-    console.error("Error setting up DB", error);
+    logger.error("Error setting up DB", error);
     throw error;
   }
-}
+};

package/src/utils.ts

@@ -4,14 +4,14 @@ import {logger} from "./logger";
 
 // A better version of mongoose's ObjectId.isValid,
 // which falsely will say any 12 character string is valid.
-export function isValidObjectId(id: string): boolean {
+export const isValidObjectId = (id: string): boolean => {
   try {
     return new Types.ObjectId(id).toString() === id;
   } catch (error) {
     logger.error(`Error validating object id ${id}: ${error}`);
     return false;
   }
-}
+};
 
 export const timeout = async (ms: number): Promise<NodeJS.Timeout> => {
   return new Promise((resolve) => setTimeout(resolve, ms));
@@ -25,7 +25,7 @@ export const timeout = async (ms: number): Promise<NodeJS.Timeout> => {
  * @param ignoredModels - Array of model names to skip validation for
  * @throws Error if any model is not set to strict mode or missing virtual settings
  */
-export function checkModelsStrict(ignoredModels: string[] = []): void {
+export const checkModelsStrict = (ignoredModels: string[] = []): void => {
   const models = mongoose.modelNames();
   for (const model of models) {
     const schema = mongoose.model(model).schema;
@@ -44,4 +44,4 @@ export function checkModelsStrict(ignoredModels: string[] = []): void {
       throw new Error(`Model ${model} is not set to strict mode.`);
     }
   }
-}
+};