@rws-framework/db 3.3.7 → 3.4.1

package/src/helper/db/schema-generator.ts

@@ -30,19 +30,26 @@ export class SchemaGenerator {
      * @param dbUrl The database URL
      * @returns The base schema
      */
-    static generateBaseSchema(dbType: string, dbUrl: string): string {
+    static generateBaseSchema(dbType: string, dbUrl: string, output?: string, binaryTargets?: string[]): string {
         process.env = { ...process.env, [this.dbUrlVarName]: dbUrl };
 
         return `generator client {
     provider = "prisma-client-js"
+    ${output ? `output = "${this.ospath(output)}"` : ''}
+    ${binaryTargets ? `binaryTargets = ${JSON.stringify(binaryTargets)}` : ''}
 }
 
 datasource db {
     provider = "${dbType}"
-    url = env("${this.dbUrlVarName}")
+    url = env("${this.dbUrlVarName}")    
 }`;
     }
 
+    private static ospath(outPath: string): string
+    {
+        return outPath.split('')[1] === ':' ? outPath.replace(/\\/g,'\\\\') : outPath
+    }
+
     /**
      * Generate model sections for the schema
      * @param model The model to generate a section for
@@ -125,12 +132,20 @@ datasource db {
 
                 const relatedToField = modelMetadata.relatedToField || 'id';
                 const bindingFieldExists = !!modelMetadatas[relationFieldName];  
-                
+                const relatedFieldMeta = relatedModelMetadatas[relatedToField];
+
+                const foundInverseRelation = Object.values(relatedModelMetadatas).find(item => item.metadata.foreignKey === relationFieldName && item.metadata.inversionModel._collection === modelName);
+
                 if(modelMetadata.required === false){
                     requiredString = '?';
                 }               
 
-                const cascadeStr = cascadeOpts.length ? `, ${cascadeOpts.join(', ')}` : '' ;
+                let cascadeStr = cascadeOpts.length ? `, ${cascadeOpts.join(', ')}` : '' ;
+
+                if(foundInverseRelation && foundInverseRelation.metadata.singular){                     
+                    cascadeStr = '';
+                    requiredString = '?';
+                }
 
                 if (isMany) {
                     // Add an inverse field to the related model if it doesn't exist
@@ -138,7 +153,6 @@ datasource db {
                 } else {                             
                     section += `\t${key} ${relatedModel._collection}${requiredString} @relation(${relationName ? `"${relationName}", ` : ''}fields: [${relationFieldName}], references: [${relatedToField}]${mapName ? `, map: "${mapName}"` : ''}${cascadeStr})\n`;
                     if(!bindingFieldExists){
-                        const relatedFieldMeta = relatedModelMetadatas[relatedToField];
 
                         if(!relatedFieldMeta.metadata.required){                     
                             requiredString = '';
@@ -150,21 +164,28 @@ datasource db {
                         if(relationMeta.required === false){
                             requiredString = '?';
                         }
+
+                        let appendix = '';
+
+                        if(foundInverseRelation && foundInverseRelation.metadata.singular){                           
+                            appendix = ' @unique';
+                            requiredString = '?';
+                        }
                     
                         // Add relation field with appropriate type based on database
                         if (dbType === 'mongodb') {
-                            section += `\t${relationFieldName} String${requiredString} @db.ObjectId\n`;
+                            section += `\t${relationFieldName} String${requiredString} @db.ObjectId${appendix}\n`;
                         } else if (dbType === 'mysql') {
                             // For MySQL, determine the type based on the related model's ID type
-                            section += `\t${relationFieldName} ${relatedFieldType}${requiredString}\n`;
+                            section += `\t${relationFieldName} ${relatedFieldType}${requiredString}${appendix}\n`;
                         } else if (dbType === 'postgresql' || dbType === 'postgres') {
                             if (relatedFieldType === 'String') {
-                                section += `\t${relationFieldName} ${relatedFieldType}${requiredString} @db.Uuid\n`;
+                                section += `\t${relationFieldName} ${relatedFieldType}${requiredString} @db.Uuid${appendix}\n`;
                             } else {
-                                section += `\t${relationFieldName} ${relatedFieldType}${requiredString}\n`;
+                                section += `\t${relationFieldName} ${relatedFieldType}${requiredString}${appendix}\n`;
                             }
                         } else {                        
-                            section += `\t${relationFieldName} String${requiredString}\n`;
+                            section += `\t${relationFieldName} String${requiredString}${appendix}\n`;
                         }
                     }
                 }
@@ -182,6 +203,7 @@ datasource db {
                 const relationIndex = RelationManager.getRelationCounter(relationKey, true);
 
                 const relationName = RelationManager.getShortenedRelationName(relatedModelName, modelName, relationIndex);                
+                const singular: boolean = relationMeta.singular;            
 
                 let relationTag = '';
 
@@ -189,7 +211,7 @@ datasource db {
                     relationTag = ` @relation("${relationMeta.relationName}")`;
                 }
 
-                section += `\t${key} ${relationMeta.inversionModel._collection}[]${relationTag}\n`;
+                section += `\t${key} ${relationMeta.inversionModel._collection}${singular ? '?' : '[]'}${relationTag}\n`;
                 
                 RelationManager.completeRelation(relationKey, relationIndex, true);
             } else if (annotationType === 'InverseTimeSeries') {
@@ -341,8 +363,10 @@ datasource db {
     static async installPrisma(configService: IDbConfigHandler, dbService: DBService, leaveFile = false): Promise<void> {
         const dbUrl = configService.get('db_url');
         const dbType = configService.get('db_type') || 'mongodb';
+        const dbPrismaOutput = configService.get('db_prisma_output');
+        const dbPrismaBinaryTargets = configService.get('db_prisma_binary_targets');
 
-        let template: string = this.generateBaseSchema(dbType, dbUrl);
+        let template: string = this.generateBaseSchema(dbType, dbUrl, dbPrismaOutput, dbPrismaBinaryTargets);
 
         const dbModels: OpModelType<unknown>[] | null = configService.get('db_models');
 

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/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 |number | 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/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/ITrackerOpts.ts

@@ -9,6 +9,8 @@ export interface ITrackerOpts extends IDbOpts {
     relatedToField?: string,
     relatedTo?: OpModelType<any>,
     inversionModel?: OpModelType<any>,
-    relationName?: string    
+    relationName?: string;
+    foreignKey?: string        
     noAuto?: boolean;
+    singular?: boolean;
   }

package/src/models/types/RelationTypes.ts

@@ -20,6 +20,7 @@ export type RelManyMetaType<T extends IRWSModel> = {
     [key: string]: {
         key: string, 
         inversionModel: OpModelType<T>, 
-        foreignKey: string
+        foreignKey: string,
+        singular: boolean
     }
 };

package/src/models/utils/HydrateUtils.ts

@@ -61,13 +61,22 @@ export class HydrateUtils {
 
                  if (relationEnabled) {         
                     const pk = ModelUtils.findPrimaryKeyFields(model.constructor as OpModelType<any>) as string;
-                            
-                    model[relMeta.key] = await relMeta.inversionModel.findBy({
-                         conditions: {
-                             [relMeta.foreignKey]: data[pk]
-                         },
-                         allowRelations: false
-                     });          
+                    
+                    if(relMeta.singular){
+                        model[relMeta.key] = await relMeta.inversionModel.findOneBy({
+                            conditions: {
+                                [relMeta.foreignKey]: data[pk]
+                            },
+                            allowRelations: false
+                       });
+                    } else {
+                        model[relMeta.key] = await relMeta.inversionModel.findBy({
+                            conditions: {
+                                [relMeta.foreignKey]: data[pk]
+                            },
+                            allowRelations: false
+                       });
+                    }                              
                  }                                
              }
              

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

@@ -47,7 +47,8 @@ export class RelationUtils {
                     relIds[key] = {       
                         key: resolvedMetadata.key,         
                         inversionModel: resolvedMetadata.inversionModel,
-                        foreignKey: resolvedMetadata.foreignKey                   
+                        foreignKey: resolvedMetadata.foreignKey,     
+                        singular: resolvedMetadata?.singular || false             
                     };
                 }
             }                         

package/src/models/utils/TimeSeriesUtils.ts

@@ -1,38 +1,38 @@
-import { RWSModel } from "../_model";
-
-export class TimeSeriesUtils {
-    static getTimeSeriesModelFields(model: RWSModel<any>): {[key: string]: {collection: string, hydrationField: string, ids: string[]}} {
-        const timeSeriesIds: {[key: string]: {collection: string, hydrationField: string, ids: string[]}} = {};
-
-        for (const key in model) {
-            if (model.hasOwnProperty(key)) {             
-                const meta = Reflect.getMetadata(`InverseTimeSeries:${key}`, model);            
-                if(meta){
-                    if(!timeSeriesIds[key]){
-                        timeSeriesIds[key] = {
-                            collection: meta.timeSeriesModel,
-                            hydrationField: meta.hydrationField,
-                            ids: model[key]
-                        };
-                    }
-                }                         
-            }
-        } 
-
-        return timeSeriesIds;
-    }
-
-    static checkTimeSeries(constructor: any): boolean {            
-        const data = constructor.prototype as any;
-
-        for (const key in data) {
-            if (data.hasOwnProperty(key)) {   
-                if(Reflect.getMetadata(`InverseTimeSeries:${key}`, constructor.prototype)){
-                    return true;
-                }
-            }
-        }
-
-        return false;
-    }
-}
+import { RWSModel } from "../_model";
+
+export class TimeSeriesUtils {
+    static getTimeSeriesModelFields(model: RWSModel<any>): {[key: string]: {collection: string, hydrationField: string, ids: string[]}} {
+        const timeSeriesIds: {[key: string]: {collection: string, hydrationField: string, ids: string[]}} = {};
+
+        for (const key in model) {
+            if (model.hasOwnProperty(key)) {             
+                const meta = Reflect.getMetadata(`InverseTimeSeries:${key}`, model);            
+                if(meta){
+                    if(!timeSeriesIds[key]){
+                        timeSeriesIds[key] = {
+                            collection: meta.timeSeriesModel,
+                            hydrationField: meta.hydrationField,
+                            ids: model[key]
+                        };
+                    }
+                }                         
+            }
+        } 
+
+        return timeSeriesIds;
+    }
+
+    static checkTimeSeries(constructor: any): boolean {            
+        const data = constructor.prototype as any;
+
+        for (const key in data) {
+            if (data.hasOwnProperty(key)) {   
+                if(Reflect.getMetadata(`InverseTimeSeries:${key}`, constructor.prototype)){
+                    return true;
+                }
+            }
+        }
+
+        return false;
+    }
+}

package/src/types/DbConfigHandler.ts

@@ -4,7 +4,9 @@ export interface IDbConfigParams {
     db_url?: string;
     db_name?: string;
     db_type?: 'mongodb' | 'mysql' | 'sqlite' | 'postgresql' | 'postgres';
-    db_models?: OpModelType<any>[]
+    db_models?: OpModelType<any>[],
+    db_prisma_output?: string,
+    db_prisma_binary_targets?: string[]
 }
 
 export interface IdGeneratorOptions {

package/src/types/FindParams.ts

@@ -1,13 +1,13 @@
-export type FindByType = {
-    conditions?: any  
-    ordering?: { [fieldName: string]: string }
-    fields?: string[]
-    allowRelations?: boolean
-    fullData?: boolean
-    pagination?: IPaginationParams
-}
-
-export interface IPaginationParams {
-    page: number,
-    per_page?: number
-}
+export type FindByType = {
+    conditions?: any  
+    ordering?: { [fieldName: string]: string }
+    fields?: string[]
+    allowRelations?: boolean
+    fullData?: boolean
+    pagination?: IPaginationParams
+}
+
+export interface IPaginationParams {
+    page: number,
+    per_page?: number
+}

package/src/types/ITimeSeries.ts

@@ -1,6 +1,6 @@
-export interface ITimeSeries {  
-    value: number,  
-    timestamp?: Date;
-    params?: any;
-    time_tracker_id?: string
+export interface ITimeSeries {  
+    value: number,  
+    timestamp?: Date;
+    params?: any;
+    time_tracker_id?: string
 }