@rws-framework/db 3.3.3 → 3.3.5

package/dist/decorators/RWSCollection.d.ts

@@ -2,7 +2,10 @@ import { OpModelType } from "../models/_model";
 export interface ISuperTagData {
     tagType: string;
     fields: string[];
-    map: string;
+    fieldParams?: {
+        [key: string]: any;
+    };
+    map?: string;
 }
 export interface IRWSCollectionOpts {
     relations?: {

package/dist/decorators/Relation.js

@@ -20,6 +20,9 @@ function Relation(theModel, relationOptions = _DEFAULTS) {
                     null
             };
             if (relationOptions.required) {
+                if (!metaOpts.cascade) {
+                    metaOpts.cascade = {};
+                }
                 metaOpts.cascade.onDelete = 'Restrict';
             }
             return metaOpts;

package/dist/helper/db/schema-generator.d.ts

@@ -20,6 +20,7 @@ export declare class SchemaGenerator {
      * @returns The model section
      */
     static generateModelSections(model: OpModelType<any>, configService: IDbConfigHandler): Promise<string>;
+    private static getSuperFieldFromModel;
     /**
      * Install Prisma with the generated schema
      * @param configService The configuration service

package/dist/helper/db/schema-generator.js

@@ -108,13 +108,8 @@ datasource db {
                         if (!relatedFieldMeta.metadata.required) {
                             requiredString = '';
                         }
-                        let relatedFieldType = type_converter_1.TypeConverter.toConfigCase(relatedFieldMeta.metadata, dbType, true);
-                        /**
-                         * @todo: Detect type
-                         */
-                        if (relatedToField === 'id' && dbType !== 'mongodb') {
-                            relatedFieldType = 'Int';
-                        }
+                        const defaultIdType = utils_1.DbUtils.getDefaultPrismaType(dbType, relatedFieldMeta.annotationType !== 'TrackType' && relatedFieldMeta.metadata.type.name === 'String' && relatedToField === 'id' && dbType !== 'mongodb');
+                        let relatedFieldType = type_converter_1.TypeConverter.toConfigCase(relatedFieldMeta.metadata, dbType, true, relatedFieldMeta.annotationType !== 'TrackType' && relatedToField === 'id' && relatedFieldMeta.metadata.type !== defaultIdType);
                         if (relationMeta.required === false) {
                             requiredString = '?';
                         }
@@ -218,10 +213,24 @@ datasource db {
             section += '\n';
         }
         for (const superTag of model._SUPER_TAGS) {
-            const mapStr = superTag.map ? `, map: "${superTag.map}"` : '';
+            let mapStr = '';
+            if (superTag.map) {
+                const superFieldMapMeta = modelMetadatas[superTag.map];
+                let mapField = superTag.map;
+                if (superFieldMapMeta) {
+                    mapField = this.getSuperFieldFromModel(mapField, superFieldMapMeta);
+                }
+                mapStr = `, map: "${mapField}"`;
+            }
             const superFields = [];
-            for (const superField of superTag.fields) {
-                const fieldMetadata = modelMetadatas[superField]['metadata'];
+            for (let superField of superTag.fields) {
+                const superFieldElemMeta = modelMetadatas[superField];
+                if (!superFieldElemMeta) {
+                    console.log(chalk_1.default.yellowBright(`Ignoring "${superField}" field in "${superTag.tagType}" supertag in model "${modelName}"`));
+                    continue;
+                }
+                const fieldMetadata = superFieldElemMeta.metadata;
+                superField = this.getSuperFieldFromModel(superField, superFieldElemMeta);
                 let pushed = false;
                 if (fieldMetadata.dbOptions && fieldMetadata.dbOptions.mysql && fieldMetadata.dbOptions.mysql.useType) {
                     switch (fieldMetadata.dbOptions.mysql.useType) {
@@ -240,6 +249,14 @@ datasource db {
         section += '}\n';
         return section;
     }
+    static getSuperFieldFromModel(superFieldElemName, superFieldElemMeta) {
+        const fieldDecorator = superFieldElemMeta.annotationType;
+        if (fieldDecorator === 'Relation') {
+            const fieldMetadata = superFieldElemMeta.metadata;
+            superFieldElemName = fieldMetadata.relationField;
+        }
+        return superFieldElemName;
+    }
     /**
      * Install Prisma with the generated schema
      * @param configService The configuration service

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

@@ -65,5 +65,6 @@ declare class RWSModel<T> implements IModel {
     static setServices(services: IRWSModelServices): void;
     getDb(): DBService;
     static getDb(): DBService;
+    reload(): Promise<T | null>;
 }
 export { RWSModel };

package/dist/models/core/RWSModel.js

@@ -160,8 +160,8 @@ class RWSModel {
         const entryExists = await ModelUtils_1.ModelUtils.entryExists(this);
         if (entryExists) {
             this.preUpdate();
-            const compoundId = ModelUtils_1.ModelUtils.findPrimaryKeyFields(this.constructor);
-            updatedModelData = await this.dbService.update(data, this.getCollection(), Array.isArray(compoundId) ? compoundId : null);
+            const pk = ModelUtils_1.ModelUtils.findPrimaryKeyFields(this.constructor);
+            updatedModelData = await this.dbService.update(data, this.getCollection(), pk);
             await this._asyncFill(updatedModelData);
             this.postUpdate();
         }
@@ -265,6 +265,19 @@ class RWSModel {
     static getDb() {
         return this.services.dbService;
     }
+    async reload() {
+        const pk = ModelUtils_1.ModelUtils.findPrimaryKeyFields(this.constructor);
+        const where = {};
+        if (Array.isArray(pk)) {
+            for (const pkElem of pk) {
+                where[pkElem] = this[pkElem];
+            }
+        }
+        else {
+            where[pk] = this[pk];
+        }
+        return await FindUtils_1.FindUtils.findOneBy(this.constructor, { conditions: where });
+    }
 }
 exports.RWSModel = RWSModel;
 __decorate([

package/dist/models/utils/FindUtils.js

@@ -10,7 +10,7 @@ class FindUtils {
         const fullData = findParams?.fullData ?? false;
         opModel.checkForInclusionWithThrow('');
         const collection = Reflect.get(opModel, '_collection');
-        const dbData = await opModel.services.dbService.findOneBy(collection, conditions, fields, ordering, allowRelations);
+        const dbData = await opModel.services.dbService.findOneBy(collection, conditions, fields, ordering);
         if (dbData) {
             const inst = new opModel();
             return await inst._asyncFill(dbData, fullData, allowRelations);
@@ -24,7 +24,7 @@ class FindUtils {
         const fullData = findParams?.fullData ?? false;
         const collection = Reflect.get(opModel, '_collection');
         opModel.checkForInclusionWithThrow(opModel.name);
-        const dbData = await opModel.services.dbService.findOneBy(collection, { id }, fields, ordering, allowRelations);
+        const dbData = await opModel.services.dbService.findOneBy(collection, { id }, fields, ordering);
         if (dbData) {
             const inst = new opModel();
             return await inst._asyncFill(dbData, fullData, allowRelations);

package/dist/models/utils/HydrateUtils.js

@@ -1,9 +1,13 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.HydrateUtils = void 0;
 const TimeSeriesUtils_1 = require("./TimeSeriesUtils");
 const RelationUtils_1 = require("./RelationUtils");
 const ModelUtils_1 = require("./ModelUtils");
+const chalk_1 = __importDefault(require("chalk"));
 class HydrateUtils {
     static async hydrateDataFields(model, collections_to_models, relOneData, seriesHydrationfields, fullDataMode, data) {
         const timeSeriesIds = TimeSeriesUtils_1.TimeSeriesUtils.getTimeSeriesModelFields(model);
@@ -43,9 +47,10 @@ class HydrateUtils {
             const relMeta = relManyData[key];
             const relationEnabled = !RelationUtils_1.RelationUtils.checkRelDisabled(model, relMeta.key);
             if (relationEnabled) {
+                const pk = ModelUtils_1.ModelUtils.findPrimaryKeyFields(model.constructor);
                 model[relMeta.key] = await relMeta.inversionModel.findBy({
                     conditions: {
-                        [relMeta.foreignKey]: data.id
+                        [relMeta.foreignKey]: data[pk]
                     },
                     allowRelations: false
                 });
@@ -62,7 +67,16 @@ class HydrateUtils {
                 throw new Error(`Relation field "${relMeta.hydrationField}" is required in model ${this.constructor.name}.`);
             }
             if (relationEnabled && data[relMeta.hydrationField]) {
-                model[relMeta.key] = await relMeta.model.findOneBy({ conditions: { [relMeta.foreignKey]: data[relMeta.hydrationField] } }, { allowRelations: false });
+                const pk = ModelUtils_1.ModelUtils.findPrimaryKeyFields(relMeta.model);
+                const where = {};
+                if (Array.isArray(pk)) {
+                    console.log(chalk_1.default.yellowBright(`Hydration field "${relMeta.hydrationField}" on model "${model.constructor.name}" leads to compound key. Ignoring.`));
+                    continue;
+                }
+                else {
+                    where[pk] = data[relMeta.hydrationField];
+                }
+                model[relMeta.key] = await relMeta.model.findOneBy({ conditions: where }, { allowRelations: false });
             }
             else if (relationEnabled && !data[relMeta.hydrationField] && data[relMeta.key]) {
                 const newRelModel = await relMeta.model.create(data[relMeta.key]);

package/dist/services/DBService.d.ts

@@ -21,12 +21,10 @@ declare class DBService {
     cloneDatabase(source: string, target: string): Promise<void>;
     watchCollection(collectionName: string, preRun: () => void): Promise<any>;
     insert(data: any, collection: string, isTimeSeries?: boolean): Promise<any>;
-    update(data: any, collection: string, compoundId?: {
-        [key: string]: any;
-    }): Promise<IModel>;
+    update(data: any, collection: string, pk: string | string[]): Promise<IModel>;
     findOneBy(collection: string, conditions: any, fields?: string[] | null, ordering?: {
         [fieldName: string]: string;
-    }, allowRelations?: boolean): Promise<IModel | null>;
+    }): Promise<IModel | null>;
     delete(collection: string, conditions: any): Promise<void>;
     findBy(collection: string, conditions: any, fields?: string[] | null, ordering?: {
         [fieldName: string]: string;

package/dist/services/DBService.js

@@ -101,16 +101,22 @@ class DBService {
         result = await prismaCollection.create({ data });
         return await this.findOneBy(collection, { id: result.id });
     }
-    async update(data, collection, compoundId = null) {
+    async update(data, collection, pk) {
         const prismaCollection = this.getCollectionHandler(collection);
-        const where = compoundId ? compoundId : {
-            id: data.id,
-        };
-        if (!compoundId) {
-            delete data['id'];
+        const where = {};
+        if (Array.isArray(pk)) {
+            for (const pkElem of pk) {
+                where[pkElem] = data[pkElem];
+            }
+        }
+        else {
+            where[pk] = data[pk];
+        }
+        if (!Array.isArray(pk)) {
+            delete data[pk];
         }
         else {
-            for (const cKey in compoundId) {
+            for (const cKey in pk) {
                 delete data[cKey];
             }
         }
@@ -120,7 +126,7 @@ class DBService {
         });
         return await this.findOneBy(collection, where);
     }
-    async findOneBy(collection, conditions, fields = null, ordering = null, allowRelations = true) {
+    async findOneBy(collection, conditions, fields = null, ordering = null) {
         const params = { where: conditions };
         if (fields) {
             params.select = {};

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@rws-framework/db",
   "private": false,
-  "version": "3.3.3",
+  "version": "3.3.5",
   "description": "",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/decorators/RWSCollection.ts

@@ -5,7 +5,8 @@ import { OpModelType } from "../models/_model";
 export interface ISuperTagData {
     tagType: string,
     fields: string[],
-    map: string
+    fieldParams?: {[key: string]: any};
+    map?: string;
 }
 
 export interface IRWSCollectionOpts {

package/src/decorators/Relation.ts

@@ -44,6 +44,9 @@ function Relation(theModel: () => OpModelType<RWSModel<any>>, relationOptions: P
             };  
             
             if(relationOptions.required){
+                if(!metaOpts.cascade){
+                    metaOpts.cascade = {};
+                }
                 metaOpts.cascade.onDelete = 'Restrict';
             }
 

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

@@ -144,15 +144,9 @@ datasource db {
                             requiredString = '';
                         }
                         
-                        let relatedFieldType = TypeConverter.toConfigCase(relatedFieldMeta.metadata, dbType, true);
-        
-                        /**
-                         * @todo: Detect type
-                         */
-                        if(relatedToField === 'id' && dbType !== 'mongodb'){
-                            relatedFieldType = 'Int';
-                        }                                      
-                        
+                        const defaultIdType = DbUtils.getDefaultPrismaType(dbType, relatedFieldMeta.annotationType !== 'TrackType' && relatedFieldMeta.metadata.type.name === 'String' && relatedToField === 'id' && dbType !== 'mongodb');
+                        let relatedFieldType = TypeConverter.toConfigCase(relatedFieldMeta.metadata, dbType, true, relatedFieldMeta.annotationType !== 'TrackType' && relatedToField === 'id'  && relatedFieldMeta.metadata.type !== defaultIdType);                                 
+                                                                    
                         if(relationMeta.required === false){
                             requiredString = '?';
                         }
@@ -271,13 +265,33 @@ datasource db {
 
         for(const superTag of model._SUPER_TAGS){
 
-            const mapStr = superTag.map ? `, map: "${superTag.map}"` : '';
+            let mapStr = '';
+
+            if(superTag.map){
+                const superFieldMapMeta = modelMetadatas[superTag.map];    
+                
+                let mapField: string = superTag.map;
+
+                if(superFieldMapMeta){
+                    mapField = this.getSuperFieldFromModel(mapField, superFieldMapMeta);
+                }
+
+                mapStr = `, map: "${mapField}"`;
+            }                    
 
             const superFields = [];
         
-            for(const superField of superTag.fields){
-                const fieldMetadata = modelMetadatas[superField]['metadata'];
-       
+            for(let superField of superTag.fields){
+                const superFieldElemMeta = modelMetadatas[superField];                
+
+                if(!superFieldElemMeta){
+                    console.log(chalk.yellowBright(`Ignoring "${superField}" field in "${superTag.tagType}" supertag in model "${modelName}"`));
+                    continue;
+                }
+
+                const fieldMetadata = superFieldElemMeta.metadata;
+
+                superField = this.getSuperFieldFromModel(superField, superFieldElemMeta);
     
                 let pushed = false;
 
@@ -302,6 +316,22 @@ datasource db {
         return section;
     }
 
+    private static getSuperFieldFromModel(superFieldElemName: string, superFieldElemMeta: {
+        annotationType: string;
+        metadata: any;
+    }): string
+    {
+
+        const fieldDecorator = superFieldElemMeta.annotationType;
+
+        if(fieldDecorator === 'Relation'){
+            const fieldMetadata = superFieldElemMeta.metadata as IRelationOpts;
+            superFieldElemName = fieldMetadata.relationField;
+        }
+
+        return superFieldElemName;
+    }
+
     /**
      * Install Prisma with the generated schema
      * @param configService The configuration service

package/src/helper/db/type-converter.ts

@@ -1,8 +1,8 @@
 import { IDbOpts } from '../../models/interfaces/IDbOpts';
 import { ITrackerMetaOpts } from '../../models/_model';
-import { IIdMetaOpts } from 'src/decorators/IdType';
+import { IIdMetaOpts } from '../../decorators/IdType';
 import { DbUtils } from './utils';
-import { IDbConfigParams } from 'src/types/DbConfigHandler';
+import { IDbConfigParams } from '../../types/DbConfigHandler';
 
 /**
  * Handles type conversion for database schema generation

package/src/models/core/RWSModel.ts

@@ -207,9 +207,9 @@ class RWSModel<T> implements IModel {
         if (entryExists) {
             this.preUpdate();
 
-            const compoundId = ModelUtils.findPrimaryKeyFields(this.constructor as OpModelType<any>);
+            const pk = ModelUtils.findPrimaryKeyFields(this.constructor as OpModelType<any>);
 
-            updatedModelData = await this.dbService.update(data, this.getCollection(), Array.isArray(compoundId) ? compoundId : null);
+            updatedModelData = await this.dbService.update(data, this.getCollection(), pk);
 
             await this._asyncFill(updatedModelData);
             this.postUpdate();
@@ -365,6 +365,22 @@ class RWSModel<T> implements IModel {
     {
         return this.services.dbService;
     }
+
+    public async reload(): Promise<T | null>
+    {
+        const pk = ModelUtils.findPrimaryKeyFields(this.constructor as OpModelType<any>);
+        const where: any = {};
+                    
+        if(Array.isArray(pk)){            
+            for(const pkElem of pk){
+                where[pkElem] = this[pkElem];
+            }
+        }else{
+            where[pk as string] = this[pk as string]
+        }         
+        
+        return await FindUtils.findOneBy(this.constructor as OpModelType<any>, { conditions: where });
+    }
 }
 
 export { RWSModel };

package/src/models/utils/FindUtils.ts

@@ -22,7 +22,7 @@ export class FindUtils {
 
 
         const collection = Reflect.get(opModel, '_collection');
-        const dbData = await opModel.services.dbService.findOneBy(collection, conditions, fields, ordering, allowRelations);
+        const dbData = await opModel.services.dbService.findOneBy(collection, conditions, fields, ordering);
 
 
         if (dbData) {
@@ -46,7 +46,7 @@ export class FindUtils {
         const collection = Reflect.get(opModel, '_collection');
         opModel.checkForInclusionWithThrow(opModel.name);
 
-        const dbData = await opModel.services.dbService.findOneBy(collection, { id }, fields, ordering, allowRelations);
+        const dbData = await opModel.services.dbService.findOneBy(collection, { id }, fields, ordering);
 
         if (dbData) {
             const inst: T = new (opModel as { new(): T })();

package/src/models/utils/HydrateUtils.ts

@@ -5,6 +5,7 @@ import { TimeSeriesUtils } from "./TimeSeriesUtils";
 import { RelationUtils } from "./RelationUtils";
 import { OpModelType } from "..";
 import { ModelUtils } from "./ModelUtils";
+import chalk from 'chalk';
 
 export class HydrateUtils {
     static async hydrateDataFields(model: RWSModel<any>, collections_to_models: {[key: string]: any}, relOneData: RelOneMetaType<IRWSModel>, seriesHydrationfields: string[], fullDataMode: boolean, data: {[key: string] : any}){
@@ -58,13 +59,15 @@ export class HydrateUtils {
 
                        
 
-                 if (relationEnabled) {                                
+                 if (relationEnabled) {         
+                    const pk = ModelUtils.findPrimaryKeyFields(model.constructor as OpModelType<any>) as string;
+                            
                     model[relMeta.key] = await relMeta.inversionModel.findBy({
                          conditions: {
-                             [relMeta.foreignKey]: data.id
+                             [relMeta.foreignKey]: data[pk]
                          },
                          allowRelations: false
-                     });    
+                     });          
                  }                                
              }
              
@@ -81,8 +84,19 @@ export class HydrateUtils {
                      throw new Error(`Relation field "${relMeta.hydrationField}" is required in model ${this.constructor.name}.`)
                  }
                                   
-                 if (relationEnabled && data[relMeta.hydrationField]) {                        
-                    model[relMeta.key] = await relMeta.model.findOneBy({conditions: {[relMeta.foreignKey] : data[relMeta.hydrationField]}}, { allowRelations: false });    
+                 if (relationEnabled && data[relMeta.hydrationField]) {    
+                    const pk = ModelUtils.findPrimaryKeyFields(relMeta.model);
+
+                    const where: any = {};
+                    
+                    if(Array.isArray(pk)){
+                        console.log(chalk.yellowBright(`Hydration field "${relMeta.hydrationField}" on model "${model.constructor.name}" leads to compound key. Ignoring.`));
+                        continue;
+                    }else{
+                        where[pk as string] = data[relMeta.hydrationField]
+                    }            
+                                    
+                    model[relMeta.key] = await relMeta.model.findOneBy({conditions: where}, { allowRelations: false });    
                  }                                
                  else if(relationEnabled && !data[relMeta.hydrationField] && data[relMeta.key]){                    
                      const newRelModel: RWSModel<any> = await relMeta.model.create(data[relMeta.key]);                    

package/src/services/DBService.ts

@@ -137,19 +137,26 @@ class DBService {
         return await this.findOneBy(collection, { id: result.id });
     }
 
-    async update(data: any, collection: string, compoundId: {[key: string]: any} = null): Promise<IModel> 
+    async update(data: any, collection: string, pk: string | string[]): Promise<IModel> 
     {        
 
         const prismaCollection = this.getCollectionHandler(collection);
 
-        const where = compoundId ? compoundId : {
-            id: data.id,
-        };
 
-        if(!compoundId){
-            delete data['id'];
+        const where: any = {};
+                    
+        if(Array.isArray(pk)){            
+            for(const pkElem of pk){
+                where[pkElem] = data[pkElem];
+            }
+        }else{
+            where[pk as string] = data[pk as string]
+        }         
+
+        if(!Array.isArray(pk)){
+            delete data[pk];
         }else{
-            for(const cKey in compoundId){
+            for(const cKey in pk){
                 delete data[cKey];
             }
         }        
@@ -164,7 +171,7 @@ class DBService {
     }
   
 
-    async findOneBy(collection: string, conditions: any, fields: string[] | null = null, ordering: { [fieldName: string]: string } = null, allowRelations: boolean = true): Promise<IModel|null>
+    async findOneBy(collection: string, conditions: any, fields: string[] | null = null, ordering: { [fieldName: string]: string } = null): Promise<IModel|null>
     {    
         const params: any = { where: conditions };