@rws-framework/db 2.4.0 → 2.4.2

package/dist/models/core/TimeSeriesModel.d.ts

@@ -1 +1 @@
-export {};
+export {};

package/dist/models/core/TimeSeriesModel.js

@@ -1,14 +1,14 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-// export default class TimeSeriesModel<T> extends RWSModel<T> {
-//     @TrackType(Number) value: number;
-//     @TrackType(Date) timestamp: Date;
-//     @TrackType(Object)
-//     params: any;
-//     constructor(data?: any) {    
-//         super(data);
-//         if(!this.timestamp) {
-//             this.timestamp = new Date();
-//         }
-//     }
-// }
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// export default class TimeSeriesModel<T> extends RWSModel<T> {
+//     @TrackType(Number) value: number;
+//     @TrackType(Date) timestamp: Date;
+//     @TrackType(Object)
+//     params: any;
+//     constructor(data?: any) {    
+//         super(data);
+//         if(!this.timestamp) {
+//             this.timestamp = new Date();
+//         }
+//     }
+// }

package/dist/models/index.d.ts

@@ -1,7 +1,7 @@
-import { IModel } from './interfaces/IModel';
-import { IRWSModelServices } from './interfaces/IRWSModelServices';
-import { OpModelType } from './interfaces/OpModelType';
-import { RelationBindType, RelOneMetaType, RelManyMetaType } from './types/RelationTypes';
-import { RWSModel } from './core/RWSModel';
-import { TrackType, IMetaOpts } from '../decorators';
-export { IModel, IRWSModelServices, OpModelType, RelationBindType, RelOneMetaType, RelManyMetaType, RWSModel, TrackType, IMetaOpts };
+import { IModel } from './interfaces/IModel';
+import { IRWSModelServices } from './interfaces/IRWSModelServices';
+import { OpModelType } from './interfaces/OpModelType';
+import { RelationBindType, RelOneMetaType, RelManyMetaType } from './types/RelationTypes';
+import { RWSModel } from './core/RWSModel';
+import { TrackType, IMetaOpts } from '../decorators';
+export { IModel, IRWSModelServices, OpModelType, RelationBindType, RelOneMetaType, RelManyMetaType, RWSModel, TrackType, IMetaOpts };

package/dist/models/index.js

@@ -1,8 +1,8 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TrackType = exports.RWSModel = void 0;
-const RWSModel_1 = require("./core/RWSModel");
-Object.defineProperty(exports, "RWSModel", { enumerable: true, get: function () { return RWSModel_1.RWSModel; } });
-// import TimeSeriesModel from './core/TimeSeriesModel';
-const decorators_1 = require("../decorators");
-Object.defineProperty(exports, "TrackType", { enumerable: true, get: function () { return decorators_1.TrackType; } });
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TrackType = exports.RWSModel = void 0;
+const RWSModel_1 = require("./core/RWSModel");
+Object.defineProperty(exports, "RWSModel", { enumerable: true, get: function () { return RWSModel_1.RWSModel; } });
+// import TimeSeriesModel from './core/TimeSeriesModel';
+const decorators_1 = require("../decorators");
+Object.defineProperty(exports, "TrackType", { enumerable: true, get: function () { return decorators_1.TrackType; } });

package/dist/models/interfaces/IModel.d.ts

@@ -1,11 +1,11 @@
-import { IDbConfigHandler } from '../../types/DbConfigHandler';
-import { DBService } from '../../services/DBService';
-export interface IModel {
-    [key: string]: any;
-    id: string | null;
-    save: () => void;
-    getDb: () => DBService;
-    getCollection: () => string | null;
-    configService?: IDbConfigHandler;
-    dbService?: DBService;
-}
+import { IDbConfigHandler } from '../../types/DbConfigHandler';
+import { DBService } from '../../services/DBService';
+export interface IModel {
+    [key: string]: any;
+    id: string | number | null;
+    save: () => void;
+    getDb: () => DBService;
+    getCollection: () => string | null;
+    configService?: IDbConfigHandler;
+    dbService?: DBService;
+}

package/dist/models/interfaces/IModel.js

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

package/dist/models/interfaces/IRWSModelServices.d.ts

@@ -1,6 +1,6 @@
-import { IDbConfigHandler } from '../../types/DbConfigHandler';
-import { DBService } from '../../services/DBService';
-export interface IRWSModelServices {
-    configService?: IDbConfigHandler;
-    dbService?: DBService;
-}
+import { IDbConfigHandler } from '../../types/DbConfigHandler';
+import { DBService } from '../../services/DBService';
+export interface IRWSModelServices {
+    configService?: IDbConfigHandler;
+    dbService?: DBService;
+}

package/dist/models/interfaces/IRWSModelServices.js

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

package/dist/models/interfaces/OpModelType.d.ts

@@ -1,31 +1,31 @@
-import { IRWSModel } from '../../types/IRWSModel';
-import { FindByType, IPaginationParams } from '../../types/FindParams';
-import { IRWSModelServices } from './IRWSModelServices';
-import { RelOneMetaType, RelManyMetaType } from '../types/RelationTypes';
-import { DBService } from '../../services/DBService';
-import type { RWSModel } from '../core/RWSModel';
-export interface OpModelType<T> {
-    new (data?: any | null): T;
-    services: IRWSModelServices;
-    name: string;
-    _collection: string;
-    _RELATIONS: {
-        [key: string]: boolean;
-    };
-    _CUT_KEYS: string[];
-    allModels: OpModelType<any>[];
-    loadModels: () => OpModelType<any>[];
-    checkForInclusionWithThrow: (className: string) => void;
-    checkForInclusion: (className: string) => boolean;
-    findOneBy<T extends RWSModel<T>>(this: OpModelType<T>, findParams?: FindByType): Promise<T | null>;
-    find<T extends RWSModel<T>>(this: OpModelType<T>, id: string, findParams?: Omit<FindByType, 'conditions'>): Promise<T | null>;
-    findBy<T extends RWSModel<T>>(this: OpModelType<T>, findParams?: FindByType): Promise<T[]>;
-    paginate<T extends RWSModel<T>>(this: OpModelType<T>, paginateParams?: IPaginationParams, findParams?: FindByType): Promise<T[]>;
-    delete<T extends RWSModel<T>>(this: OpModelType<T>, conditions: any): Promise<void>;
-    create<T extends RWSModel<T>>(this: new () => T, data: any): Promise<T>;
-    getRelationOneMeta(model: any, classFields: string[]): Promise<RelOneMetaType<IRWSModel>>;
-    getRelationManyMeta(model: any, classFields: string[]): Promise<RelManyMetaType<IRWSModel>>;
-    getCollection(): string;
-    getDb(): DBService;
-    setServices(services: IRWSModelServices): void;
-}
+import { IRWSModel } from '../../types/IRWSModel';
+import { FindByType, IPaginationParams } from '../../types/FindParams';
+import { IRWSModelServices } from './IRWSModelServices';
+import { RelOneMetaType, RelManyMetaType } from '../types/RelationTypes';
+import { DBService } from '../../services/DBService';
+import type { RWSModel } from '../core/RWSModel';
+export interface OpModelType<T> {
+    new (data?: any | null): T;
+    services: IRWSModelServices;
+    name: string;
+    _collection: string;
+    _RELATIONS: {
+        [key: string]: boolean;
+    };
+    _CUT_KEYS: string[];
+    allModels: OpModelType<any>[];
+    loadModels: () => OpModelType<any>[];
+    checkForInclusionWithThrow: (className: string) => void;
+    checkForInclusion: (className: string) => boolean;
+    findOneBy<T extends RWSModel<T>>(this: OpModelType<T>, findParams?: FindByType): Promise<T | null>;
+    find<T extends RWSModel<T>>(this: OpModelType<T>, id: string, findParams?: Omit<FindByType, 'conditions'>): Promise<T | null>;
+    findBy<T extends RWSModel<T>>(this: OpModelType<T>, findParams?: FindByType): Promise<T[]>;
+    paginate<T extends RWSModel<T>>(this: OpModelType<T>, paginateParams?: IPaginationParams, findParams?: FindByType): Promise<T[]>;
+    delete<T extends RWSModel<T>>(this: OpModelType<T>, conditions: any): Promise<void>;
+    create<T extends RWSModel<T>>(this: new () => T, data: any): Promise<T>;
+    getRelationOneMeta(model: any, classFields: string[]): Promise<RelOneMetaType<IRWSModel>>;
+    getRelationManyMeta(model: any, classFields: string[]): Promise<RelManyMetaType<IRWSModel>>;
+    getCollection(): string;
+    getDb(): DBService;
+    setServices(services: IRWSModelServices): void;
+}

package/dist/models/interfaces/OpModelType.js

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

package/dist/models/types/RelationTypes.d.ts

@@ -1,24 +1,24 @@
-import { IRWSModel } from '../../types/IRWSModel';
-type OpModelType<T> = any;
-export type RelationBindType = {
-    connect: {
-        id: string;
-    };
-};
-export type RelOneMetaType<T extends IRWSModel> = {
-    [key: string]: {
-        required: boolean;
-        key?: string;
-        model: OpModelType<T>;
-        hydrationField: string;
-        foreignKey: string;
-    };
-};
-export type RelManyMetaType<T extends IRWSModel> = {
-    [key: string]: {
-        key: string;
-        inversionModel: OpModelType<T>;
-        foreignKey: string;
-    };
-};
-export {};
+import { IRWSModel } from '../../types/IRWSModel';
+type OpModelType<T> = any;
+export type RelationBindType = {
+    connect: {
+        id: string;
+    };
+};
+export type RelOneMetaType<T extends IRWSModel> = {
+    [key: string]: {
+        required: boolean;
+        key?: string;
+        model: OpModelType<T>;
+        hydrationField: string;
+        foreignKey: string;
+    };
+};
+export type RelManyMetaType<T extends IRWSModel> = {
+    [key: string]: {
+        key: string;
+        inversionModel: OpModelType<T>;
+        foreignKey: string;
+    };
+};
+export {};

package/dist/models/types/RelationTypes.js

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

package/dist/models/utils/ModelUtils.d.ts

@@ -1,10 +1,10 @@
-import { RWSModel } from "../core/RWSModel";
-export declare class ModelUtils {
-    static getModelAnnotations<T extends unknown>(constructor: new () => T): Promise<Record<string, {
-        annotationType: string;
-        metadata: any;
-    }>>;
-    static checkDbVariable(constructor: any, variable: string): Promise<boolean>;
-    static isSubclass<T, C extends new () => T>(constructor: C, baseClass: new () => T): boolean;
-    static getModelScalarFields(model: RWSModel<any>): string[];
-}
+import { RWSModel } from "../core/RWSModel";
+export declare class ModelUtils {
+    static getModelAnnotations<T extends unknown>(constructor: new () => T): Promise<Record<string, {
+        annotationType: string;
+        metadata: any;
+    }>>;
+    static checkDbVariable(constructor: any, variable: string): Promise<boolean>;
+    static isSubclass<T, C extends new () => T>(constructor: C, baseClass: new () => T): boolean;
+    static getModelScalarFields(model: RWSModel<any>): string[];
+}

package/dist/models/utils/ModelUtils.js

@@ -1,56 +1,56 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ModelUtils = void 0;
-const FieldsHelper_1 = require("../../helper/FieldsHelper");
-class ModelUtils {
-    static async getModelAnnotations(constructor) {
-        const annotationsData = {};
-        const metadataKeys = Reflect.getMetadataKeys(constructor.prototype);
-        // Process all metadata keys and collect promises
-        const metadataPromises = metadataKeys.map(async (fullKey) => {
-            const [annotationType, propertyKey] = fullKey.split(':');
-            const metadata = Reflect.getMetadata(fullKey, constructor.prototype);
-            if (metadata) {
-                // If this is a relation metadata with a promise
-                if (metadata.promise && (annotationType === 'Relation' || annotationType === 'InverseRelation')) {
-                    const resolvedMetadata = await metadata.promise;
-                    annotationsData[propertyKey] = {
-                        annotationType,
-                        metadata: resolvedMetadata
-                    };
-                }
-                else {
-                    // Handle non-relation metadata as before
-                    const key = metadata.key || propertyKey;
-                    annotationsData[key] = {
-                        annotationType,
-                        metadata
-                    };
-                }
-            }
-        });
-        // Wait for all metadata to be processed
-        await Promise.all(metadataPromises);
-        return annotationsData;
-    }
-    static async checkDbVariable(constructor, variable) {
-        if (variable === 'id') {
-            return true;
-        }
-        const dbAnnotations = await ModelUtils.getModelAnnotations(constructor);
-        const dbProperties = Object.keys(dbAnnotations)
-            .map((key) => { return { ...dbAnnotations[key], key }; })
-            .filter((element) => element.annotationType === 'TrackType')
-            .map((element) => element.key);
-        return dbProperties.includes(variable);
-    }
-    static isSubclass(constructor, baseClass) {
-        return baseClass.prototype.isPrototypeOf(constructor.prototype);
-    }
-    static getModelScalarFields(model) {
-        return FieldsHelper_1.FieldsHelper.getAllClassFields(model)
-            .filter((item) => item.indexOf('TrackType') === 0)
-            .map((item) => item.split(':').at(-1));
-    }
-}
-exports.ModelUtils = ModelUtils;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModelUtils = void 0;
+const FieldsHelper_1 = require("../../helper/FieldsHelper");
+class ModelUtils {
+    static async getModelAnnotations(constructor) {
+        const annotationsData = {};
+        const metadataKeys = Reflect.getMetadataKeys(constructor.prototype);
+        // Process all metadata keys and collect promises
+        const metadataPromises = metadataKeys.map(async (fullKey) => {
+            const [annotationType, propertyKey] = fullKey.split(':');
+            const metadata = Reflect.getMetadata(fullKey, constructor.prototype);
+            if (metadata) {
+                // If this is a relation metadata with a promise
+                if (metadata.promise && (annotationType === 'Relation' || annotationType === 'InverseRelation')) {
+                    const resolvedMetadata = await metadata.promise;
+                    annotationsData[propertyKey] = {
+                        annotationType,
+                        metadata: resolvedMetadata
+                    };
+                }
+                else {
+                    // Handle non-relation metadata as before
+                    const key = metadata.key || propertyKey;
+                    annotationsData[key] = {
+                        annotationType,
+                        metadata
+                    };
+                }
+            }
+        });
+        // Wait for all metadata to be processed
+        await Promise.all(metadataPromises);
+        return annotationsData;
+    }
+    static async checkDbVariable(constructor, variable) {
+        if (variable === 'id') {
+            return true;
+        }
+        const dbAnnotations = await ModelUtils.getModelAnnotations(constructor);
+        const dbProperties = Object.keys(dbAnnotations)
+            .map((key) => { return { ...dbAnnotations[key], key }; })
+            .filter((element) => element.annotationType === 'TrackType')
+            .map((element) => element.key);
+        return dbProperties.includes(variable);
+    }
+    static isSubclass(constructor, baseClass) {
+        return baseClass.prototype.isPrototypeOf(constructor.prototype);
+    }
+    static getModelScalarFields(model) {
+        return FieldsHelper_1.FieldsHelper.getAllClassFields(model)
+            .filter((item) => item.indexOf('TrackType') === 0)
+            .map((item) => item.split(':').at(-1));
+    }
+}
+exports.ModelUtils = ModelUtils;

package/dist/models/utils/PaginationUtils.d.ts

@@ -1,5 +1,5 @@
-import { OpModelType, RWSModel } from '../_model';
-import { FindByType, IPaginationParams } from '../../types/FindParams';
-export declare class PaginationUtils {
-    static paginate<T extends RWSModel<T>>(this: OpModelType<T>, paginationParams?: IPaginationParams, findParams?: FindByType): Promise<T[]>;
-}
+import { OpModelType, RWSModel } from '../_model';
+import { FindByType, IPaginationParams } from '../../types/FindParams';
+export declare class PaginationUtils {
+    static paginate<T extends RWSModel<T>>(this: OpModelType<T>, paginationParams?: IPaginationParams, findParams?: FindByType): Promise<T[]>;
+}

package/dist/models/utils/PaginationUtils.js

@@ -1,32 +1,32 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PaginationUtils = void 0;
-class PaginationUtils {
-    static async paginate(paginationParams = { page: 0, per_page: 50 }, findParams = {}) {
-        var _a, _b, _c, _d, _e;
-        const conditions = (_a = findParams === null || findParams === void 0 ? void 0 : findParams.conditions) !== null && _a !== void 0 ? _a : {};
-        const ordering = (_b = findParams === null || findParams === void 0 ? void 0 : findParams.ordering) !== null && _b !== void 0 ? _b : null;
-        const fields = (_c = findParams === null || findParams === void 0 ? void 0 : findParams.fields) !== null && _c !== void 0 ? _c : null;
-        const allowRelations = (_d = findParams === null || findParams === void 0 ? void 0 : findParams.allowRelations) !== null && _d !== void 0 ? _d : true;
-        const fullData = (_e = findParams === null || findParams === void 0 ? void 0 : findParams.fullData) !== null && _e !== void 0 ? _e : false;
-        const collection = Reflect.get(this, '_collection');
-        this.checkForInclusionWithThrow(this.name);
-        try {
-            const dbData = await this.services.dbService.findBy(collection, conditions, fields, ordering, paginationParams);
-            if (dbData.length) {
-                const instanced = [];
-                for (const data of dbData) {
-                    const inst = new this();
-                    instanced.push((await inst._asyncFill(data, fullData, allowRelations)));
-                }
-                return instanced;
-            }
-            return [];
-        }
-        catch (rwsError) {
-            console.error(rwsError);
-            throw rwsError;
-        }
-    }
-}
-exports.PaginationUtils = PaginationUtils;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PaginationUtils = void 0;
+class PaginationUtils {
+    static async paginate(paginationParams = { page: 0, per_page: 50 }, findParams = {}) {
+        var _a, _b, _c, _d, _e;
+        const conditions = (_a = findParams === null || findParams === void 0 ? void 0 : findParams.conditions) !== null && _a !== void 0 ? _a : {};
+        const ordering = (_b = findParams === null || findParams === void 0 ? void 0 : findParams.ordering) !== null && _b !== void 0 ? _b : null;
+        const fields = (_c = findParams === null || findParams === void 0 ? void 0 : findParams.fields) !== null && _c !== void 0 ? _c : null;
+        const allowRelations = (_d = findParams === null || findParams === void 0 ? void 0 : findParams.allowRelations) !== null && _d !== void 0 ? _d : true;
+        const fullData = (_e = findParams === null || findParams === void 0 ? void 0 : findParams.fullData) !== null && _e !== void 0 ? _e : false;
+        const collection = Reflect.get(this, '_collection');
+        this.checkForInclusionWithThrow(this.name);
+        try {
+            const dbData = await this.services.dbService.findBy(collection, conditions, fields, ordering, paginationParams);
+            if (dbData.length) {
+                const instanced = [];
+                for (const data of dbData) {
+                    const inst = new this();
+                    instanced.push((await inst._asyncFill(data, fullData, allowRelations)));
+                }
+                return instanced;
+            }
+            return [];
+        }
+        catch (rwsError) {
+            console.error(rwsError);
+            throw rwsError;
+        }
+    }
+}
+exports.PaginationUtils = PaginationUtils;

package/dist/models/utils/RelationUtils.d.ts

@@ -1,14 +1,14 @@
-import { RelOneMetaType, RelManyMetaType } from '../types/RelationTypes';
-import { IRWSModel } from '../../types/IRWSModel';
-import { RWSModel } from '../_model';
-export declare class RelationUtils {
-    static getRelationOneMeta(model: RWSModel<any>, classFields: string[]): Promise<RelOneMetaType<IRWSModel>>;
-    static getRelationManyMeta(model: RWSModel<any>, classFields: string[]): Promise<RelManyMetaType<IRWSModel>>;
-    static bindRelation(relatedModel: RWSModel<any>): {
-        connect: {
-            id: string;
-        };
-    };
-    static hasRelation(model: RWSModel<any>, key: string): boolean;
-    static checkRelEnabled(model: RWSModel<any>, key: string): boolean;
-}
+import { RelOneMetaType, RelManyMetaType } from '../types/RelationTypes';
+import { IRWSModel } from '../../types/IRWSModel';
+import { RWSModel } from '../_model';
+export declare class RelationUtils {
+    static getRelationOneMeta(model: RWSModel<any>, classFields: string[]): Promise<RelOneMetaType<IRWSModel>>;
+    static getRelationManyMeta(model: RWSModel<any>, classFields: string[]): Promise<RelManyMetaType<IRWSModel>>;
+    static bindRelation(relatedModel: RWSModel<any>): {
+        connect: {
+            id: string | number;
+        };
+    };
+    static hasRelation(model: RWSModel<any>, key: string): boolean;
+    static checkRelEnabled(model: RWSModel<any>, key: string): boolean;
+}

package/dist/models/utils/RelationUtils.js

@@ -1,65 +1,65 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RelationUtils = void 0;
-class RelationUtils {
-    static async getRelationOneMeta(model, classFields) {
-        const relIds = {};
-        const relationFields = classFields
-            .filter((item) => item.indexOf('Relation') === 0 && !item.includes('Inverse'))
-            .map((item) => item.split(':').at(-1));
-        for (const key of relationFields) {
-            const metadataKey = `Relation:${key}`;
-            const metadata = Reflect.getMetadata(metadataKey, model);
-            if (metadata && metadata.promise) {
-                const resolvedMetadata = await metadata.promise;
-                if (!relIds[key]) {
-                    relIds[key] = {
-                        key: resolvedMetadata.key,
-                        required: resolvedMetadata.required,
-                        model: resolvedMetadata.relatedTo,
-                        hydrationField: resolvedMetadata.relationField,
-                        foreignKey: resolvedMetadata.relatedToField
-                    };
-                }
-            }
-        }
-        return relIds;
-    }
-    static async getRelationManyMeta(model, classFields) {
-        const relIds = {};
-        const inverseFields = classFields
-            .filter((item) => item.indexOf('InverseRelation') === 0)
-            .map((item) => item.split(':').at(-1));
-        for (const key of inverseFields) {
-            const metadataKey = `InverseRelation:${key}`;
-            const metadata = Reflect.getMetadata(metadataKey, model);
-            if (metadata && metadata.promise) {
-                const resolvedMetadata = await metadata.promise;
-                if (!relIds[key]) {
-                    relIds[key] = {
-                        key: resolvedMetadata.key,
-                        inversionModel: resolvedMetadata.inversionModel,
-                        foreignKey: resolvedMetadata.foreignKey
-                    };
-                }
-            }
-        }
-        return relIds;
-    }
-    static bindRelation(relatedModel) {
-        return {
-            connect: {
-                id: relatedModel.id
-            }
-        };
-    }
-    static hasRelation(model, key) {
-        // Check if the property exists and is an object with an id property
-        return !!model[key] && typeof model[key] === 'object' && model[key] !== null && 'id' in model[key];
-    }
-    static checkRelEnabled(model, key) {
-        return Object.keys(model.constructor._RELATIONS).includes(key) &&
-            model.constructor._RELATIONS[key] === true;
-    }
-}
-exports.RelationUtils = RelationUtils;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RelationUtils = void 0;
+class RelationUtils {
+    static async getRelationOneMeta(model, classFields) {
+        const relIds = {};
+        const relationFields = classFields
+            .filter((item) => item.indexOf('Relation') === 0 && !item.includes('Inverse'))
+            .map((item) => item.split(':').at(-1));
+        for (const key of relationFields) {
+            const metadataKey = `Relation:${key}`;
+            const metadata = Reflect.getMetadata(metadataKey, model);
+            if (metadata && metadata.promise) {
+                const resolvedMetadata = await metadata.promise;
+                if (!relIds[key]) {
+                    relIds[key] = {
+                        key: resolvedMetadata.key,
+                        required: resolvedMetadata.required,
+                        model: resolvedMetadata.relatedTo,
+                        hydrationField: resolvedMetadata.relationField,
+                        foreignKey: resolvedMetadata.relatedToField
+                    };
+                }
+            }
+        }
+        return relIds;
+    }
+    static async getRelationManyMeta(model, classFields) {
+        const relIds = {};
+        const inverseFields = classFields
+            .filter((item) => item.indexOf('InverseRelation') === 0)
+            .map((item) => item.split(':').at(-1));
+        for (const key of inverseFields) {
+            const metadataKey = `InverseRelation:${key}`;
+            const metadata = Reflect.getMetadata(metadataKey, model);
+            if (metadata && metadata.promise) {
+                const resolvedMetadata = await metadata.promise;
+                if (!relIds[key]) {
+                    relIds[key] = {
+                        key: resolvedMetadata.key,
+                        inversionModel: resolvedMetadata.inversionModel,
+                        foreignKey: resolvedMetadata.foreignKey
+                    };
+                }
+            }
+        }
+        return relIds;
+    }
+    static bindRelation(relatedModel) {
+        return {
+            connect: {
+                id: relatedModel.id
+            }
+        };
+    }
+    static hasRelation(model, key) {
+        // Check if the property exists and is an object with an id property
+        return !!model[key] && typeof model[key] === 'object' && model[key] !== null && 'id' in model[key];
+    }
+    static checkRelEnabled(model, key) {
+        return Object.keys(model.constructor._RELATIONS).includes(key) &&
+            model.constructor._RELATIONS[key] === true;
+    }
+}
+exports.RelationUtils = RelationUtils;