@orion-js/paginated-mongodb 3.12.0 → 3.13.1

package/lib/tokenPaginatedResolver/getReturnModel.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const models_1 = require("@orion-js/models");
+const resolvers_1 = require("@orion-js/resolvers");
+exports.default = ({ collection, modelName }) => {
+    const items = (0, resolvers_1.modelResolver)({
+        returns: [collection.model],
+        async resolve(params) {
+            const { cursor } = params;
+            return await cursor.toArray();
+        }
+    });
+    return (0, models_1.createModel)({
+        name: modelName || `tokenPaginated${collection.model.name}`,
+        resolvers: {
+            items
+        }
+    });
+};

package/lib/tokenPaginatedResolver/index.d.ts

@@ -0,0 +1,10 @@
+export default function ({ collection, params, resolve, ...otherOptions }: {
+    [x: string]: any;
+    collection: any;
+    params: any;
+    resolve: any;
+}): import("@orion-js/resolvers").Resolver<(params: any, viewer: any, info?: any) => Promise<{
+    params: any;
+    cursor: any;
+    viewer: any;
+}>, undefined>;

package/lib/tokenPaginatedResolver/index.js

@@ -0,0 +1,128 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const resolvers_1 = require("@orion-js/resolvers");
+const getReturnModel_1 = __importDefault(require("./getReturnModel"));
+const getArgs_1 = require("@orion-js/resolvers/lib/resolver/getArgs");
+function default_1({ collection, params, resolve, ...otherOptions }) {
+    /* executes the resolve function, obtaining the query that will
+     be applied to the collection */
+    const runResolve = async (...args) => {
+        if (resolve) {
+            return await resolve(...args);
+        }
+        return { query: {} };
+    };
+    /* This function does the query to the collection. The logic is based
+       in this article:
+       https://medium.com/swlh/mongodb-pagination-fast-consistent-ece2a97070f3 */
+    const getCursor = async ({ query, sort: sortingCriteria, limit, idOffset }) => {
+        if (sortingCriteria && Object.keys(sortingCriteria).length > 1)
+            throw new Error('sorting criteria supports at most one field');
+        if (!sortingCriteria || !Object.keys(sortingCriteria).length) {
+            sortingCriteria = { _id: 1 };
+            if (idOffset)
+                query = { ...query, _id: { $gt: idOffset } };
+        }
+        else {
+            const sortingField = Object.keys(sortingCriteria)[0];
+            sortingCriteria = { ...sortingCriteria, _id: 1 };
+            if (idOffset) {
+                const offsetDocument = await collection.findOne({ _id: idOffset });
+                const { [sortingField]: originalSortingFieldQuery, ...restOfQuery } = query;
+                /* Suppose the following documents, and pages with 2 elements on each page:
+                  [
+                    {_id: 1, name: 'a', v: 1},
+                    {_id: 2, name: 'b', v: 2},
+                    {_id: 3, name: 'c', v: 2},
+                    {_id: 4, name: 'd', v: 3},
+                    {_id: 5, name: 'e', v: 4},
+                  ]
+        
+                  If the query results are sorted by {v: 1}, then the first page will
+                  contain the documents with ids 1 & 2, and the last one will be the document
+                  with id 2.
+                  In order to get the documents of the second page, we cannot get the documents
+                  with the sorting criteria (v) greater than the last document, because we
+                  would skip the document with id 3. In that case, we need to get all the
+                  documents where either:
+                   1.- The sorting field is the same than the last one, and the _id field is greater
+                   2.- The sorting field is greater than the last one.
+        
+                  In this case, we can get the documents of the second page with the following query:
+        
+                    {
+                      $or: [
+                        {
+                            v: 2,
+                            _id: {$gt: 2}
+                        },
+                        {
+                            v: {$gt: 2}
+                        }
+                      ]
+                    }
+        
+                  For decreasing order it is exactly the same, but the second part of the or has
+                  to be changed for $lt.
+                  */
+                const sortOperator = sortingCriteria[sortingField] === 1 ? '$gt' : '$lt';
+                query = {
+                    $or: [
+                        { ...restOfQuery, [sortingField]: offsetDocument[sortingField], _id: { $gt: idOffset } },
+                        { ...query, [sortingField]: { [sortOperator]: offsetDocument[sortingField] } }
+                    ]
+                };
+            }
+        }
+        return collection.find(query).sort(sortingCriteria).limit(limit);
+    };
+    const validateQuery = async (query) => {
+        if (typeof query === 'object') {
+            const fields = Object.keys(query);
+            fields.forEach(field => {
+                if (['$or', '$expr'].includes(field)) {
+                    throw new Error("tokenPaginatedResolvers don't support $or nor $expr on query");
+                }
+                if (typeof query[field] === 'object')
+                    validateQuery(query[field]);
+                else if (Array.isArray(query[field]))
+                    query[field].forEach(queryElement => validateQuery(queryElement));
+            });
+        }
+    };
+    const { modelName } = otherOptions;
+    return (0, resolvers_1.resolver)({
+        params: {
+            ...params,
+            idOffset: {
+                type: 'ID',
+                optional: true
+            },
+            limit: {
+                type: 'integer',
+                defaultValue: 10,
+                min: 1,
+                max: 200
+            }
+        },
+        returns: (0, getReturnModel_1.default)({ modelName, collection }),
+        async resolve(...args) {
+            const { params, viewer } = (0, getArgs_1.getArgs)(...args);
+            const { query, sort } = await runResolve(...args);
+            if (!query)
+                throw new Error("'query' object not found in return of resolve function");
+            await validateQuery(query);
+            const cursor = await getCursor({ ...params, query, sort });
+            return {
+                params,
+                cursor,
+                viewer
+            };
+        },
+        ...otherOptions
+    });
+}
+exports.default = default_1;

package/package.json

@@ -1,45 +1,41 @@
 {
   "name": "@orion-js/paginated-mongodb",
-  "version": "3.12.0",
-  "main": "./dist/index.cjs",
-  "types": "./dist/index.d.ts",
+  "version": "3.13.1",
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
   "files": [
-    "dist"
+    "/lib"
   ],
   "author": "nicolaslopezj",
   "license": "MIT",
   "scripts": {
-    "test": "bun test",
+    "test": "jest",
     "prepare": "yarn run build",
-    "clean": "rm -rf ./dist",
-    "build": "bun run build.ts",
+    "clean": "rm -rf ./lib",
+    "build": "yarn run clean && tsc",
     "watch": "tsc -w",
-    "upgrade-interactive": "yarn upgrade-interactive",
-    "dev": "bun --watch src/index.ts"
+    "upgrade-interactive": "yarn upgrade-interactive"
   },
   "dependencies": {
-    "@orion-js/helpers": "3.12.0",
-    "@orion-js/models": "3.12.0",
-    "@orion-js/mongodb": "3.12.0",
-    "@orion-js/resolvers": "3.12.0",
-    "@orion-js/schema": "3.12.0",
-    "@orion-js/services": "3.12.0",
-    "@orion-js/typed-model": "3.12.0"
+    "@orion-js/helpers": "^3.13.1",
+    "@orion-js/models": "^3.13.1",
+    "@orion-js/mongodb": "^3.13.1",
+    "@orion-js/resolvers": "^3.13.1",
+    "@orion-js/schema": "^3.13.1",
+    "@orion-js/services": "^3.13.1",
+    "@orion-js/typed-model": "^3.13.1"
   },
   "devDependencies": {
+    "@shelf/jest-mongodb": "^4.3.2",
+    "@types/jest": "^29.5.12",
     "@types/lodash": "4.14.176",
-    "typescript": "^5.4.5",
-    "@types/bun": "^1.2.4"
+    "@types/node": "16.11.7",
+    "jest": "29.7.0",
+    "ts-jest": "29.1.2",
+    "typescript": "^4.4.4"
   },
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "9fd28b6f6b348cebc9f0dc207805647969277372",
-  "type": "module",
-  "module": "./dist/index.js",
-  "exports": {
-    "types": "./dist/index.d.ts",
-    "import": "./dist/index.js",
-    "require": "./dist/index.cjs"
-  }
-}
+  "gitHead": "18ab5a9711863e6bd3d3c61e7bb8f9067afca82c"
+}