@orion-js/paginated-mongodb 3.11.15 → 3.12.0

package/lib/service/index.d.ts

@@ -1,5 +0,0 @@
-import { PaginatedResolverOpts } from '../paginatedResolver';
-export interface PagiantedQueryDescriptor extends Omit<PropertyDecorator, 'value'> {
-    value?: PaginatedResolverOpts['getCursor'];
-}
-export declare function PaginatedQuery(options: Omit<PaginatedResolverOpts, 'getCursor'>): (target: any, propertyKey: string, descriptor: PagiantedQueryDescriptor) => void;

package/lib/service/index.js

@@ -1,23 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PaginatedQuery = void 0;
-const paginatedResolver_1 = __importDefault(require("../paginatedResolver"));
-const services_1 = require("@orion-js/services");
-function PaginatedQuery(options) {
-    return function (target, propertyKey, descriptor) {
-        if (!descriptor.value)
-            throw new Error(`You must pass resolver function to ${propertyKey}`);
-        target.resolvers = target.resolvers || {};
-        target.resolvers[propertyKey] = (0, paginatedResolver_1.default)({
-            ...options,
-            getCursor: async (params, viewer) => {
-                const instance = (0, services_1.getInstance)(target.service);
-                return await instance[propertyKey](params, viewer);
-            }
-        });
-    };
-}
-exports.PaginatedQuery = PaginatedQuery;

package/lib/tests/setup.d.ts

@@ -1 +0,0 @@
-export {};

package/lib/tests/setup.js

@@ -1,19 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const mongodb_1 = require("@orion-js/mongodb");
-const url = `${global.__MONGO_URI__}jest`;
-process.env.MONGO_URL = url;
-beforeAll(async () => {
-    const connection = (0, mongodb_1.getMongoConnection)({ name: 'main' });
-    await connection.connectionPromise;
-});
-afterAll(async () => {
-    /**
-     * We need to wait on indexes promises to be resolved to close all the handlers
-     */
-    await Promise.all(mongodb_1.createIndexesPromises);
-    for (const connectionName in mongodb_1.connections) {
-        const connection = mongodb_1.connections[connectionName];
-        await connection.client.close();
-    }
-});

package/lib/tokenPaginatedResolver/getReturnModel.d.ts

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

package/lib/tokenPaginatedResolver/getReturnModel.js

@@ -1,19 +0,0 @@
-"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

@@ -1,10 +0,0 @@
-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

@@ -1,128 +0,0 @@
-"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;