@goatlab/fluent 0.7.21 → 0.7.24

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

@@ -0,0 +1,193 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.basicTestSuite = void 0;
+const js_utils_1 = require("@goatlab/js-utils");
+const flock_1 = require("../flock");
+const basicTestSuite = Repo => {
+    let storedId;
+    let Repository;
+    beforeAll(() => {
+        Repository = new Repo();
+    });
+    test('insert - Should  insert data', async () => {
+        const a = await Repository.insert({ name: 'myGoat', age: 13 });
+        expect(typeof a.id).toBe('string');
+        expect(a.name).toBe('myGoat');
+        expect(0).toBe(0);
+    });
+    test('insert - Should  insert data with customId', async () => {
+        const a = await Repository.insert({
+            id: '631ce4304f9183f61ffb613a',
+            name: 'myGoat',
+            age: 13
+        });
+        expect(typeof a.id).toBe('string');
+        expect(a.id).toBe('631ce4304f9183f61ffb613a');
+    });
+    it('insertMany - Should insert Multiple elements', async () => {
+        const insertedFlock = await Repository.insertMany(flock_1.flock);
+        expect(insertedFlock[0].name).toBe('Goatee');
+        storedId = insertedFlock[0].id;
+    });
+    test('findById - Should  GET an object by its ID', async () => {
+        const goats = await Repository.insertMany(flock_1.flock);
+        const goat = await Repository.findById(goats[0].id);
+        expect(goat?.id).toBe(goats[0].id);
+        expect(typeof goat?.id).toBe('string');
+        const anotherGoat = await Repository.findById('507f1f77bcf86cd799439011');
+        expect(anotherGoat).toBe(null);
+    });
+    test('findById - Should  GET selected Data', async () => {
+        const goats = await Repository.insertMany(flock_1.flock);
+        const goat = await Repository.findById(goats[0].id, {
+            select: {
+                age: true
+            }
+        });
+        expect(goat).not.toHaveProperty('name');
+        expect(goat?.age).toBe(goats[0].age);
+    });
+    test('findByIds - Should  GET data', async () => {
+        const goats = await Repository.insertMany(flock_1.flock);
+        const ids = [goats[0].id, goats[1].id];
+        const selectedGoats = await Repository.findByIds(ids);
+        expect(selectedGoats.length).toBe(2);
+        expect(selectedGoats[0].id === ids[0] || selectedGoats[1].id === ids[0]).toBe(true);
+    });
+    test('findByIds - Should  GET selectedData', async () => {
+        const goats = await Repository.insertMany(flock_1.flock);
+        const ids = [goats[0].id, goats[1].id];
+        const ages = [goats[0].age, goats[1].age];
+        const selectedGoats = await Repository.findByIds(ids, {
+            select: {
+                age: true
+            }
+        });
+        expect(selectedGoats.length).toBe(2);
+        expect(selectedGoats[0].age === ages[0] || selectedGoats[1].age === ages[0]).toBe(true);
+        expect(selectedGoats[0]).not.toHaveProperty('name');
+    });
+    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);
+    });
+    test('findMany - Should  SELECT attributes', async () => {
+        await Repository.insertMany(flock_1.flock);
+        const storedGoats = await Repository.findMany({
+            where: {
+                name: 'Goatee'
+            },
+            select: {
+                age: true
+            }
+        });
+        expect(Array.isArray(storedGoats)).toBe(true);
+        expect(storedGoats.length > 0).toBe(true);
+        expect(storedGoats[0]).not.toHaveProperty('name');
+    });
+    test('findFirst - Should  get only 1 object back', async () => {
+        await Repository.insertMany(flock_1.flock);
+        const storedGoats = await Repository.findFirst({
+            where: {
+                name: 'Goatee'
+            }
+        });
+        expect(Array.isArray(storedGoats)).toBe(false);
+        expect(typeof storedGoats.id).toBe('string');
+    });
+    test('findFirst - Should  FILTER AND SELECT DATA', async () => {
+        await Repository.insertMany(flock_1.flock);
+        const storedGoats = await Repository.findFirst({
+            where: {
+                name: 'Goatee'
+            },
+            select: {
+                name: true,
+                age: true,
+            }
+        });
+        expect(Array.isArray(storedGoats)).toBe(false);
+        expect(storedGoats.name).toBe('Goatee');
+        expect(storedGoats).not.toHaveProperty('id');
+    });
+    test('requireFirst - Should fail if not found', async () => {
+        const insertedUser = await Repository.insert({
+            name: 'testGoat',
+            age: 20
+        });
+        const [error] = await js_utils_1.Promises.try(Repository.requireFirst({
+            where: {
+                name: 'noneExistingGoat'
+            }
+        }));
+        expect(error?.message).toBe('No objects found matching:  {"where":{"name":"noneExistingGoat"}}');
+    });
+    test('requireFirst - Should find first item', async () => {
+        const insertedUser = await Repository.insert({
+            name: 'testGoat',
+            age: 20
+        });
+        const [error, goat] = await js_utils_1.Promises.try(Repository.requireFirst({
+            where: {
+                name: 'testGoat'
+            }
+        }));
+        expect(error).toBe(null);
+        expect(goat.name).toBe(insertedUser.name);
+    });
+    it('UpdateById - Should Update a single element', async () => {
+        await Repository.insertMany(flock_1.flock);
+        const goats = await Repository.findMany();
+        const data = await Repository.updateById(goats[0].id, {
+            age: 99,
+            name: 'MyUpdatedGoat'
+        });
+        expect(data.name).toBe('MyUpdatedGoat');
+        expect(data.id).toBe(goats[0].id);
+    });
+    it('ReplaceById - Should Update a single element', async () => {
+        await 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('MyReplacedGoat');
+        expect(data.id).toBe(goats[0].id);
+    });
+    it('deleteById - Should delete an item', async () => {
+        await Repository.insertMany(flock_1.flock);
+        const goats = await Repository.findMany();
+        const foundGoat = await Repository.requireById(goats[0].id);
+        expect(foundGoat.id).toBe(goats[0].id);
+        await Repository.deleteById(foundGoat.id);
+        const [error] = await js_utils_1.Promises.try(Repository.requireById(goats[0].id));
+        expect(error?.message).toBe(`Object ${goats[0].id} not found`);
+    });
+};
+exports.basicTestSuite = basicTestSuite;

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

@@ -0,0 +1,53 @@
+import { z } from 'zod';
+export declare class Breed {
+    family?: string;
+    members?: number;
+}
+export declare class GoatEntity {
+    id: string;
+    name: string;
+    age?: number;
+    breed?: Breed;
+}
+export declare const BreedSchema: z.ZodObject<{
+    family: z.ZodString;
+    members: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    family: string;
+    members: number;
+}, {
+    family: string;
+    members: number;
+}>;
+export declare const GoatSchema: z.ZodObject<{
+    id: z.ZodOptional<z.ZodString>;
+    name: z.ZodOptional<z.ZodString>;
+    age: z.ZodNumber;
+    breed: z.ZodOptional<z.ZodObject<{
+        family: z.ZodString;
+        members: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        family: string;
+        members: number;
+    }, {
+        family: string;
+        members: number;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    id?: string | undefined;
+    name?: string | undefined;
+    breed?: {
+        family: string;
+        members: number;
+    } | undefined;
+    age: number;
+}, {
+    id?: string | undefined;
+    name?: string | undefined;
+    breed?: {
+        family: string;
+        members: number;
+    } | undefined;
+    age: number;
+}>;
+export declare type GoatInputSchema = z.infer<typeof GoatSchema>;

package/dist/TypeOrmConnector/test/basic/goat.entity.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GoatSchema = exports.BreedSchema = exports.GoatEntity = exports.Breed = void 0;
+const tslib_1 = require("tslib");
+const types_1 = require("../../../core/types");
+const decorators_1 = require("../../../decorators");
+const zod_1 = require("zod");
+let Breed = class Breed {
+};
+tslib_1.__decorate([
+    decorators_1.f.property({ required: false }),
+    tslib_1.__metadata("design:type", String)
+], Breed.prototype, "family", void 0);
+tslib_1.__decorate([
+    decorators_1.f.property({ required: false }),
+    tslib_1.__metadata("design:type", Number)
+], Breed.prototype, "members", void 0);
+Breed = tslib_1.__decorate([
+    (0, types_1.ObjectType)()
+], Breed);
+exports.Breed = Breed;
+let GoatEntity = class GoatEntity {
+};
+tslib_1.__decorate([
+    decorators_1.f.id(),
+    tslib_1.__metadata("design:type", String)
+], GoatEntity.prototype, "id", void 0);
+tslib_1.__decorate([
+    decorators_1.f.property({ required: true }),
+    tslib_1.__metadata("design:type", String)
+], GoatEntity.prototype, "name", void 0);
+tslib_1.__decorate([
+    decorators_1.f.property({ required: false }),
+    tslib_1.__metadata("design:type", Number)
+], GoatEntity.prototype, "age", void 0);
+tslib_1.__decorate([
+    decorators_1.f.embed(Breed),
+    tslib_1.__metadata("design:type", Breed)
+], GoatEntity.prototype, "breed", void 0);
+GoatEntity = tslib_1.__decorate([
+    decorators_1.f.entity('goat')
+], GoatEntity);
+exports.GoatEntity = GoatEntity;
+exports.BreedSchema = zod_1.z.object({
+    family: zod_1.z.string(),
+    members: zod_1.z.number()
+});
+exports.GoatSchema = zod_1.z.object({
+    id: zod_1.z.string().optional(),
+    name: zod_1.z.string().optional(),
+    age: zod_1.z.number(),
+    breed: exports.BreedSchema.optional()
+});

package/dist/TypeOrmConnector/test/basic/goat.mongo.repository.d.ts

@@ -0,0 +1,5 @@
+import { GoatInputSchema, GoatEntity } from './goat.entity';
+import { TypeOrmConnector } from '../../TypeOrmConnector';
+export declare class GoatRepository extends TypeOrmConnector<GoatEntity, GoatInputSchema> {
+    constructor();
+}

package/dist/TypeOrmConnector/test/basic/goat.mongo.repository.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GoatRepository = void 0;
+const goat_entity_1 = require("./goat.entity");
+const TypeOrmConnector_1 = require("../../TypeOrmConnector");
+const mongoDatasource_1 = require("../mongo/mongoDatasource");
+class GoatRepository extends TypeOrmConnector_1.TypeOrmConnector {
+    constructor() {
+        super({
+            entity: goat_entity_1.GoatEntity,
+            dataSource: mongoDatasource_1.MongoDataSource,
+            inputSchema: goat_entity_1.GoatSchema
+        });
+    }
+}
+exports.GoatRepository = GoatRepository;

package/dist/TypeOrmConnector/test/basic/goat.mysql.repository.d.ts

@@ -0,0 +1,5 @@
+import { GoatEntity, GoatInputSchema } from './goat.entity';
+import { TypeOrmConnector } from '../../TypeOrmConnector';
+export declare class GoatRepository extends TypeOrmConnector<GoatEntity, GoatInputSchema> {
+    constructor();
+}

package/dist/TypeOrmConnector/test/basic/goat.mysql.repository.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GoatRepository = void 0;
+const goat_entity_1 = require("./goat.entity");
+const TypeOrmConnector_1 = require("../../TypeOrmConnector");
+const mysqlDataSource_1 = require("../mysql/mysqlDataSource");
+class GoatRepository extends TypeOrmConnector_1.TypeOrmConnector {
+    constructor() {
+        super({
+            entity: goat_entity_1.GoatEntity,
+            dataSource: mysqlDataSource_1.MYSQLDataSource,
+            inputSchema: goat_entity_1.GoatSchema
+        });
+    }
+}
+exports.GoatRepository = GoatRepository;

package/dist/TypeOrmConnector/test/basic/goat.repository.d.ts

@@ -0,0 +1,5 @@
+import { GoatEntity, GoatInputSchema } from './goat.entity';
+import { TypeOrmConnector } from '../../TypeOrmConnector';
+export declare class GoatRepository extends TypeOrmConnector<GoatEntity, GoatInputSchema> {
+    constructor();
+}

package/dist/TypeOrmConnector/test/basic/goat.repository.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GoatRepository = void 0;
+const goat_entity_1 = require("./goat.entity");
+const TypeOrmConnector_1 = require("../../TypeOrmConnector");
+const memoryDataSource_1 = require("../sqlite/memoryDataSource");
+class GoatRepository extends TypeOrmConnector_1.TypeOrmConnector {
+    constructor() {
+        super({
+            entity: goat_entity_1.GoatEntity,
+            dataSource: memoryDataSource_1.MemoryDataSource,
+            inputSchema: goat_entity_1.GoatSchema
+        });
+    }
+}
+exports.GoatRepository = GoatRepository;

package/dist/TypeOrmConnector/test/dbEntities.d.ts

@@ -0,0 +1,6 @@
+import { TypeORMDataModel } from './advanced/typeOrm.entity';
+import { GoatEntity } from './basic/goat.entity';
+import { CarsEntity } from './relations/car/car.entity';
+import { RoleEntity } from './relations/roles/roles.entity';
+import { RolesUser } from './relations/roles/roles_user.entity';
+export declare const dbEntities: (typeof TypeORMDataModel | typeof GoatEntity | typeof RoleEntity | typeof CarsEntity | typeof RolesUser)[];

package/dist/TypeOrmConnector/test/dbEntities.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dbEntities = void 0;
+const typeOrm_entity_1 = require("./advanced/typeOrm.entity");
+const goat_entity_1 = require("./basic/goat.entity");
+const car_entity_1 = require("./relations/car/car.entity");
+const roles_entity_1 = require("./relations/roles/roles.entity");
+const roles_user_entity_1 = require("./relations/roles/roles_user.entity");
+const user_entity_1 = require("./relations/user/user.entity");
+exports.dbEntities = [
+    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
+];

package/dist/TypeOrmConnector/test/docker/docker.d.ts

@@ -0,0 +1,35 @@
+export declare const detectPort: (defaultPort: number) => Promise<number>;
+export interface Options {
+    debug: boolean;
+    image: string;
+    containerName: string;
+    defaultExternalPort: number;
+    externalPort?: number;
+    internalPort: number;
+    connectTimeoutSeconds: number;
+    environment?: {
+        [key: string]: string;
+    };
+    command?: string[];
+    cap_add?: 'SYS_NICE' | 'IPC_LOCK';
+    refreshImage?: boolean;
+    detached?: boolean;
+    enableDebugInstructions?: string;
+    testConnection?: (opts: NormalizedOptions & {
+        testPortConnection: () => Promise<boolean>;
+    }) => Promise<boolean>;
+}
+export interface NormalizedOptions extends Pick<Options, Exclude<keyof Options, 'defaultExternalPort'>> {
+    detached: boolean;
+    externalPort: number;
+}
+export declare function imageExists(options: NormalizedOptions | Options): Promise<boolean>;
+export declare function pullDockerImage(options: NormalizedOptions | Options): Promise<void>;
+export declare function startDockerContainer(options: NormalizedOptions): any;
+export declare function waitForDatabaseToStart(options: NormalizedOptions): Promise<void>;
+export declare function killOldContainers(options: Pick<NormalizedOptions, 'debug' | 'containerName'>): Promise<void>;
+export default function startContainer(options: Options): Promise<{
+    proc: any;
+    externalPort: number;
+    kill: () => Promise<void>;
+}>;

package/dist/TypeOrmConnector/test/docker/docker.js

@@ -0,0 +1,148 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.killOldContainers = exports.waitForDatabaseToStart = exports.startDockerContainer = exports.pullDockerImage = exports.imageExists = exports.detectPort = void 0;
+const net_1 = require("net");
+const spawn = require("cross-spawn");
+const modern_spawn_1 = require("modern-spawn");
+exports.detectPort = require('detect-port');
+async function imageExists(options) {
+    const stdout = await (0, modern_spawn_1.spawnBuffered)('docker', ['images', '--format', '{{json .}}'], {
+        debug: options.debug
+    }).getResult('utf8');
+    const existingImages = stdout
+        .trim()
+        .split('\n')
+        .map(str => {
+        try {
+            return JSON.parse(str);
+        }
+        catch (ex) {
+            console.log('Unable to parse: ' + str);
+            return null;
+        }
+    })
+        .filter(n => n != null);
+    const [Repository, Tag] = options.image.split(':');
+    return existingImages.some(i => i.Repository === Repository && (!Tag || i.Tag === Tag));
+}
+exports.imageExists = imageExists;
+async function pullDockerImage(options) {
+    if (!options.refreshImage &&
+        /.+\:.+/.test(options.image) &&
+        (await imageExists(options))) {
+        console.log(options.image +
+            ' already pulled (use mysql-test start --refresh or ops.refreshImage to refresh)');
+        return;
+    }
+    console.log('Pulling Docker Image ' + options.image);
+    await (0, modern_spawn_1.spawnBuffered)('docker', ['pull', options.image], {
+        debug: options.debug
+    }).getResult();
+}
+exports.pullDockerImage = pullDockerImage;
+function startDockerContainer(options) {
+    const env = options.environment || {};
+    const envArgs = [];
+    Object.keys(env).forEach(key => {
+        envArgs.push('--env');
+        envArgs.push(`${key}=${env[key]}`);
+    });
+    return spawn('docker', [
+        'run',
+        '--name',
+        options.containerName,
+        '-t',
+        '--rm',
+        '-p',
+        `${options.externalPort}:${options.internalPort}`,
+        ...(options.detached ? ['--detach'] : []),
+        ...envArgs,
+        options.image
+    ], {
+        stdio: options.debug ? 'inherit' : 'ignore'
+    });
+}
+exports.startDockerContainer = startDockerContainer;
+async function waitForDatabaseToStart(options) {
+    await new Promise((resolve, reject) => {
+        let finished = false;
+        const timeout = setTimeout(() => {
+            finished = true;
+            reject(new Error(`Unable to connect to database after ${options.connectTimeoutSeconds} seconds.${options.enableDebugInstructions
+                ? ` ${options.enableDebugInstructions}`
+                : ``}`));
+        }, options.connectTimeoutSeconds * 1000);
+        function test() {
+            console.log(`Waiting for ${options.containerName} on port ${options.externalPort}...`);
+            (options.testConnection
+                ? options.testConnection({
+                    ...options,
+                    testPortConnection: async () => await testConnection(options)
+                })
+                : testConnection(options)).then(isConnected => {
+                if (finished)
+                    return;
+                if (isConnected) {
+                    finished = true;
+                    clearTimeout(timeout);
+                    setTimeout(resolve, 1000);
+                }
+                else {
+                    setTimeout(test, 500);
+                }
+            }, err => {
+                reject(err);
+            });
+        }
+        test();
+    });
+}
+exports.waitForDatabaseToStart = waitForDatabaseToStart;
+async function testConnection(options) {
+    return new Promise(resolve => {
+        const connection = (0, net_1.connect)(options.externalPort)
+            .on('error', () => {
+            resolve(false);
+        })
+            .on('connect', () => {
+            connection.end();
+            resolve(true);
+        });
+    });
+}
+async function killOldContainers(options) {
+    await (0, modern_spawn_1.spawnBuffered)('docker', ['kill', options.containerName], {
+        debug: options.debug
+    });
+    await (0, modern_spawn_1.spawnBuffered)('docker', ['rm', options.containerName], {
+        debug: options.debug
+    });
+}
+exports.killOldContainers = killOldContainers;
+async function startContainer(options) {
+    if (isNaN(options.connectTimeoutSeconds)) {
+        throw new Error('connectTimeoutSeconds must be a valid integer.');
+    }
+    await Promise.all([pullDockerImage(options), killOldContainers(options)]);
+    const { defaultExternalPort, ...rawOptions } = options;
+    const externalPort = rawOptions.externalPort || (await (0, exports.detectPort)(defaultExternalPort));
+    if (typeof externalPort !== 'number') {
+        throw new Error('Expected external port to be a number');
+    }
+    const opts = {
+        detached: false,
+        ...rawOptions,
+        externalPort
+    };
+    console.log('Starting Docker Container ' + opts.containerName);
+    const proc = startDockerContainer(opts);
+    await waitForDatabaseToStart(opts);
+    return {
+        proc,
+        externalPort,
+        kill: async () => {
+            return await killOldContainers(options);
+        }
+    };
+}
+exports.default = startContainer;

package/dist/TypeOrmConnector/test/docker/mongo.d.ts

@@ -0,0 +1,16 @@
+import { Options as WithContainerOptions } from './docker';
+export interface Options extends Omit<WithContainerOptions, 'internalPort' | 'enableDebugInstructions' | 'testConnection'> {
+    mongoUser: string;
+    mongoPassword: string;
+    mongoDb: string;
+}
+export declare function waitForConnection(databaseURL: string, timeoutSeconds: number): Promise<void>;
+export default function getDatabase(options?: Partial<Options>): Promise<{
+    proc: any;
+    databaseURL: string;
+    kill: () => Promise<void>;
+    user: string;
+    password: string;
+    port: number;
+    dbName: string;
+}>;