@tsed/mongoose 6.88.0 → 6.91.0

package/lib/types/interfaces/MongooseDocument.d.ts

@@ -0,0 +1,2 @@
+import { Document } from "mongoose";
+export declare type MongooseDocument<T> = T & Document;

package/lib/types/interfaces/MongooseModel.d.ts

@@ -0,0 +1,9 @@
+import { Document, Model } from "mongoose";
+export declare type MongooseMergedDocument<T> = {
+    [K in keyof T]: T[K];
+};
+export interface MongooseDocumentMethods<T> {
+    toClass(): T;
+}
+export interface MongooseModel<T> extends Model<MongooseMergedDocument<Document & T & MongooseDocumentMethods<T>>> {
+}

package/lib/types/interfaces/MongooseModelOptions.d.ts

@@ -0,0 +1,8 @@
+import { MongooseSchemaOptions } from "./MongooseSchemaOptions";
+export interface MongooseModelOptions extends MongooseSchemaOptions {
+    name?: string;
+    connection?: string;
+    collection?: string;
+    skipInit?: boolean;
+    discriminatorValue?: string;
+}

package/lib/types/interfaces/MongooseSchemaOptions.d.ts

@@ -0,0 +1,35 @@
+import { NativeError, Schema, SchemaOptions } from "mongoose";
+import { MongooseDocument } from "./MongooseDocument";
+export declare type MongooseNextCB = (err?: NativeError) => void;
+export interface MongooseHookOptions {
+    document?: boolean;
+    query?: boolean;
+    parallel?: boolean;
+}
+export declare type MongoosePreHookCB<T = any> = ((doc: T | MongooseDocument<T>, next: MongooseNextCB) => void) | ((doc: T | MongooseDocument<T>) => Promise<void> | void);
+export declare type MongoosePostHookCB<T = any> = ((doc: T | MongooseDocument<T>, error: NativeError, next: MongooseNextCB) => void) | ((doc: T | MongooseDocument<T>, error: NativeError) => Promise<void> | void) | ((doc: T | MongooseDocument<T>, next: MongooseNextCB) => void) | ((doc: T | MongooseDocument<T>) => Promise<void> | void);
+export interface MongoosePreHook<T = any> {
+    method: string | RegExp;
+    fn: MongoosePreHookCB<T>;
+    options?: MongooseHookOptions;
+}
+export interface MongoosePostHook<T = any> {
+    method: string | RegExp;
+    fn: MongoosePostHookCB<T>;
+    options?: MongooseHookOptions;
+}
+export interface MongoosePluginOptions {
+    plugin: (schema: Schema, options?: any) => void;
+    options?: Record<string, unknown>;
+}
+export interface MongooseIndexOptions {
+    fields: object;
+    options?: Record<string, unknown>;
+}
+export interface MongooseSchemaOptions {
+    schemaOptions?: SchemaOptions;
+    plugins?: MongoosePluginOptions[];
+    indexes?: MongooseIndexOptions[];
+    pre?: MongoosePreHook[];
+    post?: MongoosePostHook[];
+}

package/lib/types/interfaces/MongooseSchemaTypes.d.ts

@@ -0,0 +1,5 @@
+export declare enum MongooseSchemaTypes {
+    OBJECT_ID = "ObjectId",
+    STRING = "String",
+    NUMBER = "Number"
+}

package/lib/types/interfaces/MongooseVirtualRefOptions.d.ts

@@ -0,0 +1,13 @@
+import { Type } from "@tsed/core";
+export interface MongooseVirtualRefOptions {
+    /**
+     * @deprecated Since v6. Use ref instead.
+     */
+    type?: string | Type<any> | (() => Type<any>);
+    ref?: string | Type<any> | (() => Type<any>);
+    foreignField?: string;
+    localField?: string;
+    justOne?: boolean;
+    count?: boolean;
+    options?: object;
+}

package/lib/types/interfaces/index.d.ts

@@ -0,0 +1,14 @@
+import { MongooseConnectionOptions } from "./MongooseConnectionOptions";
+declare global {
+    namespace TsED {
+        interface Configuration {
+            mongoose: Omit<MongooseConnectionOptions, "id"> | MongooseConnectionOptions[];
+        }
+    }
+}
+export * from "./MongooseConnectionOptions";
+export * from "./MongooseDocument";
+export * from "./MongooseModel";
+export * from "./MongooseModelOptions";
+export * from "./MongooseSchemaOptions";
+export * from "./MongooseVirtualRefOptions";

package/lib/types/registries/MongooseModels.d.ts

@@ -0,0 +1,2 @@
+import { Type } from "@tsed/core";
+export declare const MongooseModels: Map<string, Type>;

package/lib/types/services/MongooseConnections.d.ts

@@ -0,0 +1,9 @@
+import { MongooseService } from "../services/MongooseService";
+/**
+ * @ignore
+ */
+export declare const MONGOOSE_CONNECTIONS: unique symbol;
+/**
+ * @ignore
+ */
+export declare type MONGOOSE_CONNECTIONS = MongooseService;

package/lib/types/services/MongooseService.d.ts

@@ -0,0 +1,25 @@
+import { Logger } from "@tsed/logger";
+import Mongoose from "mongoose";
+import { ConnectOptions } from "mongoose";
+export declare class MongooseService {
+    readonly connections: Map<string, Mongoose.Connection>;
+    private defaultConnection;
+    logger: Logger;
+    /**
+     *
+     * @returns {Promise<"mongoose".Connection>}
+     */
+    connect(id: string, url: string, connectionOptions: ConnectOptions, isDefault?: boolean): Promise<any>;
+    /**
+     *
+     * @returns {"mongoose".Connection}
+     */
+    get(id?: string): Mongoose.Connection | undefined;
+    /**
+     *
+     * @param {string} id
+     * @returns {boolean}
+     */
+    has(id?: string): boolean;
+    closeConnections(): Promise<void>;
+}

package/lib/types/utils/createModel.d.ts

@@ -0,0 +1,19 @@
+import { Type } from "@tsed/core";
+import mongoose, { Connection } from "mongoose";
+export declare function getModelToken(target: Type<any>, options: any): {
+    token: symbol;
+    collectionName: any;
+};
+/**
+ * Create an instance of mongoose.model from a class.
+ *
+ * @param {Type<any>} target Class attached to the schema and model.
+ * @param {"mongoose".Schema} schema Schema that will be attached to the model.
+ * @param name model name
+ * @param collection (optional, induced from model name)
+ * @param skipInit whether to skip initialization (defaults to false)
+ * @param connection
+ * @param discriminatorValue
+ * @returns {Model<T extends Document>}
+ */
+export declare function createModel<T>(target: any, schema: mongoose.Schema, name?: string, collection?: string, skipInit?: boolean, connection?: Connection, discriminatorValue?: string): mongoose.Model<mongoose.Document<any, {}>, {}> | mongoose.Model<any, {}>;

package/lib/types/utils/createSchema.d.ts

@@ -0,0 +1,28 @@
+import { Type } from "@tsed/core";
+import { JsonEntityStore } from "@tsed/schema";
+import mongoose, { Schema, SchemaDefinition, SchemaTypeOptions } from "mongoose";
+import { MongooseSchemaOptions } from "../interfaces";
+import { MongooseVirtualRefOptions } from "../interfaces/MongooseVirtualRefOptions";
+export interface MongooseSchemaMetadata {
+    schema: SchemaDefinition;
+    virtuals: Map<string, MongooseVirtualRefOptions>;
+}
+export declare function createSchema(target: Type<any>, options?: MongooseSchemaOptions): mongoose.Schema;
+/**
+ * Get a schema already created. If the schema doesn't exists in registry, it'll be created.
+ * @param target
+ * @param options
+ */
+export declare function getSchema(target: Type<any>, options?: MongooseSchemaOptions): Schema;
+export declare function getSchemaToken(target: Type<any>, options?: any): {
+    token: symbol;
+    collectionName: any;
+};
+/**
+ * @ignore
+ */
+export declare function buildMongooseSchema(target: any): MongooseSchemaMetadata;
+/**
+ * @ignore
+ */
+export declare function createSchemaTypeOptions<T = any>(propEntity: JsonEntityStore): SchemaTypeOptions<T> | SchemaTypeOptions<T>[];

package/lib/types/utils/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./createSchema";
+export * from "./createModel";

package/lib/types/utils/resolveRefType.d.ts

@@ -0,0 +1,5 @@
+import { Type } from "@tsed/core";
+/**
+ * @ignore
+ */
+export declare function resolveRefType(type: string | (() => Type<any>) | Type<any>): string;

package/lib/types/utils/schemaOptions.d.ts

@@ -0,0 +1,14 @@
+import { Schema } from "mongoose";
+import { MongooseNextCB, MongooseSchemaOptions } from "../interfaces";
+/**
+ * @ignore
+ */
+export declare function schemaOptions(target: any, options?: MongooseSchemaOptions): any;
+/**
+ * @ignore
+ */
+export declare function buildPreHook(fn: Function): (next: MongooseNextCB, options: any) => any;
+/**
+ * @ignore
+ */
+export declare function applySchemaOptions(schema: Schema, options: MongooseSchemaOptions): void;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tsed/mongoose",
-  "version": "6.88.0",
+  "version": "6.91.0",
   "description": "Mongoose package for Ts.ED framework",
   "private": false,
   "keywords": [
@@ -11,14 +11,18 @@
     "orm"
   ],
   "source": "./src/index.ts",
-  "main": "./lib/index.js",
-  "typings": "./lib/index.d.ts",
+  "main": "./lib/cjs/index.js",
+  "typings": "./lib/types/index.d.ts",
   "exports": {
-    "require": "./lib/index.js",
-    "default": "./lib/index.modern.js"
+    "types": "./lib/types/index.d.ts",
+    "import": "./lib/esm/index.js",
+    "require": "./lib/cjs/index.js",
+    "default": "./lib/esm/index.js"
   },
   "scripts": {
-    "build": "microbundle --target node --no-compress --format modern,cjs --tsconfig ./tsconfig.compile.json",
+    "build": "yarn run build:esm && yarn run build:cjs",
+    "build:cjs": "tsc --build tsconfig.compile.json",
+    "build:esm": "tsc --build tsconfig.compile.esm.json",
     "test": "cross-env NODE_ENV=test yarn jest"
   },
   "dependencies": {
@@ -26,21 +30,21 @@
     "tslib": "2.2.0"
   },
   "devDependencies": {
-    "@tsed/ajv": "6.88.0",
-    "@tsed/core": "6.88.0",
-    "@tsed/di": "6.88.0",
-    "@tsed/json-mapper": "6.88.0",
+    "@tsed/ajv": "6.91.0",
+    "@tsed/core": "6.91.0",
+    "@tsed/di": "6.91.0",
+    "@tsed/json-mapper": "6.91.0",
     "@tsed/logger": "^6.0.0",
-    "@tsed/schema": "6.88.0",
+    "@tsed/schema": "6.91.0",
     "mongoose": "^5.12.2"
   },
   "peerDependencies": {
-    "@tsed/ajv": "^6.88.0",
-    "@tsed/core": "^6.88.0",
-    "@tsed/di": "^6.88.0",
-    "@tsed/json-mapper": "^6.88.0",
+    "@tsed/ajv": "^6.91.0",
+    "@tsed/core": "^6.91.0",
+    "@tsed/di": "^6.91.0",
+    "@tsed/json-mapper": "^6.91.0",
     "@tsed/logger": ">=6.0.0",
-    "@tsed/schema": "^6.88.0",
+    "@tsed/schema": "^6.91.0",
     "mongoose": ">=5.12.2"
   },
   "repository": "https://github.com/tsedio/tsed",

package/tsconfig.compile.esm.json

@@ -0,0 +1,23 @@
+{
+  "extends": "./tsconfig.compile.json",
+  "compilerOptions": {
+    "baseUrl": ".",
+    "module": "ES2020",
+    "rootDir": "src",
+    "outDir": "./lib/esm",
+    "declaration": true,
+    "declarationDir": "./lib/types"
+  },
+  "exclude": [
+    "node_modules",
+    "test",
+    "lib",
+    "benchmark",
+    "coverage",
+    "spec",
+    "**/*.benchmark.ts",
+    "**/*.spec.ts",
+    "keys",
+    "jest.config.js"
+  ]
+}