@flowerforce/flowerbase 1.3.1-beta.3 → 1.3.1-beta.4

package/dist/features/functions/utils.d.ts

@@ -1,3 +1,4 @@
+import { Document } from 'mongodb';
 import { ExecuteQueryParams, Functions } from './interface';
 /**
  * > Loads the functions config json file
@@ -15,12 +16,12 @@ export declare const executeQuery: ({ currentMethod, query, update, filter, opti
     findOne: () => Promise<unknown>;
     count: () => Promise<number>;
     deleteOne: () => Promise<unknown>;
-    insertOne: () => Promise<import("mongodb/mongodb").InsertOneResult<import("bson").Document>>;
-    updateOne: () => Promise<unknown> | import("mongodb/mongodb").FindCursor<any> | import("mongodb/mongodb").ChangeStream<import("bson").Document, import("bson").Document> | import("mongodb/mongodb").AggregationCursor<import("bson").Document>;
-    findOneAndUpdate: () => Promise<import("bson").Document | null>;
-    aggregate: () => Promise<import("bson").Document[]>;
-    insertMany: () => Promise<import("mongodb/mongodb").InsertManyResult<import("bson").Document>>;
-    updateMany: () => Promise<import("mongodb/mongodb").UpdateResult<import("bson").Document>>;
-    deleteMany: () => Promise<import("mongodb/mongodb").DeleteResult>;
+    insertOne: () => Promise<import("mongodb").InsertOneResult<Document>>;
+    updateOne: () => Promise<unknown> | import("mongodb").FindCursor<any> | import("mongodb").ChangeStream<Document, Document> | import("mongodb").AggregationCursor<Document>;
+    findOneAndUpdate: () => Promise<Document | null>;
+    aggregate: () => Promise<Document[]>;
+    insertMany: () => Promise<import("mongodb").InsertManyResult<Document>>;
+    updateMany: () => Promise<import("mongodb").UpdateResult<Document>>;
+    deleteMany: () => Promise<import("mongodb").DeleteResult>;
 }>;
 //# sourceMappingURL=utils.d.ts.map

package/dist/features/functions/utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/features/functions/utils.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,kBAAkB,EAAE,SAAS,EAAE,MAAM,aAAa,CAAA;AAE3D;;;GAGG;AACH,eAAO,MAAM,aAAa,GAAU,gBAAuB,KAAG,OAAO,CAAC,SAAS,CAwB9E,CAAA;AAED;;;;;GAKG;AACH,eAAO,MAAM,YAAY,GAAU,+GAWhC,kBAAkB;;;;;;;;;;;;EA+DpB,CAAA"}
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/features/functions/utils.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAA;AAGlC,OAAO,EAAE,kBAAkB,EAAE,SAAS,EAAE,MAAM,aAAa,CAAA;AAE3D;;;GAGG;AACH,eAAO,MAAM,aAAa,GAAU,gBAAuB,KAAG,OAAO,CAAC,SAAS,CAwB9E,CAAA;AAED;;;;;GAKG;AACH,eAAO,MAAM,YAAY,GAAU,+GAWhC,kBAAkB;;;;;;;;;;;;EA4EpB,CAAA"}

package/dist/features/functions/utils.js

@@ -70,16 +70,29 @@ const executeQuery = (_a) => __awaiter(void 0, [_a], void 0, function* ({ curren
         : typeof returnNewDocument === 'boolean'
             ? { returnDocument: returnNewDocument ? 'after' : 'before' }
             : undefined;
+    const parsedOptions = resolvedOptions ? bson_1.EJSON.deserialize(resolvedOptions) : undefined;
     return {
         find: () => __awaiter(void 0, void 0, void 0, function* () {
-            return yield currentMethod(bson_1.EJSON.deserialize(resolvedQuery)).toArray();
+            return yield (() => {
+                const cursor = currentMethod(bson_1.EJSON.deserialize(resolvedQuery));
+                if (parsedOptions === null || parsedOptions === void 0 ? void 0 : parsedOptions.sort) {
+                    cursor.sort(parsedOptions.sort);
+                }
+                if (typeof (parsedOptions === null || parsedOptions === void 0 ? void 0 : parsedOptions.skip) === 'number') {
+                    cursor.skip(parsedOptions.skip);
+                }
+                if (typeof (parsedOptions === null || parsedOptions === void 0 ? void 0 : parsedOptions.limit) === 'number') {
+                    cursor.limit(parsedOptions.limit);
+                }
+                return cursor.toArray();
+            })();
         }),
         findOne: () => currentMethod(bson_1.EJSON.deserialize(resolvedQuery)),
-        count: () => currentMethod(bson_1.EJSON.deserialize(resolvedQuery), resolvedOptions ? bson_1.EJSON.deserialize(resolvedOptions) : undefined),
+        count: () => currentMethod(bson_1.EJSON.deserialize(resolvedQuery), parsedOptions),
         deleteOne: () => currentMethod(bson_1.EJSON.deserialize(resolvedQuery)),
         insertOne: () => currentMethod(bson_1.EJSON.deserialize(document)),
         updateOne: () => currentMethod(bson_1.EJSON.deserialize(resolvedQuery), bson_1.EJSON.deserialize(resolvedUpdate)),
-        findOneAndUpdate: () => currentMethod(bson_1.EJSON.deserialize(resolvedQuery), bson_1.EJSON.deserialize(resolvedUpdate), resolvedOptions ? bson_1.EJSON.deserialize(resolvedOptions) : undefined),
+        findOneAndUpdate: () => currentMethod(bson_1.EJSON.deserialize(resolvedQuery), bson_1.EJSON.deserialize(resolvedUpdate), parsedOptions),
         aggregate: () => __awaiter(void 0, void 0, void 0, function* () {
             return (yield currentMethod(bson_1.EJSON.deserialize(pipeline), {}, // TODO -> ADD OPTIONS
             isClient)).toArray();

package/dist/utils/crypto/index.js

@@ -36,7 +36,7 @@ exports.hashPassword = hashPassword;
 const comparePassword = (plaintext, storedPassword) => __awaiter(void 0, void 0, void 0, function* () {
     const [storedHash, storedSalt] = storedPassword.split('.');
     if (!storedHash || !storedSalt) {
-        throw new Error(`Invalid stored password: ${storedPassword}`);
+        throw new Error('Invalid credentials');
     }
     const storedBuffer = Buffer.from(storedHash, 'hex');
     const buffer = (yield scrypt(plaintext, storedSalt, 64));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@flowerforce/flowerbase",
-  "version": "1.3.1-beta.3",
+  "version": "1.3.1-beta.4",
   "description": "",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/features/functions/utils.ts

@@ -1,5 +1,6 @@
 import fs from 'fs'
 import path from 'node:path'
+import { Document } from 'mongodb'
 import { EJSON } from 'bson'
 import { GetOperatorsFunction } from '../../services/mongodb-atlas/model'
 import { ExecuteQueryParams, Functions } from './interface'
@@ -65,11 +66,24 @@ export const executeQuery = async ({
       : typeof returnNewDocument === 'boolean'
         ? { returnDocument: returnNewDocument ? 'after' : 'before' }
         : undefined
+  const parsedOptions = resolvedOptions ? EJSON.deserialize(resolvedOptions) : undefined
   return {
     find: async () =>
-      await (currentMethod as ReturnType<GetOperatorsFunction>['find'])(
-        EJSON.deserialize(resolvedQuery)
-      ).toArray(),
+      await (() => {
+        const cursor = (currentMethod as ReturnType<GetOperatorsFunction>['find'])(
+          EJSON.deserialize(resolvedQuery)
+        )
+        if (parsedOptions?.sort) {
+          cursor.sort(parsedOptions.sort as Document)
+        }
+        if (typeof parsedOptions?.skip === 'number') {
+          cursor.skip(parsedOptions.skip)
+        }
+        if (typeof parsedOptions?.limit === 'number') {
+          cursor.limit(parsedOptions.limit)
+        }
+        return cursor.toArray()
+      })(),
     findOne: () =>
       (currentMethod as ReturnType<GetOperatorsFunction>['findOne'])(
         EJSON.deserialize(resolvedQuery)
@@ -77,7 +91,7 @@ export const executeQuery = async ({
     count: () =>
       (currentMethod as ReturnType<GetOperatorsFunction>['count'])(
         EJSON.deserialize(resolvedQuery),
-        resolvedOptions ? EJSON.deserialize(resolvedOptions) : undefined
+        parsedOptions
       ),
     deleteOne: () =>
       (currentMethod as ReturnType<GetOperatorsFunction>['deleteOne'])(
@@ -92,7 +106,7 @@ export const executeQuery = async ({
       (currentMethod as ReturnType<GetOperatorsFunction>['findOneAndUpdate'])(
         EJSON.deserialize(resolvedQuery),
         EJSON.deserialize(resolvedUpdate),
-        resolvedOptions ? EJSON.deserialize(resolvedOptions) : undefined
+        parsedOptions
       ),
     aggregate: async () =>
       (await (currentMethod as ReturnType<GetOperatorsFunction>['aggregate'])(

package/src/utils/crypto/index.ts

@@ -24,7 +24,7 @@ export const comparePassword = async (plaintext: string, storedPassword: string)
   const [storedHash, storedSalt] = storedPassword.split('.')
 
   if (!storedHash || !storedSalt) {
-    throw new Error(`Invalid stored password: ${storedPassword}`);
+    throw new Error('Invalid credentials');
   }
 
   const storedBuffer = Buffer.from(storedHash, 'hex')