@goatlab/fluent 0.7.21 → 0.7.24

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

@@ -0,0 +1,256 @@
+"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('findFirst() should take the first result from data', async () => {
+        await insertTestData(Model);
+        const form = await Model.findFirst({
+            select: {
+                id: true,
+                test: true,
+                nestedTest: {
+                    c: true,
+                    a: 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.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({ 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: {
+                id: true,
+                test: true,
+                nestedTest: {
+                    c: true,
+                    a: true
+                },
+                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: {
+                id: true,
+                test: true,
+                nestedTest: {
+                    c: true,
+                    a: 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.findMany({
+            select: {
+                id: true,
+                test: true,
+                order: true,
+                nestedTest: {
+                    c: true,
+                    a: true,
+                    b: {
+                        c: true,
+                        d: 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.findMany({
+            select: {
+                id: true,
+                test: true,
+                order: true,
+                nestedTest: {
+                    c: true,
+                    a: true,
+                    b: {
+                        c: true,
+                        d: 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.findMany({
+            select: {
+                id: true,
+                test: true,
+                order: true,
+                nestedTest: {
+                    c: true,
+                    a: true,
+                    b: {
+                        c: true,
+                        d: 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.findMany({
+            orderBy: [
+                {
+                    created: 'asc'
+                }
+            ]
+        });
+        expect(forms[0].order).toBe(3);
+    });
+};
+exports.advancedTestSuite = advancedTestSuite;

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

@@ -0,0 +1,116 @@
+import { z } from 'zod';
+export declare class FurtherNested {
+    c: boolean;
+    d: string[];
+}
+export declare class Nested {
+    a: string[];
+    c: number;
+    b?: FurtherNested;
+}
+export declare class TypeORMDataModel {
+    id: string;
+    created?: string;
+    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;
+    c: number;
+    a: string[];
+}, {
+    b?: {
+        c: boolean;
+        d: string[];
+    } | undefined;
+    c: number;
+    a: string[];
+}>;
+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;
+        c: number;
+        a: string[];
+    }, {
+        b?: {
+            c: boolean;
+            d: string[];
+        } | undefined;
+        c: number;
+        a: string[];
+    }>>;
+    test: z.ZodBoolean;
+}, "strip", z.ZodTypeAny, {
+    id?: string | undefined;
+    order?: number | undefined;
+    created?: string | undefined;
+    nestedTest?: {
+        b?: {
+            c: boolean;
+            d: string[];
+        } | undefined;
+        c: number;
+        a: string[];
+    } | undefined;
+    test: boolean;
+}, {
+    id?: string | undefined;
+    order?: number | undefined;
+    created?: string | undefined;
+    nestedTest?: {
+        b?: {
+            c: boolean;
+            d: string[];
+        } | undefined;
+        c: number;
+        a: string[];
+    } | undefined;
+    test: boolean;
+}>;
+export declare type TypeORMDataModelInputSchema = z.output<typeof TypeORMDataModelSchema>;

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

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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.f.property({ required: false }),
+    tslib_1.__metadata("design:type", Boolean)
+], FurtherNested.prototype, "c", void 0);
+tslib_1.__decorate([
+    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.f.stringArray({ required: true }),
+    tslib_1.__metadata("design:type", Array)
+], Nested.prototype, "a", void 0);
+tslib_1.__decorate([
+    decorators_1.f.property({ required: false }),
+    tslib_1.__metadata("design:type", Number)
+], Nested.prototype, "c", void 0);
+tslib_1.__decorate([
+    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.f.id(),
+    tslib_1.__metadata("design:type", String)
+], TypeORMDataModel.prototype, "id", void 0);
+tslib_1.__decorate([
+    decorators_1.f.property({ required: false }),
+    tslib_1.__metadata("design:type", String)
+], TypeORMDataModel.prototype, "created", void 0);
+tslib_1.__decorate([
+    decorators_1.f.embed(Nested),
+    tslib_1.__metadata("design:type", Object)
+], TypeORMDataModel.prototype, "nestedTest", void 0);
+tslib_1.__decorate([
+    decorators_1.f.property({ required: false }),
+    tslib_1.__metadata("design:type", Number)
+], TypeORMDataModel.prototype, "order", void 0);
+tslib_1.__decorate([
+    decorators_1.f.property({ required: true }),
+    tslib_1.__metadata("design:type", Boolean)
+], TypeORMDataModel.prototype, "test", void 0);
+TypeORMDataModel = tslib_1.__decorate([
+    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

@@ -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.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 memoryDataSource_1 = require("../sqlite/memoryDataSource");
+class TypeOrmRepository extends TypeOrmConnector_1.TypeOrmConnector {
+    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

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