@goatlab/fluent 0.6.6 → 0.6.9

package/dist/core/Nestjs/types/utils/model-properties-accessor.d.ts

@@ -0,0 +1,6 @@
+import { Type } from '../common';
+import 'reflect-metadata';
+export declare class ModelPropertiesAccessor {
+    getModelProperties(prototype: Type<unknown>): string[];
+    applyMetadataFactory(prototype: Type<unknown>): void;
+}

package/dist/core/Nestjs/types/utils/model-properties-accessor.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModelPropertiesAccessor = void 0;
+const common_1 = require("../common");
+require("reflect-metadata");
+const api_property_decorator_1 = require("../decorators/api-property.decorator");
+const type_metadata_storage_1 = require("../type-metadata.storage");
+class ModelPropertiesAccessor {
+    getModelProperties(prototype) {
+        const properties = Reflect.getMetadata(api_property_decorator_1.DECORATORS.API_MODEL_PROPERTIES_ARRAY, prototype) ||
+            [];
+        return properties
+            .filter(common_1.isString)
+            .filter((key) => key.charAt(0) === ':' && !(0, common_1.isFunction)(prototype[key]))
+            .map((key) => key.slice(1));
+    }
+    applyMetadataFactory(prototype) {
+        const classPrototype = prototype;
+        do {
+            if (!prototype.constructor) {
+                return;
+            }
+            if (!prototype.constructor[type_metadata_storage_1.METADATA_FACTORY_NAME]) {
+                continue;
+            }
+            const metadata = prototype.constructor[type_metadata_storage_1.METADATA_FACTORY_NAME]();
+            const properties = Object.keys(metadata);
+            properties.forEach(key => {
+                (0, api_property_decorator_1.createApiPropertyDecorator)(metadata[key], false)(classPrototype, key);
+            });
+        } while ((prototype = Reflect.getPrototypeOf(prototype)) &&
+            prototype !== Object.prototype &&
+            prototype);
+    }
+}
+exports.ModelPropertiesAccessor = ModelPropertiesAccessor;

package/dist/core/Nestjs/types/utils/type-helpers.utils.d.ts

@@ -0,0 +1,2 @@
+import { PropertyMetadata } from '../metadata';
+export declare function applyFieldDecorators(targetClass: Function, item: PropertyMetadata): void;

package/dist/core/Nestjs/types/utils/type-helpers.utils.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyFieldDecorators = void 0;
+const directive_decorator_1 = require("../decorators/directive.decorator");
+const extensions_decorator_1 = require("../decorators/extensions.decorator");
+function applyFieldDecorators(targetClass, item) {
+    if (item.extensions) {
+        (0, extensions_decorator_1.Extensions)(item.extensions)(targetClass.prototype, item.name);
+    }
+    if (item.directives?.length) {
+        item.directives.map(directive => {
+            (0, directive_decorator_1.Directive)(directive.sdl)(targetClass.prototype, item.name);
+        });
+    }
+}
+exports.applyFieldDecorators = applyFieldDecorators;

package/dist/core/database/createConnection.d.ts

@@ -0,0 +1,30 @@
+import { DataSource } from 'typeorm';
+interface ConnectionOptions {
+    type: 'mongodb' | 'firebase' | 'sqlite' | 'mysql';
+    username?: string;
+    password?: string;
+    host?: string;
+    port?: number;
+    connectionName: string;
+    databaseName?: string;
+    entitiesPath?: string[] | any[];
+    synchronize?: boolean;
+    logging?: boolean;
+}
+export interface FluentConnectionFactory {
+    type: 'mongodb' | 'firebase' | 'sqlite' | 'mysql';
+    connection?: DataSource;
+}
+export declare const createConnection: ({ type, username, password, host, port, databaseName, entitiesPath, connectionName, synchronize, logging }: ConnectionOptions) => {
+    provide: string;
+    useFactory: () => Promise<{
+        type: "firebase";
+    }>;
+} | {
+    provide: string;
+    useFactory: () => Promise<{
+        type: "mysql" | "sqlite" | "mongodb";
+        connection: DataSource;
+    }>;
+};
+export {};

package/dist/core/database/createConnection.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createConnection = void 0;
+const typeorm_1 = require("typeorm");
+const createConnection = ({ type, username, password, host, port, databaseName, entitiesPath, connectionName, synchronize, logging }) => {
+    if (type === 'firebase') {
+        return {
+            provide: connectionName,
+            useFactory: async () => ({ type })
+        };
+    }
+    return {
+        provide: connectionName,
+        useFactory: async () => {
+            const dataSource = new typeorm_1.DataSource({
+                name: connectionName,
+                type,
+                username,
+                password,
+                host,
+                port,
+                database: databaseName,
+                useNewUrlParser: type === 'mongodb' ? true : undefined,
+                useUnifiedTopology: type === 'mongodb' ? true : undefined,
+                entities: [...entitiesPath],
+                synchronize,
+                logging
+            });
+            if (dataSource.isInitialized) {
+                return {
+                    type,
+                    connection: dataSource
+                };
+            }
+            const connection = await dataSource.initialize();
+            return {
+                type,
+                connection
+            };
+        }
+    };
+};
+exports.createConnection = createConnection;

package/dist/core/database/decorators.d.ts

@@ -0,0 +1,43 @@
+import { Primitives } from '../../types';
+interface PropertyInterface {
+    required?: boolean;
+    unique?: boolean;
+    hidden?: boolean;
+}
+interface EnumProperty {
+    enum: any[];
+    default?: Primitives;
+}
+export declare type ObjectTypeI<T> = new () => T;
+interface ManyToManyInterface<T> {
+    entity: (type?: any) => ObjectTypeI<T>;
+    joinTableName: string;
+    foreignKey: string;
+    inverseForeignKey: string;
+}
+interface BelongsToInterface<T> {
+    entity: (type?: any) => ObjectTypeI<T>;
+    inverse: string | ((object: T) => any);
+    pivotColumnName: string;
+}
+interface hasManyInterface<T> {
+    entity: (type?: any) => ObjectTypeI<T>;
+    inverse: string | ((object: T) => any);
+}
+export declare const Decorators: Readonly<{
+    id: (isMongo?: boolean) => PropertyDecorator;
+    entity: (name: string) => ClassDecorator;
+    property: (params?: PropertyInterface) => PropertyDecorator;
+    embed: (e: any) => PropertyDecorator;
+    embedArray: (e: any, params?: PropertyInterface) => PropertyDecorator;
+    array: (e: any, params?: PropertyInterface) => PropertyDecorator;
+    Enum: (e: EnumProperty, params?: PropertyInterface) => PropertyDecorator;
+    created: (e?: any) => PropertyDecorator;
+    updated: (e?: any) => PropertyDecorator;
+    version: (e?: any) => PropertyDecorator;
+    deleted: (e?: any) => PropertyDecorator;
+    belongsToMany: <T>({ entity, joinTableName, foreignKey, inverseForeignKey }: ManyToManyInterface<T>) => PropertyDecorator;
+    hasMany: <T_1>({ entity, inverse }: hasManyInterface<T_1>) => PropertyDecorator;
+    belongsTo: <T_2>({ entity, inverse, pivotColumnName }: BelongsToInterface<T_2>) => PropertyDecorator;
+}>;
+export {};

package/dist/core/database/decorators.js

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Decorators = void 0;
+const typeorm_1 = require("typeorm");
+const fireorm_1 = require("fireorm");
+const graphql_1 = require("graphql");
+const types_1 = require("../types");
+const applyDecorators_1 = require("../Nestjs/applyDecorators");
+const field_decorator_1 = require("../Nestjs/types/decorators/field.decorator");
+exports.Decorators = (() => {
+    const id = (isMongo) => {
+        isMongo = false;
+        if (process.env.MAIN_DATABASE_TYPE === 'mongodb' || isMongo) {
+            return (0, applyDecorators_1.applyDecorators)((0, typeorm_1.ObjectIdColumn)(), (0, typeorm_1.PrimaryGeneratedColumn)('uuid'), (0, types_1.ApiProperty)(), (0, field_decorator_1.Field)(() => graphql_1.GraphQLID), (0, typeorm_1.Column)());
+        }
+        return (0, applyDecorators_1.applyDecorators)((0, typeorm_1.PrimaryGeneratedColumn)('uuid'), (0, types_1.ApiProperty)(), (0, field_decorator_1.Field)(() => graphql_1.GraphQLID), (0, typeorm_1.Column)());
+    };
+    const entity = (name) => {
+        const PascalCase = name;
+        return (0, applyDecorators_1.applyDecorators)((0, typeorm_1.Entity)({ name: PascalCase }), (0, types_1.ObjectType)(), (0, fireorm_1.Collection)(PascalCase));
+    };
+    const property = (params) => {
+        if (params && params.hidden) {
+            return (0, applyDecorators_1.applyDecorators)((0, types_1.HideField)(), (0, typeorm_1.Column)({
+                select: false,
+                nullable: !params.required
+            }), (0, types_1.ApiProperty)({
+                nullable: !params.required,
+                required: !!params.required
+            }), (0, types_1.ApiHideProperty)());
+        }
+        return (0, applyDecorators_1.applyDecorators)((0, typeorm_1.Column)({
+            nullable: !params.required
+        }), (0, types_1.ApiProperty)({
+            nullable: !params.required,
+            required: !!params.required
+        }), (0, field_decorator_1.Field)());
+    };
+    const embed = (e) => (0, applyDecorators_1.applyDecorators)((0, typeorm_1.Column)(type => e), (0, types_1.ApiProperty)({ type: e }));
+    const embedArray = (e, params) => (0, applyDecorators_1.applyDecorators)((0, typeorm_1.Column)(type => e), (0, types_1.ApiProperty)({
+        isArray: true,
+        type: e,
+        nullable: !params.required,
+        required: !!params.required
+    }));
+    const array = (e, params) => (0, applyDecorators_1.applyDecorators)((0, typeorm_1.Column)({
+        type: 'simple-array',
+        nullable: !params?.required
+    }), (0, types_1.ApiProperty)({
+        type: [e],
+        nullable: !params?.required,
+        required: !!params?.required
+    }));
+    const Enum = (e, params) => (0, applyDecorators_1.applyDecorators)((0, typeorm_1.Column)({
+        type: 'enum',
+        enum: e.enum,
+        default: e.default,
+        nullable: !params.required
+    }), (0, types_1.ApiProperty)({
+        enum: e.enum,
+        default: e.default,
+        nullable: !params.required,
+        required: !!params.required
+    }));
+    const created = (e) => (0, applyDecorators_1.applyDecorators)((0, typeorm_1.CreateDateColumn)(), (0, types_1.ApiProperty)());
+    const updated = (e) => (0, applyDecorators_1.applyDecorators)((0, typeorm_1.UpdateDateColumn)(), (0, types_1.ApiProperty)());
+    const deleted = (e) => (0, applyDecorators_1.applyDecorators)((0, typeorm_1.DeleteDateColumn)(), (0, types_1.ApiProperty)());
+    const version = (e) => (0, applyDecorators_1.applyDecorators)((0, typeorm_1.VersionColumn)(), (0, types_1.ApiProperty)());
+    function belongsToMany({ entity, joinTableName, foreignKey, inverseForeignKey }) {
+        return (0, applyDecorators_1.applyDecorators)((0, typeorm_1.ManyToMany)(entity), (0, typeorm_1.JoinTable)({
+            name: joinTableName,
+            joinColumns: [{ name: foreignKey }],
+            inverseJoinColumns: [{ name: inverseForeignKey }]
+        }));
+    }
+    function belongsTo({ entity, inverse, pivotColumnName }) {
+        return (0, applyDecorators_1.applyDecorators)((0, typeorm_1.ManyToOne)(entity, inverse), (0, typeorm_1.JoinColumn)({ name: pivotColumnName }));
+    }
+    function hasMany({ entity, inverse }) {
+        return (0, applyDecorators_1.applyDecorators)((0, typeorm_1.OneToMany)(entity, inverse));
+    }
+    return Object.freeze({
+        id,
+        entity,
+        property,
+        embed,
+        embedArray,
+        array,
+        Enum,
+        created,
+        updated,
+        version,
+        deleted,
+        belongsToMany,
+        hasMany,
+        belongsTo
+    });
+})();

package/dist/core/dtos/access.dto.d.ts

@@ -0,0 +1,4 @@
+export declare class Access {
+    type?: string;
+    roles?: string[];
+}

package/dist/core/dtos/access.dto.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Access = void 0;
+const tslib_1 = require("tslib");
+const types_1 = require("../types");
+let Access = class Access {
+};
+tslib_1.__decorate([
+    (0, types_1.Column)({ nullable: true }),
+    (0, types_1.ApiProperty)(),
+    tslib_1.__metadata("design:type", String)
+], Access.prototype, "type", void 0);
+tslib_1.__decorate([
+    (0, types_1.Column)({ nullable: true, type: 'simple-array' }),
+    (0, types_1.ApiProperty)(),
+    tslib_1.__metadata("design:type", Array)
+], Access.prototype, "roles", void 0);
+Access = tslib_1.__decorate([
+    (0, types_1.ObjectType)()
+], Access);
+exports.Access = Access;

package/dist/core/types.d.ts

@@ -0,0 +1,23 @@
+import { Column as TypeORMColumn } from 'typeorm';
+import { SchemaObject as LBSchemaObject } from 'openapi3-ts';
+import { InputType as NestInputType } from './Nestjs/types/decorators/input-type.decorator';
+import { PartialType as NestjsPartialType } from './Nestjs/types/decorators/partial-type.helper';
+import { ObjectType as NestObjectType } from './Nestjs/types/object-type.decorator';
+import { ApiProperty as NEstJSApiProperty } from './Nestjs/types/decorators/api-property.decorator';
+import { OmitType as NEstJSOmitType } from './Nestjs/types/omit-type';
+import { ApiHideProperty as NEstApiHideProperty } from './Nestjs/types/decorators/api-hide-property.decorator';
+import { SchemaRef } from './Loopback/json-to-schema';
+import { JsonSchemaOptions } from './Loopback/build-schema';
+export declare function LBgetModelSchemaRef<T extends object>(modelCtor: Function & {
+    prototype: T;
+}, options?: JsonSchemaOptions<T>): SchemaRef;
+export declare const ApiProperty: typeof NEstJSApiProperty;
+export declare const ApiHideProperty: typeof NEstApiHideProperty;
+export declare const OmitType: typeof NEstJSOmitType;
+export declare const InputType: typeof NestInputType;
+export declare const PartialType: typeof NestjsPartialType;
+export declare const Column: typeof TypeORMColumn;
+export declare const getModelSchemaRef: typeof LBgetModelSchemaRef;
+export declare const ObjectType: typeof NestObjectType;
+export declare type SchemaObject = LBSchemaObject;
+export declare function HideField(): PropertyDecorator;

package/dist/core/types.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HideField = exports.ObjectType = exports.getModelSchemaRef = exports.Column = exports.PartialType = exports.InputType = exports.OmitType = exports.ApiHideProperty = exports.ApiProperty = exports.LBgetModelSchemaRef = void 0;
+const typeorm_1 = require("typeorm");
+const input_type_decorator_1 = require("./Nestjs/types/decorators/input-type.decorator");
+const partial_type_helper_1 = require("./Nestjs/types/decorators/partial-type.helper");
+const object_type_decorator_1 = require("./Nestjs/types/object-type.decorator");
+const api_property_decorator_1 = require("./Nestjs/types/decorators/api-property.decorator");
+const omit_type_1 = require("./Nestjs/types/omit-type");
+const api_hide_property_decorator_1 = require("./Nestjs/types/decorators/api-hide-property.decorator");
+const json_to_schema_1 = require("./Loopback/json-to-schema");
+const build_schema_1 = require("./Loopback/build-schema");
+function LBgetModelSchemaRef(modelCtor, options) {
+    const jsonSchema = (0, build_schema_1.getJsonSchemaRef)(modelCtor, options);
+    return (0, json_to_schema_1.jsonToSchemaObject)(jsonSchema);
+}
+exports.LBgetModelSchemaRef = LBgetModelSchemaRef;
+exports.ApiProperty = api_property_decorator_1.ApiProperty;
+exports.ApiHideProperty = api_hide_property_decorator_1.ApiHideProperty;
+exports.OmitType = omit_type_1.OmitType;
+exports.InputType = input_type_decorator_1.InputType;
+exports.PartialType = partial_type_helper_1.PartialType;
+exports.Column = typeorm_1.Column;
+exports.getModelSchemaRef = LBgetModelSchemaRef;
+exports.ObjectType = object_type_decorator_1.ObjectType;
+function HideField() {
+    return (target, propertyKey) => { };
+}
+exports.HideField = HideField;

package/dist/generatorDatasource.d.ts

@@ -0,0 +1,2 @@
+import { DataSource } from 'typeorm';
+export declare const modelGeneratorDataSource: DataSource;

package/dist/generatorDatasource.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.modelGeneratorDataSource = void 0;
+const typeorm_1 = require("typeorm");
+exports.modelGeneratorDataSource = new typeorm_1.DataSource({
+    name: '_goat_model_generator',
+    type: 'sqlite',
+    database: ':memory:',
+    logging: false,
+    synchronize: true,
+    dropSchema: true
+});

package/dist/loadRelations.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadRelations = void 0;
+const js_utils_1 = require("@goatlab/js-utils");
+const TypeOrmConnector_1 = require("./TypeOrmConnector/TypeOrmConnector");
+const loadRelations = async ({ data, relations, modelRelations, connectionName, provider, self }) => {
+    if (!relations) {
+        return data;
+    }
+    const chunkSize = provider === 'typeorm' ? 100 : 10;
+    for (const relation of Object.keys(relations)) {
+        if (modelRelations[relation]) {
+            const relationModel = modelRelations[relation];
+            let firebaseConnector;
+            if (provider === 'firebase') {
+                firebaseConnector = require('../FirebaseConnector').FirebaseConnector;
+            }
+            const Model = typeof self[relation] === 'function'
+                ? self[relation]()
+                : provider === 'typeorm'
+                    ? new TypeOrmConnector_1.TypeOrmConnector(relationModel.targetClass, undefined, connectionName || 'LOCAL_DB')
+                    : new firebaseConnector(relationModel.targetClass);
+            if (relationModel.isOneToMany) {
+                const ids = js_utils_1.Arrays.deDuplicate(data.map(d => Model.isMongoDB ? js_utils_1.Ids.objectID(d.id) : d.id));
+                const chunks = js_utils_1.Arrays.chunk(ids, chunkSize);
+                const promises = [];
+                for (const relatedIds of chunks) {
+                    const results = await Model.andWhere(Model._keys[relationModel.inverseSidePropertyPath], 'in', relatedIds).get();
+                    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]);
+                data.forEach(d => {
+                    if (grouped[d.id]) {
+                        d[relationModel.propertyPath] = grouped[d.id];
+                    }
+                });
+            }
+            else if (relationModel.isManyToOne) {
+                const ids = js_utils_1.Arrays.deDuplicate(data.map(d => d[relationModel.joinColumns[0].propertyPath]));
+                const chunks = js_utils_1.Arrays.chunk(ids, chunkSize);
+                const promises = [];
+                for (const relatedIds of chunks) {
+                    const results = await Model.andWhere(Model._keys.id, 'in', relatedIds).get();
+                    promises.push(results);
+                }
+                const relatedResults = js_utils_1.Arrays.collapse(promises);
+                const grouped = js_utils_1.Arrays.groupBy(relatedResults, r => r.id);
+                data.forEach(d => {
+                    if (grouped[d[relationModel.joinColumns[0].propertyPath]]) {
+                        d[relationModel.propertyPath] =
+                            grouped[d[relationModel.joinColumns[0].propertyPath]][0];
+                    }
+                });
+            }
+            else if (relationModel.isManyToMany) {
+                const ids = js_utils_1.Arrays.deDuplicate(data.map(d => Model.isMongoDB ? js_utils_1.Ids.objectID(d.id) : d.id));
+                const chunks = js_utils_1.Arrays.chunk(ids, chunkSize);
+                if (relationModel.joinColumns.length === 0) {
+                    return data;
+                }
+                const pivotRepository = self[relationModel.propertyPath]().relationQuery.pivot;
+                const promises = [];
+                for (const pivotIds of chunks) {
+                    const results = await pivotRepository
+                        .where(relationModel.joinColumns[0].propertyName, 'in', pivotIds)
+                        .get();
+                    promises.push(results);
+                }
+                const pivotResults = js_utils_1.Arrays.collapse(await Promise.all(promises));
+                const uniquePivotIds = pivotResults.map(p => p[relationModel.inverseJoinColumns[0].propertyName]);
+                const relationChunks = js_utils_1.Arrays.chunk(uniquePivotIds, chunkSize);
+                const relationPromises = [];
+                for (const relatedIds of relationChunks) {
+                    const results = await Model.andWhere(Model._keys.id, 'in', relatedIds).get();
+                    relationPromises.push(results);
+                }
+                const relatedResults = js_utils_1.Arrays.collapse(await Promise.all(relationPromises));
+                const groupedPivot = js_utils_1.Arrays.groupBy(pivotResults, r => r[relationModel.joinColumns[0].propertyName]);
+                const groupedRelated = js_utils_1.Arrays.groupBy(relatedResults, r => r.id);
+                data.forEach(d => {
+                    groupedPivot[d.id]?.forEach(gp => {
+                        d[relationModel.propertyPath] =
+                            groupedRelated[gp[relationModel.inverseJoinColumns[0].propertyName]];
+                    });
+                });
+            }
+        }
+    }
+    return data;
+};
+exports.loadRelations = loadRelations;

package/dist/outputKeys.d.ts

@@ -0,0 +1,2 @@
+import { Repository } from 'typeorm';
+export declare const getOutputKeys: (repository: Repository<any>) => string[];

package/dist/outputKeys.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getOutputKeys = void 0;
+const js_utils_1 = require("@goatlab/js-utils");
+const getOutputKeys = (repository) => {
+    const excludedCols = [];
+    repository.metadata.columns.forEach(c => {
+        if (!c.isSelect) {
+            excludedCols.push(c.propertyName);
+        }
+    });
+    const keys = repository.metadata.propertiesMap;
+    const flatKeys = js_utils_1.Objects.flatten(keys, true);
+    const outputKeys = Object.keys(flatKeys).filter(e => !excludedCols.includes(e));
+    return outputKeys;
+};
+exports.getOutputKeys = getOutputKeys;