@goatlab/fluent 0.6.24 → 0.7.1

package/dist/TypeOrmConnector/test/advanced/advancedTestSuite.js

@@ -12,8 +12,8 @@ const advancedTestSuite = Model => {
         await Repository.insert({
             created: '2018-12-03',
             nestedTest: {
-                a: [6, 5, 4],
-                b: { c: true, d: [2, 1, 0] },
+                a: ['6', '5', '4'],
+                b: { c: true, d: ['2', '1', '0'] },
                 c: 4
             },
             order: 1,
@@ -22,8 +22,8 @@ const advancedTestSuite = Model => {
         await Repository.insert({
             created: '2017-12-03',
             nestedTest: {
-                a: [3, 2, 1],
-                b: { c: true, d: [1, 1, 0] },
+                a: ['3', '2', '1'],
+                b: { c: true, d: ['1', '1', '0'] },
                 c: 3
             },
             order: 2,
@@ -32,84 +32,218 @@ const advancedTestSuite = Model => {
         await Repository.insert({
             created: '2016-12-03',
             nestedTest: {
-                a: [0, -1, -2],
-                b: { c: true, d: [0, 1, 0] },
+                a: ['0', '-1', '-2'],
+                b: { c: true, d: ['0', '1', '0'] },
                 c: 2
             },
             order: 3,
             test: false
         });
     };
+    it('findFirst() should take the first result from data', async () => {
+        await insertTestData(Model);
+        const form = await Model.findFirst({
+            select: {
+                id: true,
+                nestedTest: {
+                    c: true
+                }
+            },
+            where: {
+                nestedTest: {
+                    c: {
+                        greaterOrEqualThan: 3
+                    }
+                }
+            }
+        });
+        expect(!Array.isArray(form)).toBe(true);
+        expect(typeof form.nestedTest.c).toBe('number');
+        expect(form.nestedTest.c >= 3).toBe(true);
+    });
     it('Should get local data', async () => {
         await insertTestData(Model);
-        const data = await Model.all();
+        const data = await Model.findMany();
         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(keys => keys.test);
+        const data = await Model.pluck({ test: true });
         expect(typeof data[0]).toBe('boolean');
     });
+    it('limit() should limit the amount of results', async () => {
+        await insertTestData(Model);
+        const forms = await Model.findMany({
+            select: {
+                created: true,
+                order: true
+            },
+            limit: 2,
+            orderBy: [{ created: 'asc' }]
+        });
+        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.findMany({
+            select: {
+                created: true,
+                order: true
+            },
+            offset: 1,
+            limit: 1
+        });
+        expect(forms.length).toBe(1);
+    });
+    it('where() should filter the data', async () => {
+        await insertTestData(Model);
+        const forms = await Model.findMany({
+            where: {
+                nestedTest: {
+                    c: {
+                        greaterOrEqualThan: 3
+                    }
+                }
+            }
+        });
+        expect(forms.length > 0).toBe(true);
+        forms.forEach(form => {
+            expect(form.nestedTest.c >= 3).toBe(true);
+        });
+    });
+    it('andWhere() should filter the data', async () => {
+        const forms = await Model.findMany({
+            where: {
+                AND: [
+                    {
+                        nestedTest: {
+                            c: {
+                                greaterOrEqualThan: 3
+                            }
+                        }
+                    },
+                    {
+                        order: 2
+                    }
+                ]
+            },
+            limit: 1
+        });
+        expect(forms.length).toBe(1);
+        expect(forms[0].nestedTest.c >= 3).toBe(true);
+        expect(forms[0].order).toBe(2);
+    });
+    it('orWhere() should filter the data', async () => {
+        const forms = await Model.findMany({
+            where: {
+                OR: [
+                    {
+                        nestedTest: {
+                            c: {
+                                greaterOrEqualThan: 5
+                            }
+                        }
+                    },
+                    {
+                        order: 2
+                    }
+                ]
+            },
+            limit: 1
+        });
+        expect(forms.length).toBe(1);
+        expect(forms[0].order).toBe(2);
+    });
     it('orderBy() should order results desc', async () => {
         await insertTestData(Model);
-        const forms = await Model.select(keys => [keys.test, keys.nestedTest.b.c, keys.order])
-            .orderBy(keys => keys.order, 'desc')
-            .get();
+        const forms = await Model.findMany({
+            select: {
+                test: true,
+                order: true,
+                nestedTest: {
+                    a: true,
+                    b: {
+                        c: true
+                    }
+                }
+            },
+            orderBy: [
+                {
+                    order: 'desc'
+                }
+            ]
+        });
         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(keys => [keys.test, keys.nestedTest.b.c, keys.order])
-            .orderBy(keys => keys.order, 'asc')
-            .get();
+        const forms = await Model.findMany({
+            select: {
+                test: true,
+                order: true,
+                nestedTest: {
+                    a: true,
+                    b: {
+                        c: true
+                    }
+                }
+            },
+            orderBy: [
+                {
+                    order: 'asc'
+                }
+            ]
+        });
         expect(forms[0].order).toBe(1);
     });
     it('orderBy() should order by Dates with Select()', async () => {
         await insertTestData(Model);
-        const forms = await Model.select(keys => [keys.created, keys.order])
-            .orderBy(keys => keys.created, 'asc', 'date')
-            .get();
+        const forms = await Model.findMany({
+            select: {
+                created: true,
+                order: true
+            },
+            orderBy: [
+                {
+                    created: 'asc'
+                }
+            ]
+        });
         expect(forms[0].order).toBe(3);
     });
     it('orderBy() should order by Dates without Select()', async () => {
         await insertTestData(Model);
-        const forms = await Model.orderBy(keys => keys.created, 'asc', 'date').get();
+        const forms = await Model.findMany({
+            orderBy: [
+                {
+                    created: 'asc'
+                }
+            ]
+        });
         expect(forms[0].order).toBe(3);
     });
-    it('limit() should limit the amount of results', async () => {
-        await insertTestData(Model);
-        const forms = await Model.select(keys => [keys.created, keys.order])
-            .orderBy(keys => keys.created, 'asc', 'date')
-            .limit(2)
-            .get();
-        console.log('FOOORMS LENGTH', forms[0]);
-        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(keys => [keys.created, keys.order])
-            .offset(1)
-            .limit(1)
-            .get();
-        expect(forms.length).toBe(1);
-    });
-    it('where() should filter the data', async () => {
+    it('Should get paginated data', async () => {
         await insertTestData(Model);
-        const forms = await Model.where(keys => keys.nestedTest.c, '>=', 3).get();
-        expect(forms.length > 0).toBe(true);
-        forms.forEach(form => {
-            expect(form.nestedTest.c >= 3).toBe(true);
+        const result = await Model.findMany({
+            paginated: {
+                page: 3,
+                perPage: 5
+            }
         });
-    });
-    it('first() should take the first result from data', async () => {
-        await insertTestData(Model);
-        const form = await Model.select(keys => [keys.nestedTest.c, keys.id])
-            .where(keys => keys.nestedTest.c, '>=', 3)
-            .first();
-        expect(typeof form.nestedTest.c).toBe('number');
+        expect(Array.isArray(result.data)).toBe(true);
+        expect(result.data.length > 0).toBe(true);
+        expect(isNaN(result.total)).toBe(false);
+        expect(isNaN(result.perPage)).toBe(false);
+        expect(isNaN(result.currentPage)).toBe(false);
+        expect(isNaN(result.nextPage)).toBe(false);
+        expect(isNaN(result.firstPage)).toBe(false);
+        expect(isNaN(result.lastPage)).toBe(false);
+        expect(isNaN(result.prevPage)).toBe(false);
+        expect(isNaN(result.from)).toBe(false);
+        expect(isNaN(result.to)).toBe(false);
     });
 };
 exports.advancedTestSuite = advancedTestSuite;

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

@@ -1,16 +1,116 @@
+import { z } from 'zod';
 export declare class FurtherNested {
     c: boolean;
-    d: number[];
+    d: string[];
 }
 export declare class Nested {
-    a: number[];
+    a: string[];
     c: number;
     b?: FurtherNested;
 }
 export declare class TypeORMDataModel {
     id: string;
     created?: string;
-    nestedTest?: Nested;
+    nestedTest?: Nested | undefined;
     order?: number;
     test: boolean;
 }
+export declare const FurtherNestedSchema: z.ZodObject<{
+    c: z.ZodBoolean;
+    d: z.ZodArray<z.ZodString, "many">;
+}, "strip", z.ZodTypeAny, {
+    c: boolean;
+    d: string[];
+}, {
+    c: boolean;
+    d: string[];
+}>;
+export declare const NestedSchema: z.ZodObject<{
+    a: z.ZodArray<z.ZodString, "many">;
+    c: z.ZodNumber;
+    b: z.ZodOptional<z.ZodObject<{
+        c: z.ZodBoolean;
+        d: z.ZodArray<z.ZodString, "many">;
+    }, "strip", z.ZodTypeAny, {
+        c: boolean;
+        d: string[];
+    }, {
+        c: boolean;
+        d: string[];
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    b?: {
+        c: boolean;
+        d: string[];
+    } | undefined;
+    a: string[];
+    c: number;
+}, {
+    b?: {
+        c: boolean;
+        d: string[];
+    } | undefined;
+    a: string[];
+    c: number;
+}>;
+export declare const TypeORMDataModelSchema: z.ZodObject<{
+    id: z.ZodOptional<z.ZodString>;
+    created: z.ZodOptional<z.ZodString>;
+    order: z.ZodOptional<z.ZodNumber>;
+    nestedTest: z.ZodOptional<z.ZodObject<{
+        a: z.ZodArray<z.ZodString, "many">;
+        c: z.ZodNumber;
+        b: z.ZodOptional<z.ZodObject<{
+            c: z.ZodBoolean;
+            d: z.ZodArray<z.ZodString, "many">;
+        }, "strip", z.ZodTypeAny, {
+            c: boolean;
+            d: string[];
+        }, {
+            c: boolean;
+            d: string[];
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        b?: {
+            c: boolean;
+            d: string[];
+        } | undefined;
+        a: string[];
+        c: number;
+    }, {
+        b?: {
+            c: boolean;
+            d: string[];
+        } | undefined;
+        a: string[];
+        c: number;
+    }>>;
+    test: z.ZodBoolean;
+}, "strip", z.ZodTypeAny, {
+    id?: string | undefined;
+    order?: number | undefined;
+    created?: string | undefined;
+    nestedTest?: {
+        b?: {
+            c: boolean;
+            d: string[];
+        } | undefined;
+        a: string[];
+        c: number;
+    } | undefined;
+    test: boolean;
+}, {
+    id?: string | undefined;
+    order?: number | undefined;
+    created?: string | undefined;
+    nestedTest?: {
+        b?: {
+            c: boolean;
+            d: string[];
+        } | undefined;
+        a: string[];
+        c: number;
+    } | undefined;
+    test: boolean;
+}>;
+export declare type TypeORMDataModelInputSchema = z.output<typeof TypeORMDataModelSchema>;

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

@@ -1,57 +1,74 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TypeORMDataModel = exports.Nested = exports.FurtherNested = void 0;
+exports.TypeORMDataModelSchema = exports.NestedSchema = exports.FurtherNestedSchema = exports.TypeORMDataModel = exports.Nested = exports.FurtherNested = void 0;
 const tslib_1 = require("tslib");
+const zod_1 = require("zod");
 const decorators_1 = require("../../../decorators");
 class FurtherNested {
 }
 tslib_1.__decorate([
-    decorators_1.Decorators.property({ required: true }),
+    decorators_1.f.property({ required: false }),
     tslib_1.__metadata("design:type", Boolean)
 ], FurtherNested.prototype, "c", void 0);
 tslib_1.__decorate([
-    decorators_1.Decorators.array({ required: true }),
+    decorators_1.f.stringArray({ required: true }),
     tslib_1.__metadata("design:type", Array)
 ], FurtherNested.prototype, "d", void 0);
 exports.FurtherNested = FurtherNested;
 class Nested {
 }
 tslib_1.__decorate([
-    decorators_1.Decorators.array({ required: true }),
+    decorators_1.f.stringArray({ required: true }),
     tslib_1.__metadata("design:type", Array)
 ], Nested.prototype, "a", void 0);
 tslib_1.__decorate([
-    decorators_1.Decorators.property({ required: true }),
+    decorators_1.f.property({ required: false }),
     tslib_1.__metadata("design:type", Number)
 ], Nested.prototype, "c", void 0);
 tslib_1.__decorate([
-    decorators_1.Decorators.embed(FurtherNested),
+    decorators_1.f.embed(FurtherNested),
     tslib_1.__metadata("design:type", FurtherNested)
 ], Nested.prototype, "b", void 0);
 exports.Nested = Nested;
 let TypeORMDataModel = class TypeORMDataModel {
 };
 tslib_1.__decorate([
-    decorators_1.Decorators.id(),
+    decorators_1.f.id(),
     tslib_1.__metadata("design:type", String)
 ], TypeORMDataModel.prototype, "id", void 0);
 tslib_1.__decorate([
-    decorators_1.Decorators.property({ required: false }),
+    decorators_1.f.property({ required: false }),
     tslib_1.__metadata("design:type", String)
 ], TypeORMDataModel.prototype, "created", void 0);
 tslib_1.__decorate([
-    decorators_1.Decorators.embed(Nested),
-    tslib_1.__metadata("design:type", Nested)
+    decorators_1.f.embed(Nested),
+    tslib_1.__metadata("design:type", Object)
 ], TypeORMDataModel.prototype, "nestedTest", void 0);
 tslib_1.__decorate([
-    decorators_1.Decorators.property({ required: false }),
+    decorators_1.f.property({ required: false }),
     tslib_1.__metadata("design:type", Number)
 ], TypeORMDataModel.prototype, "order", void 0);
 tslib_1.__decorate([
-    decorators_1.Decorators.property({ required: true }),
+    decorators_1.f.property({ required: true }),
     tslib_1.__metadata("design:type", Boolean)
 ], TypeORMDataModel.prototype, "test", void 0);
 TypeORMDataModel = tslib_1.__decorate([
-    decorators_1.Decorators.entity('numbers')
+    decorators_1.f.entity('numbers')
 ], TypeORMDataModel);
 exports.TypeORMDataModel = TypeORMDataModel;
+exports.FurtherNestedSchema = zod_1.z.object({
+    c: zod_1.z.boolean(),
+    d: zod_1.z.string().array()
+});
+exports.NestedSchema = zod_1.z.object({
+    a: zod_1.z.string().array(),
+    c: zod_1.z.number(),
+    b: exports.FurtherNestedSchema.optional()
+});
+exports.TypeORMDataModelSchema = zod_1.z.object({
+    id: zod_1.z.string().optional(),
+    created: zod_1.z.string().optional(),
+    order: zod_1.z.number().optional(),
+    nestedTest: exports.NestedSchema.optional(),
+    test: zod_1.z.boolean()
+});

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

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

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

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TypeOrmRepository = void 0;
+const typeOrm_entity_1 = require("./typeOrm.entity");
+const TypeOrmConnector_1 = require("../../TypeOrmConnector");
+const mongoDatasource_1 = require("../mongo/mongoDatasource");
+class TypeOrmRepository extends TypeOrmConnector_1.TypeOrmConnector {
+    constructor() {
+        super({
+            entity: typeOrm_entity_1.TypeORMDataModel,
+            dataSource: mongoDatasource_1.MongoDataSource,
+            inputSchema: typeOrm_entity_1.TypeORMDataModelSchema,
+            outputSchema: typeOrm_entity_1.TypeORMDataModelSchema
+        });
+    }
+}
+exports.TypeOrmRepository = TypeOrmRepository;

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

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

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

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TypeOrmRepository = void 0;
+const typeOrm_entity_1 = require("./typeOrm.entity");
+const TypeOrmConnector_1 = require("../../TypeOrmConnector");
+const mysqlDataSource_1 = require("../mysql/mysqlDataSource");
+class TypeOrmRepository extends TypeOrmConnector_1.TypeOrmConnector {
+    constructor() {
+        super({
+            entity: typeOrm_entity_1.TypeORMDataModel,
+            dataSource: mysqlDataSource_1.MYSQLDataSource,
+            inputSchema: typeOrm_entity_1.TypeORMDataModelSchema,
+            outputSchema: typeOrm_entity_1.TypeORMDataModelSchema
+        });
+    }
+}
+exports.TypeOrmRepository = TypeOrmRepository;

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

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

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

@@ -3,10 +3,15 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.TypeOrmRepository = void 0;
 const typeOrm_entity_1 = require("./typeOrm.entity");
 const TypeOrmConnector_1 = require("../../TypeOrmConnector");
-const memoryDataSource_1 = require("../memoryDataSource");
+const memoryDataSource_1 = require("../sqlite/memoryDataSource");
 class TypeOrmRepository extends TypeOrmConnector_1.TypeOrmConnector {
-    constructor(relations) {
-        super(typeOrm_entity_1.TypeORMDataModel, memoryDataSource_1.MemoryDataSource, relations);
+    constructor() {
+        super({
+            entity: typeOrm_entity_1.TypeORMDataModel,
+            dataSource: memoryDataSource_1.MemoryDataSource,
+            inputSchema: typeOrm_entity_1.TypeORMDataModelSchema,
+            outputSchema: typeOrm_entity_1.TypeORMDataModelSchema
+        });
     }
 }
 exports.TypeOrmRepository = TypeOrmRepository;

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

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

package/dist/TypeOrmConnector/test/basic/basicTestSuite.js

@@ -2,30 +2,55 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.basicTestSuite = void 0;
 const flock_1 = require("../flock");
-const basicTestSuite = Model => {
+const basicTestSuite = Repository => {
     let storedId;
     beforeAll(() => {
-        Model = new Model();
-    });
-    test('Get - Should  GET data', async () => {
-        const storedGoats = await Model.get();
-        expect(Array.isArray(storedGoats)).toBe(true);
+        Repository = new Repository();
     });
     test('Insert - Should  insert data', async () => {
-        const a = await Model.insert({ name: 'myGoat', age: 13 });
+        const a = await Repository.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);
+        const insertedFlock = await Repository.insertMany(flock_1.flock);
         expect(insertedFlock[0].name).toBe('Goatee');
         storedId = insertedFlock[0].id;
     });
+    test('findMany - Should  GET data', async () => {
+        await Repository.insertMany(flock_1.flock);
+        const storedGoats = await Repository.findMany();
+        expect(Array.isArray(storedGoats)).toBe(true);
+        expect(typeof storedGoats[0].id).toBe('string');
+    });
+    test('findMany - Should  FILTER data', async () => {
+        await Repository.insertMany(flock_1.flock);
+        const storedGoats = await Repository.findMany({
+            where: {
+                name: 'Goatee'
+            }
+        });
+        expect(Array.isArray(storedGoats)).toBe(true);
+        for (const goat of storedGoats) {
+            expect(goat.name).toBe('Goatee');
+        }
+        expect(typeof storedGoats[0].id).toBe('string');
+    });
+    test('findMany - Should  FILTER not existing data', async () => {
+        await Repository.insertMany(flock_1.flock);
+        const storedGoats = await Repository.findMany({
+            where: {
+                name: 'SOMENOTEXISTINGGOAT'
+            }
+        });
+        expect(Array.isArray(storedGoats)).toBe(true);
+        expect(storedGoats.length).toBe(0);
+    });
     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, {
+        await Repository.insertMany(flock_1.flock);
+        const goats = await Repository.findMany();
+        const data = await Repository.updateById(goats[0].id, {
             age: 99,
             name: 'MyUpdatedGoat'
         });
@@ -33,12 +58,13 @@ const basicTestSuite = Model => {
         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'
+        await Repository.insertMany(flock_1.flock);
+        const goats = await Repository.findMany();
+        const data = await Repository.replaceById(goats[0].id, {
+            age: 2,
+            name: 'MyReplacedGoat'
         });
-        expect(data.name).toBe('MyUpdatedGoat');
+        expect(data.name).toBe('MyReplacedGoat');
         expect(data.id).toBe(goats[0].id);
     });
 };