@orion-js/paginated-mongodb 3.0.16 → 3.0.23

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2018 Orionjs Team
+Copyright (c) 2021 Orionjs Team
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/lib/paginatedResolver/getModel.d.ts

@@ -0,0 +1,5 @@
+declare const _default: ({ returns, modelName }: {
+    returns: any;
+    modelName: any;
+}) => import("@orion-js/models").Model;
+export default _default;

package/lib/paginatedResolver/getModel.js

@@ -0,0 +1,77 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const models_1 = require("@orion-js/models");
+const hash_1 = __importDefault(require("./hash"));
+const resolvers_1 = require("@orion-js/resolvers");
+exports.default = ({ returns, modelName }) => {
+    const getTotalCount = async function (paginated) {
+        if (typeof paginated.count === 'undefined') {
+            paginated.count = await paginated.cursor.count();
+        }
+        return paginated.count;
+    };
+    const _id = (0, resolvers_1.modelResolver)({
+        returns: 'ID',
+        async resolve(paginated, p, viewer) {
+            const { params } = paginated;
+            const num = (0, hash_1.default)({
+                modelName: modelName,
+                typename: returns.name,
+                userId: viewer.userId,
+                params: params
+            });
+            return String(Math.abs(num));
+        }
+    });
+    const totalCount = (0, resolvers_1.modelResolver)({
+        returns: 'integer',
+        resolve: getTotalCount
+    });
+    const totalPages = (0, resolvers_1.modelResolver)({
+        returns: 'integer',
+        async resolve(paginated) {
+            const count = await getTotalCount(paginated);
+            if (!paginated.options.limit)
+                return 1;
+            return Math.ceil(count / paginated.options.limit);
+        }
+    });
+    const hasNextPage = (0, resolvers_1.modelResolver)({
+        returns: Boolean,
+        async resolve(paginated) {
+            const count = await getTotalCount(paginated);
+            const { skip, limit } = paginated.options;
+            if (!limit)
+                return false;
+            return skip + limit < count;
+        }
+    });
+    const hasPreviousPage = (0, resolvers_1.modelResolver)({
+        returns: Boolean,
+        async resolve(paginated) {
+            const count = await getTotalCount(paginated);
+            const { skip } = paginated.options;
+            return count && skip !== 0;
+        }
+    });
+    const items = (0, resolvers_1.modelResolver)({
+        returns: [returns],
+        async resolve({ cursor }) {
+            return await cursor.toArray();
+        }
+    });
+    return (0, models_1.createModel)({
+        name: modelName || `Paginated${returns.name}`,
+        resolvers: {
+            _id,
+            totalCount,
+            totalPages,
+            hasNextPage,
+            hasPreviousPage,
+            items
+        }
+    });
+};

package/lib/paginatedResolver/hash.d.ts

@@ -0,0 +1 @@
+export default function (obj?: object): number;

package/lib/paginatedResolver/hash.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function default_1(obj = {}) {
+    return JSON.stringify(obj)
+        .split('')
+        .reduce((prevHash, currVal) => (prevHash << 5) - prevHash + currVal.charCodeAt(0), 0);
+}
+exports.default = default_1;

package/lib/paginatedResolver/index.d.ts

@@ -0,0 +1,20 @@
+import { Collection, FindCursor } from '@orion-js/mongodb';
+export interface PaginatedResolverOpts<T = any> {
+    returns: any;
+    collection?: Collection<T>;
+    params?: object;
+    getCursor: (params?: any, viewer?: any) => Promise<FindCursor<T>>;
+    modelName?: string;
+}
+export default function paginatedResolver<T = any>({ returns, collection, params, getCursor, modelName, ...otherOptions }: PaginatedResolverOpts<T> & {
+    [key: string]: any;
+}): import("@orion-js/resolvers").Resolver<(params: any, viewer: any) => Promise<{
+    cursor: FindCursor<T>;
+    params: any;
+    viewer: any;
+    options: {
+        skip: number;
+        limit: any;
+    };
+    count: number;
+}>, undefined>;

package/lib/paginatedResolver/index.js

@@ -0,0 +1,39 @@
+"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 getModel_1 = __importDefault(require("./getModel"));
+const params_1 = __importDefault(require("./params"));
+const setOptions_1 = __importDefault(require("./setOptions"));
+const getArgs_1 = require("@orion-js/resolvers/lib/resolver/getArgs");
+function paginatedResolver({ returns, collection, params, getCursor, modelName, ...otherOptions }) {
+    const getPaginatedCursor = async (...args) => {
+        if (getCursor) {
+            return await getCursor(...args);
+        }
+        return collection.find({});
+    };
+    return (0, resolvers_1.resolver)({
+        params: (0, params_1.default)({ params }),
+        returns: (0, getModel_1.default)({ modelName, returns }),
+        async resolve(...args) {
+            const { params, viewer } = (0, getArgs_1.getArgs)(...args);
+            const cursor = await getPaginatedCursor(...args);
+            /* counting the total number of elements of this cursor, so we make sure
+             that it is going to be computed only once */
+            const count = await cursor.count();
+            const options = (0, setOptions_1.default)(params, cursor);
+            return {
+                cursor,
+                params,
+                viewer,
+                options,
+                count
+            };
+        },
+        ...otherOptions
+    });
+}
+exports.default = paginatedResolver;

package/lib/paginatedResolver/params.d.ts

@@ -0,0 +1,4 @@
+declare const _default: ({ params }: {
+    params: any;
+}) => any;
+export default _default;

package/lib/paginatedResolver/params.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = ({ params }) => ({
+    page: {
+        type: 'integer',
+        defaultValue: 1,
+        min: 1
+    },
+    limit: {
+        type: 'integer',
+        defaultValue: 0,
+        min: 0,
+        max: 200
+    },
+    ...params
+});

package/lib/paginatedResolver/setOptions.d.ts

@@ -0,0 +1,7 @@
+export default function ({ page, limit }: {
+    page: any;
+    limit: any;
+}, cursor: any): {
+    skip: number;
+    limit: any;
+};

package/lib/paginatedResolver/setOptions.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function default_1({ page, limit }, cursor) {
+    const skip = limit * (page - 1);
+    if (limit) {
+        cursor.limit(limit);
+    }
+    if (skip) {
+        cursor.skip(skip);
+    }
+    return {
+        skip,
+        limit
+    };
+}
+exports.default = default_1;

package/lib/tokenPaginatedResolver/getReturnModel.d.ts

@@ -0,0 +1,5 @@
+declare const _default: ({ collection, modelName }: {
+    collection: any;
+    modelName: any;
+}) => import("@orion-js/models").Model;
+export default _default;

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) => 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,6 +1,6 @@
 {
   "name": "@orion-js/paginated-mongodb",
-  "version": "3.0.16",
+  "version": "3.0.23",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
   "files": [
@@ -13,11 +13,13 @@
     "prepare": "yarn run build",
     "clean": "rm -rf ./lib",
     "build": "yarn run clean && tsc",
-    "watch": "yarn run clean && tsc -w"
+    "watch": "tsc -w",
+    "upgrade-interactive": "yarn upgrade-interactive"
   },
   "dependencies": {
-    "@orion-js/mongodb": "^3.0.16",
-    "@orion-js/resolvers": "^3.0.16"
+    "@orion-js/models": "^3.0.20",
+    "@orion-js/mongodb": "^3.0.23",
+    "@orion-js/resolvers": "^3.0.17"
   },
   "devDependencies": {
     "@shelf/jest-mongodb": "^2.1.0",
@@ -30,5 +32,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "99af482fd83086d4588da728d7c5d4ee1688aff7"
+  "gitHead": "26691f9507db91bd6ed1659d231f7e5e1dcc2e55"
 }