@orion-js/paginated-mongodb 3.2.55 → 3.3.1

package/lib/paginatedResolver/index.d.ts

@@ -1,16 +1,31 @@
-import { Collection, FindCursor } from '@orion-js/mongodb';
-export interface PaginatedResolverOpts<T = any> {
+export interface PaginatedCursor {
+    count?: () => Promise<number> | number;
+    toArray: () => Promise<any[]>;
+    limit?: (newLimit: number) => void;
+    skip?: (newSkip: number) => void;
+    sort?: (newSort: {
+        [key: string]: 1 | -1;
+    }) => void;
+}
+export declare type PaginatedResolverGetCursorResultWithCount = {
+    count: () => Promise<number> | number;
+    cursor: PaginatedCursor;
+};
+export declare type PaginatedResolverGetCursorResult = PaginatedCursor | PaginatedResolverGetCursorResultWithCount;
+export interface PaginatedResolverOpts {
     returns: any;
-    collection?: Collection<T>;
-    params?: object;
-    getCursor: (params?: any, viewer?: any) => Promise<FindCursor<T>>;
+    getCursor: (params?: any, viewer?: any) => Promise<PaginatedResolverGetCursorResult>;
+    allowedSorts?: string[];
+    defaultSortBy?: string;
+    defaultSortType?: 'asc' | 'desc';
+    params?: any;
     modelName?: string;
     permissionsOptions?: any;
 }
-export default function paginatedResolver<T = any>({ returns, collection, params, getCursor, modelName, ...otherOptions }: PaginatedResolverOpts<T> & {
+export default function paginatedResolver({ returns, params, allowedSorts, defaultSortBy, defaultSortType, getCursor, getCursorAndCount, modelName, ...otherOptions }: PaginatedResolverOpts & {
     [key: string]: any;
 }): import("@orion-js/resolvers").Resolver<(params: any, viewer: any) => Promise<{
-    cursor: FindCursor<T>;
+    cursor: PaginatedCursor;
     params: any;
     viewer: any;
     options: {

package/lib/paginatedResolver/index.js

@@ -8,22 +8,27 @@ 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);
+function paginatedResolver({ returns, params, allowedSorts, defaultSortBy, defaultSortType, getCursor, getCursorAndCount, modelName, ...otherOptions }) {
+    const getCursorResult = async (...args) => {
+        const result = await getCursor(...args);
+        if (result.cursor) {
+            const resultWithCount = result;
+            return { cursor: resultWithCount.cursor, getCount: () => resultWithCount.count() };
+        }
+        else {
+            const resultWithoutCount = result;
+            return { cursor: resultWithoutCount, getCount: () => resultWithoutCount.count() };
         }
-        return collection.find({});
     };
     return (0, resolvers_1.resolver)({
-        params: (0, params_1.default)({ params }),
+        params: (0, params_1.default)({ params, allowedSorts, defaultSortBy, defaultSortType }),
         returns: (0, getModel_1.default)({ modelName, returns }),
         async resolve(...args) {
             const { params, viewer } = (0, getArgs_1.getArgs)(...args);
-            const cursor = await getPaginatedCursor(...args);
+            const { cursor, getCount } = await getCursorResult(...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 count = await getCount();
             const options = (0, setOptions_1.default)(params, cursor);
             return {
                 cursor,

package/lib/paginatedResolver/index.test.d.ts

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

package/lib/paginatedResolver/index.test.js

@@ -0,0 +1,123 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+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 helpers_1 = require("@orion-js/helpers");
+const _1 = __importDefault(require("."));
+const typed_model_1 = require("@orion-js/typed-model");
+const mongodb_1 = require("@orion-js/mongodb");
+describe('Full example of paginated resolver', () => {
+    const createResolver = async () => {
+        let ItemSchema = class ItemSchema {
+        };
+        __decorate([
+            (0, typed_model_1.Prop)(),
+            __metadata("design:type", String)
+        ], ItemSchema.prototype, "name", void 0);
+        __decorate([
+            (0, typed_model_1.Prop)(),
+            __metadata("design:type", Number)
+        ], ItemSchema.prototype, "index", void 0);
+        ItemSchema = __decorate([
+            (0, typed_model_1.TypedSchema)()
+        ], ItemSchema);
+        const collection = (0, mongodb_1.createCollection)({
+            name: (0, helpers_1.generateId)(),
+            schema: ItemSchema
+        });
+        await collection.insertMany([
+            { name: `Number 1`, index: 1 },
+            { name: `Number 2`, index: 2 },
+            { name: `Number 3`, index: 3 },
+            { name: `Number 4`, index: 4 },
+            { name: `Number 5`, index: 5 },
+            { name: `Number 6`, index: 6 }
+        ]);
+        let Params = class Params {
+        };
+        __decorate([
+            (0, typed_model_1.Prop)({ optional: true }),
+            __metadata("design:type", String)
+        ], Params.prototype, "filter", void 0);
+        Params = __decorate([
+            (0, typed_model_1.TypedSchema)()
+        ], Params);
+        return (0, _1.default)({
+            returns: ItemSchema,
+            params: Params,
+            allowedSorts: ['index'],
+            async getCursor(params) {
+                const query = {};
+                if (params.filter) {
+                    query.name = params.filter;
+                }
+                return collection.find(query);
+            }
+        });
+    };
+    it('should work passing custom params', async () => {
+        const resolver = await createResolver();
+        const result = (await resolver.resolve({
+            filter: `Number 1`
+        }, {}));
+        const items = await result.items();
+        const count = await result.totalCount();
+        expect(items.length).toBe(1);
+        expect(items[0].index).toBe(1);
+        expect(count).toBe(1);
+    });
+    it('should using sorts', async () => {
+        const resolver = await createResolver();
+        const result = (await resolver.resolve({
+            sortBy: 'index',
+            sortType: 'asc'
+        }, {}));
+        const items = await result.items();
+        const count = await result.totalCount();
+        expect(items.map(item => item.index)).toEqual([1, 2, 3, 4, 5, 6]);
+        expect(count).toBe(6);
+    });
+});
+describe('Cursors with count', () => {
+    const createResolver = async () => {
+        const cursor = {
+            count: () => 100,
+            toArray: async () => [{ hello: 'foo' }]
+        };
+        return (0, _1.default)({
+            returns: (0, models_1.createModel)({
+                name: 'Hello',
+                schema: {
+                    hello: {
+                        type: String
+                    }
+                }
+            }),
+            async getCursor() {
+                return {
+                    cursor: cursor,
+                    count: () => 10
+                };
+            }
+        });
+    };
+    it('should not call cursor.count', async () => {
+        const resolver = await createResolver();
+        const result = (await resolver.resolve({}, {}));
+        const items = await result.items();
+        const count = await result.totalCount();
+        expect(items.length).toBe(1);
+        expect(count).toBe(10);
+    });
+});

package/lib/paginatedResolver/params.d.ts

@@ -1,4 +1,5 @@
-declare const _default: ({ params }: {
-    params: any;
-}) => any;
-export default _default;
+import { Schema } from '@orion-js/schema';
+import { PaginatedResolverOpts } from '.';
+declare type OptionsKeys = 'params' | 'allowedSorts' | 'defaultSortBy' | 'defaultSortType';
+export default function getParams(options: Pick<PaginatedResolverOpts, OptionsKeys>): Schema;
+export {};

package/lib/paginatedResolver/params.js

@@ -1,16 +1,52 @@
 "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
-});
+const lodash_1 = require("lodash");
+function getParams(options) {
+    const { params, allowedSorts, defaultSortBy, defaultSortType } = options;
+    const schema = {
+        page: {
+            type: 'integer',
+            defaultValue: 1,
+            min: 1
+        },
+        limit: {
+            type: 'integer',
+            defaultValue: 0,
+            min: 0,
+            max: 200
+        }
+    };
+    if (allowedSorts && allowedSorts.length) {
+        schema.sortBy = {
+            type: String,
+            allowedValues: allowedSorts,
+            optional: true
+        };
+        if (defaultSortBy) {
+            schema.sortBy.defaultValue = defaultSortBy;
+        }
+        schema.sortType = {
+            type: String,
+            allowedValues: ['asc', 'desc'],
+            optional: true
+        };
+        if (defaultSortType) {
+            schema.sortType.defaultValue = defaultSortType;
+        }
+    }
+    if (params) {
+        if (typeof params === 'function' && params.getModel && params.__schemaId) {
+            const modelSchema = params.getModel().getSchema();
+            Object.assign(schema, (0, lodash_1.omit)(modelSchema, '__model'));
+        }
+        else if (params.__isModel) {
+            const modelSchema = params.getSchema();
+            Object.assign(schema, (0, lodash_1.omit)(modelSchema, '__model'));
+        }
+        else {
+            Object.assign(schema, params);
+        }
+    }
+    return schema;
+}
+exports.default = getParams;

package/lib/paginatedResolver/params.test.d.ts

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

package/lib/paginatedResolver/params.test.js

@@ -0,0 +1,149 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+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 params_1 = __importDefault(require("./params"));
+const typed_model_1 = require("@orion-js/typed-model");
+describe('Get params', () => {
+    it('should return the params', () => {
+        const params = (0, params_1.default)({
+            params: { foo: 'bar' }
+        });
+        expect(params).toEqual({
+            page: {
+                type: 'integer',
+                defaultValue: 1,
+                min: 1
+            },
+            limit: {
+                type: 'integer',
+                defaultValue: 0,
+                min: 0,
+                max: 200
+            },
+            foo: 'bar'
+        });
+    });
+    it('should return the params with allowed sort', () => {
+        const params = (0, params_1.default)({
+            params: { foo: 'bar' },
+            allowedSorts: ['foo']
+        });
+        expect(params).toEqual({
+            page: {
+                type: 'integer',
+                defaultValue: 1,
+                min: 1
+            },
+            limit: {
+                type: 'integer',
+                defaultValue: 0,
+                min: 0,
+                max: 200
+            },
+            sortBy: {
+                type: String,
+                allowedValues: ['foo'],
+                optional: true
+            },
+            sortType: {
+                type: String,
+                allowedValues: ['asc', 'desc'],
+                optional: true
+            },
+            foo: 'bar'
+        });
+    });
+    it('should return the params correctly if we pass a model', () => {
+        const model = (0, models_1.createModel)({
+            name: 'Params',
+            schema: {
+                foo: {
+                    type: 'string'
+                }
+            }
+        });
+        const params = (0, params_1.default)({
+            params: model,
+            allowedSorts: ['foo']
+        });
+        expect(params).toEqual({
+            page: {
+                type: 'integer',
+                defaultValue: 1,
+                min: 1
+            },
+            limit: {
+                type: 'integer',
+                defaultValue: 0,
+                min: 0,
+                max: 200
+            },
+            sortBy: {
+                type: String,
+                allowedValues: ['foo'],
+                optional: true
+            },
+            sortType: {
+                type: String,
+                allowedValues: ['asc', 'desc'],
+                optional: true
+            },
+            foo: {
+                type: 'string'
+            }
+        });
+    });
+    it('should return the params correctly if we pass a typed schema', () => {
+        let Schema = class Schema {
+        };
+        __decorate([
+            (0, typed_model_1.Prop)(),
+            __metadata("design:type", String)
+        ], Schema.prototype, "foo", void 0);
+        Schema = __decorate([
+            (0, typed_model_1.TypedSchema)()
+        ], Schema);
+        const params = (0, params_1.default)({
+            params: Schema,
+            allowedSorts: ['foo']
+        });
+        expect(params).toEqual({
+            page: {
+                type: 'integer',
+                defaultValue: 1,
+                min: 1
+            },
+            limit: {
+                type: 'integer',
+                defaultValue: 0,
+                min: 0,
+                max: 200
+            },
+            sortBy: {
+                type: String,
+                allowedValues: ['foo'],
+                optional: true
+            },
+            sortType: {
+                type: String,
+                allowedValues: ['asc', 'desc'],
+                optional: true
+            },
+            foo: {
+                type: String
+            }
+        });
+    });
+});

package/lib/paginatedResolver/setOptions.d.ts

@@ -1,7 +1,10 @@
-export default function ({ page, limit }: {
+import { PaginatedCursor } from './index';
+export default function ({ page, limit, sortBy, sortType }: {
     page: any;
     limit: any;
-}, cursor: any): {
+    sortBy: any;
+    sortType: any;
+}, cursor: PaginatedCursor): {
     skip: number;
     limit: any;
 };

package/lib/paginatedResolver/setOptions.js

@@ -1,13 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-function default_1({ page, limit }, cursor) {
+function default_1({ page, limit, sortBy, sortType }, cursor) {
     const skip = limit * (page - 1);
-    if (limit) {
+    if (limit && cursor.limit) {
         cursor.limit(limit);
     }
-    if (skip) {
+    if (skip && cursor.skip) {
         cursor.skip(skip);
     }
+    if (sortBy && sortType && cursor.sort) {
+        cursor.sort({
+            [`${sortBy}`]: sortType === 'asc' ? 1 : -1
+        });
+    }
     return {
         skip,
         limit

package/lib/service/index.d.ts

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

package/lib/tests/setup.d.ts

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

package/lib/tests/setup.js

@@ -0,0 +1,19 @@
+"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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@orion-js/paginated-mongodb",
-  "version": "3.2.55",
+  "version": "3.3.1",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
   "files": [
@@ -9,7 +9,7 @@
   "author": "nicolaslopezj",
   "license": "MIT",
   "scripts": {
-    "test": "exit 0",
+    "test": "jest",
     "prepare": "yarn run build",
     "clean": "rm -rf ./lib",
     "build": "yarn run clean && tsc",
@@ -20,7 +20,8 @@
     "@orion-js/models": "^3.2.53",
     "@orion-js/mongodb": "^3.2.55",
     "@orion-js/resolvers": "^3.2.53",
-    "@orion-js/services": "^3.2.48"
+    "@orion-js/services": "^3.2.48",
+    "@orion-js/typed-model": "^3.2.53"
   },
   "devDependencies": {
     "@shelf/jest-mongodb": "^2.1.0",
@@ -33,5 +34,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "ce5164ec1e1f513042436572b0fbf0d4df0fd224"
+  "gitHead": "f47ed0366f06654d5353c188e91d69f92fd6d536"
 }