@rws-framework/db 2.3.2 → 2.4.1

package/src/models/core/TimeSeriesModel.ts

@@ -1,19 +1,19 @@
-import { RWSModel } from './RWSModel';
-import { TrackType } from '../../decorators';
-
-// 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();
-//         }
-//     }
-// }
+import { RWSModel } from './RWSModel';
+import { TrackType } from '../../decorators';
+
+// 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/src/models/index.ts

@@ -1,20 +1,20 @@
-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 TimeSeriesModel from './core/TimeSeriesModel';
-import { TrackType, IMetaOpts } from '../decorators';
-
-export {
-    IModel,
-    IRWSModelServices,
-    OpModelType,
-    RelationBindType,
-    RelOneMetaType,
-    RelManyMetaType,
-    RWSModel,
-    // TimeSeriesModel,
-    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 TimeSeriesModel from './core/TimeSeriesModel';
+import { TrackType, IMetaOpts } from '../decorators';
+
+export {
+    IModel,
+    IRWSModelServices,
+    OpModelType,
+    RelationBindType,
+    RelOneMetaType,
+    RelManyMetaType,
+    RWSModel,
+    // TimeSeriesModel,
+    TrackType,
+    IMetaOpts
+};

package/src/models/interfaces/IModel.ts

@@ -1,12 +1,12 @@
-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 | null;
+    save: () => void;
+    getDb: () => DBService;
+    getCollection: () => string | null;
+    configService?: IDbConfigHandler;
+    dbService?: DBService;
+}

package/src/models/interfaces/IRWSModelServices.ts

@@ -1,7 +1,7 @@
-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/src/models/interfaces/OpModelType.ts

@@ -1,49 +1,49 @@
-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';
-
-// Reference to the RWSModel class to avoid circular dependency
-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';
+
+// Reference to the RWSModel class to avoid circular dependency
+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/src/models/types/RelationTypes.ts

@@ -1,25 +1,25 @@
-import { IRWSModel } from '../../types/IRWSModel';
-// Using a type reference to avoid circular dependency
-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
-    }
-};
+import { IRWSModel } from '../../types/IRWSModel';
+// Using a type reference to avoid circular dependency
+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
+    }
+};

package/src/models/utils/ModelUtils.ts

@@ -1,65 +1,65 @@
-import { RWSModel } from "../core/RWSModel";
-import { FieldsHelper } from '../../helper/FieldsHelper';
-
-export class ModelUtils {
-    static async getModelAnnotations<T extends unknown>(constructor: new () => T): Promise<Record<string, {annotationType: string, metadata: any}>> {    
-        const annotationsData: Record<string, {annotationType: string, metadata: any}> = {};
-    
-        const metadataKeys = Reflect.getMetadataKeys(constructor.prototype);
-        
-        // Process all metadata keys and collect promises
-        const metadataPromises = metadataKeys.map(async (fullKey: string) => {
-            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: any, variable: string): Promise<boolean> {                   
-        if(variable === 'id'){
-            return true;
-        }
-        
-        const dbAnnotations = await ModelUtils.getModelAnnotations(constructor);
-        type AnnotationType = { annotationType: string, key: string };
-    
-        const dbProperties: string[] = Object.keys(dbAnnotations)
-            .map((key: string): AnnotationType => {return {...dbAnnotations[key], key};})
-            .filter((element: AnnotationType) => element.annotationType === 'TrackType' )
-            .map((element: AnnotationType) => element.key);
-    
-        return dbProperties.includes(variable);
-    }
-
-    static isSubclass<T, C extends new () => T>(constructor: C, baseClass: new () => T): boolean {
-        return baseClass.prototype.isPrototypeOf(constructor.prototype);
-    }
-
-    static getModelScalarFields(model: RWSModel<any>): string[] {       
-        return FieldsHelper.getAllClassFields(model)
-                .filter((item: string) => item.indexOf('TrackType') === 0)
-                .map((item: string) => item.split(':').at(-1));
-    }
-}
+import { RWSModel } from "../core/RWSModel";
+import { FieldsHelper } from '../../helper/FieldsHelper';
+
+export class ModelUtils {
+    static async getModelAnnotations<T extends unknown>(constructor: new () => T): Promise<Record<string, {annotationType: string, metadata: any}>> {    
+        const annotationsData: Record<string, {annotationType: string, metadata: any}> = {};
+    
+        const metadataKeys = Reflect.getMetadataKeys(constructor.prototype);
+        
+        // Process all metadata keys and collect promises
+        const metadataPromises = metadataKeys.map(async (fullKey: string) => {
+            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: any, variable: string): Promise<boolean> {                   
+        if(variable === 'id'){
+            return true;
+        }
+        
+        const dbAnnotations = await ModelUtils.getModelAnnotations(constructor);
+        type AnnotationType = { annotationType: string, key: string };
+    
+        const dbProperties: string[] = Object.keys(dbAnnotations)
+            .map((key: string): AnnotationType => {return {...dbAnnotations[key], key};})
+            .filter((element: AnnotationType) => element.annotationType === 'TrackType' )
+            .map((element: AnnotationType) => element.key);
+    
+        return dbProperties.includes(variable);
+    }
+
+    static isSubclass<T, C extends new () => T>(constructor: C, baseClass: new () => T): boolean {
+        return baseClass.prototype.isPrototypeOf(constructor.prototype);
+    }
+
+    static getModelScalarFields(model: RWSModel<any>): string[] {       
+        return FieldsHelper.getAllClassFields(model)
+                .filter((item: string) => item.indexOf('TrackType') === 0)
+                .map((item: string) => item.split(':').at(-1));
+    }
+}

package/src/models/utils/PaginationUtils.ts

@@ -1,42 +1,42 @@
-import { RelOneMetaType, RelManyMetaType } from '../types/RelationTypes';
-import { IRWSModel } from '../../types/IRWSModel';
-import { OpModelType, RWSModel } from '../_model';
-import { FindByType, IPaginationParams } from '../../types/FindParams';
-
-export class PaginationUtils {
-
-    public static async paginate<T extends RWSModel<T>>(
-            this: OpModelType<T>,             
-            paginationParams: IPaginationParams = { page: 0, per_page: 50 },
-            findParams: FindByType = {},
-        ): Promise<T[]> {
-        const conditions = findParams?.conditions ?? {};
-        const ordering = findParams?.ordering ?? null;
-        const fields = findParams?.fields ?? null;
-        const allowRelations = findParams?.allowRelations ?? true;
-        const fullData = findParams?.fullData ?? 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: T[] = [];
-        
-                for (const data of dbData) { 
-                    const inst: T = new (this as { new(): T })();
-                    instanced.push((await inst._asyncFill(data, fullData,allowRelations)) as T);
-                }
-        
-                return instanced;
-            }
-        
-            return [];
-        } catch (rwsError: Error | any) {
-            console.error(rwsError);
-
-            throw rwsError;
-        }          
-    }
-    
-}
+import { RelOneMetaType, RelManyMetaType } from '../types/RelationTypes';
+import { IRWSModel } from '../../types/IRWSModel';
+import { OpModelType, RWSModel } from '../_model';
+import { FindByType, IPaginationParams } from '../../types/FindParams';
+
+export class PaginationUtils {
+
+    public static async paginate<T extends RWSModel<T>>(
+            this: OpModelType<T>,             
+            paginationParams: IPaginationParams = { page: 0, per_page: 50 },
+            findParams: FindByType = {},
+        ): Promise<T[]> {
+        const conditions = findParams?.conditions ?? {};
+        const ordering = findParams?.ordering ?? null;
+        const fields = findParams?.fields ?? null;
+        const allowRelations = findParams?.allowRelations ?? true;
+        const fullData = findParams?.fullData ?? 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: T[] = [];
+        
+                for (const data of dbData) { 
+                    const inst: T = new (this as { new(): T })();
+                    instanced.push((await inst._asyncFill(data, fullData,allowRelations)) as T);
+                }
+        
+                return instanced;
+            }
+        
+            return [];
+        } catch (rwsError: Error | any) {
+            console.error(rwsError);
+
+            throw rwsError;
+        }          
+    }
+    
+}

package/src/models/utils/RelationUtils.ts

@@ -1,76 +1,76 @@
-import { RelOneMetaType, RelManyMetaType } from '../types/RelationTypes';
-import { IRWSModel } from '../../types/IRWSModel';
-import { RWSModel } from '../_model';
-
-export class RelationUtils {
-    static async getRelationOneMeta(model: RWSModel<any>, classFields: string[]): Promise<RelOneMetaType<IRWSModel>> {
-        const relIds: RelOneMetaType<IRWSModel> = {};
-        const relationFields = classFields
-            .filter((item: string) => item.indexOf('Relation') === 0 && !item.includes('Inverse'))
-            .map((item: string) => 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: RWSModel<any>, classFields: string[]): Promise<RelManyMetaType<IRWSModel>> {
-        const relIds: RelManyMetaType<IRWSModel> = {};
-    
-        const inverseFields = classFields
-            .filter((item: string) => item.indexOf('InverseRelation') === 0)
-            .map((item: string) => 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: RWSModel<any>): { connect: { id: string } } {
-        return {
-            connect: {
-                id: relatedModel.id
-            }
-        };
-    }
-
-    static hasRelation(model: RWSModel<any>, key: string): boolean {
-        // 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: RWSModel<any>, key: string): boolean {
-        return Object.keys((model.constructor as any)._RELATIONS).includes(key) && 
-               (model.constructor as any)._RELATIONS[key] === true;
-    }
-}
+import { RelOneMetaType, RelManyMetaType } from '../types/RelationTypes';
+import { IRWSModel } from '../../types/IRWSModel';
+import { RWSModel } from '../_model';
+
+export class RelationUtils {
+    static async getRelationOneMeta(model: RWSModel<any>, classFields: string[]): Promise<RelOneMetaType<IRWSModel>> {
+        const relIds: RelOneMetaType<IRWSModel> = {};
+        const relationFields = classFields
+            .filter((item: string) => item.indexOf('Relation') === 0 && !item.includes('Inverse'))
+            .map((item: string) => 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: RWSModel<any>, classFields: string[]): Promise<RelManyMetaType<IRWSModel>> {
+        const relIds: RelManyMetaType<IRWSModel> = {};
+    
+        const inverseFields = classFields
+            .filter((item: string) => item.indexOf('InverseRelation') === 0)
+            .map((item: string) => 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: RWSModel<any>): { connect: { id: string } } {
+        return {
+            connect: {
+                id: relatedModel.id
+            }
+        };
+    }
+
+    static hasRelation(model: RWSModel<any>, key: string): boolean {
+        // 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: RWSModel<any>, key: string): boolean {
+        return Object.keys((model.constructor as any)._RELATIONS).includes(key) && 
+               (model.constructor as any)._RELATIONS[key] === true;
+    }
+}