@goatlab/fluent-loki 0.6.2 → 0.6.5

package/dist/Database.d.ts

@@ -0,0 +1,19 @@
+interface _FLUENT_ {
+    models?: {
+        [key: string]: boolean;
+    };
+}
+declare global {
+    interface Window {
+        _FLUENT_: _FLUENT_;
+    }
+    namespace NodeJS {
+        interface Global {
+            _FLUENT_: _FLUENT_;
+        }
+    }
+}
+export declare const Database: Readonly<{
+    get: () => Promise<any>;
+}>;
+export {};

package/dist/Database.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Database = void 0;
+const tslib_1 = require("tslib");
+const lokijs_1 = tslib_1.__importDefault(require("lokijs"));
+const loki_indexed_adapter_1 = tslib_1.__importDefault(require("lokijs/src/loki-indexed-adapter"));
+let DB = null;
+exports.Database = (() => {
+    const getModels = () => {
+        const models = typeof window !== 'undefined' &&
+            window &&
+            window._FLUENT_ &&
+            window._FLUENT_.models
+            ? window._FLUENT_.models
+            : global && global._FLUENT_ && global._FLUENT_.models
+                ? global._FLUENT_.models
+                : {};
+        return models;
+    };
+    const _create = () => new Promise(resolve => {
+        let idbAdapter;
+        let pa;
+        let db;
+        const dbConfig = {
+            autoload: true,
+            autoloadCallback: databaseInitialize,
+            autosave: true,
+            autosaveInterval: 1000,
+            throttledSaves: false
+        };
+        try {
+            idbAdapter = new loki_indexed_adapter_1.default('GOAT');
+            pa = new lokijs_1.default.LokiPartitioningAdapter(idbAdapter, {
+                paging: true
+            });
+            db = new lokijs_1.default('GOAT', { ...dbConfig, adapter: pa });
+        }
+        catch (error) {
+            db = new lokijs_1.default('GOAT', dbConfig);
+        }
+        function databaseInitialize() {
+            const baseModels = getModels();
+            if (!baseModels) {
+                throw new Error('Cannot Start FLUENT, no models registered or you don`t have access to the "window" or "global" variable');
+            }
+            Object.keys(baseModels).forEach(model => {
+                const dbModel = db.getCollection(model);
+                if (!dbModel) {
+                    db.addCollection(model);
+                }
+            });
+            resolve(db);
+        }
+    });
+    const shouldCreate = () => {
+        const windowModels = getModels();
+        const dbModels = DB.collections.reduce((acc, collection) => {
+            acc.push(collection.name);
+            return acc;
+        }, []);
+        const models = [];
+        Object.keys(windowModels).forEach(m => {
+            if (!dbModels.includes(m)) {
+                models.push(m);
+            }
+        });
+        return models;
+    };
+    const get = async () => {
+        if (!DB) {
+            DB = await _create();
+        }
+        const recreateModels = shouldCreate();
+        if (recreateModels.length > 0) {
+            recreateModels.forEach(model => {
+                DB.addCollection(model);
+            });
+        }
+        return DB;
+    };
+    return Object.freeze({
+        get
+    });
+})();

package/dist/Database.spec.d.ts

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

package/dist/Database.spec.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const lokijs_1 = tslib_1.__importDefault(require("lokijs"));
+const Database_1 = require("./Database");
+let db;
+beforeAll(async () => {
+    db = await Database_1.Database.get();
+});
+it('Should return and instance of LockiJS DB', () => {
+    const isLoki = db instanceof lokijs_1.default;
+    expect(isLoki).toBe(true);
+});
+it('Should be named GOAT', () => {
+    expect(db.filename).toBe('GOAT');
+});
+it('Should start with no collections', () => {
+    const expectedCollections = [];
+    const dbCollections = db.collections.reduce((dbColArray, dbCol) => {
+        dbColArray.push(dbCol.name);
+        return dbColArray;
+    }, []);
+    const uniqueCollections = {};
+    expectedCollections.forEach((collection, index) => {
+        uniqueCollections[collection] = true;
+        uniqueCollections[dbCollections[index]] = true;
+    });
+    const areTheSame = Object.keys(uniqueCollections).length === expectedCollections.length;
+    expect(areTheSame).toBe(true);
+});

package/dist/LokiConnector.d.ts

@@ -0,0 +1,18 @@
+import { BaseDataElement, Sure, Filter, PaginatedData, Paginator, BaseConnector, FluentConnectorInterface } from '@goatlab/fluent';
+export declare class LokiConnector<ModelDTO = BaseDataElement, InputDTO = ModelDTO, OutputDTO = ModelDTO> extends BaseConnector<ModelDTO, InputDTO, OutputDTO> implements FluentConnectorInterface<InputDTO, OutputDTO> {
+    private name;
+    constructor(name: string);
+    get(): Promise<OutputDTO[]>;
+    all(): Promise<OutputDTO[]>;
+    find(filter: Filter): Promise<OutputDTO[]>;
+    paginate(paginator: Paginator): Promise<PaginatedData<OutputDTO>>;
+    deleteById(id: string): Promise<string>;
+    findById(id: string): Promise<OutputDTO>;
+    insert(data: InputDTO): Promise<OutputDTO>;
+    insertMany(data: InputDTO[]): Promise<OutputDTO[]>;
+    updateById(id: string, data: InputDTO): Promise<OutputDTO>;
+    clear({ sure }: Sure): Promise<any>;
+    private prepareFilter;
+    private getLokiOperator;
+    private getModel;
+}

package/dist/LokiConnector.js

@@ -0,0 +1,174 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LokiConnector = void 0;
+const js_utils_1 = require("@goatlab/js-utils");
+const Database_1 = require("./Database");
+const dates_1 = require("@goatlab/dates");
+const fluent_1 = require("@goatlab/fluent");
+class LokiConnector extends fluent_1.BaseConnector {
+    constructor(name) {
+        super();
+        this.name = 'baseModel';
+        this.name = name;
+    }
+    async get() {
+        const filterObject = this.prepareFilter();
+        let data = await (await this.getModel())
+            .chain()
+            .find(filterObject)
+            .offset(this.offsetNumber)
+            .limit(this.limitNumber)
+            .data();
+        data = this.jsApplyOrderBy(data);
+        this.reset();
+        return data;
+    }
+    async all() {
+        return this.get();
+    }
+    async find(filter) {
+        return this.get();
+    }
+    async paginate(paginator) {
+        const results = {
+            current_page: 1,
+            data: [],
+            first_page_url: 'response[0].meta.firstPageUrl,',
+            next_page_url: 'response[0].meta.nextPageUrl',
+            path: 'response[0].meta.path',
+            per_page: 1,
+            prev_page_url: ' response[0].meta.previousPageUrl',
+            total: 10
+        };
+        return results;
+    }
+    async deleteById(id) {
+        if (!id) {
+            throw new Error('No id assign to remove().You must give and id to delete');
+        }
+        const model = await this.getModel();
+        await model.findAndRemove({ id });
+        this.reset();
+        return id;
+    }
+    async findById(id) {
+        if (!id) {
+            throw new Error('No id assign to remove().You must give and id to delete');
+        }
+        const model = await this.getModel();
+        const result = await model.find({
+            id
+        });
+        this.reset();
+        return result;
+    }
+    async insert(data) {
+        const _data = js_utils_1.Objects.clone(data);
+        const model = await this.getModel();
+        const inserted = {
+            ..._data
+        };
+        model.insert(inserted);
+        this.reset();
+        return inserted;
+    }
+    async insertMany(data) {
+        const insertedElements = [];
+        for (const element of data) {
+            const inserted = await this.insert({
+                ...element
+            });
+            insertedElements.push(inserted);
+        }
+        this.reset();
+        return insertedElements;
+    }
+    async updateById(id, data) {
+        if (!id) {
+            throw new Error('Loki connector error. Cannot update a Model without id key');
+        }
+        const model = await this.getModel();
+        const local = await model.findOne({ id });
+        const mod = {
+            ...local,
+            ...data,
+            ...{ modified: dates_1.Dates.currentIsoString() }
+        };
+        const updated = model.update(mod);
+        this.reset();
+        return updated;
+    }
+    async clear({ sure }) {
+        const model = await this.getModel();
+        return model.clear({ removeIndices: true });
+    }
+    prepareFilter() {
+        const andObject = { $and: [] };
+        const orObject = { $or: [] };
+        let globalFilter = {};
+        if (this.whereArray.length > 0) {
+            this.whereArray.forEach(c => {
+                const conditionToObject = {};
+                if (c[0].includes('[')) {
+                    throw new Error(`Error in: "${c[0]}" "Where" close does not work with Array elements`);
+                }
+                conditionToObject[c[0]] = {};
+                const lokiOperator = this.getLokiOperator(c[1]);
+                conditionToObject[c[0]][lokiOperator] = c[2];
+                if (lokiOperator.includes('$regex|')) {
+                    delete conditionToObject[c[0]][lokiOperator];
+                    conditionToObject[c[0]].$regex = lokiOperator
+                        .replace('$regex|', '')
+                        .replace('{{$var}}', c[2]);
+                }
+                andObject.$and.push(conditionToObject);
+            });
+            globalFilter = andObject;
+        }
+        if (this.orWhereArray.length > 0) {
+            this.orWhereArray.forEach(c => {
+                const conditionToObject = {};
+                conditionToObject[c[0]] = {};
+                const lokiOperator = this.getLokiOperator(c[1]);
+                conditionToObject[c[0]][lokiOperator] = c[2];
+                if (lokiOperator.includes('$regex|')) {
+                    delete conditionToObject[c[0]][lokiOperator];
+                    conditionToObject[c[0]].$regex = lokiOperator
+                        .replace('$regex|', '')
+                        .replace('{{$var}}', c[2]);
+                }
+                orObject.$or.push(conditionToObject);
+            });
+            globalFilter = { $or: [andObject, orObject] };
+        }
+        return globalFilter;
+    }
+    getLokiOperator(operator) {
+        const lokiOperators = {
+            '=': '$eq',
+            '<': '$lt',
+            '>': '$gt',
+            '<=': '$lte',
+            '>=': '$gte',
+            '<>': '$ne',
+            '!=': '$ne',
+            in: '$in',
+            nin: '$nin',
+            like: '$aeq',
+            regexp: '$regex',
+            startsWith: '$regex|^{{$var}}',
+            endsWith: '$regex|{{$var}}$',
+            contains: '$regex|{{$var}}'
+        };
+        const converted = js_utils_1.Objects.get(() => lokiOperators[operator], undefined);
+        if (!converted) {
+            throw new Error(`The operator "${operator}" is not supported in Loki `);
+        }
+        return converted;
+    }
+    async getModel() {
+        const DB = await Database_1.Database.get();
+        return DB.getCollection(this.name);
+    }
+}
+exports.LokiConnector = LokiConnector;

package/dist/LokiConnector.spec.d.ts

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

package/dist/LokiConnector.spec.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const LokiConnector_1 = require("./LokiConnector");
+const advancedTestSuite_1 = require("./test/advanced/advancedTestSuite");
+const basicTestSuite_1 = require("./test/basic/basicTestSuite");
+class Goat extends LokiConnector_1.LokiConnector {
+    constructor() {
+        super('myModel');
+    }
+}
+class Goat2 extends LokiConnector_1.LokiConnector {
+    constructor() {
+        super('myModel2');
+    }
+}
+describe('Execute all basic test Suite', () => {
+    (0, basicTestSuite_1.basicTestSuite)(Goat);
+});
+describe('Execute all advanced test Suite', () => {
+    (0, advancedTestSuite_1.advancedTestSuite)(Goat2);
+});

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+import { LokiConnector } from './LokiConnector';
+export { LokiConnector };

package/dist/test/advanced/advancedTestSuite.d.ts

@@ -0,0 +1 @@
+export declare const advancedTestSuite: (Model: any) => void;

package/dist/test/advanced/advancedTestSuite.js

@@ -0,0 +1,114 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.advancedTestSuite = void 0;
+const advancedTestSuite = Model => {
+    beforeAll(() => {
+        try {
+            Model = new Model();
+        }
+        catch (error) { }
+    });
+    const insertTestData = async (Repository) => {
+        await Repository.insert({
+            created: '2018-12-03',
+            nestedTest: {
+                a: [6, 5, 4],
+                b: { c: true, d: [2, 1, 0] },
+                c: 4
+            },
+            order: 1,
+            test: true
+        });
+        await Repository.insert({
+            created: '2017-12-03',
+            nestedTest: {
+                a: [3, 2, 1],
+                b: { c: true, d: [1, 1, 0] },
+                c: 3
+            },
+            order: 2,
+            test: false
+        });
+        await Repository.insert({
+            created: '2016-12-03',
+            nestedTest: {
+                a: [0, -1, -2],
+                b: { c: true, d: [0, 1, 0] },
+                c: 2
+            },
+            order: 3,
+            test: false
+        });
+    };
+    it('Should get local data', async () => {
+        await insertTestData(Model);
+        const data = await Model.all();
+        expect(Array.isArray(data)).toBe(true);
+        expect(typeof data[0].nestedTest.b.c).toBe('boolean');
+    });
+    it('pluck() should return a single array', async () => {
+        await insertTestData(Model);
+        const data = await Model.pluck(Model._keys.test);
+        expect(typeof data[0]).toBe('boolean');
+    });
+    it('orderBy() should order results desc', async () => {
+        await insertTestData(Model);
+        const forms = await Model.select(Model._keys.test, Model._keys.nestedTest.b.c, Model._keys.order)
+            .orderBy(Model._keys.order, 'desc')
+            .get();
+        expect(forms[0].order).toBe(3);
+        expect(forms[0].nestedTest.b.c).toBe(true);
+    });
+    it('orderBy() should order results asc', async () => {
+        await insertTestData(Model);
+        const forms = await Model.select(Model._keys.test, Model._keys.nestedTest.b.c, Model._keys.order)
+            .orderBy(Model._keys.order, 'asc')
+            .get();
+        expect(forms[0].order).toBe(1);
+    });
+    it('orderBy() should order by Dates with Select()', async () => {
+        await insertTestData(Model);
+        const forms = await Model.select(Model._keys.created, Model._keys.order)
+            .orderBy(Model._keys.created, 'asc', 'date')
+            .get();
+        expect(forms[0].order).toBe(3);
+    });
+    it('orderBy() should order by Dates without Select()', async () => {
+        await insertTestData(Model);
+        const forms = await Model.orderBy(Model._keys.created, 'asc', 'date').get();
+        expect(forms[0].order).toBe(3);
+    });
+    it('limit() should limit the amount of results', async () => {
+        await insertTestData(Model);
+        const forms = await Model.select(Model._keys.created, Model._keys.order)
+            .orderBy(Model._keys.created, 'asc', 'date')
+            .limit(2)
+            .get();
+        expect(forms.length > 0).toBe(true);
+        expect(forms.length <= 2).toBe(true);
+    });
+    it('offset() should start at the given position', async () => {
+        await insertTestData(Model);
+        const forms = await Model.select(Model._keys.created, Model._keys.order)
+            .offset(1)
+            .limit(1)
+            .get();
+        expect(forms.length).toBe(1);
+    });
+    it('where() should filter the data', async () => {
+        await insertTestData(Model);
+        const forms = await Model.where(Model._keys.nestedTest.c, '>=', 3).get();
+        expect(forms.length > 0).toBe(true);
+        forms.forEach(form => {
+            expect(form.nestedTest.c >= 3).toBe(true);
+        });
+    });
+    it('first() should take the first result from data', async () => {
+        await insertTestData(Model);
+        const form = await Model.select(Model._keys.nestedTest.c, Model._keys.id)
+            .where(Model._keys.nestedTest.c, '>=', 3)
+            .first();
+        expect(typeof form.nestedTest.c).toBe('number');
+    });
+};
+exports.advancedTestSuite = advancedTestSuite;

package/dist/test/advanced/typeOrm.entity.d.ts

@@ -0,0 +1,16 @@
+export declare class FurtherNested {
+    c: boolean;
+    d: number[];
+}
+export declare class Nested {
+    a: number[];
+    c: number;
+    b?: FurtherNested;
+}
+export declare class TypeORMDataModel {
+    id: string;
+    created?: string;
+    nestedTest?: Nested;
+    order?: number;
+    test: boolean;
+}

package/dist/test/advanced/typeOrm.entity.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TypeORMDataModel = exports.Nested = exports.FurtherNested = void 0;
+const tslib_1 = require("tslib");
+const fluent_1 = require("@goatlab/fluent");
+class FurtherNested {
+}
+tslib_1.__decorate([
+    fluent_1.Decorators.property({ required: true }),
+    tslib_1.__metadata("design:type", Boolean)
+], FurtherNested.prototype, "c", void 0);
+tslib_1.__decorate([
+    fluent_1.Decorators.array({ required: true }),
+    tslib_1.__metadata("design:type", Array)
+], FurtherNested.prototype, "d", void 0);
+exports.FurtherNested = FurtherNested;
+class Nested {
+}
+tslib_1.__decorate([
+    fluent_1.Decorators.array({ required: true }),
+    tslib_1.__metadata("design:type", Array)
+], Nested.prototype, "a", void 0);
+tslib_1.__decorate([
+    fluent_1.Decorators.property({ required: true }),
+    tslib_1.__metadata("design:type", Number)
+], Nested.prototype, "c", void 0);
+tslib_1.__decorate([
+    fluent_1.Decorators.embed(FurtherNested),
+    tslib_1.__metadata("design:type", FurtherNested)
+], Nested.prototype, "b", void 0);
+exports.Nested = Nested;
+let TypeORMDataModel = class TypeORMDataModel {
+};
+tslib_1.__decorate([
+    fluent_1.Decorators.id(),
+    tslib_1.__metadata("design:type", String)
+], TypeORMDataModel.prototype, "id", void 0);
+tslib_1.__decorate([
+    fluent_1.Decorators.property({ required: false }),
+    tslib_1.__metadata("design:type", String)
+], TypeORMDataModel.prototype, "created", void 0);
+tslib_1.__decorate([
+    fluent_1.Decorators.embed(Nested),
+    tslib_1.__metadata("design:type", Nested)
+], TypeORMDataModel.prototype, "nestedTest", void 0);
+tslib_1.__decorate([
+    fluent_1.Decorators.property({ required: false }),
+    tslib_1.__metadata("design:type", Number)
+], TypeORMDataModel.prototype, "order", void 0);
+tslib_1.__decorate([
+    fluent_1.Decorators.property({ required: true }),
+    tslib_1.__metadata("design:type", Boolean)
+], TypeORMDataModel.prototype, "test", void 0);
+TypeORMDataModel = tslib_1.__decorate([
+    fluent_1.Decorators.entity('numbers')
+], TypeORMDataModel);
+exports.TypeORMDataModel = TypeORMDataModel;

package/dist/test/advanced/typeOrm.repository.d.ts

@@ -0,0 +1,5 @@
+import { TypeORMDataModel } from './typeOrm.entity';
+import { TypeOrmConnector } from '@goatlab/fluent';
+export declare class TypeOrmRepository extends TypeOrmConnector<TypeORMDataModel> {
+    constructor(relations?: any);
+}

package/dist/test/advanced/typeOrm.repository.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TypeOrmRepository = void 0;
+const typeOrm_entity_1 = require("./typeOrm.entity");
+const fluent_1 = require("@goatlab/fluent");
+class TypeOrmRepository extends fluent_1.TypeOrmConnector {
+    constructor(relations) {
+        super(typeOrm_entity_1.TypeORMDataModel, relations, 'runningTest');
+    }
+}
+exports.TypeOrmRepository = TypeOrmRepository;

package/dist/test/basic/basicTestSuite.d.ts

@@ -0,0 +1 @@
+export declare const basicTestSuite: (Model: any) => void;

package/dist/test/basic/basicTestSuite.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.basicTestSuite = void 0;
+const flock_1 = require("../flock");
+const basicTestSuite = Model => {
+    let storedId;
+    beforeAll(() => {
+        Model = new Model();
+    });
+    test('Get - Should  GET data', async () => {
+        const storedGoats = await Model.get();
+        expect(Array.isArray(storedGoats)).toBe(true);
+    });
+    test('Insert - Should  insert data', async () => {
+        const a = await Model.insert({ name: 'myGoat', age: 13 });
+        expect(typeof a.id).toBe('string');
+        expect(a.name).toBe('myGoat');
+        expect(0).toBe(0);
+    });
+    it('Create Multiple - Should insert Multiple elements', async () => {
+        const insertedFlock = await Model.insertMany(flock_1.flock);
+        expect(insertedFlock[0].name).toBe('Goatee');
+        storedId = insertedFlock[0].id;
+    });
+    it('UpdateById - Should Update a single element', async () => {
+        await Model.insertMany(flock_1.flock);
+        const goats = await Model.get();
+        const data = await Model.updateById(goats[0].id, {
+            age: 99,
+            name: 'MyUpdatedGoat'
+        });
+        expect(data.name).toBe('MyUpdatedGoat');
+        expect(data.id).toBe(goats[0].id);
+    });
+    it('ReplaceById - Should Update a single element', async () => {
+        await Model.insertMany(flock_1.flock);
+        const goats = await Model.get();
+        const data = await Model.updateById(goats[0].id, {
+            name: 'MyUpdatedGoat'
+        });
+        expect(data.name).toBe('MyUpdatedGoat');
+        expect(data.id).toBe(goats[0].id);
+    });
+};
+exports.basicTestSuite = basicTestSuite;

package/dist/test/basic/goat.dto.d.ts

@@ -0,0 +1,8 @@
+import { GoatEntity } from './goat.entity';
+declare const GoatEntityOut_base: import("@goatlab/fluent/dist/core/Nestjs/types/common").Type<Omit<GoatEntity, never>>;
+export declare class GoatEntityOut extends GoatEntityOut_base {
+}
+declare const GoatEntityIn_base: import("@goatlab/fluent/dist/core/Nestjs/types/common").Type<Omit<GoatEntity, "id">>;
+export declare class GoatEntityIn extends GoatEntityIn_base {
+}
+export {};

package/dist/test/basic/goat.dto.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GoatEntityIn = exports.GoatEntityOut = void 0;
+const tslib_1 = require("tslib");
+const goat_entity_1 = require("./goat.entity");
+const fluent_1 = require("@goatlab/fluent");
+let GoatEntityOut = class GoatEntityOut extends (0, fluent_1.OmitType)(goat_entity_1.GoatEntity, []) {
+};
+GoatEntityOut = tslib_1.__decorate([
+    (0, fluent_1.InputType)()
+], GoatEntityOut);
+exports.GoatEntityOut = GoatEntityOut;
+let GoatEntityIn = class GoatEntityIn extends (0, fluent_1.OmitType)(goat_entity_1.GoatEntity, ['id']) {
+};
+GoatEntityIn = tslib_1.__decorate([
+    (0, fluent_1.InputType)()
+], GoatEntityIn);
+exports.GoatEntityIn = GoatEntityIn;

package/dist/test/basic/goat.entity.d.ts

@@ -0,0 +1,10 @@
+export declare class Breed {
+    family?: string;
+    members?: number;
+}
+export declare class GoatEntity {
+    id: string;
+    name: string;
+    age?: number;
+    breed?: Breed;
+}