@tsed/mongoose 8.11.1 → 8.11.2-rc.1

package/src/utils/createSchema.ts

@@ -1,207 +0,0 @@
-import {classOf, cleanObject, isClassObject, nameOf, Store, Type} from "@tsed/core";
-import {deserialize, serialize} from "@tsed/json-mapper";
-import {getProperties, JsonEntityStore} from "@tsed/schema";
-import {pascalCase} from "change-case";
-import mongoose, {Schema, SchemaDefinition, SchemaDefinitionProperty, SchemaOptions, SchemaTypeOptions} from "mongoose";
-
-import {MONGOOSE_SCHEMA, MONGOOSE_SCHEMA_OPTIONS} from "../constants/constants.js";
-import {MongooseSchemaOptions} from "../interfaces/MongooseSchemaOptions.js";
-import {MongooseVirtualRefOptions} from "../interfaces/MongooseVirtualRefOptions.js";
-import {resolveRefType} from "./resolveRefType.js";
-import {schemaOptions} from "./schemaOptions.js";
-
-export interface MongooseSchemaMetadata {
-  schema: SchemaDefinition;
-  virtuals: Map<string, MongooseVirtualRefOptions>;
-}
-
-/**
- * @ignore
- */
-function setUpSchema({schema, virtuals}: MongooseSchemaMetadata, options?: SchemaOptions) {
-  const mongooseSchema = new mongoose.Schema(schema, options as never);
-
-  for (const [key, options] of virtuals.entries()) {
-    mongooseSchema.virtual(key, options);
-  }
-
-  return mongooseSchema;
-}
-
-/**
- * @ignore
- */
-function isVirtualRef(target: Partial<MongooseVirtualRefOptions>): target is MongooseVirtualRefOptions {
-  return !!(target.ref && target.localField && target.foreignField);
-}
-
-function hasVersionField(schema: mongoose.Schema, versionKey?: string | boolean) {
-  // Check if versioning was disabled explicitly
-  if (!versionKey) return false;
-
-  // Check for alternative version field in schema
-  return (versionKey as string) in schema.paths;
-}
-
-export function createSchema(target: Type<any>, options: MongooseSchemaOptions = {}): mongoose.Schema {
-  const entity = JsonEntityStore.from(target);
-  const schemaOptionsFromStore = entity.store.get(MONGOOSE_SCHEMA_OPTIONS) || {};
-  options.schemaOptions = {...options.schemaOptions, ...schemaOptionsFromStore};
-
-  if (entity.schema.isDiscriminator) {
-    options.schemaOptions!.discriminatorKey = entity.schema.discriminator().propertyName;
-  }
-
-  const schema = setUpSchema(buildMongooseSchema(target), options.schemaOptions);
-
-  schemaOptions(target, options);
-
-  const outputVersionKey = hasVersionField(schema, options.schemaOptions?.versionKey);
-
-  schema.methods.toClass = function toClass() {
-    return deserialize(
-      this.toObject({
-        virtuals: true,
-        versionKey: outputVersionKey,
-        flattenMaps: true
-      }),
-      {
-        type: target,
-        useAlias: false,
-        additionalProperties: true,
-        disabledUnsecureConstructor: false,
-        groups: false
-      }
-    );
-  };
-
-  schema.methods.toJSON = function toJSON(options?: any) {
-    return serialize((this as any).toClass(), options);
-  };
-
-  schema.loadClass(target);
-
-  Store.from(target).set(MONGOOSE_SCHEMA, schema);
-
-  return schema;
-}
-
-/**
- * Get a schema already created. If the schema doesn't exists in registry, it'll be created.
- * @param target
- * @param options
- */
-export function getSchema(target: Type<any>, options: MongooseSchemaOptions = {}): Schema {
-  const store = Store.from(target);
-
-  if (!store.has(MONGOOSE_SCHEMA)) {
-    createSchema(target, options);
-  }
-
-  return store.get(MONGOOSE_SCHEMA);
-}
-
-export function getSchemaToken(target: Type<any>, options?: any) {
-  const collectionName = options.name || nameOf(target);
-  const token = Symbol.for(pascalCase(`${collectionName}Schema`));
-
-  return {token, collectionName};
-}
-
-/**
- * @ignore
- */
-export function buildMongooseSchema(target: any): MongooseSchemaMetadata {
-  const properties = getProperties(target, {withIgnoredProps: true, mongoose: true, groups: false});
-  const schema: MongooseSchemaMetadata = {schema: {}, virtuals: new Map()};
-
-  properties.forEach((propertyMetadata, key) => {
-    // Keeping the Mongoose Schema separate, so it can overwrite everything once schema has been built.
-    const schemaTypeOptions: any = propertyMetadata.store.get(MONGOOSE_SCHEMA) || {};
-
-    if (schemaTypeOptions.schemaIgnore || propertyMetadata.isDiscriminatorKey() || propertyMetadata.isGetterOnly()) {
-      return;
-    }
-
-    if (schemaTypeOptions.ref) {
-      schemaTypeOptions.ref = resolveRefType(schemaTypeOptions.ref as any);
-    }
-
-    if (isVirtualRef(schemaTypeOptions)) {
-      schema.virtuals.set(key as string, schemaTypeOptions);
-
-      return;
-    }
-
-    schema.schema[key as string] = createSchemaTypeOptions(propertyMetadata);
-  });
-
-  return schema;
-}
-
-/**
- * @ignore
- */
-export function createSchemaTypeOptions(propEntity: JsonEntityStore): SchemaDefinitionProperty {
-  const key = propEntity.propertyKey;
-  const rawMongooseSchema = propEntity.store.get(MONGOOSE_SCHEMA) || {};
-
-  let schemaTypeOptions: SchemaTypeOptions<any> = {
-    required: propEntity.required
-      ? function () {
-          return propEntity.isRequired(this[key]);
-        }
-      : false
-  };
-
-  if (!propEntity.isClass) {
-    const jsonSchema = propEntity.itemSchema.toJSON();
-    const {minimum: min, maximum: max, minLength: minlength, maxLength: maxlength} = jsonSchema;
-
-    let match: string | RegExp = jsonSchema.pattern;
-    if (match) {
-      match = new RegExp(match);
-    }
-
-    schemaTypeOptions = {
-      ...schemaTypeOptions,
-      type: jsonSchema["enum"] && isClassObject(propEntity.type) ? classOf(jsonSchema["enum"][0]) : propEntity.type,
-      match: match as RegExp,
-      min,
-      max,
-      minlength,
-      maxlength,
-      enum: jsonSchema["enum"],
-      default: jsonSchema["default"]
-    };
-  } else if (!rawMongooseSchema.ref) {
-    // References are handled by the final merge
-    schemaTypeOptions = {...schemaTypeOptions, type: getSchema(propEntity.type) as any};
-  }
-
-  schemaTypeOptions = cleanObject({...schemaTypeOptions, ...rawMongooseSchema});
-
-  if (propEntity.isCollection) {
-    if (propEntity.isArray) {
-      return {
-        ...schemaTypeOptions,
-        type: [schemaTypeOptions.type]
-      };
-    }
-    // Can be a Map or a Set;
-    // Mongoose implements only Map;
-    if (propEntity.collectionType !== Map) {
-      throw new Error(`Invalid collection type. ${nameOf(propEntity.collectionType)} is not supported.`);
-    }
-
-    const {default: defaultValue, required, ...otherOpts} = schemaTypeOptions;
-    return {
-      type: Map,
-      of: otherOpts,
-      default: defaultValue,
-      required
-    };
-  }
-
-  return schemaTypeOptions;
-}

package/src/utils/resolveRefType.spec.ts

@@ -1,30 +0,0 @@
-import {Store} from "@tsed/core";
-
-import {MONGOOSE_MODEL_NAME} from "../constants/constants.js";
-import {resolveRefType} from "./resolveRefType.js";
-
-describe("resolveRefType", () => {
-  it("should return type as string (from string)", () => {
-    expect(resolveRefType("Test")).toBe("Test");
-  });
-  it("should return type as string (from class)", () => {
-    class Test {}
-
-    Store.from(Test).set(MONGOOSE_MODEL_NAME, "Test");
-
-    expect(resolveRefType(Test)).toBe("Test");
-  });
-
-  it("should return type as string (from class without store)", () => {
-    class Test {}
-
-    expect(resolveRefType(Test)).toBe("Test");
-  });
-  it("should return type as string (from arrow resolver)", () => {
-    class Test {}
-
-    Store.from(Test).set(MONGOOSE_MODEL_NAME, "Test");
-
-    expect(resolveRefType(() => Test)).toBe("Test");
-  });
-});

package/src/utils/resolveRefType.ts

@@ -1,18 +0,0 @@
-import {isClass, isString, nameOf, Store, Type} from "@tsed/core";
-
-import {MONGOOSE_MODEL_NAME} from "../constants/constants.js";
-
-/**
- * @ignore
- */
-export function resolveRefType(type: string | (() => Type<any>) | Type<any>): string {
-  if (isString(type)) {
-    return type;
-  }
-
-  if (!isClass(type)) {
-    type = (type as any)();
-  }
-
-  return Store.from(type).get(MONGOOSE_MODEL_NAME) || nameOf(type);
-}

package/src/utils/schemaOptions.spec.ts

@@ -1,68 +0,0 @@
-import {applySchemaOptions, schemaOptions} from "../../src/utils/schemaOptions.js";
-
-describe("schemaOptions", () => {
-  describe("schemaOptions()", () => {
-    class Test {}
-
-    beforeEach(() => {});
-
-    it("should return schema options (1)", () => {
-      expect(schemaOptions(Test)).toEqual({});
-    });
-
-    it("should return schema options (2)", () => {
-      expect(schemaOptions(Test, {options: "options"} as any)).toEqual({options: "options"});
-    });
-
-    it("should return schema options (3)", () => {
-      expect(schemaOptions(Test, {options2: "options2"} as any)).toEqual({
-        options: "options",
-        options2: "options2"
-      });
-    });
-  });
-  describe("applySchemaOptions()", () => {
-    const schema: any = {
-      pre: vi.fn(),
-      post: vi.fn(),
-      plugin: vi.fn(),
-      index: vi.fn()
-    };
-
-    beforeEach(() => {
-      applySchemaOptions(schema, {
-        pre: [
-          {
-            method: "method",
-            fn: (doc: any, pre: any) => {},
-            options: {query: true}
-          }
-        ],
-        post: [
-          {
-            method: "method",
-            fn: "fn"
-          }
-        ],
-        plugins: [{plugin: "plugin", options: "options"}],
-        indexes: [{fields: "fields", options: "options"}]
-      } as any);
-    });
-
-    it("should call schema.pre", () => {
-      expect(schema.pre).toHaveBeenCalledWith("method", {query: true}, expect.any(Function));
-    });
-
-    it("should call schema.post", () => {
-      expect(schema.post).toHaveBeenCalledWith("method", "fn");
-    });
-
-    it("should call schema.plugin", () => {
-      expect(schema.plugin).toHaveBeenCalledWith("plugin", "options");
-    });
-
-    it("should call schema.index", () => {
-      expect(schema.index).toHaveBeenCalledWith("fields", "options");
-    });
-  });
-});

package/src/utils/schemaOptions.ts

@@ -1,74 +0,0 @@
-import {deepMerge, Store} from "@tsed/core";
-import {Schema} from "mongoose";
-
-import {MONGOOSE_SCHEMA_OPTIONS} from "../constants/constants.js";
-import {
-  MongooseHookPromised,
-  MongoosePostHook,
-  MongoosePreHook,
-  MongoosePreHookCB,
-  MongooseSchemaOptions
-} from "../interfaces/MongooseSchemaOptions.js";
-
-/**
- * @ignore
- */
-export function schemaOptions(target: any, options?: MongooseSchemaOptions) {
-  const store = Store.from(target);
-
-  if (!store.has(MONGOOSE_SCHEMA_OPTIONS)) {
-    store.set(MONGOOSE_SCHEMA_OPTIONS, {});
-  }
-
-  if (options) {
-    store.set(MONGOOSE_SCHEMA_OPTIONS, deepMerge(store.get(MONGOOSE_SCHEMA_OPTIONS), options));
-  }
-
-  return store.get(MONGOOSE_SCHEMA_OPTIONS);
-}
-
-function mapHookArgs(hook: MongoosePreHook | MongoosePostHook): [string | RegExp, Function] {
-  return [hook.method, hook.options || hook.fn, hook.options ? hook.fn : undefined].filter(Boolean) as any;
-}
-
-/**
- * @ignore
- */
-export function buildPreHook(fn: MongoosePreHookCB) {
-  return fn.length === 1
-    ? function () {
-        return (fn as MongooseHookPromised)(this);
-      }
-    : // we need to explicitly gives args to avoid a bug with mongoose
-      function (next: Function, arg1: unknown, arg2: unknown) {
-        return (fn as any)(this, next, arg1, arg2);
-      };
-}
-
-/**
- * @ignore
- */
-export function applySchemaOptions(schema: Schema, options: MongooseSchemaOptions) {
-  if (options.plugins) {
-    options.plugins.forEach((item) => schema.plugin(item.plugin, item.options));
-  }
-
-  if (options.indexes) {
-    options.indexes.forEach((item) => schema.index(item.fields, item.options));
-  }
-
-  if (options.pre) {
-    options.pre.forEach((item) => {
-      item = {
-        ...item,
-        fn: buildPreHook(item.fn)
-      };
-
-      (schema.pre as any)(...mapHookArgs(item));
-    });
-  }
-
-  if (options.post) {
-    options.post.forEach((item) => (schema.post as any)(...mapHookArgs(item)));
-  }
-}

package/vitest.config.mts

@@ -1,25 +0,0 @@
-// @ts-ignore
-import {presets} from "@tsed/vitest/presets";
-import {defineConfig} from "vitest/config";
-
-export default defineConfig(
-  {
-    ...presets,
-    test: {
-      ...presets.test,
-      // @ts-ignore
-      globalSetup: [
-        "../testcontainers-mongo/src/setup/vi.setup.ts"
-      ],
-      coverage: {
-        ...presets.test.coverage,
-        thresholds: {
-          statements: 0,
-          branches: 0,
-          functions: 0,
-          lines: 0
-        }
-      }
-    }
-  }
-);