@aptana/multichannel-common 2.9.12

package/shared/plugins/mongoose.d.ts

@@ -0,0 +1,31 @@
+import { Schema, Model } from 'mongoose';
+interface PaginationMeta {
+    limit: number | undefined;
+    offset: number | undefined;
+    total: number | undefined;
+}
+export declare class PaginationModel<T> {
+    meta: PaginationMeta;
+    docs: T[];
+}
+export interface PaginationOptions {
+    query?: any | undefined;
+    aggregate?: any | undefined;
+    populate?: any | undefined;
+    select?: any | undefined;
+    search?: {
+        value: string | undefined;
+        fields: string[] | undefined;
+    };
+    sort?: any | undefined;
+    projection?: any | undefined;
+    page?: {
+        limit?: any | undefined;
+        offset?: any | undefined;
+    };
+}
+export interface Pagination<T> extends Model<T> {
+    paginate(options?: PaginationOptions | undefined, onError?: Function | undefined): Promise<PaginationModel<T> | undefined>;
+}
+export declare function mongoosePaginate<T>(schema: Schema<T>): void;
+export {};

package/shared/plugins/mongoose.js

@@ -0,0 +1,125 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mongoosePaginate = exports.PaginationModel = void 0;
+class PaginationModel {
+    meta = {
+        limit: 0,
+        offset: 0,
+        total: undefined,
+    };
+    docs = [];
+}
+exports.PaginationModel = PaginationModel;
+function mongoosePaginate(schema) {
+    schema.statics.paginate = async function paginate(options, onError) {
+        // INIT
+        let query = options?.query ?? {};
+        let aggregate = options?.aggregate ?? undefined;
+        let populate = options?.populate ?? undefined;
+        let select = options?.select ?? undefined;
+        let search = options?.search ?? undefined;
+        let sort = options?.sort ?? '-_id';
+        let projection = options?.projection ?? {};
+        // PAGING
+        const limit = parseInt(options?.page?.limit) > 0 ? parseInt(options?.page?.limit) : 0;
+        const skip = parseInt(options?.page?.offset) > 0 ? parseInt(options?.page?.offset) : 0;
+        // SEARCHING
+        if (search
+            && search.value
+            && search.fields
+            && search.fields.length) {
+            let searchQuery = {
+                '$regex': search.value,
+                '$options': 'i',
+            };
+            if (search.fields?.length == 1) {
+                query[search.fields[0]] = searchQuery;
+            }
+            else {
+                if (!query.$or) {
+                    query.$or = [];
+                }
+                search.fields.forEach(function (el) {
+                    let obj = {};
+                    obj[el] = searchQuery;
+                    query.$or.push(obj);
+                });
+            }
+        }
+        // QUERY
+        let docsPromise;
+        if (aggregate != undefined) {
+            var mQuery = this.aggregate(aggregate);
+            if (select != undefined) {
+                mQuery = mQuery.project(select);
+            }
+        }
+        else {
+            var mQuery = this.find(query, projection);
+            if (select != undefined) {
+                mQuery = mQuery.select(select);
+            }
+            if (populate != undefined) {
+                mQuery = mQuery.populate(populate);
+            }
+        }
+        if (sort != undefined) {
+            mQuery = mQuery.sort(sort);
+        }
+        if (limit > 0) {
+            mQuery = mQuery.skip(skip);
+            mQuery = mQuery.limit(limit);
+        }
+        docsPromise = mQuery.exec();
+        // COUNTING
+        let countPromise;
+        if (aggregate != undefined) {
+            countPromise = this.aggregate(aggregate).count('count');
+        }
+        else {
+            countPromise = this.countDocuments(query).exec();
+        }
+        // PERFORM
+        try {
+            const [counts, docs] = await Promise.all([countPromise, docsPromise]);
+            let count = 0;
+            if (aggregate != undefined) {
+                if (counts != undefined
+                    && counts[0] != undefined
+                    && counts[0]['count'] != undefined) {
+                    count = counts[0]['count'];
+                }
+            }
+            else {
+                count = counts;
+            }
+            const myModel = new PaginationModel();
+            myModel.meta.total = count;
+            myModel.meta.offset = skip;
+            if (limit > 0) {
+                myModel.meta.limit = limit;
+            }
+            if (limit == 0) {
+                myModel.meta.limit = 0;
+            }
+            myModel.docs = docs;
+            return myModel;
+        }
+        catch (error) {
+            if (onError != undefined) {
+                onError(error);
+            }
+            return undefined;
+        }
+    };
+    const options = {
+        virtuals: true,
+        transform: function (doc, ret) {
+            ret.id = ret._id;
+            delete ret.__v;
+        }
+    };
+    schema.set('toJSON', options);
+    schema.set('toObject', options);
+}
+exports.mongoosePaginate = mongoosePaginate;

package/shared/resources/JsonResource.d.ts

@@ -0,0 +1,16 @@
+export declare class JsonResource {
+    [property: string]: any;
+    protected hidden: string[];
+    protected fillable: string[];
+    protected attributes: any;
+    constructor(attributes: object);
+    protected fill(attributes: any): void;
+    protected isAttribute(key: string): boolean;
+    protected getAttribute(key: string): any;
+    protected setAttribute(key: string, value: any): void;
+    protected getHidden(): string[];
+    protected setHidden(keys: string[]): void;
+    protected getFillable(): string[];
+    protected setFillable(keys: string[]): void;
+    toJSON(): any;
+}

package/shared/resources/JsonResource.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JsonResource = void 0;
+class JsonResource {
+    hidden = [];
+    fillable = [];
+    attributes = {};
+    constructor(attributes) {
+        this.fill(attributes);
+        return new Proxy(this, {
+            get: (target, property) => {
+                if (target.isAttribute(property)) {
+                    return target.getAttribute(property);
+                }
+                return target[property];
+            },
+            set: (target, property, value) => {
+                target.setAttribute(property, value);
+                return true;
+            }
+        });
+    }
+    fill(attributes) {
+        for (const key in attributes) {
+            this.setAttribute(key, attributes[key]);
+        }
+    }
+    isAttribute(key) {
+        return this.attributes.hasOwnProperty(key);
+    }
+    getAttribute(key) {
+        return this.attributes[key];
+    }
+    setAttribute(key, value) {
+        this.attributes[key] = value;
+    }
+    getHidden() {
+        return this.hidden;
+    }
+    setHidden(keys) {
+        this.hidden = keys;
+    }
+    getFillable() {
+        return this.fillable;
+    }
+    setFillable(keys) {
+        this.fillable = keys;
+    }
+    toJSON() {
+        return Object.keys(this.attributes)
+            .filter(key => this.getFillable().includes(key))
+            .filter(key => !this.getHidden().includes(key))
+            .reduce((target, key) => {
+            target[key] = this.attributes[key];
+            return target;
+        }, {});
+    }
+}
+exports.JsonResource = JsonResource;