@goatlab/fluent 0.7.6 → 0.7.9

package/dist/fluent/src/core/Nestjs/types/metadata/union.metadata.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/{index.d.ts → fluent/src/index.d.ts}

@@ -1,22 +1,23 @@
 import { ApiHideProperty, ApiProperty, Column, HideField, InputType, ObjectType, OmitType, PartialType, getModelSchemaRef } from './core/types';
-import type { AnyObject, Deleted, PaginatedData, Paginator, Primitives, PrimitivesArray, FluentQuery, QueryOutput, LoadedResult, FindByIdFilter, SingleQueryOutput } from './types';
+import type { AnyObject, Deleted, PaginatedData, Paginator, Primitives, PrimitivesArray, FluentQuery, QueryOutput, LoadedResult, FindByIdFilter } from './types';
 import { LogicOperator } from './types';
 import { BaseConnector } from './BaseConnector';
 import { Collection } from '@goatlab/js-utils';
 import { f } from './decorators';
 import { Fluent } from './Fluent';
-import type { FluentConnectorInterface } from './BaseConnector';
+import type { FluentConnectorInterface } from './FluentConnectorInterface';
 import type { SchemaObject } from './core/types';
-import { getRelationsFromModelGenerator, TypeOrmConnector } from './TypeOrmConnector/TypeOrmConnector';
+import { TypeOrmConnector } from './TypeOrmConnector/TypeOrmConnector';
 import { getOutputKeys } from './outputKeys';
 import { loadRelations } from './loadRelations';
 import { modelGeneratorDataSource } from './generatorDatasource';
 import { Cache } from './cache';
 import { ValidationError } from 'class-validator';
+import { getRelationsFromModelGenerator } from './TypeOrmConnector/util/getRelationsFromModelGenerator';
 export { DataSource } from 'typeorm';
 export { ApiHideProperty, ApiProperty, BaseConnector, Collection, Column, f, Fluent, getModelSchemaRef, getOutputKeys, HideField, InputType, loadRelations, modelGeneratorDataSource, ObjectType, OmitType, PartialType, TypeOrmConnector, Cache, getRelationsFromModelGenerator, LogicOperator };
 interface ValidatedInput<T> {
     errors: ValidationError[] | null;
     result: Awaited<T>;
 }
-export type { AnyObject, Deleted, FluentConnectorInterface, PaginatedData, Paginator, Primitives, PrimitivesArray, SchemaObject, ValidatedInput, FluentQuery, QueryOutput, LoadedResult, FindByIdFilter, SingleQueryOutput };
+export type { AnyObject, Deleted, FluentConnectorInterface, PaginatedData, Paginator, Primitives, PrimitivesArray, SchemaObject, ValidatedInput, FluentQuery, QueryOutput, LoadedResult, FindByIdFilter };

package/dist/{index.js → fluent/src/index.js}

@@ -22,7 +22,6 @@ Object.defineProperty(exports, "f", { enumerable: true, get: function () { retur
 const Fluent_1 = require("./Fluent");
 Object.defineProperty(exports, "Fluent", { enumerable: true, get: function () { return Fluent_1.Fluent; } });
 const TypeOrmConnector_1 = require("./TypeOrmConnector/TypeOrmConnector");
-Object.defineProperty(exports, "getRelationsFromModelGenerator", { enumerable: true, get: function () { return TypeOrmConnector_1.getRelationsFromModelGenerator; } });
 Object.defineProperty(exports, "TypeOrmConnector", { enumerable: true, get: function () { return TypeOrmConnector_1.TypeOrmConnector; } });
 const outputKeys_1 = require("./outputKeys");
 Object.defineProperty(exports, "getOutputKeys", { enumerable: true, get: function () { return outputKeys_1.getOutputKeys; } });
@@ -32,5 +31,7 @@ const generatorDatasource_1 = require("./generatorDatasource");
 Object.defineProperty(exports, "modelGeneratorDataSource", { enumerable: true, get: function () { return generatorDatasource_1.modelGeneratorDataSource; } });
 const cache_1 = require("./cache");
 Object.defineProperty(exports, "Cache", { enumerable: true, get: function () { return cache_1.Cache; } });
+const getRelationsFromModelGenerator_1 = require("./TypeOrmConnector/util/getRelationsFromModelGenerator");
+Object.defineProperty(exports, "getRelationsFromModelGenerator", { enumerable: true, get: function () { return getRelationsFromModelGenerator_1.getRelationsFromModelGenerator; } });
 var typeorm_1 = require("typeorm");
 Object.defineProperty(exports, "DataSource", { enumerable: true, get: function () { return typeorm_1.DataSource; } });

package/dist/{loadRelations.js → fluent/src/loadRelations.js}

@@ -21,14 +21,13 @@ const loadRelations = async ({ data, relations, modelRelations, provider, self,
             const chunks = js_utils_1.Arrays.chunk(Array.from(ids), chunkSize);
             const promises = [];
             for (const relatedIds of chunks) {
-                const results = await Repository.findMany({
+                promises.push(Repository.findMany({
                     where: {
                         [relationModel.inverseSidePropertyPath]: {
                             in: relatedIds
                         }
                     }
-                });
-                promises.push(results);
+                }));
             }
             const relatedResults = js_utils_1.Arrays.collapse(await Promise.all(promises));
             const grouped = js_utils_1.Arrays.groupBy(relatedResults, r => r[relationModel.inverseSidePropertyPath]);
@@ -45,14 +44,13 @@ const loadRelations = async ({ data, relations, modelRelations, provider, self,
             const chunks = js_utils_1.Arrays.chunk(ids, chunkSize);
             const promises = [];
             for (const relatedIds of chunks) {
-                const results = await Repository.findMany({
+                promises.push(Repository.findMany({
                     where: {
                         id: {
                             in: relatedIds
                         }
                     }
-                });
-                promises.push(results);
+                }));
             }
             const relatedResults = js_utils_1.Arrays.collapse(await Promise.all(promises));
             const grouped = js_utils_1.Arrays.groupBy(relatedResults, r => r.id);
@@ -121,10 +119,10 @@ const loadRelations = async ({ data, relations, modelRelations, provider, self,
                     if (!d[calleeKey]) {
                         d[calleeKey] = [];
                     }
-                    d[calleeKey] = [
-                        ...d[calleeKey],
-                        ...groupedRelated[gp[relationModel.inverseJoinColumns[0].propertyName]]
-                    ];
+                    const mapped = groupedRelated[gp[relationModel.inverseJoinColumns[0].propertyName]];
+                    if (mapped) {
+                        d[calleeKey] = [...d[calleeKey], ...mapped];
+                    }
                 });
             });
             return data;

package/dist/{types.d.ts → fluent/src/types.d.ts}

@@ -1,15 +1,21 @@
 import { ObjectID } from 'bson';
 export interface AnyObject {
-    id?: string;
-    _id?: string;
     [key: string]: any;
 }
 declare type Unpacked<T> = T extends (infer U)[] ? U : T;
+export declare type ExpandRecursively<T> = T extends (...args: infer A) => infer R ? (...args: ExpandRecursively<A>) => ExpandRecursively<R> : T extends object ? T extends infer O ? O extends any[] ? {
+    [K in keyof Unpacked<O>]: ExpandRecursively<Unpacked<O>[K]>;
+}[] : {
+    [K in keyof O]: ExpandRecursively<O[K]>;
+} : never : T;
 export declare type Concrete<Type> = {
     [Property in keyof Type]-?: Type[Property];
 };
+export declare type Subset<T, U> = {
+    [key in keyof T]: key extends keyof U ? T[key] : never;
+};
 export declare type QueryFieldSelector<T> = Partial<{
-    [K in keyof Concrete<T>]: Concrete<T>[K] extends object ? Unpacked<Partial<QueryFieldSelector<Concrete<T>[K]>>> : boolean | undefined;
+    [K in keyof Concrete<T>]: Concrete<T>[K] extends object ? true | Unpacked<Partial<QueryFieldSelector<Concrete<T>[K]>>> : true | undefined;
 }>;
 export declare type QueryOrderSelector<T> = Partial<{
     [K in keyof Concrete<T>]: Concrete<T>[K] extends object ? Partial<QueryOrderSelector<Concrete<T>[K]>> : 'asc' | 'desc' | undefined;
@@ -18,14 +24,16 @@ export declare type QueryOperations<T> = {
     [key in LogicOperator]: key extends LogicOperator.in ? T[] : key extends LogicOperator.notIn ? T[] : T;
 };
 export declare type QueryWhereFitler<T> = Partial<{
-    [K in keyof Concrete<T>]: Concrete<T>[K] extends object ? Partial<QueryWhereFitler<Concrete<T>[K]>> : Partial<QueryOperations<Concrete<T>[K]>> | T[K];
+    [K in keyof Concrete<T>]: Concrete<T>[K] extends object ? Unpacked<Partial<QueryWhereFitler<Concrete<T>[K]>>> : Unpacked<Partial<QueryOperations<Concrete<T>[K]>>> | T[K];
 }>;
 export declare type QueryInsert<T> = {
     [K in keyof T]: T[K] extends object ? QueryInsert<T[K]> : T[K];
 };
 export declare type ModelRelation<T> = T;
 export declare type QueryIncludeRelation<T> = {
-    [K in keyof Partial<T>]: FluentQuery<Unpacked<T[K]>> | boolean;
+    [K in keyof Partial<T>]: (FluentQuery<Unpacked<T[K]>> & {
+        withPivot?: true;
+    }) | true;
 };
 export declare type FluentQuery<T> = {
     select?: QueryFieldSelector<T>;
@@ -36,29 +44,38 @@ export declare type FluentQuery<T> = {
     orderBy?: QueryOrderSelector<T>[];
     limit?: number;
     offset?: number;
+    take?: number;
     include?: QueryIncludeRelation<T>;
     paginated?: Paginator;
 };
 export declare type AddUndefinedIfNullable<T> = T extends null | undefined ? undefined : never;
-export declare type GetSelectedFromObject<T extends FluentQuery<Model>, Model, OutputDTO> = {
-    [P in keyof T['select']]: T['select'][P] extends object ? QueryOutput<{
-        select: T['select'][P];
-    }, NonNullable<Model[P]>, OutputDTO[P]> | AddUndefinedIfNullable<Model[P]> : OutputDTO[P];
+export declare type GetSelectedFromInclude<T extends FluentQuery<Model>, Model> = {
+    [P in keyof T['include']]: T['include'][P] extends object ? NonNullable<Model[P]> extends any[] ? T['include'][P] extends {
+        withPivot: true;
+    } ? (QueryOutput<T['include'][P], Unpacked<NonNullable<Model[P]>>> & {
+        pivot: AnyObject;
+    })[] | AddUndefinedIfNullable<Model[P]> : (QueryOutput<T['include'][P], Unpacked<NonNullable<Model[P]>>> & {
+        pivot: AnyObject;
+    })[] | AddUndefinedIfNullable<Model[P]> : T['include'][P] extends {
+        withPivot: true;
+    } ? (QueryOutput<T['include'][P], Unpacked<NonNullable<Model[P]>>> & {
+        pivot: AnyObject;
+    }) | AddUndefinedIfNullable<Model[P]> : QueryOutput<T['include'][P], Unpacked<NonNullable<Model[P]>>> | AddUndefinedIfNullable<Model[P]> : Model[P];
 };
-export declare type QueryOutput<T extends FluentQuery<Model>, Model, OutputDTO> = T extends {
-    select: T['select'];
-} ? T extends {
-    paginated: T['paginated'];
-} ? PaginatedData<GetSelectedFromObject<T, Model, OutputDTO>> : GetSelectedFromObject<T, Model, OutputDTO>[] : T extends {
-    paginated: T['paginated'];
-} ? PaginatedData<OutputDTO> : OutputDTO[];
-export declare type SingleQueryOutput<T extends FluentQuery<Model>, Model, OutputDTO> = T extends {
+export declare type GetSelectedFromObject<T extends FluentQuery<Model>, Model> = {
+    [P in keyof T['select']]: T['select'][P] extends object ? NonNullable<Model[P]> extends any[] ? QueryOutput<{
+        select: T['select'][P];
+    }, Unpacked<NonNullable<Model[P]>>>[] | AddUndefinedIfNullable<Model[P]> : QueryOutput<{
+        select: T['select'][P];
+    }, Unpacked<NonNullable<Model[P]>>> | AddUndefinedIfNullable<Model[P]> : Model[P];
+} & GetSelectedFromInclude<T, Model>;
+export declare type QueryOutput<T extends FluentQuery<Model>, Model> = ExpandRecursively<T extends {
     select: T['select'];
 } ? T extends {
     paginated: T['paginated'];
-} ? PaginatedData<GetSelectedFromObject<T, Model, OutputDTO>> : GetSelectedFromObject<T, Model, OutputDTO> : T extends {
+} ? PaginatedData<GetSelectedFromObject<T, Model>> : ExpandRecursively<GetSelectedFromObject<T, Model>> : T extends {
     paginated: T['paginated'];
-} ? PaginatedData<OutputDTO> : OutputDTO;
+} ? PaginatedData<Model> : Model & GetSelectedFromInclude<T, Model>>;
 export interface PaginatedData<T> {
     currentPage: number;
     data: T[];
@@ -103,7 +120,7 @@ export declare enum LogicOperator {
     notExists = "notExists"
 }
 export declare type FluentHasManyRelatedAttribute<T> = Partial<{
-    [K in keyof Concrete<T>]: Concrete<T>[K] extends object ? Unpacked<Partial<FluentHasManyRelatedAttribute<Concrete<T>[K]>>> | boolean : boolean | undefined;
+    [K in keyof Concrete<T>]: Concrete<T>[K] extends object ? Unpacked<Partial<FluentHasManyRelatedAttribute<Concrete<T>[K]>>> | true : true | undefined;
 }>;
 export declare type FluentHasManyParams<T extends FluentHasManyParams<T>> = {
     repository: new () => InstanceType<T['repository']>;

package/dist/fluent-firebase/src/test/firebase.d.ts

@@ -0,0 +1,16 @@
+import { Options as WithContainerOptions } from '@goatlab/fluent/src/TypeOrmConnector/test/docker/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;
+}>;

package/dist/fluent-firebase/src/test/firebase.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.waitForConnection = void 0;
+const tslib_1 = require("tslib");
+const docker_1 = tslib_1.__importDefault(require("@goatlab/fluent/src/TypeOrmConnector/test/docker/docker"));
+const mongodb_1 = require("mongodb");
+const DEFAULT_IMAGE = 'mongo:6.0.1';
+const DEFAULT_CONTAINER_NAME = `fluent-${DEFAULT_IMAGE.replace(':', '-')}-test`;
+const DEFAULT_CONNECT_TIMEOUT_SECONDS = 10;
+const DEFAULT_MONGO_PORT = 27017;
+const DEFAULT_MONGO_USER = 'test-user';
+const DEFAULT_MONGO_PASSWORD = 'password';
+const DEFAULT_MONGO_DB = 'test-db';
+const DEFAULT_MONGO_DEBUG = false;
+async function waitForConnection(databaseURL, timeoutSeconds) {
+    const start = Date.now();
+    const timeoutMilliseconds = timeoutSeconds * 1000;
+    let lastAttempt = false;
+    while (true) {
+        await new Promise(resolve => setTimeout(resolve, 1000));
+        const conn = new mongodb_1.MongoClient(databaseURL);
+        try {
+            try {
+                await conn.connect();
+                const db = conn.db('anyDB');
+                const result = await db.command({
+                    ping: 1
+                });
+                if (result.ok) {
+                    break;
+                }
+                else {
+                    if (lastAttempt) {
+                        throw new Error('Got unexpected result: ' + JSON.stringify(result));
+                    }
+                }
+            }
+            catch (ex) {
+                console.log(ex);
+                if (lastAttempt) {
+                    throw ex;
+                }
+            }
+        }
+        finally {
+            await conn.close();
+        }
+        if (Date.now() - timeoutMilliseconds > start) {
+            lastAttempt = true;
+        }
+    }
+}
+exports.waitForConnection = waitForConnection;
+async function getDatabase(options = {}) {
+    const { mongoUser, mongoPassword, mongoDb, environment, ...rawOptions } = {
+        debug: DEFAULT_MONGO_DEBUG,
+        image: DEFAULT_IMAGE,
+        containerName: DEFAULT_CONTAINER_NAME,
+        connectTimeoutSeconds: DEFAULT_CONNECT_TIMEOUT_SECONDS,
+        mongoUser: DEFAULT_MONGO_USER,
+        mongoPassword: DEFAULT_MONGO_PASSWORD,
+        mongoDb: DEFAULT_MONGO_DB,
+        defaultExternalPort: DEFAULT_MONGO_PORT,
+        ...options
+    };
+    const { proc, externalPort, kill } = await (0, docker_1.default)({
+        ...rawOptions,
+        internalPort: DEFAULT_MONGO_PORT,
+        environment: {
+            MONGO_HOST: '127.0.0.1',
+            ...environment,
+            MONGO_INITDB_ROOT_USERNAME: mongoUser,
+            MONGO_INITDB_ROOT_PASSWORD: mongoPassword,
+            MONGO_DB_USER: mongoUser,
+            MONGO_DB_PASSWORD: mongoPassword,
+            MONGO_PASSWORD: mongoPassword,
+            MONGO_INITDB_DATABASE: mongoDb
+        },
+        enableDebugInstructions: `To view logs, run with MONGO_TEST_DEBUG=true environment variable.`
+    });
+    const databaseURL = `mongodb://${mongoUser}:${mongoPassword}@localhost:${externalPort}`;
+    await waitForConnection(databaseURL, rawOptions.connectTimeoutSeconds);
+    return {
+        proc,
+        databaseURL,
+        kill,
+        user: mongoUser,
+        password: mongoPassword,
+        port: externalPort,
+        dbName: mongoDb
+    };
+}
+exports.default = getDatabase;