@goatlab/fluent 0.6.23 → 0.7.0

package/dist/core/Loopback/query.js

@@ -1,8 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.filterTemplate = exports.FilterBuilder = exports.WhereBuilder = exports.isFilter = void 0;
-const tslib_1 = require("tslib");
-const assert_1 = tslib_1.__importDefault(require("assert"));
 const nonWhereFields = ['fields', 'order', 'limit', 'skip', 'offset', 'include'];
 const filterFields = ['where', ...nonWhereFields];
 function isFilter(candidate) {
@@ -142,7 +140,9 @@ class FilterBuilder {
         this.filter = f ?? {};
     }
     limit(limit) {
-        (0, assert_1.default)(limit >= 1, `Limit ${limit} must a positive number`);
+        if (!(limit >= 1)) {
+            throw new Error(`Limit ${limit} must a positive number`);
+        }
         this.filter.limit = limit;
         return this;
     }
@@ -175,7 +175,9 @@ class FilterBuilder {
         return this;
     }
     validateOrder(order) {
-        (0, assert_1.default)(order.match(/^[^\s]+( (ASC|DESC))?$/), `Invalid order: ${order}`);
+        if (!(order.match(/^[^\s]+( (ASC|DESC))?$/))) {
+            throw new Error(`Invalid order: ${order}`);
+        }
     }
     order(...o) {
         if (!this.filter.order) {

package/dist/core/Loopback/type-resolver.d.ts

@@ -1,7 +1,7 @@
 import { Class } from './common-types';
 export declare type TypeResolver<Type extends Object, StaticMembers = Function> = () => Class<Type> & StaticMembers;
 export declare function isTypeResolver<T extends object>(fn: any): fn is TypeResolver<T>;
-export declare function Null(): any;
+export declare function Null(): null;
 export declare function isBuiltinType(fn: Function): boolean;
 export declare function resolveType<T extends Object>(fn: TypeResolver<T> | Class<T>): Class<T>;
 export declare function resolveType<T>(fn: T): T;

package/dist/core/Nestjs/applyDecorators.d.ts

@@ -1 +1 @@
-export declare function applyDecorators(...decorators: Array<ClassDecorator | MethodDecorator | PropertyDecorator>): <TFunction extends Function, Y>(target: object | TFunction, propertyKey?: string | symbol, descriptor?: TypedPropertyDescriptor<Y>) => void;
+export declare function applyDecorators(...decorators: Array<ClassDecorator | MethodDecorator | PropertyDecorator>): <TFunction extends Function, Y>(target: object | TFunction, propertyKey?: string | symbol | undefined, descriptor?: TypedPropertyDescriptor<Y> | undefined) => void;

package/dist/core/Nestjs/types/common.js

@@ -12,7 +12,9 @@ var ClassType;
 })(ClassType = exports.ClassType || (exports.ClassType = {}));
 function flatten(arr) {
     const flat = [].concat(...arr);
-    return flat.some(Array.isArray) ? flatten(flat) : flat;
+    return (flat.some(Array.isArray)
+        ? flatten(flat)
+        : flat);
 }
 exports.flatten = flatten;
 const isUndefined = (obj) => typeof obj === 'undefined';

package/dist/core/Nestjs/types/decorators/apply-is-optional.decorator.d.ts

@@ -1,5 +1,5 @@
 import { Type } from '../common';
 export declare function applyIsOptionalDecorator(targetClass: Function, propertyKey: string): void;
-export declare function inheritValidationMetadata(parentClass: Type<any>, targetClass: Function, isPropertyInherited?: (key: string) => boolean): string[];
+export declare function inheritValidationMetadata(parentClass: Type<any>, targetClass: Function, isPropertyInherited?: (key: string) => boolean): string[] | undefined;
 export declare function inheritTransformationMetadata(parentClass: Type<any>, targetClass: Function, isPropertyInherited?: (key: string) => boolean): void;
 export declare function inheritPropertyInitializers(target: Record<string, any>, sourceClass: Type<any>, isPropertyInherited?: (key: string) => boolean): void;

package/dist/core/Nestjs/types/decorators/create-property.decorator.js

@@ -1,9 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getTypeIsArrayTuple = exports.createPropertyDecorator = void 0;
-const lodash_1 = require("lodash");
 const type_metadata_storage_1 = require("../type-metadata.storage");
 const api_property_decorator_1 = require("./api-property.decorator");
+const isUndefined = val => typeof val === 'undefined';
+const OmitBy = (obj, check) => {
+    obj = { ...obj };
+    Object.entries(obj).forEach(([key, value]) => check(value) && delete obj[key]);
+    return obj;
+};
 function createPropertyDecorator(metakey, metadata, overrideExisting = true) {
     return (target, propertyKey) => {
         const properties = Reflect.getMetadata(api_property_decorator_1.DECORATORS.API_MODEL_PROPERTIES_ARRAY, target) || [];
@@ -13,7 +18,7 @@ function createPropertyDecorator(metakey, metadata, overrideExisting = true) {
         }
         const existingMetadata = Reflect.getMetadata(metakey, target, propertyKey);
         if (existingMetadata) {
-            const newMetadata = (0, lodash_1.pickBy)(metadata, (0, lodash_1.negate)(lodash_1.isUndefined));
+            const newMetadata = OmitBy(metadata, isUndefined);
             const metadataToSave = overrideExisting
                 ? {
                     ...existingMetadata,
@@ -30,7 +35,7 @@ function createPropertyDecorator(metakey, metadata, overrideExisting = true) {
                 Reflect.getMetadata('design:type', target, propertyKey);
             Reflect.defineMetadata(metakey, {
                 type,
-                ...(0, lodash_1.pickBy)(metadata, (0, lodash_1.negate)(lodash_1.isUndefined))
+                ...OmitBy(metadata, isUndefined)
             }, target, propertyKey);
         }
     };
@@ -43,7 +48,7 @@ function getTypeIsArrayTuple(input, isArrayFlag) {
     if (isArrayFlag) {
         return [input, isArrayFlag];
     }
-    const isInputArray = (0, lodash_1.isArray)(input);
+    const isInputArray = Array.isArray(input);
     const type = isInputArray ? input[0] : input;
     return [type, isInputArray];
 }

package/dist/core/Nestjs/types/decorators/field.decorator.d.ts

@@ -12,4 +12,4 @@ export interface FieldOptions extends BaseTypeOptions {
 export declare function Field(): PropertyDecorator & MethodDecorator;
 export declare function Field(options: FieldOptions): PropertyDecorator & MethodDecorator;
 export declare function Field(returnTypeFunction?: ReturnTypeFunc, options?: FieldOptions): PropertyDecorator & MethodDecorator;
-export declare function addFieldMetadata(typeOrOptions: ReturnTypeFunc | FieldOptions, fieldOptions: FieldOptions, prototype: Object, propertyKey?: string, descriptor?: TypedPropertyDescriptor<any>, loadEagerly?: boolean): void;
+export declare function addFieldMetadata(typeOrOptions?: ReturnTypeFunc | FieldOptions, fieldOptions?: FieldOptions | undefined, prototype?: Object, propertyKey?: string, descriptor?: TypedPropertyDescriptor<any>, loadEagerly?: boolean): void;

package/dist/core/Nestjs/types/decorators/field.decorator.js

@@ -21,16 +21,16 @@ function addFieldMetadata(typeOrOptions, fieldOptions, prototype, propertyKey, d
         const { typeFn: getType, options: typeOptions } = (0, reflection_utils_1.reflectTypeFromMetadata)({
             metadataKey: isResolverMethod ? 'design:returntype' : 'design:type',
             prototype,
-            propertyKey,
+            propertyKey: propertyKey || '',
             explicitTypeFn: typeFunc,
             typeOptions: options
         });
         type_metadata_storage_1.TypeMetadataStorage.addClassFieldMetadata({
-            name: propertyKey,
+            name: propertyKey || '',
             schemaName: options.name || propertyKey,
             typeFn: getType,
             options: typeOptions,
-            target: prototype.constructor,
+            target: prototype?.constructor,
             description: options.description,
             deprecationReason: options.deprecationReason,
             complexity: options.complexity,
@@ -39,9 +39,9 @@ function addFieldMetadata(typeOrOptions, fieldOptions, prototype, propertyKey, d
         if (isResolver) {
             type_metadata_storage_1.TypeMetadataStorage.addResolverPropertyMetadata({
                 kind: 'internal',
-                methodName: propertyKey,
+                methodName: propertyKey || '',
                 schemaName: options.name || propertyKey,
-                target: prototype.constructor,
+                target: prototype?.constructor,
                 complexity: options.complexity
             });
         }
@@ -50,7 +50,7 @@ function addFieldMetadata(typeOrOptions, fieldOptions, prototype, propertyKey, d
         applyMetadataFn();
     }
     else {
-        lazy_metadata_storage_1.LazyMetadataStorage.store(prototype.constructor, applyMetadataFn, { isField: true });
+        lazy_metadata_storage_1.LazyMetadataStorage.store(prototype?.constructor, applyMetadataFn, { isField: true });
     }
 }
 exports.addFieldMetadata = addFieldMetadata;

package/dist/core/Nestjs/types/lazy-metadata.storage.js

@@ -27,11 +27,11 @@ class LazyMetadataStorageHost {
         let loadersToExecute = (0, common_1.flatten)(types
             .map(target => this.lazyMetadataByTarget.get(target))
             .filter(metadata => metadata));
-        loadersToExecute = loadersToExecute.concat(...(this.lazyMetadataByTarget.get(NO_TARGET_METADATA) || []));
+        loadersToExecute = loadersToExecute?.concat(...(this.lazyMetadataByTarget.get(NO_TARGET_METADATA) || []));
         if (!options.skipFieldLazyMetadata) {
-            loadersToExecute = loadersToExecute.concat(...(this.lazyMetadataByTarget.get(FIELD_LAZY_METADATA) || []));
+            loadersToExecute = loadersToExecute?.concat(...(this.lazyMetadataByTarget.get(FIELD_LAZY_METADATA) || []));
         }
-        loadersToExecute.forEach(func => func());
+        loadersToExecute?.forEach(func => func());
     }
     concatPrototypes(types) {
         const typesWithPrototypes = types

package/dist/core/Nestjs/types/omit-type.js

@@ -1,11 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.OmitType = void 0;
-const lodash_1 = require("lodash");
 const api_property_decorator_1 = require("./decorators/api-property.decorator");
 const mapped_types_utils_1 = require("./utils/mapped-types.utils");
 const model_properties_accessor_1 = require("./utils/model-properties-accessor");
 const apply_is_optional_decorator_1 = require("./decorators/apply-is-optional.decorator");
+const omit = (obj, props) => {
+    obj = { ...obj };
+    props.forEach(prop => delete obj[prop]);
+    return obj;
+};
 const modelPropertiesAccessor = new model_properties_accessor_1.ModelPropertiesAccessor();
 function OmitType(classRef, keys) {
     const fields = modelPropertiesAccessor
@@ -19,7 +23,7 @@ function OmitType(classRef, keys) {
     }
     (0, apply_is_optional_decorator_1.inheritValidationMetadata)(classRef, OmitTypeClass, isInheritedPredicate);
     (0, apply_is_optional_decorator_1.inheritTransformationMetadata)(classRef, OmitTypeClass, isInheritedPredicate);
-    (0, mapped_types_utils_1.clonePluginMetadataFactory)(OmitTypeClass, classRef.prototype, (metadata) => (0, lodash_1.omit)(metadata, keys));
+    (0, mapped_types_utils_1.clonePluginMetadataFactory)(OmitTypeClass, classRef.prototype, (metadata) => omit(metadata, keys));
     fields.forEach(propertyKey => {
         const metadata = Reflect.getMetadata(api_property_decorator_1.DECORATORS.API_MODEL_PROPERTIES, classRef.prototype, propertyKey);
         const decoratorFactory = (0, api_property_decorator_1.ApiProperty)(metadata);

package/dist/core/Nestjs/types/reflection.utils.d.ts

@@ -2,7 +2,7 @@ import { GqlTypeReference, ReturnTypeFunc } from './interfaces/return-type-func.
 import { TypeOptions } from './interfaces/type-options.interface';
 export interface ReflectTypeOptions {
     metadataKey: 'design:type' | 'design:returntype' | 'design:paramtypes';
-    prototype: Object;
+    prototype?: Object;
     propertyKey: string;
     explicitTypeFn?: ReturnTypeFunc;
     typeOptions?: TypeOptions;

package/dist/core/Nestjs/types/reflection.utils.js

@@ -1,8 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.reflectTypeFromMetadata = void 0;
-const lodash_1 = require("lodash");
 const undefined_type_error_1 = require("./errors/undefined-type.error");
+const get = (obj, path, defaultValue = undefined) => {
+    const travel = regexp => String.prototype.split
+        .call(path, regexp)
+        .filter(Boolean)
+        .reduce((res, key) => (res !== null && res !== undefined ? res[key] : res), obj);
+    const result = travel(/[,[\]]+?/) || travel(/[,[\].]+?/);
+    return result === undefined || result === obj ? defaultValue : result;
+};
 const NOT_ALLOWED_TYPES = [Promise, Array, Object, Function];
 function reflectTypeFromMetadata(reflectOptions) {
     const { metadataKey, prototype, propertyKey, explicitTypeFn, typeOptions = {}, index } = reflectOptions;
@@ -12,7 +19,7 @@ function reflectTypeFromMetadata(reflectOptions) {
     const isNotAllowed = implicitType && NOT_ALLOWED_TYPES.includes(implicitType);
     if ((!explicitTypeFn && (!implicitType || isNotAllowed)) ||
         (!implicitType && !explicitTypeFn)) {
-        throw new undefined_type_error_1.UndefinedTypeError((0, lodash_1.get)(prototype, 'constructor.name'), propertyKey, index);
+        throw new undefined_type_error_1.UndefinedTypeError(get(prototype, 'constructor.name'), propertyKey, index);
     }
     if (explicitTypeFn) {
         return {

package/dist/core/Nestjs/types/type-metadata.storage.js

@@ -240,7 +240,7 @@ class TypeMetadataStorageHost {
                 .reduce((curr, acc) => ({ ...curr, ...acc.value }), {});
             item.objectTypeFn =
                 item.kind === 'external'
-                    ? this.resolvers.find(belongsToClass).typeFn
+                    ? this.resolvers?.find(belongsToClass)?.typeFn
                     : () => item.target;
             if (item.kind === 'external') {
                 this.compileExternalFieldResolverMetadata(item);
@@ -250,13 +250,13 @@ class TypeMetadataStorageHost {
     compileExternalFieldResolverMetadata(item) {
         const objectTypeRef = this.resolvers
             .find(el => (0, common_1.isTargetEqual)(el, item))
-            .typeFn();
+            ?.typeFn();
         const objectOrInterfaceTypeMetadata = this.objectTypes.find(objTypeDef => objTypeDef.target === objectTypeRef) ||
             this.interfaces.find(interfaceTypeDef => interfaceTypeDef.target === objectTypeRef);
         if (!objectOrInterfaceTypeMetadata) {
             throw new cannot_determine_host_type_error_1.CannotDetermineHostTypeError(item.schemaName, objectTypeRef?.name);
         }
-        const objectOrInterfaceTypeField = objectOrInterfaceTypeMetadata.properties.find(fieldDef => fieldDef.name === item.methodName);
+        const objectOrInterfaceTypeField = objectOrInterfaceTypeMetadata.properties?.find(fieldDef => fieldDef.name === item.methodName);
         if (!objectOrInterfaceTypeField) {
             if (!item.typeFn || !item.typeOptions) {
                 throw new undefined_type_error_1.UndefinedTypeError(item.target.name, item.methodName);
@@ -275,7 +275,7 @@ class TypeMetadataStorageHost {
                 complexity: item.complexity
             };
             this.addClassFieldMetadata(fieldMetadata);
-            objectOrInterfaceTypeMetadata.properties.push(fieldMetadata);
+            objectOrInterfaceTypeMetadata.properties?.push(fieldMetadata);
         }
         else {
             const isEmpty = (arr) => arr.length === 0;

package/dist/core/Nestjs/types/utils/get-fields-and-decorator.util.d.ts

@@ -1,13 +1,3 @@
 import 'reflect-metadata';
 import { Type } from '../common';
-import { ArgsType } from '../decorators/args-type.decorator';
-import { InputType } from '../decorators/input-type.decorator';
-import { InterfaceType } from '../decorators/interface-type.decorator';
-import { PropertyMetadata } from '../metadata';
-import { ObjectType } from '../object-type.decorator';
-export declare function getFieldsAndDecoratorForType<T>(objType: Type<T>): {
-    fields: PropertyMetadata[];
-    decoratorFactory: ClassDecorator;
-};
-declare type ClassDecorator = typeof ArgsType | typeof InterfaceType | typeof ObjectType | typeof InputType;
-export {};
+export declare function getFieldsAndDecoratorForType<T>(objType: Type<T>): any;

package/dist/core/Nestjs/types/utils/mapped-types.utils.js

@@ -1,9 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.clonePluginMetadataFactory = void 0;
-const lodash_1 = require("lodash");
 const type_metadata_storage_1 = require("../type-metadata.storage");
-function clonePluginMetadataFactory(target, parent, transformFn = lodash_1.identity) {
+const identity = a => a;
+function clonePluginMetadataFactory(target, parent, transformFn = identity) {
     let targetMetadata = {};
     do {
         if (!parent.constructor) {

package/dist/decorators.d.ts

@@ -1,43 +1,47 @@
+import { ColumnType } from 'typeorm';
 import { Primitives } from './types';
 interface PropertyInterface {
     required?: boolean;
     unique?: boolean;
     hidden?: boolean;
+    type?: ColumnType;
 }
 interface EnumProperty {
     enum: any[];
     default?: Primitives;
 }
-export declare type ObjectTypeI<T> = new () => T;
+export declare type DbEntity<T> = new () => T;
 interface ManyToManyInterface<T> {
-    entity: (type?: any) => ObjectTypeI<T>;
+    entity: (type?: any) => DbEntity<T>;
     joinTableName: string;
     foreignKey: string;
     inverseForeignKey: string;
 }
 interface BelongsToInterface<T> {
-    entity: (type?: any) => ObjectTypeI<T>;
+    entity: (type?: any) => DbEntity<T>;
     inverse: string | ((object: T) => any);
-    pivotColumnName: string;
+    pivotColumnName?: string;
 }
 interface hasManyInterface<T> {
-    entity: (type?: any) => ObjectTypeI<T>;
+    entity: (type?: any) => DbEntity<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 declare class DecoratorsClass {
+    id(): PropertyDecorator;
+    mongoId(): PropertyDecorator;
+    entity(name: string): ClassDecorator;
+    property(params?: PropertyInterface): PropertyDecorator;
+    embed(e: any): PropertyDecorator;
+    embedArray(e: any, params?: PropertyInterface): PropertyDecorator;
+    stringArray(e: any, params?: PropertyInterface): PropertyDecorator;
+    Enum(e: EnumProperty, params?: PropertyInterface): PropertyDecorator;
+    created(e?: any): PropertyDecorator;
+    updated(e?: any): PropertyDecorator;
+    deleted(e?: any): PropertyDecorator;
+    version(e?: any): PropertyDecorator;
+    belongsToMany<T>({ entity, joinTableName, foreignKey, inverseForeignKey }: ManyToManyInterface<T>): PropertyDecorator;
+    belongsTo<T>({ entity, inverse, pivotColumnName }: BelongsToInterface<T>): PropertyDecorator;
+    hasMany<T>({ entity, inverse }: hasManyInterface<T>): PropertyDecorator;
+}
+export declare const f: DecoratorsClass;
 export {};

package/dist/decorators.js

@@ -1,98 +1,104 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Decorators = void 0;
+exports.f = exports.DecoratorsClass = void 0;
 const typeorm_1 = require("typeorm");
-const fireorm_1 = require("fireorm");
 const graphql_1 = require("graphql");
 const types_1 = require("./core/types");
 const applyDecorators_1 = require("./core/Nestjs/applyDecorators");
 const field_decorator_1 = require("./core/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 js_utils_1 = require("@goatlab/js-utils");
+class DecoratorsClass {
+    id() {
+        return (0, applyDecorators_1.applyDecorators)((0, typeorm_1.ObjectIdColumn)({ type: 'uuid' }), (0, typeorm_1.PrimaryGeneratedColumn)('uuid'), (0, types_1.ApiProperty)(), (0, field_decorator_1.Field)(() => graphql_1.GraphQLID));
+    }
+    mongoId() {
+        return (0, applyDecorators_1.applyDecorators)((0, typeorm_1.ObjectIdColumn)(), (0, types_1.ApiProperty)(), (0, field_decorator_1.Field)(() => graphql_1.GraphQLID));
+    }
+    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) => {
+        return (0, applyDecorators_1.applyDecorators)((0, typeorm_1.Entity)({ name: PascalCase }), (0, types_1.ObjectType)());
+    }
+    property(params) {
         if (params && params.hidden) {
             return (0, applyDecorators_1.applyDecorators)((0, types_1.HideField)(), (0, typeorm_1.Column)({
                 select: false,
-                nullable: !params.required
+                nullable: !params.required,
+                type: params.type
             }), (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
+            nullable: !params?.required
         }), (0, types_1.ApiProperty)({
-            nullable: !params.required,
-            required: !!params.required
+            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 }) {
+    }
+    embed(e) {
+        return (0, applyDecorators_1.applyDecorators)((0, typeorm_1.Column)(type => e), (0, types_1.ApiProperty)({ type: e }));
+    }
+    embedArray(e, params) {
+        return (0, applyDecorators_1.applyDecorators)((0, typeorm_1.Column)(type => e), (0, types_1.ApiProperty)({
+            isArray: true,
+            type: e,
+            nullable: !params?.required,
+            required: !!params?.required
+        }));
+    }
+    stringArray(e, params) {
+        return (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
+        }));
+    }
+    Enum(e, params) {
+        return (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
+        }));
+    }
+    created(e) {
+        return (0, applyDecorators_1.applyDecorators)((0, typeorm_1.CreateDateColumn)(), (0, types_1.ApiProperty)());
+    }
+    updated(e) {
+        return (0, applyDecorators_1.applyDecorators)((0, typeorm_1.UpdateDateColumn)(), (0, types_1.ApiProperty)());
+    }
+    deleted(e) {
+        return (0, applyDecorators_1.applyDecorators)((0, typeorm_1.DeleteDateColumn)(), (0, types_1.ApiProperty)());
+    }
+    version(e) {
+        return (0, applyDecorators_1.applyDecorators)((0, typeorm_1.VersionColumn)(), (0, types_1.ApiProperty)());
+    }
+    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 }));
+    belongsTo({ entity, inverse, pivotColumnName }) {
+        return (0, applyDecorators_1.applyDecorators)((0, typeorm_1.ManyToOne)(entity, inverse), (0, typeorm_1.JoinColumn)({
+            name: pivotColumnName,
+            referencedColumnName: 'id',
+            foreignKeyConstraintName: `${pivotColumnName}_id_${js_utils_1.Ids.nanoId()}`
+        }));
     }
-    function hasMany({ entity, inverse }) {
+    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
-    });
-})();
+}
+exports.DecoratorsClass = DecoratorsClass;
+exports.f = new DecoratorsClass();

package/dist/index.d.ts

@@ -1,23 +1,22 @@
 import { ApiHideProperty, ApiProperty, Column, HideField, InputType, ObjectType, OmitType, PartialType, getModelSchemaRef } from './core/types';
-import type { BaseDataElement, DaoOutput, Deleted, Filter, LogicOperator, PaginatedData, Paginator, Paths, Primitives, PrimitivesArray, Sure, WhereClause } from './types';
-import { PaginationLinks, PaginationMeta } from './core/dtos/pagination.dto';
-import { Access } from './core/dtos/access.dto';
+import type { AnyObject, Deleted, PaginatedData, Paginator, Primitives, PrimitivesArray, FluentQuery, QueryOutput, LoadedResult, FindByIdFilter, SingleQueryOutput } from './types';
+import { LogicOperator } from './types';
 import { BaseConnector } from './BaseConnector';
 import { Collection } from '@goatlab/js-utils';
-import { Decorators } from './decorators';
+import { f } from './decorators';
 import { Fluent } from './Fluent';
 import type { FluentConnectorInterface } from './BaseConnector';
 import type { SchemaObject } from './core/types';
-import { TypeOrmConnector } from './TypeOrmConnector/TypeOrmConnector';
+import { getRelationsFromModelGenerator, 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';
 export { DataSource } from 'typeorm';
-export { Access, ApiHideProperty, ApiProperty, BaseConnector, Collection, Column, Decorators, Fluent, getModelSchemaRef, getOutputKeys, HideField, InputType, loadRelations, modelGeneratorDataSource, ObjectType, OmitType, PaginationLinks, PaginationMeta, PartialType, TypeOrmConnector, Cache };
+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 { BaseDataElement, DaoOutput, Deleted, Filter, FluentConnectorInterface, LogicOperator, PaginatedData, Paginator, Paths, Primitives, PrimitivesArray, Sure, WhereClause, SchemaObject, ValidatedInput };
+export type { AnyObject, Deleted, FluentConnectorInterface, PaginatedData, Paginator, Primitives, PrimitivesArray, SchemaObject, ValidatedInput, FluentQuery, QueryOutput, LoadedResult, FindByIdFilter, SingleQueryOutput };

package/dist/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Cache = exports.TypeOrmConnector = exports.PartialType = exports.PaginationMeta = exports.PaginationLinks = exports.OmitType = exports.ObjectType = exports.modelGeneratorDataSource = exports.loadRelations = exports.InputType = exports.HideField = exports.getOutputKeys = exports.getModelSchemaRef = exports.Fluent = exports.Decorators = exports.Column = exports.Collection = exports.BaseConnector = exports.ApiProperty = exports.ApiHideProperty = exports.Access = exports.DataSource = void 0;
+exports.LogicOperator = exports.getRelationsFromModelGenerator = exports.Cache = exports.TypeOrmConnector = exports.PartialType = exports.OmitType = exports.ObjectType = exports.modelGeneratorDataSource = exports.loadRelations = exports.InputType = exports.HideField = exports.getOutputKeys = exports.getModelSchemaRef = exports.Fluent = exports.f = exports.Column = exports.Collection = exports.BaseConnector = exports.ApiProperty = exports.ApiHideProperty = exports.DataSource = void 0;
 const types_1 = require("./core/types");
 Object.defineProperty(exports, "ApiHideProperty", { enumerable: true, get: function () { return types_1.ApiHideProperty; } });
 Object.defineProperty(exports, "ApiProperty", { enumerable: true, get: function () { return types_1.ApiProperty; } });
@@ -11,20 +11,18 @@ Object.defineProperty(exports, "ObjectType", { enumerable: true, get: function (
 Object.defineProperty(exports, "OmitType", { enumerable: true, get: function () { return types_1.OmitType; } });
 Object.defineProperty(exports, "PartialType", { enumerable: true, get: function () { return types_1.PartialType; } });
 Object.defineProperty(exports, "getModelSchemaRef", { enumerable: true, get: function () { return types_1.getModelSchemaRef; } });
-const pagination_dto_1 = require("./core/dtos/pagination.dto");
-Object.defineProperty(exports, "PaginationLinks", { enumerable: true, get: function () { return pagination_dto_1.PaginationLinks; } });
-Object.defineProperty(exports, "PaginationMeta", { enumerable: true, get: function () { return pagination_dto_1.PaginationMeta; } });
-const access_dto_1 = require("./core/dtos/access.dto");
-Object.defineProperty(exports, "Access", { enumerable: true, get: function () { return access_dto_1.Access; } });
+const types_2 = require("./types");
+Object.defineProperty(exports, "LogicOperator", { enumerable: true, get: function () { return types_2.LogicOperator; } });
 const BaseConnector_1 = require("./BaseConnector");
 Object.defineProperty(exports, "BaseConnector", { enumerable: true, get: function () { return BaseConnector_1.BaseConnector; } });
 const js_utils_1 = require("@goatlab/js-utils");
 Object.defineProperty(exports, "Collection", { enumerable: true, get: function () { return js_utils_1.Collection; } });
 const decorators_1 = require("./decorators");
-Object.defineProperty(exports, "Decorators", { enumerable: true, get: function () { return decorators_1.Decorators; } });
+Object.defineProperty(exports, "f", { enumerable: true, get: function () { return decorators_1.f; } });
 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; } });