@goatlab/fluent 0.6.1 → 0.6.4

package/dist/TypeOrmConnector/TypeOrmConnector.js

@@ -0,0 +1,509 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TypeOrmConnector = exports.getRelations = exports.GoatRepository = void 0;
+const typeorm_1 = require("typeorm");
+const mongodb_1 = require("mongodb");
+const js_utils_1 = require("@goatlab/js-utils");
+const loadRelations_1 = require("../loadRelations");
+const index_1 = require("../index");
+class GoatRepository extends typeorm_1.Repository {
+}
+exports.GoatRepository = GoatRepository;
+const getRelations = typeOrmRepo => {
+    const relations = {};
+    for (const relation of typeOrmRepo.metadata.relations) {
+        relations[relation.inverseEntityMetadata.givenTableName.toLowerCase()] = {
+            isOneToMany: relation.isOneToMany,
+            isManyToOne: relation.isManyToOne,
+            isManyToMany: relation.isManyToMany,
+            inverseSidePropertyPath: relation.inverseSidePropertyPath,
+            propertyPath: relation.propertyName,
+            entityName: relation.inverseEntityMetadata.name,
+            tableName: relation.inverseEntityMetadata.tableName,
+            targetClass: relation.inverseEntityMetadata.target,
+            joinColumns: relation.joinColumns,
+            inverseJoinColumns: relation.inverseJoinColumns
+        };
+    }
+    return {
+        relations
+    };
+};
+exports.getRelations = getRelations;
+class TypeOrmConnector extends index_1.BaseConnector {
+    constructor(entity, relationQuery, connectionName) {
+        super();
+        this.connectionName = connectionName;
+        if (!index_1.modelGeneratorDataSource.isInitialized) {
+            throw new Error('Fluent model generator data source is not initialized');
+        }
+        this.repository = index_1.modelGeneratorDataSource.getRepository(entity);
+        this.relationQuery = relationQuery;
+        const { relations } = (0, exports.getRelations)(this.repository);
+        this.modelRelations = relations;
+        this.outputKeys = (0, index_1.getOutputKeys)(this.repository) || [];
+        this.isMongoDB =
+            this.repository.metadata.connection.driver.options.type === 'mongodb';
+    }
+    async get() {
+        const query = this.getGeneratedQuery();
+        const result = await this.repository.find(query);
+        let data = this.jsApplySelect(result);
+        data = await (0, loadRelations_1.loadRelations)({
+            data,
+            relations: this.relations,
+            modelRelations: this.modelRelations,
+            connectionName: this.connectionName,
+            provider: 'typeorm',
+            self: this
+        });
+        this.reset();
+        return data;
+    }
+    async getPaginated() {
+        const response = await this.get();
+        const results = {
+            current_page: response[0].meta.currentPage,
+            data: response[0].data,
+            first_page_url: response[0].meta.firstPageUrl,
+            next_page_url: response[0].meta.nextPageUrl,
+            path: response[0].meta.path,
+            per_page: response[0].meta.itemsPerPage,
+            prev_page_url: response[0].meta.previousPageUrl,
+            total: response[0].meta.totalItemCount
+        };
+        if (results && results.data && this.selectArray.length > 0) {
+            results.data = this.jsApplySelect(results.data);
+            return results;
+        }
+        return results;
+    }
+    async all() {
+        return this.get();
+    }
+    async find(filter = {}) {
+        const stringFilter = filter;
+        let parsedFilter = {};
+        try {
+            parsedFilter = JSON.parse(stringFilter);
+        }
+        catch (error) {
+            parsedFilter = {};
+        }
+        this.selectArray = (parsedFilter && parsedFilter.fields) || [];
+        this.whereArray =
+            (parsedFilter && parsedFilter.where && parsedFilter.where.and) || [];
+        this.orWhereArray =
+            (parsedFilter && parsedFilter.where && parsedFilter.where.or) || [];
+        this.limit((parsedFilter && (parsedFilter.limit || parsedFilter.take)) || 100);
+        this.offset((parsedFilter && (parsedFilter.offset || parsedFilter.skip)) || 0);
+        if (parsedFilter && parsedFilter.order) {
+            const orderB = [
+                parsedFilter.order.field,
+                parsedFilter.order.asc ? 'asc' : 'desc',
+                parsedFilter.order.type || 'string'
+            ];
+            this.chainReference.push({ method: 'orderBy', orderB });
+            this.orderByArray = orderB;
+        }
+        return this.get();
+    }
+    async paginate(paginator) {
+        if (!paginator) {
+            throw new Error('Paginator cannot be empty');
+        }
+        this.paginator = paginator;
+        const response = await this.getPaginated();
+        return response;
+    }
+    raw() {
+        return this.repository;
+    }
+    async insert(data) {
+        const datum = await this.repository.save(data);
+        const result = this.jsApplySelect([datum]);
+        this.reset();
+        return result[0];
+    }
+    async insertMany(data) {
+        const inserted = await this.repository.save(data, {
+            chunk: data.length / 300
+        });
+        this.reset();
+        const result = this.jsApplySelect(inserted);
+        return result;
+    }
+    async updateById(id, data) {
+        const parsedId = this.isMongoDB
+            ? new mongodb_1.ObjectId(id)
+            : id;
+        const dataToInsert = this.outputKeys.includes('updated')
+            ? {
+                ...data,
+                ...{ updated: new Date() }
+            }
+            : data;
+        const updated = await this.repository.update(id, dataToInsert);
+        const dbResult = await this.repository.findBy({
+            id: (0, typeorm_1.In)([parsedId])
+        });
+        const result = this.jsApplySelect(dbResult);
+        this.reset();
+        return result[0];
+    }
+    async replaceById(id, data) {
+        const parsedId = this.isMongoDB
+            ? new mongodb_1.ObjectId(id)
+            : id;
+        const value = await this.repository.findOneOrFail({
+            where: { id: parsedId }
+        });
+        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;
+        await this.repository.update(id, dataToInsert);
+        const val = await this.repository.findOneOrFail({
+            where: {
+                id: parsedId
+            }
+        });
+        const returnValue = this.jsApplySelect([val]);
+        this.reset();
+        return returnValue[0];
+    }
+    async clear({ sure }) {
+        if (!sure || sure !== true) {
+            throw new Error('Clear() method will delete everything!, you must set the "sure" parameter "clear({sure:true})" to continue');
+        }
+        return;
+        const data = await this.repository.clear();
+        this.reset();
+        return true;
+    }
+    async deleteById(id) {
+        const parsedId = this.isMongoDB
+            ? new mongodb_1.ObjectId(id)
+            : id;
+        const removed = this.repository.delete(parsedId);
+        this.reset();
+        return id;
+    }
+    async findById(id) {
+        const parsedId = this.isMongoDB
+            ? new mongodb_1.ObjectId(id)
+            : id;
+        const data = await this.repository.findBy({
+            id: (0, typeorm_1.In)([parsedId])
+        });
+        const result = this.jsApplySelect(data);
+        this.reset();
+        return result[0];
+    }
+    getPage() {
+        const page = 'page=';
+        if (this.paginator && this.paginator.page) {
+            return `${page + this.paginator.page}&`;
+        }
+        return '';
+    }
+    getPaginatorLimit(filter) {
+        if (this.paginator && this.paginator.perPage) {
+            return { ...filter, limit: this.paginator.perPage };
+        }
+        return filter;
+    }
+    getPopulate() {
+        const populate = [];
+        this.populateArray.forEach(relation => {
+            if (typeof relation === 'string') {
+                populate.push({ relation });
+            }
+            else if (Array.isArray(relation)) {
+                relation.forEach(nestedRelation => {
+                    if (typeof nestedRelation === 'string') {
+                        populate.push({ relation: nestedRelation });
+                    }
+                    else if (typeof nestedRelation === 'object') {
+                        populate.push(nestedRelation);
+                    }
+                });
+            }
+            else if (typeof relation === 'object') {
+                populate.push(relation);
+            }
+        });
+        return populate;
+    }
+    getGeneratedQuery() {
+        let filter = {};
+        filter = this.isMongoDB
+            ? this.getMongoFilters(filter)
+            : this.getFilters(filter);
+        filter = this.getLimit(filter);
+        filter = this.getSkip(filter);
+        filter = this.getSelect(filter);
+        filter = this.getOrderBy(filter);
+        filter = this.getPaginatorLimit(filter);
+        const page = this.getPage();
+        const populate = this.getPopulate();
+        if (this.rawQuery) {
+            filter.relations = populate || this.rawQuery.populate;
+            filter.take = filter.take || this.rawQuery.limit;
+            filter.skip = filter.skip || this.rawQuery.skip;
+            filter.order = filter.order || this.rawQuery.order;
+            filter.select = { ...filter.select, ...this.rawQuery.fields };
+            filter.where = { ...this.rawQuery.where };
+        }
+        return filter;
+    }
+    getFilters(filters) {
+        const andFilters = this.whereArray;
+        const orFilters = this.orWhereArray;
+        if (this.relationQuery && this.relationQuery.data) {
+            const ids = this.relationQuery.data.map(d => d.id);
+            andFilters.push([
+                this.relationQuery.relation.inverseSidePropertyPath,
+                'in',
+                ids
+            ]);
+        }
+        if (!andFilters || andFilters.length === 0) {
+            return filters;
+        }
+        const Filters = { where: [{}] };
+        andFilters.forEach(condition => {
+            const element = condition[0];
+            const operator = condition[1];
+            const value = condition[2];
+            switch (operator) {
+                case '=':
+                    Filters.where[0] = js_utils_1.Objects.nest({
+                        ...Filters.where[0],
+                        ...{ [element]: (0, typeorm_1.Equal)(value) }
+                    });
+                    break;
+                case '!=':
+                    Filters.where[0] = js_utils_1.Objects.nest({
+                        ...Filters.where[0],
+                        ...{ [element]: (0, typeorm_1.Not)((0, typeorm_1.Equal)(value)) }
+                    });
+                    break;
+                case '>':
+                    Filters.where[0] = js_utils_1.Objects.nest({
+                        ...Filters.where[0],
+                        ...{ [element]: (0, typeorm_1.MoreThan)(value) }
+                    });
+                    break;
+                case '>=':
+                    Filters.where[0] = js_utils_1.Objects.nest({
+                        ...Filters.where[0],
+                        ...{ [element]: (0, typeorm_1.MoreThanOrEqual)(value) }
+                    });
+                    break;
+                case '<':
+                    Filters.where[0] = js_utils_1.Objects.nest({
+                        ...Filters.where[0],
+                        ...{ [element]: (0, typeorm_1.LessThan)(value) }
+                    });
+                    break;
+                case '<=':
+                    Filters.where[0] = js_utils_1.Objects.nest({
+                        ...Filters.where[0],
+                        ...{ [element]: (0, typeorm_1.LessThanOrEqual)(value) }
+                    });
+                    break;
+                case 'in':
+                    Filters.where[0] = js_utils_1.Objects.nest({
+                        ...Filters.where[0],
+                        ...{ [element]: (0, typeorm_1.In)(value) }
+                    });
+                    break;
+                case 'nin':
+                    Filters.where[0] = js_utils_1.Objects.nest({
+                        ...Filters.where[0],
+                        ...{ [element]: (0, typeorm_1.Not)((0, typeorm_1.In)(value)) }
+                    });
+                    break;
+                case 'exists':
+                    Filters.where[0] = js_utils_1.Objects.nest({
+                        ...Filters.where[0],
+                        ...{ [element]: (0, typeorm_1.Not)((0, typeorm_1.IsNull)()) }
+                    });
+                    break;
+                case '!exists':
+                    Filters.where[0] = js_utils_1.Objects.nest({
+                        ...Filters.where[0],
+                        ...{ [element]: (0, typeorm_1.IsNull)() }
+                    });
+                    break;
+                case 'regexp':
+                    Filters.where[0] = js_utils_1.Objects.nest({
+                        ...Filters.where[0],
+                        ...{ [element]: (0, typeorm_1.Like)(value) }
+                    });
+                    break;
+            }
+        });
+        orFilters.forEach(condition => {
+            const element = condition[0];
+            const operator = condition[1];
+            const value = condition[2];
+            switch (operator) {
+                case '=':
+                    Filters.where.push({ [element]: (0, typeorm_1.Equal)(value) });
+                    break;
+                case '!=':
+                    Filters.where.push({ [element]: (0, typeorm_1.Not)((0, typeorm_1.Equal)(value)) });
+                    break;
+                case '>':
+                    Filters.where.push({ [element]: (0, typeorm_1.MoreThan)(value) });
+                    break;
+                case '>=':
+                    Filters.where.push(js_utils_1.Objects.nest({ [element]: (0, typeorm_1.MoreThanOrEqual)(value) }));
+                    break;
+                case '<':
+                    Filters.where.push({ [element]: (0, typeorm_1.LessThan)(value) });
+                    break;
+                case '<=':
+                    Filters.where.push({ [element]: (0, typeorm_1.LessThanOrEqual)(value) });
+                    break;
+                case 'in':
+                    Filters.where.push({ [element]: (0, typeorm_1.In)(value) });
+                    break;
+                case 'nin':
+                    Filters.where.push({ [element]: (0, typeorm_1.Not)((0, typeorm_1.In)(value)) });
+                    break;
+                case 'exists':
+                    Filters.where.push({ [element]: (0, typeorm_1.Not)((0, typeorm_1.IsNull)()) });
+                    break;
+                case '!exists':
+                    Filters.where.push({ [element]: (0, typeorm_1.IsNull)() });
+                    break;
+                case 'regexp':
+                    Filters.where.push({ [element]: (0, typeorm_1.Like)(value) });
+                    break;
+            }
+        });
+        return Filters;
+    }
+    getMongoFilters(filters) {
+        const andFilters = this.whereArray;
+        const orFilters = this.orWhereArray;
+        if (this.relationQuery && this.relationQuery.data) {
+            const ids = this.relationQuery.data.map(d => js_utils_1.Ids.objectID(d.id));
+            andFilters.push([
+                this.relationQuery.relation.inverseSidePropertyPath,
+                'in',
+                ids
+            ]);
+        }
+        if (!andFilters || andFilters.length === 0) {
+            return filters;
+        }
+        const Filters = { where: { $and: [] } };
+        andFilters.forEach(condition => {
+            let element = condition[0];
+            const operator = condition[1];
+            let value = condition[2];
+            if (element === 'id') {
+                element = '_id';
+                value = Array.isArray(value)
+                    ? value.map(v => js_utils_1.Ids.objectID(v))
+                    : js_utils_1.Ids.objectID(value);
+            }
+            switch (operator) {
+                case '=':
+                    Filters.where.$and.push({ [element]: { $eq: value } });
+                    break;
+                case '!=':
+                    Filters.where.$and.push({ [element]: { $neq: value } });
+                    break;
+                case '>':
+                    Filters.where.$and.push({ [element]: { $gt: value } });
+                    break;
+                case '>=':
+                    Filters.where.$and.push({ [element]: { $gte: value } });
+                    break;
+                case '<':
+                    Filters.where.$and.push({ [element]: { $lt: value } });
+                    break;
+                case '<=':
+                    Filters.where.$and.push({ [element]: { $lte: value } });
+                    break;
+                case 'in':
+                    Filters.where.$and.push({ [element]: { $in: value } });
+                    break;
+                case 'nin':
+                    Filters.where.$and.push({
+                        [element]: { $not: { $in: value } }
+                    });
+                    break;
+                case 'exists':
+                    Filters.where.$and.push({ [element]: { $exists: true } });
+                    break;
+                case '!exists':
+                    Filters.where.$and.push({ [element]: { $exists: false } });
+                    break;
+                case 'regex':
+                    Filters.where.$and.push({ [element]: { $regex: value } });
+                    break;
+            }
+        });
+        return Filters;
+    }
+    getOrderBy(filter) {
+        if (!this.orderByArray || this.orderByArray.length === 0) {
+            return filter;
+        }
+        return {
+            ...filter,
+            order: {
+                [this.orderByArray[0]]: this.orderByArray[1].toUpperCase()
+            }
+        };
+    }
+    getLimit(filter) {
+        if (!this.limitNumber || this.limitNumber === 0) {
+            this.limitNumber = (this.rawQuery && this.rawQuery.limit) || 50;
+        }
+        return { ...filter, take: this.limitNumber };
+    }
+    getSkip(filter) {
+        if (!this.offsetNumber) {
+            this.offsetNumber = (this.rawQuery && this.rawQuery.skip) || 0;
+        }
+        return { ...filter, skip: this.offsetNumber };
+    }
+    getSelect(filter) {
+        let select = this.selectArray;
+        if (Object.keys(select).length === 0 && select.constructor === Object) {
+            select = [''];
+        }
+        select = select.map(s => {
+            s = s.split(' as ')[0];
+            s = s.includes('id') ? 'id' : s;
+            return s;
+        });
+        if (select.find(e => e.startsWith('data.'))) {
+            select.unshift('data');
+        }
+        if (!select) {
+            return filter;
+        }
+        return { ...filter, fields: select };
+    }
+}
+exports.TypeOrmConnector = TypeOrmConnector;

package/dist/TypeOrmConnector/TypeOrmMongoConnector._bypass.d.ts

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

package/dist/TypeOrmConnector/TypeOrmMongoConnector._bypass.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const typeorm_1 = require("typeorm");
+const car_entity_1 = require("./test/relations/car/car.entity");
+const car_repositoryTypeOrm_1 = require("./test/relations/car/car.repositoryTypeOrm");
+const goat_entity_1 = require("./test/basic/goat.entity");
+const goat_repository_1 = require("./test/basic/goat.repository");
+const roles_entity_1 = require("./test/relations/roles/roles.entity");
+const roles_repositoryTypeOrm_1 = require("./test/relations/roles/roles.repositoryTypeOrm");
+const roles_user_entity_1 = require("./test/relations/roles/roles_user.entity");
+const typeOrm_entity_1 = require("./test/advanced/typeOrm.entity");
+const typeOrm_repository_1 = require("./test/advanced/typeOrm.repository");
+const user_repositoryTypeOrm_1 = require("./test/relations/user/user.repositoryTypeOrm");
+const user_entity_1 = require("./test/relations/user/user.entity");
+const advancedTestSuite_1 = require("./test/advanced/advancedTestSuite");
+const basicTestSuite_1 = require("./test/basic/basicTestSuite");
+const relationsTestsSuite_1 = require("./test/relations/relationsTestsSuite");
+jasmine.DEFAULT_TIMEOUT_INTERVAL = 600000;
+let mongoConnection;
+beforeAll(async (done) => {
+    mongoConnection = '';
+    await (0, typeorm_1.createConnection)({
+        type: 'mongodb',
+        name: 'runningTest',
+        url: mongoConnection.url,
+        useNewUrlParser: true,
+        useUnifiedTopology: true,
+        entities: [
+            goat_entity_1.GoatEntity,
+            typeOrm_entity_1.TypeORMDataModel,
+            car_entity_1.CarsEntity,
+            user_entity_1.UsersEntity,
+            roles_entity_1.RoleEntity,
+            roles_user_entity_1.RolesUser
+        ],
+        synchronize: false,
+        logging: false
+    });
+    done();
+});
+afterAll(async () => {
+    await mongoConnection.instance.stop();
+});
+describe('Execute all basic test Suite', () => {
+    (0, basicTestSuite_1.basicTestSuite)(goat_repository_1.GoatRepository);
+});
+describe('Execute all advanced test Suite', () => {
+    (0, advancedTestSuite_1.advancedTestSuite)(typeOrm_repository_1.TypeOrmRepository);
+});
+describe('Execute all relations test suite', () => {
+    (0, relationsTestsSuite_1.relationsTestSuite)(user_repositoryTypeOrm_1.UserRepository, car_repositoryTypeOrm_1.CarsRepository, roles_repositoryTypeOrm_1.RoleRepository);
+});

package/dist/TypeOrmConnector/TypeOrmMysqlConnector._bypass.d.ts

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

package/dist/TypeOrmConnector/TypeOrmMysqlConnector._bypass.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const typeorm_1 = require("typeorm");
+const car_entity_1 = require("./test/relations/car/car.entity");
+const car_repositoryTypeOrm_1 = require("./test/relations/car/car.repositoryTypeOrm");
+const goat_entity_1 = require("./test/basic/goat.entity");
+const goat_repository_1 = require("./test/basic/goat.repository");
+const roles_entity_1 = require("./test/relations/roles/roles.entity");
+const roles_repositoryTypeOrm_1 = require("./test/relations/roles/roles.repositoryTypeOrm");
+const roles_user_entity_1 = require("./test/relations/roles/roles_user.entity");
+const typeOrm_entity_1 = require("./test/advanced/typeOrm.entity");
+const typeOrm_repository_1 = require("./test/advanced/typeOrm.repository");
+const user_repositoryTypeOrm_1 = require("./test/relations/user/user.repositoryTypeOrm");
+const user_entity_1 = require("./test/relations/user/user.entity");
+const advancedTestSuite_1 = require("./test/advanced/advancedTestSuite");
+const basicTestSuite_1 = require("./test/basic/basicTestSuite");
+const relationsTestsSuite_1 = require("./test/relations/relationsTestsSuite");
+jasmine.DEFAULT_TIMEOUT_INTERVAL = 600000;
+let tearDown;
+beforeAll(async (done) => {
+    const { databaseURL, kill } = { databaseURL: '', kill: () => { } };
+    tearDown = kill;
+    const conn = new typeorm_1.DataSource({
+        type: 'mysql',
+        name: 'runningTest',
+        database: 'test-db',
+        username: 'test-user',
+        password: 'password',
+        port: 3306,
+        entities: [
+            goat_entity_1.GoatEntity,
+            typeOrm_entity_1.TypeORMDataModel,
+            car_entity_1.CarsEntity,
+            user_entity_1.UsersEntity,
+            roles_entity_1.RoleEntity,
+            roles_user_entity_1.RolesUser
+        ],
+        synchronize: true,
+        logging: false
+    });
+    await conn.initialize();
+    done();
+});
+afterAll(() => {
+    return tearDown();
+});
+describe('Execute all basic test Suite', () => {
+    (0, basicTestSuite_1.basicTestSuite)(goat_repository_1.GoatRepository);
+});
+describe('Execute all advanced test Suite', () => {
+    (0, advancedTestSuite_1.advancedTestSuite)(typeOrm_repository_1.TypeOrmRepository);
+});
+describe('Execute all relations test suite', () => {
+    (0, relationsTestsSuite_1.relationsTestSuite)(user_repositoryTypeOrm_1.UserRepository, car_repositoryTypeOrm_1.CarsRepository, roles_repositoryTypeOrm_1.RoleRepository);
+});

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

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