c2-mongoose 2.1.358 → 2.1.360

package/dist/flow/C2Flow.js

@@ -82,14 +82,14 @@ var C2Flow = /** @class */ (function () {
             var dataAfter, log;
             return __generator(this, function (_a) {
                 switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.repository.create(data, { session: options.session })];
+                    case 0: return [4 /*yield*/, this.repository.create(data, { session: options.session, ordered: true })];
                     case 1:
                         dataAfter = _a.sent();
                         if (options.logger === false || (0, Utils_1.isEmpty)(dataAfter)) {
                             return [2 /*return*/, dataAfter];
                         }
                         log = BuildLogFlowItem_1.default.build(options, dataAfter[0]._doc, Logger_1.TypeOfOperation.CREATE, this.repository);
-                        return [4 /*yield*/, global.LoggerRepository.create([log], { session: options.session })];
+                        return [4 /*yield*/, global.LoggerRepository.create([log], { session: options.session, ordered: true })];
                     case 2:
                         _a.sent();
                         return [2 /*return*/, dataAfter];

package/dist/flow/CrudFlow.d.ts

@@ -6,19 +6,7 @@ declare class CrudFlow<D> {
     private search;
     constructor(repository: mongoose.Model<any>, search?: SearchFlow);
     prepareSearch(search: SearchFlow): void;
-    create(data: any, session?: any): Promise<((mongoose.Document<unknown, any, Omit<any, "_id"> & {
-        _id: mongoose.Types.ObjectId;
-    }> & Omit<any, "_id"> & {
-        _id: mongoose.Types.ObjectId;
-    } & {
-        _id: mongoose.Types.ObjectId;
-    }) | (mongoose.Document<unknown, any, Omit<any, "_id"> & Required<{
-        _id: unknown;
-    }>> & Omit<any, "_id"> & Required<{
-        _id: unknown;
-    }> & {
-        _id: mongoose.Types.ObjectId;
-    }))[]>;
+    create(data: any, session?: any): Promise<any[]>;
     delete(id: string, session?: any): Promise<void>;
     deleteMany(conditions: {}, session?: any): Promise<void>;
     update(id: string, data: D, session?: any): Promise<D>;

package/dist/flow/searcher/v2/item/GetFieldDefinitionFlowItem.d.ts

@@ -1,6 +1,14 @@
 import mongoose from "mongoose";
 declare class GetFieldDefinitionFlowItem {
-    execute(modelRoot: mongoose.Model<any, {}, {}, {}, any>, first: string): mongoose.SchemaType<any>;
+    execute(modelRoot: mongoose.Model<any, {}, {}, {}, any, any>, first: string): mongoose.SchemaType<any, mongoose.Document<unknown, {}, mongoose.FlatRecord<{
+        [x: string]: unknown;
+    }>, {}> & mongoose.FlatRecord<{
+        [x: string]: unknown;
+    }> & Required<{
+        _id: unknown;
+    }> & {
+        __v: number;
+    }>;
 }
 declare const _default: GetFieldDefinitionFlowItem;
 export default _default;

package/dist/flow/searcher/v2/item/GetTypeOfFieldInModelFlowItem.d.ts

@@ -1,6 +1,6 @@
 import mongoose from "mongoose";
 declare class GetTypeOfFieldInModelFlowItem {
-    exec(fieldToGroup: string, modelRoot: mongoose.Model<any, {}, {}, {}, any>): string;
+    exec(fieldToGroup: string, modelRoot: mongoose.Model<any, {}, {}, {}, any, any>): string;
 }
 declare const _default: GetTypeOfFieldInModelFlowItem;
 export default _default;

package/dist/flow/searcher/v3/item/GetFieldDefinitionFlowItem.d.ts

@@ -1,6 +1,14 @@
 import mongoose from "mongoose";
 declare class GetFieldDefinitionFlowItem {
-    execute(modelRoot: mongoose.Model<any, {}, {}, {}, any>, first: string): mongoose.SchemaType<any>;
+    execute(modelRoot: mongoose.Model<any, {}, {}, {}, any, any>, first: string): mongoose.SchemaType<any, mongoose.Document<unknown, {}, mongoose.FlatRecord<{
+        [x: string]: unknown;
+    }>, {}> & mongoose.FlatRecord<{
+        [x: string]: unknown;
+    }> & Required<{
+        _id: unknown;
+    }> & {
+        __v: number;
+    }>;
 }
 declare const _default: GetFieldDefinitionFlowItem;
 export default _default;

package/dist/flow/searcher/v3/item/GetTypeOfFieldInModelFlowItem.d.ts

@@ -1,6 +1,6 @@
 import mongoose from "mongoose";
 declare class GetTypeOfFieldInModelFlowItem {
-    exec(fieldToGroup: string, modelRoot: mongoose.Model<any, {}, {}, {}, any>): string;
+    exec(fieldToGroup: string, modelRoot: mongoose.Model<any, {}, {}, {}, any, any>): string;
 }
 declare const _default: GetTypeOfFieldInModelFlowItem;
 export default _default;

package/dist/model/Logger.d.ts

@@ -1,5 +1,5 @@
 import moment from 'moment';
-import mongoose, { Schema, Types } from 'mongoose';
+import mongoose, { Types } from 'mongoose';
 import SearchFlow from '../flow/SearchFlow';
 declare enum TypeOfOperation {
     "CREATE" = "CREATE",
@@ -16,14 +16,39 @@ interface ILogger {
     filters: any;
     notes: string;
 }
-declare const LoggerModel: mongoose.Schema<any, mongoose.Model<any, any, any, any, any>, {}, {}, any, {}, "type", {
-    owner: Schema.Types.ObjectId;
-    user: Schema.Types.ObjectId;
+declare const LoggerModel: mongoose.Schema<any, mongoose.Model<any, any, any, any, any, any>, {}, {}, {}, {}, {
+    timestamps: {
+        createdAt: string;
+        updatedAt: string;
+    };
+}, {} & {
+    owner: Types.ObjectId;
+    user: Types.ObjectId;
+    collectionName: string;
+    operation: string;
+    data?: any;
+    filters?: any;
+    notes?: string | null | undefined;
+}, mongoose.Document<unknown, {}, mongoose.FlatRecord<{} & {
+    owner: Types.ObjectId;
+    user: Types.ObjectId;
+    collectionName: string;
+    operation: string;
+    data?: any;
+    filters?: any;
+    notes?: string | null | undefined;
+}>, {}> & mongoose.FlatRecord<{} & {
+    owner: Types.ObjectId;
+    user: Types.ObjectId;
     collectionName: string;
     operation: string;
     data?: any;
     filters?: any;
-    notes?: string | undefined;
+    notes?: string | null | undefined;
+}> & {
+    _id: Types.ObjectId;
+} & {
+    __v: number;
 }>;
 declare class LoggerSearch extends SearchFlow {
     model: Partial<ILogger>;

package/dist/utils/Utils.d.ts

@@ -5,5 +5,5 @@ export declare const isNotEmpty: (obj: any) => boolean;
 export declare const isEmpty: (obj: any) => boolean;
 export declare const isIterable: (input: any) => boolean;
 export declare const isNotIterable: (input: any) => boolean;
-export declare const compareAsc: (a: any, b: any) => 1 | 0 | -1;
-export declare const compareDesc: (a: any, b: any) => 1 | 0 | -1;
+export declare const compareAsc: (a: any, b: any) => 0 | 1 | -1;
+export declare const compareDesc: (a: any, b: any) => 0 | 1 | -1;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "c2-mongoose",
-  "version": "2.1.358",
+  "version": "2.1.360",
   "description": "Lib to make any search in database mongoose and use as basic crud",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -32,7 +32,7 @@
     "express-http-context": "^1.2.4",
     "moment": "^2.29.4",
     "moment-timezone": "^0.5.43",
-    "mongoose": "6.4.0"
+    "mongoose": "8.16.1"
   },
   "devDependencies": {
     "typescript": "^4.9.5"

package/src/flow/C2Flow.ts

@@ -28,14 +28,14 @@ class C2Flow<D> {
     }
 
     async createMany(data: Partial<D>[], options: Partial<Options>): Promise<Partial<D>[]> {
-        let dataAfter = await this.repository.create(data, { session: options.session })
+        let dataAfter = await this.repository.create(data, { session: options.session, ordered: true })
 
         if (options.logger === false || isEmpty(dataAfter)) {
             return dataAfter
         }
 
         let log: Partial<ILogger> = BuildLogFlowItem.build(options, dataAfter[0]._doc, TypeOfOperation.CREATE, this.repository)
-        await (global as any).LoggerRepository.create([log], { session: options.session })
+        await (global as any).LoggerRepository.create([log], { session: options.session, ordered: true })
 
         return dataAfter
     }

package/src/flow/searcher/v2/item/GetFieldDefinitionFlowItem.ts

@@ -1,7 +1,7 @@
 import mongoose from "mongoose";
 
 class GetFieldDefinitionFlowItem {
-  execute(modelRoot: mongoose.Model<any, {}, {}, {}, any>, first: string) {
+  execute(modelRoot: mongoose.Model<any, {}, {}, {}, any, any>, first: string) {
     let fieldDefinition = modelRoot.schema.path(first);
 
     if (!fieldDefinition && modelRoot.discriminators) {

package/src/flow/searcher/v2/item/GetTypeOfFieldInModelFlowItem.ts

@@ -1,7 +1,7 @@
 import mongoose from "mongoose"
 
 class GetTypeOfFieldInModelFlowItem {
-  exec(fieldToGroup: string, modelRoot: mongoose.Model<any, {}, {}, {}, any>): string {
+  exec(fieldToGroup: string, modelRoot: mongoose.Model<any, {}, {}, {}, any, any>): string {
     let fieldDefinition = modelRoot.schema.path(fieldToGroup)
     return fieldDefinition.instance
   }

package/src/flow/searcher/v3/item/GetFieldDefinitionFlowItem.ts

@@ -1,7 +1,7 @@
 import mongoose from "mongoose";
 
 class GetFieldDefinitionFlowItem {
-  execute(modelRoot: mongoose.Model<any, {}, {}, {}, any>, first: string) {
+  execute(modelRoot: mongoose.Model<any, {}, {}, {}, any, any>, first: string) {
     let fieldDefinition = modelRoot.schema.path(first);
 
     if (!fieldDefinition && modelRoot.discriminators) {

package/src/flow/searcher/v3/item/GetTypeOfFieldInModelFlowItem.ts

@@ -1,7 +1,7 @@
 import mongoose from "mongoose"
 
 class GetTypeOfFieldInModelFlowItem {
-  exec(fieldToGroup: string, modelRoot: mongoose.Model<any, {}, {}, {}, any>): string {
+  exec(fieldToGroup: string, modelRoot: mongoose.Model<any, {}, {}, {}, any, any>): string {
     let fieldDefinition = modelRoot.schema.path(fieldToGroup)
     return fieldDefinition.instance
   }