@goatlab/fluent-loki 0.6.5 → 0.7.0

package/dist/Loki.d.ts

@@ -0,0 +1,22 @@
+import LokiJS from 'lokijs';
+export declare enum LokiStorageType {
+    indexedDB = "indexedDB",
+    memory = "memory",
+    fsStructured = "fsStructured",
+    file = "file",
+    cryptedFile = "cryptedFile"
+}
+export declare type LokiParams = {
+    dbName: string;
+    storage: LokiStorageType;
+    secret?: string;
+};
+export declare type LokiCreateParams<T extends LokiParams> = T extends {
+    storage: LokiStorageType.cryptedFile;
+} ? {
+    secret: string;
+} & LokiParams : LokiParams;
+export declare class LokiClass {
+    createDb<T extends LokiParams>({ dbName, storage, secret }: LokiCreateParams<T>): LokiJS;
+}
+export declare const Loki: LokiClass;

package/dist/Loki.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Loki = exports.LokiClass = exports.LokiStorageType = 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"));
+const loki_fs_structured_adapter_1 = tslib_1.__importDefault(require("lokijs/src/loki-fs-structured-adapter"));
+const loki_crypted_file_adapter_1 = tslib_1.__importDefault(require("lokijs/src/loki-crypted-file-adapter"));
+var LokiStorageType;
+(function (LokiStorageType) {
+    LokiStorageType["indexedDB"] = "indexedDB";
+    LokiStorageType["memory"] = "memory";
+    LokiStorageType["fsStructured"] = "fsStructured";
+    LokiStorageType["file"] = "file";
+    LokiStorageType["cryptedFile"] = "cryptedFile";
+})(LokiStorageType = exports.LokiStorageType || (exports.LokiStorageType = {}));
+class LokiClass {
+    createDb({ dbName, storage, secret }) {
+        const dbConfig = {
+            autoload: true,
+            autosave: true,
+            autosaveInterval: 1000,
+            throttledSaves: false
+        };
+        switch (storage) {
+            case LokiStorageType.indexedDB:
+                return new lokijs_1.default(dbName, {
+                    ...dbConfig,
+                    adapter: new lokijs_1.default.LokiPartitioningAdapter(new loki_indexed_adapter_1.default(dbName), {
+                        paging: true
+                    })
+                });
+            case LokiStorageType.file:
+                return new lokijs_1.default(dbName, dbConfig);
+            case LokiStorageType.memory:
+                return new lokijs_1.default(dbName, {
+                    ...dbConfig,
+                    adapter: new lokijs_1.default.LokiPartitioningAdapter(new lokijs_1.default.LokiMemoryAdapter())
+                });
+            case LokiStorageType.fsStructured:
+                return new lokijs_1.default(dbName, {
+                    ...dbConfig,
+                    adapter: new loki_fs_structured_adapter_1.default()
+                });
+            case LokiStorageType.cryptedFile:
+                loki_crypted_file_adapter_1.default.setSecret(secret);
+                return new lokijs_1.default(dbName, { ...dbConfig, adapter: new loki_crypted_file_adapter_1.default() });
+            default:
+                return new lokijs_1.default(dbName, {
+                    ...dbConfig,
+                    adapter: new lokijs_1.default.LokiPartitioningAdapter(new lokijs_1.default.LokiMemoryAdapter())
+                });
+        }
+    }
+}
+exports.LokiClass = LokiClass;
+exports.Loki = new LokiClass();

package/dist/LokiConnector.d.ts

@@ -1,18 +1,37 @@
-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>;
+import { AnyObject, BaseConnector, FluentConnectorInterface, FluentQuery, QueryOutput, LoadedResult, FindByIdFilter, SingleQueryOutput } from '@goatlab/fluent';
+import { z } from 'zod';
+import LokiJS, { Collection } from 'lokijs';
+export interface LokiConnectorParams<Input, Output> {
+    entity: any;
+    dataSource: LokiJS;
+    inputSchema: z.ZodType<Input>;
+    outputSchema?: z.ZodType<Output>;
+}
+export interface TypeOrmConnectorParams<Input, Output> {
+    entity: any;
+    dataSource: LokiJS;
+    inputSchema: z.ZodType<Input>;
+    outputSchema?: z.ZodType<Output>;
+}
+export declare class LokiConnector<ModelDTO = AnyObject, InputDTO = ModelDTO, OutputDTO = ModelDTO> extends BaseConnector<ModelDTO, InputDTO, OutputDTO> implements FluentConnectorInterface<ModelDTO, InputDTO, OutputDTO> {
+    private collection;
+    private readonly dataSource;
+    private readonly inputSchema;
+    private readonly outputSchema;
+    private readonly entity;
+    constructor({ entity, dataSource, inputSchema, outputSchema }: LokiConnectorParams<InputDTO, OutputDTO>);
     insert(data: InputDTO): Promise<OutputDTO>;
     insertMany(data: InputDTO[]): Promise<OutputDTO[]>;
+    raw(): Collection;
+    findMany<T extends FluentQuery<ModelDTO>>(query?: T): Promise<QueryOutput<T, ModelDTO, OutputDTO>>;
     updateById(id: string, data: InputDTO): Promise<OutputDTO>;
-    clear({ sure }: Sure): Promise<any>;
-    private prepareFilter;
+    replaceById(id: string, data: InputDTO): Promise<OutputDTO>;
+    getLokiWhere(where?: FluentQuery<ModelDTO>['where']): any;
+    loadFirst(query?: FluentQuery<ModelDTO>): LokiConnector<ModelDTO, InputDTO, OutputDTO>;
+    protected clone(): any;
+    loadById(id: string): LoadedResult<this>;
+    findByIds<T extends FindByIdFilter<ModelDTO>>(ids: string[], q?: T): Promise<QueryOutput<T, ModelDTO, OutputDTO>>;
+    requireById(id: string, q?: FindByIdFilter<ModelDTO>): Promise<SingleQueryOutput<FindByIdFilter<ModelDTO>, ModelDTO, OutputDTO>>;
+    clear(): Promise<boolean>;
     private getLokiOperator;
-    private getModel;
 }

package/dist/LokiConnector.js

@@ -2,146 +2,351 @@
 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) {
+    constructor({ entity, dataSource, inputSchema, outputSchema }) {
         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');
+        this.dataSource = dataSource;
+        this.inputSchema = inputSchema;
+        this.outputSchema =
+            outputSchema || inputSchema;
+        this.entity = entity;
+        const dbModels = [];
+        for (const collection of dataSource.collections) {
+            dbModels.push(collection.name);
         }
-        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');
+        if (!dbModels.includes(entity.name)) {
+            dataSource.addCollection(entity.name);
         }
-        const model = await this.getModel();
-        const result = await model.find({
-            id
-        });
-        this.reset();
-        return result;
+        this.dataSource = dataSource;
+        this.collection = dataSource.getCollection(entity.name);
+        const relationShipBuilder = fluent_1.modelGeneratorDataSource.getRepository(entity);
+        const { relations } = (0, fluent_1.getRelationsFromModelGenerator)(relationShipBuilder);
+        this.modelRelations = relations;
+        this.outputKeys = (0, fluent_1.getOutputKeys)(relationShipBuilder) || [];
     }
     async insert(data) {
         const _data = js_utils_1.Objects.clone(data);
-        const model = await this.getModel();
+        const validatedData = this.inputSchema.parse(_data);
+        const id = js_utils_1.Ids.uuid();
         const inserted = {
-            ..._data
+            id,
+            ...validatedData
         };
-        model.insert(inserted);
-        this.reset();
-        return inserted;
+        await this.collection.insert(inserted);
+        return this.outputSchema.parse(this.clearEmpties(js_utils_1.Objects.deleteNulls(inserted)));
     }
     async insertMany(data) {
+        const validatedData = this.inputSchema.array().parse(data);
         const insertedElements = [];
-        for (const element of data) {
-            const inserted = await this.insert({
-                ...element
+        for (const data of validatedData) {
+            insertedElements.push({
+                ...data,
+                id: js_utils_1.Ids.uuid()
             });
-            insertedElements.push(inserted);
         }
-        this.reset();
-        return insertedElements;
+        await this.collection.insert(insertedElements);
+        return this.outputSchema.array().parse(insertedElements.map(d => {
+            return this.clearEmpties(js_utils_1.Objects.deleteNulls(d));
+        }));
     }
-    async updateById(id, data) {
-        if (!id) {
-            throw new Error('Loki connector error. Cannot update a Model without id key');
+    raw() {
+        return this.collection;
+    }
+    async findMany(query) {
+        const where = this.getLokiWhere(query?.where);
+        const sort = [];
+        let baseQuery = this.collection
+            .chain()
+            .find(where)
+            .offset(query?.offset || 0)
+            .limit(query?.limit || 10);
+        if (query?.paginated) {
+            baseQuery.limit(query.paginated.perPage);
+            baseQuery.offset((query.paginated?.page - 1) * query.paginated.perPage);
+        }
+        if (query?.orderBy) {
+            for (const order of query?.orderBy) {
+                const flattenObject = js_utils_1.Objects.flatten(order);
+                for (const attribute of Object.keys(flattenObject)) {
+                    const isDecending = flattenObject[attribute] === 'desc';
+                    sort.push([attribute, isDecending]);
+                }
+            }
+            baseQuery = baseQuery.compoundsort(sort);
+        }
+        let found = baseQuery.data();
+        found.map(d => {
+            this.clearEmpties(js_utils_1.Objects.deleteNulls(d));
+        });
+        if (query?.paginated) {
+            const paginationInfo = {
+                total: 0,
+                perPage: query.paginated.perPage,
+                currentPage: query.paginated.page,
+                nextPage: query.paginated.page + 1,
+                firstPage: 1,
+                lastPage: Math.ceil(1 / query.paginated.perPage),
+                prevPage: query.paginated.page === 1 ? null : query.paginated.page - 1,
+                from: (query.paginated.page - 1) * query.paginated.perPage + 1,
+                to: query.paginated.perPage * query.paginated.page,
+                data: found
+            };
+            return paginationInfo;
+        }
+        if (query?.select) {
+            const selectedAttributes = this.jsApplySelect(query?.select, found);
+            return selectedAttributes;
         }
-        const model = await this.getModel();
-        const local = await model.findOne({ id });
+        return this.outputSchema?.array().parse(found);
+    }
+    async updateById(id, data) {
+        const dataToInsert = this.outputKeys.includes('updated')
+            ? {
+                ...data,
+                ...{ updated: new Date() }
+            }
+            : data;
+        const validatedData = this.inputSchema.parse(dataToInsert);
+        const local = await this.collection.findOne({ id });
         const mod = {
             ...local,
-            ...data,
-            ...{ modified: dates_1.Dates.currentIsoString() }
+            ...validatedData,
+            modified: dates_1.Dates.currentIsoString()
         };
-        const updated = model.update(mod);
-        this.reset();
-        return updated;
+        const dbResult = await this.collection.update(mod);
+        return this.outputSchema?.parse(this.clearEmpties(js_utils_1.Objects.deleteNulls(dbResult)));
     }
-    async clear({ sure }) {
-        const model = await this.getModel();
-        return model.clear({ removeIndices: true });
+    async replaceById(id, data) {
+        let value = await this.collection.findOne({ id });
+        const flatValue = js_utils_1.Objects.flatten(JSON.parse(JSON.stringify(value)));
+        Object.keys(flatValue).forEach(key => {
+            flatValue[key] = null;
+        });
+        const nullObject = js_utils_1.Objects.nest(flatValue);
+        const newValue = { ...nullObject, ...data };
+        delete newValue._id;
+        delete newValue.id;
+        delete newValue.created;
+        delete newValue.updated;
+        const dataToInsert = this.outputKeys.includes('updated')
+            ? {
+                ...data,
+                ...{ updated: new Date() }
+            }
+            : data;
+        const validatedData = this.inputSchema.parse(dataToInsert);
+        value = { ...value, ...validatedData };
+        await this.collection.update(value);
+        const val = await this.collection.findOne({ id });
+        return this.outputSchema.parse(this.clearEmpties(js_utils_1.Objects.deleteNulls(val)));
     }
-    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;
+    getLokiWhere(where) {
+        if (!where || Object.keys(where).length === 0) {
+            return {};
+        }
+        const Filters = {
+            where: { $or: [{ $and: [] }] }
+        };
+        const orConditions = this.extractConditions(where['OR']);
+        const andConditions = this.extractConditions(where['AND']);
+        const copy = js_utils_1.Objects.clone(where);
+        if (!!copy['AND']) {
+            delete copy['AND'];
+        }
+        if (!!copy['OR']) {
+            delete copy['OR'];
+        }
+        const rootLevelConditions = this.extractConditions([copy]);
+        for (const condition of andConditions) {
+            let { element, operator, value } = condition;
+            if (element === 'id') {
+                element = '_id';
+            }
+            switch (operator) {
+                case fluent_1.LogicOperator.equals:
+                    Filters.where.$or[0].$and.push({ [element]: { $eq: value } });
+                    break;
+                case fluent_1.LogicOperator.isNot:
+                    Filters.where.$or[0].$and.push({ [element]: { $neq: value } });
+                    break;
+                case fluent_1.LogicOperator.greaterThan:
+                    Filters.where.$or[0].$and.push({ [element]: { $gt: value } });
+                    break;
+                case fluent_1.LogicOperator.greaterOrEqualThan:
+                    Filters.where.$or[0].$and.push({ [element]: { $gte: value } });
+                    break;
+                case fluent_1.LogicOperator.lessThan:
+                    Filters.where.$or[0].$and.push({ [element]: { $lt: value } });
+                    break;
+                case fluent_1.LogicOperator.lessOrEqualThan:
+                    Filters.where.$or[0].$and.push({ [element]: { $lte: value } });
+                    break;
+                case fluent_1.LogicOperator.in:
+                    Filters.where.$or[0].$and.push({ [element]: { $in: value } });
+                    break;
+                case fluent_1.LogicOperator.notIn:
+                    Filters.where.$or[0].$and.push({
+                        [element]: { $not: { $in: value } }
+                    });
+                    break;
+                case fluent_1.LogicOperator.exists:
+                    Filters.where.$or[0].$and.push({ [element]: { $exists: true } });
+                    break;
+                case fluent_1.LogicOperator.notExists:
+                    Filters.where.$or[0].$and.push({ [element]: { $exists: false } });
+                    break;
+                case fluent_1.LogicOperator.regexp:
+                    Filters.where.$or[0].$and.push({ [element]: { $regex: value } });
+                    break;
+            }
+        }
+        for (const condition of rootLevelConditions) {
+            let { element, operator, value } = condition;
+            if (element === 'id') {
+                element = '_id';
+            }
+            switch (operator) {
+                case fluent_1.LogicOperator.equals:
+                    Filters.where.$or[0].$and.push({ [element]: { $eq: value } });
+                    break;
+                case fluent_1.LogicOperator.isNot:
+                    Filters.where.$or[0].$and.push({ [element]: { $neq: value } });
+                    break;
+                case fluent_1.LogicOperator.greaterThan:
+                    Filters.where.$or[0].$and.push({ [element]: { $gt: value } });
+                    break;
+                case fluent_1.LogicOperator.greaterOrEqualThan:
+                    Filters.where.$or[0].$and.push({ [element]: { $gte: value } });
+                    break;
+                case fluent_1.LogicOperator.lessThan:
+                    Filters.where.$or[0].$and.push({ [element]: { $lt: value } });
+                    break;
+                case fluent_1.LogicOperator.lessOrEqualThan:
+                    Filters.where.$or[0].$and.push({ [element]: { $lte: value } });
+                    break;
+                case fluent_1.LogicOperator.in:
+                    Filters.where.$or[0].$and.push({ [element]: { $in: value } });
+                    break;
+                case fluent_1.LogicOperator.notIn:
+                    Filters.where.$or[0].$and.push({
+                        [element]: { $not: { $in: value } }
+                    });
+                    break;
+                case fluent_1.LogicOperator.exists:
+                    Filters.where.$or[0].$and.push({ [element]: { $exists: true } });
+                    break;
+                case fluent_1.LogicOperator.notExists:
+                    Filters.where.$or[0].$and.push({ [element]: { $exists: false } });
+                    break;
+                case fluent_1.LogicOperator.regexp:
+                    Filters.where.$or[0].$and.push({ [element]: { $regex: value } });
+                    break;
+            }
         }
-        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]);
+        for (const condition of orConditions) {
+            let { element, operator, value } = condition;
+            if (element === 'id') {
+                element = 'id';
+            }
+            switch (operator) {
+                case fluent_1.LogicOperator.equals:
+                    Filters.where.$or.push({ [element]: { $eq: value } });
+                    break;
+                case fluent_1.LogicOperator.isNot:
+                    Filters.where.$or.push({ [element]: { $neq: value } });
+                    break;
+                case fluent_1.LogicOperator.greaterThan:
+                    Filters.where.$or.push({ [element]: { $gt: value } });
+                    break;
+                case fluent_1.LogicOperator.greaterOrEqualThan:
+                    Filters.where.$or.push({ [element]: { $gte: value } });
+                    break;
+                case fluent_1.LogicOperator.lessThan:
+                    Filters.where.$or.push({ [element]: { $lt: value } });
+                    break;
+                case fluent_1.LogicOperator.lessOrEqualThan:
+                    Filters.where.$or.push({ [element]: { $lte: value } });
+                    break;
+                case fluent_1.LogicOperator.in:
+                    Filters.where.$or.push({ [element]: { $in: value } });
+                    break;
+                case fluent_1.LogicOperator.notIn:
+                    Filters.where.$or.push({
+                        [element]: { $not: { $in: value } }
+                    });
+                    break;
+                case fluent_1.LogicOperator.exists:
+                    Filters.where.$or.push({ [element]: { $exists: true } });
+                    break;
+                case fluent_1.LogicOperator.notExists:
+                    Filters.where.$or.push({ [element]: { $exists: false } });
+                    break;
+                case fluent_1.LogicOperator.regexp:
+                    Filters.where.$or.push({ [element]: { $regex: value } });
+                    break;
+            }
+        }
+        return this.clearEmpties(Filters.where);
+    }
+    loadFirst(query) {
+        const detachedClass = Object.assign(Object.create(Object.getPrototypeOf(this)), this);
+        detachedClass.setRelatedQuery({
+            entity: this.entity,
+            repository: this,
+            query
+        });
+        return detachedClass;
+    }
+    clone() {
+        return new this.constructor();
+    }
+    loadById(id) {
+        const newInstance = this.clone();
+        newInstance.setRelatedQuery({
+            entity: this.entity,
+            repository: this,
+            query: {
+                where: {
+                    id
                 }
-                orObject.$or.push(conditionToObject);
-            });
-            globalFilter = { $or: [andObject, orObject] };
+            }
+        });
+        return newInstance;
+    }
+    async findByIds(ids, q) {
+        let data = await this.findMany({
+            where: {
+                id: {
+                    in: ids
+                }
+            },
+            limit: q?.limit,
+            select: q?.select,
+            include: q?.include
+        });
+        return this.outputSchema?.array().parse(data);
+    }
+    async requireById(id, q) {
+        const found = await this.findByIds([id], {
+            select: q?.select,
+            include: q?.include,
+            limit: 1
+        });
+        found.map(d => {
+            if (this.isMongoDB) {
+                d['id'] = d['id'].toString();
+            }
+            this.clearEmpties(js_utils_1.Objects.deleteNulls(d));
+        });
+        if (!found[0]) {
+            throw new Error(`Object ${id} not found`);
         }
-        return globalFilter;
+        return this.outputSchema?.parse(found[0]);
+    }
+    async clear() {
+        return true;
     }
     getLokiOperator(operator) {
         const lokiOperators = {
@@ -166,9 +371,5 @@ class LokiConnector extends fluent_1.BaseConnector {
         }
         return converted;
     }
-    async getModel() {
-        const DB = await Database_1.Database.get();
-        return DB.getCollection(this.name);
-    }
 }
 exports.LokiConnector = LokiConnector;

package/dist/index.d.ts

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

package/dist/index.js

@@ -1,5 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.LokiConnector = void 0;
+exports.Loki = exports.LokiConnector = void 0;
 const LokiConnector_1 = require("./LokiConnector");
 Object.defineProperty(exports, "LokiConnector", { enumerable: true, get: function () { return LokiConnector_1.LokiConnector; } });
+const Loki_1 = require("./Loki");
+Object.defineProperty(exports, "Loki", { enumerable: true, get: function () { return Loki_1.Loki; } });

package/dist/{Database.spec.js → test/Database.spec.js}

@@ -2,10 +2,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const tslib_1 = require("tslib");
 const lokijs_1 = tslib_1.__importDefault(require("lokijs"));
-const Database_1 = require("./Database");
+const Loki_1 = require("../Loki");
 let db;
-beforeAll(async () => {
-    db = await Database_1.Database.get();
+beforeAll(() => {
+    db = Loki_1.Loki.createDb({ dbName: 'GOAT', storage: Loki_1.LokiStorageType.memory });
 });
 it('Should return and instance of LockiJS DB', () => {
     const isLoki = db instanceof lokijs_1.default;
@@ -16,10 +16,11 @@ it('Should be named GOAT', () => {
 });
 it('Should start with no collections', () => {
     const expectedCollections = [];
-    const dbCollections = db.collections.reduce((dbColArray, dbCol) => {
-        dbColArray.push(dbCol.name);
-        return dbColArray;
-    }, []);
+    const dbCollections = [];
+    for (const collection of db.collections) {
+        dbCollections.push(collection.name);
+    }
+    expect(expectedCollections.length).toBe(dbCollections.length);
     const uniqueCollections = {};
     expectedCollections.forEach((collection, index) => {
         uniqueCollections[collection] = true;