@terreno/api 0.0.1

package/src/populate.test.ts

@@ -0,0 +1,65 @@
+import {beforeEach, describe, expect, it} from "bun:test";
+
+import {unpopulate} from "./populate";
+import {FoodModel, setupDb} from "./tests";
+
+describe("populate functions", () => {
+  let admin: any;
+  let notAdmin: any;
+
+  let spinach: any;
+
+  beforeEach(async () => {
+    [admin, notAdmin] = await setupDb();
+
+    [spinach] = await Promise.all([
+      FoodModel.create({
+        calories: 1,
+        created: new Date("2021-12-03T00:00:20.000Z"),
+        eatenBy: [admin._id],
+        hidden: false,
+        likesIds: [
+          {likes: true, userId: admin._id},
+          {likes: false, userId: notAdmin._id},
+        ],
+        name: "Spinach",
+        ownerId: admin._id,
+        source: {
+          name: "Brand",
+        },
+      }),
+    ]);
+  });
+
+  it("unpopulate", async () => {
+    let populated = await spinach.populate("ownerId");
+    populated = await populated.populate("eatenBy");
+    populated = await populated.populate("likesIds.userId");
+    expect(populated.ownerId.name).toBe("Admin");
+    expect(populated.eatenBy[0].id).toBe(admin.id);
+    expect(populated.eatenBy[0].name).toBe("Admin");
+    expect(populated.likesIds[0].userId.id).toBe(admin.id);
+    expect(populated.likesIds[0].userId.name).toBe("Admin");
+    expect(populated.likesIds[1].userId.id).toBe(notAdmin.id);
+    expect(populated.likesIds[1].userId.name).toBe("Not Admin");
+
+    let unpopulated: any = unpopulate(populated, "ownerId");
+    expect(spinach.ownerId.name).toBeUndefined();
+    expect(unpopulated.ownerId.toString()).toBe(admin.id);
+    // Ensure nothing else was touched.
+    expect(populated.likesIds[0].userId.id).toBe(admin.id);
+    expect(populated.likesIds[0].userId.name).toBe("Admin");
+    expect(populated.likesIds[1].userId.id).toBe(notAdmin.id);
+    expect(populated.likesIds[1].userId.name).toBe("Not Admin");
+
+    unpopulated = unpopulate(populated, "eatenBy");
+    expect(populated.eatenBy.toString()).toBe(admin.id);
+    expect(populated.eatenBy[0]?.name).toBeUndefined();
+
+    unpopulated = unpopulate(populated, "likesIds.userId");
+    expect(populated.likesIds[0].userId.toString()).toBe(admin.id);
+    expect(populated.likesIds[0].userId?.name).toBeUndefined();
+    expect(populated.likesIds[1].userId.toString()).toBe(notAdmin.id);
+    expect(populated.likesIds[1].userId.name).toBeUndefined();
+  });
+});

package/src/populate.ts

@@ -0,0 +1,258 @@
+import isArray from "lodash/isArray";
+import type {Document} from "mongoose";
+import m2s from "mongoose-to-swagger";
+
+import {APIError} from "./errors";
+
+const m2sOptions = {
+  props: ["readOnly", "required", "enum", "default"],
+};
+
+export type PopulatePath = {
+  // Mongoose style path population.
+  // "ownerId" // populates the User that matches `ownerId`
+  // "ownerId.organizationId" Nested. Populates the User that matches `ownerId`, as well as their organization.
+  path: string;
+  // If provided, type generation will use the already registered component.
+  // If not provided and path is provided, will use the path and optionally fields to
+  // automatically generate the types. If only generatePathFields is provided, the type will be
+  // any.
+  openApiComponent?: any;
+  // An array of strings to filter on the populated objects, following Mongoose's select
+  // rules. If each field starts a preceding "-", will act as a block list and only remove those
+  // fields. If each field does not start with a "-", will act as an allow list and only
+  // return those fields.
+  fields?: string[];
+};
+
+// This function filters an object to only include specified keys.
+// It supports nested keys using dot notation (e.g., 'user.name').
+// If no keys are provided, it returns the original object.
+// The function recursively traverses the object structure to handle nested properties.
+const filterKeys = (obj: Record<string, any>, keysToKeep?: string[]): Record<string, any> => {
+  if (!keysToKeep) {
+    return obj;
+  }
+
+  const result: Record<string, any> = {};
+
+  const filterNestedKeys = (
+    currentObj: Record<string, any>,
+    currentResult: Record<string, any>,
+    remainingKeys: string[]
+  ) => {
+    const currentKey = remainingKeys[0];
+    const nestedKeys = currentKey.split(".");
+
+    if (nestedKeys.length > 1) {
+      const [firstKey, ...rest] = nestedKeys;
+      if (firstKey === "__proto__" || firstKey === "constructor" || firstKey === "prototype") {
+        return;
+      }
+      if (!currentResult[firstKey]) {
+        currentResult[firstKey] = {};
+      }
+      filterNestedKeys(currentObj[firstKey], currentResult[firstKey], [
+        rest.join("."),
+        ...remainingKeys.slice(1),
+      ]);
+    } else {
+      // biome-ignore lint/suspicious/noPrototypeBuiltins: we need to use the prototype to check if the object has the property
+      if (Object.prototype.hasOwnProperty.call(currentObj, currentKey)) {
+        currentResult[currentKey] = currentObj[currentKey];
+      }
+      if (remainingKeys.length > 1) {
+        filterNestedKeys(currentObj, currentResult, remainingKeys.slice(1));
+      }
+    }
+  };
+
+  filterNestedKeys(obj, result, keysToKeep);
+  return result;
+};
+
+// Helper function to get the path in the OpenAPI schema, so we can swap out the type for the
+// populated model component or generated type.
+function getPathInSchema(schema: any, path: string): string {
+  const keys = path.split(".");
+  let currentSchema = schema;
+  let fullPath = "";
+
+  for (let i = 0; i < keys.length; i++) {
+    const key = keys[i];
+
+    if (currentSchema.properties?.[key]) {
+      fullPath += fullPath ? `.${key}` : key;
+      currentSchema = currentSchema.properties[key];
+
+      // If it's an array, add 'items' to the path
+      if (currentSchema.type === "array" && currentSchema.items) {
+        fullPath += ".items";
+        currentSchema = currentSchema.items;
+      }
+    } else if (i === keys.length - 1 && currentSchema.type === "array") {
+      // If we're at the last key and it's an array, we don't need to add anything
+      break;
+    } else {
+      throw new Error(`Path ${path} not found in schema at key ${key}`);
+    }
+  }
+
+  return fullPath;
+}
+
+// Replaces populated properties with the populated schema.
+export function getOpenApiSpecForModel(
+  model: any,
+  {
+    populatePaths,
+    extraModelProperties,
+  }: {populatePaths?: PopulatePath[]; extraModelProperties?: any} = {}
+): {properties: any; required: string[]} {
+  const modelSwagger = m2s(model, {
+    props: ["required", "enum"],
+  });
+
+  if (populatePaths && isArray(populatePaths)) {
+    for (const populatePath of populatePaths) {
+      // Get the referenced populate model from the model schema
+      let populateModel = model.schema.path(populatePath.path)?.options?.ref;
+      const populatePathIsArray = Array.isArray(model.schema.path(populatePath.path).options.type);
+      if (populatePathIsArray) {
+        populateModel = model.schema.path(populatePath.path).options.type[0].ref;
+      }
+      if (!populateModel) {
+        continue;
+      }
+
+      // Get the properties of the referenced model
+      const properties = filterKeys(
+        m2s(model.db.model(populateModel), m2sOptions).properties,
+        populatePath.fields
+      );
+
+      // Get the OpenAPI path for the current populate path
+      const openApiPath = getPathInSchema(modelSwagger, populatePath.path);
+
+      // Determine the schema to set
+      let schemaToSet;
+      if (populatePath.openApiComponent) {
+        schemaToSet = {
+          $ref: `#/components/schemas/${populatePath.openApiComponent}`,
+        };
+      } else {
+        schemaToSet = {
+          properties,
+          type: "object",
+        };
+      }
+
+      // Navigate through the nested structure and set the schema
+      const pathParts = openApiPath.split(".");
+      let currentSchema = modelSwagger.properties;
+      for (let i = 0; i < pathParts.length; i++) {
+        const part = pathParts[i];
+        if (i === pathParts.length - 1) {
+          // We're at the last part, merge the schema
+          if (currentSchema[part]?.properties) {
+            currentSchema[part].properties = {
+              ...currentSchema[part].properties,
+              ...(schemaToSet.properties || {[part]: schemaToSet}),
+            };
+          } else {
+            currentSchema[part] = schemaToSet;
+          }
+        } else {
+          // We're still navigating, ensure the path exists
+          if (!currentSchema[part]) {
+            currentSchema[part] = {};
+          }
+          if (part === "items" && i < pathParts.length - 1) {
+            // If we're at 'items' and it's not the last part, it should be an object
+            if (!currentSchema[part].properties) {
+              currentSchema[part] = {properties: {}, type: "object"};
+            }
+          }
+          currentSchema = currentSchema[part].properties || currentSchema[part];
+        }
+      }
+    }
+  }
+
+  // Add virtuals to the modelSwagger property
+  for (const virtual of Object.keys(model.schema.virtuals)) {
+    // Skip Mongoose internals
+    if (virtual === "id" || virtual === "__v") {
+      continue;
+    }
+    modelSwagger.properties[virtual] = {
+      type: "any",
+    };
+  }
+
+  // Check subschemas for virtuals (one level deep)
+  if (model.schema.childSchemas.length > 0) {
+    for (const childSchema of model.schema.childSchemas) {
+      for (const virtual of Object.keys(childSchema.schema.virtuals)) {
+        if (virtual === "id" || virtual === "__v") {
+          continue;
+        }
+        modelSwagger.properties[childSchema.model.path].properties[virtual] = {
+          type: "any",
+        };
+      }
+    }
+  }
+
+  return {
+    properties: {...modelSwagger.properties, ...extraModelProperties},
+    required: modelSwagger.required ?? [],
+  };
+}
+
+// Helper function to unpopulate a document that has been populated.
+// This is helpful for supporting backwards compatibility. E.g. you use populatePaths
+// to populate a document but if the version header for the request is below the version
+// that the populatePath was added, we remove the population and just return the _id.
+export function unpopulate<T>(doc: Document<T>, path: string): Document<T> {
+  if (!path) {
+    throw new APIError({status: 500, title: "path is required for unpopulate"});
+  }
+  const pathParts = path.split(".");
+
+  // Recursive because we need to support nested paths.
+  const recursiveUnpopulate = (current: any, parts: string[]): any => {
+    const part = parts[0];
+
+    // If the path doesn't exist, return the original doc
+    if (!current[part]) {
+      return doc;
+    }
+
+    if (parts.length === 1) {
+      // Base case: we've reached the last part of the path
+      if (Array.isArray(current[part])) {
+        // If the field is an array, recursively unpopulate each element
+        current[part] = current[part].map((item: any) => {
+          return item?._id ? item._id : item;
+        });
+      } else if (current[part]?._id) {
+        // If the field is a populated document, revert to _id
+        current[part] = current[part]._id;
+      }
+    } else {
+      // Recursive case: continue down the path
+      if (Array.isArray(current[part])) {
+        for (const item of current[part]) {
+          recursiveUnpopulate(item, parts.slice(1)); // Recursively handle each item in the array
+        }
+      } else {
+        recursiveUnpopulate(current[part], parts.slice(1)); // Recursively handle the next part
+      }
+    }
+
+    return current;
+  };
+
+  return recursiveUnpopulate(doc, pathParts);
+}

package/src/tests/bunSetup.ts

@@ -0,0 +1,234 @@
+import {afterAll, afterEach, beforeAll, beforeEach, mock} from "bun:test";
+import {Writable} from "node:stream";
+import mongoose from "mongoose";
+import winston from "winston";
+
+import {setupEnvironment} from "../expressServer";
+import {logger, winstonLogger} from "../logger";
+
+// Connect to MongoDB once for all tests
+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();
+});
+
+let logs: string[] = [];
+
+const SHOW_ALL_LOGS = process.env.SHOW_ALL_TEST_LOGS === "true";
+
+// Create a custom stream that captures logs
+const logStream = new Writable({
+  write(chunk: any, _encoding: any, callback: any) {
+    logs.push(chunk.toString());
+    if (SHOW_ALL_LOGS) {
+      process.stdout.write(chunk);
+    }
+    callback();
+  },
+});
+
+// Silence both winston loggers by replacing all transports with our capturing stream
+const silentTransport = new winston.transports.Stream({
+  format: winston.format.simple(),
+  stream: logStream,
+});
+
+// Clear and silence the default winston logger
+winston.clear();
+winston.add(silentTransport);
+
+// Clear and silence the custom winstonLogger
+winstonLogger.clear();
+winstonLogger.add(silentTransport);
+
+// Capture and silence console methods
+const originalConsole = {
+  debug: console.debug,
+  error: console.error,
+  info: console.info,
+  // biome-ignore lint/suspicious/noConsole: We keep the original reference.
+  log: console.log,
+  warn: console.warn,
+};
+
+const captureConsoleMethod = (method: keyof typeof originalConsole): void => {
+  (console as any)[method] = (...args: any[]) => {
+    const logMessage = `[console.${method}] ${args.map((arg) => (typeof arg === "object" ? JSON.stringify(arg) : String(arg))).join(" ")}`;
+    logs.push(logMessage);
+    if (SHOW_ALL_LOGS) {
+      originalConsole[method](...args);
+    }
+  };
+};
+
+captureConsoleMethod("log");
+captureConsoleMethod("info");
+captureConsoleMethod("warn");
+captureConsoleMethod("error");
+captureConsoleMethod("debug");
+
+// Setup before each test
+beforeEach(() => {
+  process.env.TOKEN_SECRET = "secret";
+  process.env.TOKEN_ISSUER = "terreno-api.test";
+  process.env.SESSION_SECRET = "sessionSecret";
+  process.env.REFRESH_TOKEN_SECRET = "refreshTokenSecret";
+  setupEnvironment();
+  // Re-silence loggers after setupEnvironment which may reconfigure them
+  winston.clear();
+  winston.add(silentTransport);
+  winstonLogger.clear();
+  winstonLogger.add(silentTransport);
+  logs = [];
+});
+
+// Clear logs after each test
+afterEach(() => {
+  logs = [];
+});
+
+// Mock @sentry/node module
+mock.module("@sentry/node", () => {
+  const mockFn = (): ReturnType<typeof mock> => mock(() => {});
+
+  // Mock Scope
+  const mockScope = {
+    addBreadcrumb: mockFn(),
+    clear: mockFn(),
+    getSpan: mockFn(),
+    setContext: mockFn(),
+    setFingerprint: mockFn(),
+    setLevel: mockFn(),
+    setSpan: mockFn(),
+    setTag: mockFn(),
+    setTags: mockFn(),
+    setTransactionName: mockFn(),
+    setUser: mockFn(),
+  };
+
+  // Mock Hub
+  const mockClient = {
+    captureException: mockFn(),
+    captureMessage: mockFn(),
+    close: mock(() => Promise.resolve(true)),
+    flush: mock(() => Promise.resolve(true)),
+    getOptions: mock(() => ({})),
+  };
+
+  const mockHub = {
+    addBreadcrumb: mockFn(),
+    captureException: mockFn(),
+    captureMessage: mockFn(),
+    configureScope: mockFn(),
+    getClient: mock(() => mockClient),
+    getScope: mock(() => mockScope),
+    popScope: mockFn(),
+    pushScope: mockFn(),
+    setContext: mockFn(),
+    setTag: mockFn(),
+    setTags: mockFn(),
+    setUser: mockFn(),
+    withScope: mockFn(),
+  };
+
+  const mockSpan: any = {
+    finish: mockFn(),
+    setData: mockFn(),
+    setStatus: mockFn(),
+    setTag: mockFn(),
+    startChild: mockFn(),
+    toTraceparent: mock(() => "mock-trace-parent"),
+  };
+  mockSpan.startChild = mock(() => mockSpan);
+
+  const mockTransaction = {
+    finish: mockFn(),
+    setData: mockFn(),
+    setName: mockFn(),
+    setStatus: mockFn(),
+    setTag: mockFn(),
+    startChild: mock(() => mockSpan),
+    toTraceparent: mock(() => "mock-trace-parent"),
+  };
+
+  return {
+    addBreadcrumb: mockFn(),
+    captureException: mockFn(),
+    captureMessage: mockFn(),
+    clearScope: mockFn(),
+    close: mock(() => Promise.resolve(true)),
+    configureScope: mockFn(),
+    default: {
+      addBreadcrumb: mockFn(),
+      captureException: mockFn(),
+      captureMessage: mockFn(),
+      clearScope: mockFn(),
+      close: mock(() => Promise.resolve(true)),
+      configureScope: mockFn(),
+      flush: mock(() => Promise.resolve(true)),
+      getClient: mock(() => mockClient),
+      getCurrentHub: mock(() => mockHub),
+      getCurrentScope: mock(() => mockScope),
+      Handlers: {
+        errorHandler: mock(() => (err: any, _req: any, _res: any, next: any) => next(err)),
+        requestHandler: mock(() => (_req: any, _res: any, next: any) => next()),
+        tracingHandler: mock(() => (_req: any, _res: any, next: any) => next()),
+      },
+      init: mockFn(),
+      isInitialized: mock(() => true),
+      popScope: mockFn(),
+      pushScope: mockFn(),
+      Severity: {
+        Debug: "debug",
+        Error: "error",
+        Fatal: "fatal",
+        Info: "info",
+        Warning: "warning",
+      } as const,
+      setContext: mockFn(),
+      setFingerprint: mockFn(),
+      setLevel: mockFn(),
+      setTag: mockFn(),
+      setTags: mockFn(),
+      setUser: mockFn(),
+      setupExpressErrorHandler: mockFn(),
+      startTransaction: mock(() => mockTransaction),
+      withScope: mock((callback: any) => callback(mockScope)),
+    },
+    flush: mock(() => Promise.resolve(true)),
+    getClient: mock(() => mockClient),
+    getCurrentHub: mock(() => mockHub),
+    getCurrentScope: mock(() => mockScope),
+    Handlers: {
+      errorHandler: mock(() => (err: any, _req: any, _res: any, next: any) => next(err)),
+      requestHandler: mock(() => (_req: any, _res: any, next: any) => next()),
+      tracingHandler: mock(() => (_req: any, _res: any, next: any) => next()),
+    },
+    init: mockFn(),
+    isInitialized: mock(() => true),
+    popScope: mockFn(),
+    pushScope: mockFn(),
+    Severity: {
+      Debug: "debug",
+      Error: "error",
+      Fatal: "fatal",
+      Info: "info",
+      Warning: "warning",
+    } as const,
+    setContext: mockFn(),
+    setFingerprint: mockFn(),
+    setLevel: mockFn(),
+    setTag: mockFn(),
+    setTags: mockFn(),
+    setUser: mockFn(),
+    setupExpressErrorHandler: mockFn(),
+    startTransaction: mock(() => mockTransaction),
+    withScope: mock((callback: any) => callback(mockScope)),
+  };
+});

package/src/tests/index.ts

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