@rws-framework/db 3.3.2 → 3.3.4

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

@@ -4,8 +4,6 @@ import { OpModelType } from '../interfaces/OpModelType';
 import { FindByType, IPaginationParams } from '../../types/FindParams';
 import { DBService } from '../../services/DBService';
 import { ISuperTagData } from '../../decorators/RWSCollection';
-import { RelManyMetaType, RelOneMetaType } from '../types/RelationTypes';
-import { IRWSModel } from '../../types/IRWSModel';
 declare class RWSModel<T> implements IModel {
     static services: IRWSModelServices;
     [key: string]: any;
@@ -32,9 +30,9 @@ declare class RWSModel<T> implements IModel {
     _asyncFill(data: any, fullDataMode?: boolean, allowRelations?: boolean): Promise<T>;
     private getModelScalarFields;
     private getRelationOneMeta;
-    static getRelationOneMeta(model: any, classFields: string[]): Promise<RelOneMetaType<IRWSModel>>;
+    static getRelationOneMeta(model: any, classFields: string[]): Promise<import("..").RelOneMetaType<import("../..").IRWSModel>>;
     private getRelationManyMeta;
-    static getRelationManyMeta(model: any, classFields: string[]): Promise<RelManyMetaType<IRWSModel>>;
+    static getRelationManyMeta(model: any, classFields: string[]): Promise<import("..").RelManyMetaType<import("../..").IRWSModel>>;
     static paginate<T extends RWSModel<T>>(this: OpModelType<T>, paginateParams: IPaginationParams, findParams?: FindByType): Promise<T[]>;
     toMongo(): Promise<any>;
     getCollection(): string | null;
@@ -67,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

@@ -16,6 +16,7 @@ const RelationUtils_1 = require("../utils/RelationUtils");
 const TimeSeriesUtils_1 = require("../utils/TimeSeriesUtils");
 const ModelUtils_1 = require("../utils/ModelUtils");
 const HydrateUtils_1 = require("../utils/HydrateUtils");
+const FindUtils_1 = require("../utils/FindUtils");
 class RWSModel {
     static services = {};
     id;
@@ -119,29 +120,7 @@ class RWSModel {
         return RelationUtils_1.RelationUtils.getRelationManyMeta(model, classFields);
     }
     static async paginate(paginateParams, findParams) {
-        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, paginateParams);
-            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;
-        }
+        return await FindUtils_1.FindUtils.paginate(this, paginateParams, findParams);
     }
     async toMongo() {
         const data = {};
@@ -178,9 +157,11 @@ class RWSModel {
     async save() {
         const data = await this.toMongo();
         let updatedModelData = data;
-        if (this.id) {
+        const entryExists = await ModelUtils_1.ModelUtils.entryExists(this);
+        if (entryExists) {
             this.preUpdate();
-            updatedModelData = await this.dbService.update(data, this.getCollection());
+            const pk = ModelUtils_1.ModelUtils.findPrimaryKeyFields(this.constructor);
+            updatedModelData = await this.dbService.update(data, this.getCollection(), pk);
             await this._asyncFill(updatedModelData);
             this.postUpdate();
         }
@@ -239,59 +220,13 @@ class RWSModel {
         return await this.services.dbService.watchCollection(collection, preRun);
     }
     static async findOneBy(findParams) {
-        const conditions = findParams?.conditions ?? {};
-        const ordering = findParams?.ordering ?? null;
-        const fields = findParams?.fields ?? null;
-        const allowRelations = findParams?.allowRelations ?? true;
-        const fullData = findParams?.fullData ?? false;
-        this.checkForInclusionWithThrow('');
-        const collection = Reflect.get(this, '_collection');
-        const dbData = await this.services.dbService.findOneBy(collection, conditions, fields, ordering, allowRelations);
-        if (dbData) {
-            const inst = new this();
-            return await inst._asyncFill(dbData, fullData, allowRelations);
-        }
-        return null;
+        return await FindUtils_1.FindUtils.findOneBy(this, findParams);
     }
     static async find(id, findParams = null) {
-        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);
-        const dbData = await this.services.dbService.findOneBy(collection, { id }, fields, ordering, allowRelations);
-        if (dbData) {
-            const inst = new this();
-            return await inst._asyncFill(dbData, fullData, allowRelations);
-        }
-        return null;
+        return await FindUtils_1.FindUtils.find(this, id, findParams);
     }
     static async findBy(findParams) {
-        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 paginateParams = findParams?.pagination ? findParams?.pagination : undefined;
-            const dbData = await this.services.dbService.findBy(collection, conditions, fields, ordering, paginateParams);
-            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;
-        }
+        return await FindUtils_1.FindUtils.findBy(this, findParams);
     }
     static async delete(conditions) {
         const collection = Reflect.get(this, '_collection');
@@ -330,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.d.ts

@@ -0,0 +1,9 @@
+import { RWSModel } from "../core/RWSModel";
+import { OpModelType } from "..";
+import { FindByType, IPaginationParams } from "../../types/FindParams";
+export declare class FindUtils {
+    static findOneBy<T extends RWSModel<T>>(opModel: OpModelType<T>, findParams?: FindByType): Promise<T | null>;
+    static find<T extends RWSModel<T>>(opModel: OpModelType<T>, id: string | number, findParams?: Omit<FindByType, 'conditions'>): Promise<T | null>;
+    static findBy<T extends RWSModel<T>>(opModel: OpModelType<T>, findParams?: FindByType): Promise<T[]>;
+    static paginate<T extends RWSModel<T>>(opModel: OpModelType<T>, paginateParams: IPaginationParams, findParams?: FindByType): Promise<T[]>;
+}

package/dist/models/utils/FindUtils.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FindUtils = void 0;
+class FindUtils {
+    static async findOneBy(opModel, findParams) {
+        const conditions = findParams?.conditions ?? {};
+        const ordering = findParams?.ordering ?? null;
+        const fields = findParams?.fields ?? null;
+        const allowRelations = findParams?.allowRelations ?? true;
+        const fullData = findParams?.fullData ?? false;
+        opModel.checkForInclusionWithThrow('');
+        const collection = Reflect.get(opModel, '_collection');
+        const dbData = await opModel.services.dbService.findOneBy(collection, conditions, fields, ordering);
+        if (dbData) {
+            const inst = new opModel();
+            return await inst._asyncFill(dbData, fullData, allowRelations);
+        }
+        return null;
+    }
+    static async find(opModel, id, findParams = null) {
+        const ordering = findParams?.ordering ?? null;
+        const fields = findParams?.fields ?? null;
+        const allowRelations = findParams?.allowRelations ?? true;
+        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);
+        if (dbData) {
+            const inst = new opModel();
+            return await inst._asyncFill(dbData, fullData, allowRelations);
+        }
+        return null;
+    }
+    static async findBy(opModel, findParams) {
+        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(opModel, '_collection');
+        opModel.checkForInclusionWithThrow(opModel.name);
+        try {
+            const paginateParams = findParams?.pagination ? findParams?.pagination : undefined;
+            const dbData = await opModel.services.dbService.findBy(collection, conditions, fields, ordering, paginateParams);
+            if (dbData.length) {
+                const instanced = [];
+                for (const data of dbData) {
+                    const inst = new opModel();
+                    instanced.push((await inst._asyncFill(data, fullData, allowRelations)));
+                }
+                return instanced;
+            }
+            return [];
+        }
+        catch (rwsError) {
+            console.error(rwsError);
+            throw rwsError;
+        }
+    }
+    static async paginate(opModel, paginateParams, findParams) {
+        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(opModel, '_collection');
+        opModel.checkForInclusionWithThrow(opModel.name);
+        try {
+            const dbData = await opModel.services.dbService.findBy(collection, conditions, fields, ordering, paginateParams);
+            if (dbData.length) {
+                const instanced = [];
+                for (const data of dbData) {
+                    const inst = new opModel();
+                    instanced.push((await inst._asyncFill(data, fullData, allowRelations)));
+                }
+                return instanced;
+            }
+            return [];
+        }
+        catch (rwsError) {
+            console.error(rwsError);
+            throw rwsError;
+        }
+    }
+}
+exports.FindUtils = FindUtils;

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/models/utils/ModelUtils.d.ts

@@ -1,4 +1,5 @@
 import { RWSModel } from "../core/RWSModel";
+import { OpModelType } from "..";
 export declare class ModelUtils {
     static getModelAnnotations<T extends unknown>(constructor: new () => T): Promise<Record<string, {
         annotationType: string;
@@ -7,4 +8,6 @@ export declare class ModelUtils {
     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[];
+    static findPrimaryKeyFields(opModel: OpModelType<any>): string | string[];
+    static entryExists(model: RWSModel<any>): Promise<boolean>;
 }

package/dist/models/utils/ModelUtils.js

@@ -59,5 +59,57 @@ class ModelUtils {
             .filter((item) => item.indexOf('TrackType') === 0)
             .map((item) => item.split(':').at(-1));
     }
+    static findPrimaryKeyFields(opModel) {
+        if (opModel._NO_ID) {
+            const foundSuperId = opModel._SUPER_TAGS.find(tag => tag.tagType === 'id');
+            if (foundSuperId) {
+                return foundSuperId.fields;
+            }
+            const foundSuperUnique = opModel._SUPER_TAGS.find(tag => tag.tagType === 'unique');
+            if (foundSuperUnique) {
+                return foundSuperUnique.fields;
+            }
+        }
+        return 'id';
+    }
+    static async entryExists(model) {
+        let entryHasData = true;
+        let compoundId = false;
+        const foundPrimaryKey = this.findPrimaryKeyFields(model.constructor);
+        if (Array.isArray(foundPrimaryKey)) {
+            compoundId = true;
+            for (const idKey of foundPrimaryKey) {
+                if (!Object.hasOwn(model, idKey)) {
+                    entryHasData = false;
+                }
+                if (Object.hasOwn(model, idKey) && !model[idKey]) {
+                    entryHasData = false;
+                }
+            }
+        }
+        else {
+            if (Object.hasOwn(model, foundPrimaryKey) && !model[foundPrimaryKey]) {
+                entryHasData = false;
+            }
+            if (!Object.hasOwn(model, foundPrimaryKey)) {
+                entryHasData = false;
+            }
+        }
+        if (!entryHasData) {
+            return false;
+        }
+        const constructor = model.constructor;
+        const conditions = {};
+        if (compoundId) {
+            for (const key of foundPrimaryKey) {
+                conditions[key] = model[key];
+            }
+            return (await constructor.findOneBy({ conditions }) !== null);
+        }
+        else {
+            conditions[foundPrimaryKey] = model[foundPrimaryKey];
+        }
+        return (await constructor.findOneBy({ conditions })) !== null;
+    }
 }
 exports.ModelUtils = ModelUtils;

package/dist/services/DBService.d.ts

@@ -21,10 +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): 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,19 +101,32 @@ class DBService {
         result = await prismaCollection.create({ data });
         return await this.findOneBy(collection, { id: result.id });
     }
-    async update(data, collection) {
-        const model_id = data.id;
-        delete data['id'];
+    async update(data, collection, pk) {
         const prismaCollection = this.getCollectionHandler(collection);
+        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 pk) {
+                delete data[cKey];
+            }
+        }
         await prismaCollection.update({
-            where: {
-                id: model_id,
-            },
+            where,
             data: data,
         });
-        return await this.findOneBy(collection, { id: model_id });
+        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.2",
+  "version": "3.3.4",
   "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/models/core/RWSModel.ts

@@ -1,7 +1,7 @@
 import { IModel } from '../interfaces/IModel';
 import { IRWSModelServices } from '../interfaces/IRWSModelServices';
 import { OpModelType } from '../interfaces/OpModelType';
-import { TrackType, ITrackerMetaOpts } from '../../decorators';
+import { TrackType } from '../../decorators';
 import { FieldsHelper } from '../../helper/FieldsHelper';
 import { FindByType, IPaginationParams } from '../../types/FindParams';
 import { RelationUtils } from '../utils/RelationUtils';
@@ -11,9 +11,8 @@ import { ModelUtils } from '../utils/ModelUtils';
 // import timeSeriesModel from './TimeSeriesModel';      
 import { DBService } from '../../services/DBService';
 import { ISuperTagData } from '../../decorators/RWSCollection';
-import { RelManyMetaType, RelOneMetaType } from '../types/RelationTypes';
-import { IRWSModel } from '../../types/IRWSModel';
 import { HydrateUtils } from '../utils/HydrateUtils';
+import { FindUtils } from '../utils/FindUtils';
 
 class RWSModel<T> implements IModel {
     static services: IRWSModelServices = {};
@@ -153,33 +152,7 @@ class RWSModel<T> implements IModel {
         paginateParams: IPaginationParams,  
         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, paginateParams);   
-            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;
-        }                 
+        return await FindUtils.paginate(this, paginateParams, findParams);
     }
 
     public async toMongo(): Promise<any> {
@@ -227,11 +200,16 @@ class RWSModel<T> implements IModel {
 
     async save(): Promise<this> {
         const data = await this.toMongo();
-        let updatedModelData = data;         
-        if (this.id) {
+        let updatedModelData = data;  
+
+        const entryExists = await ModelUtils.entryExists(this);        
+
+        if (entryExists) {
             this.preUpdate();
 
-            updatedModelData = await this.dbService.update(data, this.getCollection());
+            const pk = ModelUtils.findPrimaryKeyFields(this.constructor as OpModelType<any>);
+
+            updatedModelData = await this.dbService.update(data, this.getCollection(), pk);
 
             await this._asyncFill(updatedModelData);
             this.postUpdate();
@@ -316,25 +294,7 @@ class RWSModel<T> implements IModel {
         this: OpModelType<T>,
         findParams?: FindByType
     ): Promise<T | null> {
-        const conditions = findParams?.conditions ?? {};
-        const ordering = findParams?.ordering ?? null;
-        const fields = findParams?.fields ?? null;
-        const allowRelations = findParams?.allowRelations ?? true;
-        const fullData = findParams?.fullData ?? false;
-
-        this.checkForInclusionWithThrow('');
-
-        
-        const collection = Reflect.get(this, '_collection');        
-        const dbData = await this.services.dbService.findOneBy(collection, conditions, fields, ordering, allowRelations);
-        
-    
-        if (dbData) {
-            const inst: T = new (this as { new(): T })();
-            return await inst._asyncFill(dbData, fullData, allowRelations);
-        }
-    
-        return null;
+        return await FindUtils.findOneBy(this, findParams);
     }
 
     public static async find<T extends RWSModel<T>>(
@@ -342,58 +302,14 @@ class RWSModel<T> implements IModel {
         id: string | number,        
         findParams: Omit<FindByType, 'conditions'> = null
     ): Promise<T | null> {        
-        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);
-
-        const dbData = await this.services.dbService.findOneBy(collection, { id }, fields, ordering, allowRelations);
-    
-        if (dbData) {            
-            const inst: T = new (this as { new(): T })();
-            return await inst._asyncFill(dbData, fullData, allowRelations);
-        }
-    
-        return null;
+        return await FindUtils.find(this, id, findParams)
     }   
     
     public static async findBy<T extends RWSModel<T>>(
         this: OpModelType<T>,    
         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 paginateParams =  findParams?.pagination ? findParams?.pagination : undefined;
-            const dbData = await this.services.dbService.findBy(collection, conditions, fields, ordering, paginateParams);        
-
-            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;
-        }                 
+        return await FindUtils.findBy(this, findParams);                
     }
 
     public static async delete<T extends RWSModel<T>>(
@@ -449,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

@@ -0,0 +1,128 @@
+import { RWSModel } from "../core/RWSModel";
+import { RelManyMetaType, RelOneMetaType } from "../types/RelationTypes";
+import { IRWSModel } from "../../types/IRWSModel";
+import { TimeSeriesUtils } from "./TimeSeriesUtils";
+import { RelationUtils } from "./RelationUtils";
+import { OpModelType } from "..";
+import { ModelUtils } from "./ModelUtils";
+import { FindByType, IPaginationParams } from "../../types/FindParams";
+
+export class FindUtils {
+    public static async findOneBy<T extends RWSModel<T>>(
+        opModel: OpModelType<T>,
+        findParams?: FindByType
+    ): Promise<T | null> {
+        const conditions = findParams?.conditions ?? {};
+        const ordering = findParams?.ordering ?? null;
+        const fields = findParams?.fields ?? null;
+        const allowRelations = findParams?.allowRelations ?? true;
+        const fullData = findParams?.fullData ?? false;
+
+        opModel.checkForInclusionWithThrow('');
+
+
+        const collection = Reflect.get(opModel, '_collection');
+        const dbData = await opModel.services.dbService.findOneBy(collection, conditions, fields, ordering);
+
+
+        if (dbData) {
+            const inst: T = new (opModel as { new(): T })();
+            return await inst._asyncFill(dbData, fullData, allowRelations);
+        }
+
+        return null;
+    }
+
+    public static async find<T extends RWSModel<T>>(
+        opModel: OpModelType<T>,
+        id: string | number,
+        findParams: Omit<FindByType, 'conditions'> = null
+    ): Promise<T | null> {
+        const ordering = findParams?.ordering ?? null;
+        const fields = findParams?.fields ?? null;
+        const allowRelations = findParams?.allowRelations ?? true;
+        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);
+
+        if (dbData) {
+            const inst: T = new (opModel as { new(): T })();
+            return await inst._asyncFill(dbData, fullData, allowRelations);
+        }
+
+        return null;
+    }
+
+    public static async findBy<T extends RWSModel<T>>(
+        opModel: OpModelType<T>,
+        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(opModel, '_collection');
+        opModel.checkForInclusionWithThrow(opModel.name);
+        try {
+            const paginateParams = findParams?.pagination ? findParams?.pagination : undefined;
+            const dbData = await opModel.services.dbService.findBy(collection, conditions, fields, ordering, paginateParams);
+
+            if (dbData.length) {
+                const instanced: T[] = [];
+
+                for (const data of dbData) {
+                    const inst: T = new (opModel 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;
+        }
+    }
+
+    public static async paginate<T extends RWSModel<T>>(
+        opModel: OpModelType<T>,
+        paginateParams: IPaginationParams,
+        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(opModel, '_collection');
+        opModel.checkForInclusionWithThrow(opModel.name);
+        try {
+            const dbData = await opModel.services.dbService.findBy(collection, conditions, fields, ordering, paginateParams);
+            if (dbData.length) {
+                const instanced: T[] = [];
+
+                for (const data of dbData) {
+                    const inst: T = new (opModel 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/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/models/utils/ModelUtils.ts

@@ -1,5 +1,8 @@
 import { RWSModel } from "../core/RWSModel";
 import { FieldsHelper } from '../../helper/FieldsHelper';
+import { OpModelType } from "..";
+import { ISuperTagData } from "../../decorators/RWSCollection";
+import { FindByType } from "../../types/FindParams";
 
 export class ModelUtils {
     static async getModelAnnotations<T extends unknown>(constructor: new () => T): Promise<Record<string, {annotationType: string, metadata: any}>> {    
@@ -71,4 +74,71 @@ export class ModelUtils {
                 .filter((item: string) => item.indexOf('TrackType') === 0)
                 .map((item: string) => item.split(':').at(-1));
     }
+
+    static findPrimaryKeyFields(opModel: OpModelType<any>): string  | string[]
+    {
+        if(opModel._NO_ID){
+            const foundSuperId: ISuperTagData = opModel._SUPER_TAGS.find(tag => tag.tagType === 'id');
+
+            if(foundSuperId){
+                return foundSuperId.fields;
+            }
+
+            const foundSuperUnique: ISuperTagData = opModel._SUPER_TAGS.find(tag => tag.tagType === 'unique');
+
+            if(foundSuperUnique){
+                return foundSuperUnique.fields;
+            }
+        }
+
+        return 'id';
+    }
+
+    static async entryExists(model: RWSModel<any>): Promise<boolean>
+    {
+        let entryHasData = true;
+        let compoundId = false;
+
+        const foundPrimaryKey = this.findPrimaryKeyFields(model.constructor as OpModelType<any>);
+
+        if(Array.isArray(foundPrimaryKey)){
+            compoundId = true;
+            for(const idKey of foundPrimaryKey){
+                if(!Object.hasOwn(model, idKey)){
+                    entryHasData = false;
+                }
+
+                if(Object.hasOwn(model, idKey) && !model[idKey]){
+                    entryHasData = false;
+                }
+            }
+        }else{
+            if(Object.hasOwn(model, foundPrimaryKey) && !model[foundPrimaryKey]){
+                entryHasData = false;
+            }
+
+            if(!Object.hasOwn(model, foundPrimaryKey)){
+                entryHasData = false;
+            }
+        }
+
+        if(!entryHasData){
+            return false;
+        }        
+
+        const constructor = model.constructor as OpModelType<any>;
+        const conditions: FindByType['conditions'] = {};
+
+        if(compoundId){           
+            for(const key of foundPrimaryKey){
+                conditions[key] = model[key];
+            }
+
+            return (await constructor.findOneBy({ conditions  }) !== null);
+        }else{
+            conditions[foundPrimaryKey as string] = model[foundPrimaryKey as string];
+        }
+
+        return (await constructor.findOneBy({ conditions })) !== null;
+    }
 }

package/src/services/DBService.ts

@@ -137,26 +137,41 @@ class DBService {
         return await this.findOneBy(collection, { id: result.id });
     }
 
-    async update(data: any, collection: string): Promise<IModel> 
-    {
-        const model_id: string = data.id;    
-        delete data['id'];
+    async update(data: any, collection: string, pk: string | string[]): Promise<IModel> 
+    {        
 
         const prismaCollection = this.getCollectionHandler(collection);
 
+
+        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 pk){
+                delete data[cKey];
+            }
+        }        
+
         await prismaCollection.update({
-            where: {
-                id: model_id,
-            },
+            where,
             data: data,
         });    
 
         
-        return await this.findOneBy(collection, { id: model_id });
+        return await this.findOneBy(collection, where);
     }
   
 
-    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 };