@rws-framework/db 3.1.0 → 3.3.0

package/dist/models/core/RWSModel.js

@@ -17,6 +17,15 @@ const TimeSeriesUtils_1 = require("../utils/TimeSeriesUtils");
 const ModelUtils_1 = require("../utils/ModelUtils");
 const HydrateUtils_1 = require("../utils/HydrateUtils");
 class RWSModel {
+    static services = {};
+    id;
+    static _collection = null;
+    static _RELATIONS = {};
+    static _NO_ID = false;
+    static _SUPER_TAGS = [];
+    static _BANNED_KEYS = ['_collection'];
+    static allModels = [];
+    static _CUT_KEYS = [];
     constructor(data = null) {
         if (!this.getCollection()) {
             throw new Error('Model must have a collection defined');
@@ -110,12 +119,11 @@ class RWSModel {
         return RelationUtils_1.RelationUtils.getRelationManyMeta(model, classFields);
     }
     static async paginate(paginateParams, findParams) {
-        var _a, _b, _c, _d, _e;
-        const conditions = (_a = findParams === null || findParams === void 0 ? void 0 : findParams.conditions) !== null && _a !== void 0 ? _a : {};
-        const ordering = (_b = findParams === null || findParams === void 0 ? void 0 : findParams.ordering) !== null && _b !== void 0 ? _b : null;
-        const fields = (_c = findParams === null || findParams === void 0 ? void 0 : findParams.fields) !== null && _c !== void 0 ? _c : null;
-        const allowRelations = (_d = findParams === null || findParams === void 0 ? void 0 : findParams.allowRelations) !== null && _d !== void 0 ? _d : true;
-        const fullData = (_e = findParams === null || findParams === void 0 ? void 0 : findParams.fullData) !== null && _e !== void 0 ? _e : false;
+        const 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 {
@@ -231,12 +239,11 @@ class RWSModel {
         return await this.services.dbService.watchCollection(collection, preRun);
     }
     static async findOneBy(findParams) {
-        var _a, _b, _c, _d, _e;
-        const conditions = (_a = findParams === null || findParams === void 0 ? void 0 : findParams.conditions) !== null && _a !== void 0 ? _a : {};
-        const ordering = (_b = findParams === null || findParams === void 0 ? void 0 : findParams.ordering) !== null && _b !== void 0 ? _b : null;
-        const fields = (_c = findParams === null || findParams === void 0 ? void 0 : findParams.fields) !== null && _c !== void 0 ? _c : null;
-        const allowRelations = (_d = findParams === null || findParams === void 0 ? void 0 : findParams.allowRelations) !== null && _d !== void 0 ? _d : true;
-        const fullData = (_e = findParams === null || findParams === void 0 ? void 0 : findParams.fullData) !== null && _e !== void 0 ? _e : false;
+        const 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);
@@ -247,11 +254,10 @@ class RWSModel {
         return null;
     }
     static async find(id, findParams = null) {
-        var _a, _b, _c, _d;
-        const ordering = (_a = findParams === null || findParams === void 0 ? void 0 : findParams.ordering) !== null && _a !== void 0 ? _a : null;
-        const fields = (_b = findParams === null || findParams === void 0 ? void 0 : findParams.fields) !== null && _b !== void 0 ? _b : null;
-        const allowRelations = (_c = findParams === null || findParams === void 0 ? void 0 : findParams.allowRelations) !== null && _c !== void 0 ? _c : true;
-        const fullData = (_d = findParams === null || findParams === void 0 ? void 0 : findParams.fullData) !== null && _d !== void 0 ? _d : false;
+        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);
@@ -262,16 +268,15 @@ class RWSModel {
         return null;
     }
     static async findBy(findParams) {
-        var _a, _b, _c, _d, _e;
-        const conditions = (_a = findParams === null || findParams === void 0 ? void 0 : findParams.conditions) !== null && _a !== void 0 ? _a : {};
-        const ordering = (_b = findParams === null || findParams === void 0 ? void 0 : findParams.ordering) !== null && _b !== void 0 ? _b : null;
-        const fields = (_c = findParams === null || findParams === void 0 ? void 0 : findParams.fields) !== null && _c !== void 0 ? _c : null;
-        const allowRelations = (_d = findParams === null || findParams === void 0 ? void 0 : findParams.allowRelations) !== null && _d !== void 0 ? _d : true;
-        const fullData = (_e = findParams === null || findParams === void 0 ? void 0 : findParams.fullData) !== null && _e !== void 0 ? _e : false;
+        const 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 === null || findParams === void 0 ? void 0 : findParams.pagination) ? findParams === null || findParams === void 0 ? void 0 : findParams.pagination : undefined;
+            const paginateParams = findParams?.pagination ? findParams?.pagination : undefined;
             const dbData = await this.services.dbService.findBy(collection, conditions, fields, ordering, paginateParams);
             if (dbData.length) {
                 const instanced = [];
@@ -327,14 +332,6 @@ class RWSModel {
     }
 }
 exports.RWSModel = RWSModel;
-RWSModel.services = {};
-RWSModel._collection = null;
-RWSModel._RELATIONS = {};
-RWSModel._NO_ID = false;
-RWSModel._SUPER_TAGS = [];
-RWSModel._BANNED_KEYS = ['_collection'];
-RWSModel.allModels = [];
-RWSModel._CUT_KEYS = [];
 __decorate([
     (0, decorators_1.TrackType)(String),
     __metadata("design:type", Object)

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

@@ -5,13 +5,16 @@ export interface IDbOpts {
             useText?: boolean;
             maxLength?: number;
             useUuid?: boolean;
+            params?: string[];
         };
         postgres?: {
             useText?: boolean;
             useUuid?: boolean;
+            params?: string[];
         };
         mongodb?: {
             customType?: string;
+            params?: string[];
         };
     };
 }

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

@@ -1,3 +1,5 @@
 import { IDbOpts } from "./IDbOpts";
 export interface IIdTypeOpts extends IDbOpts {
+    unique?: boolean | string;
+    noAuto?: boolean;
 }

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

@@ -9,4 +9,5 @@ export interface ITrackerOpts extends IDbOpts {
     relatedTo?: OpModelType<any>;
     inversionModel?: OpModelType<any>;
     relationName?: string;
+    noAuto?: boolean;
 }

package/dist/models/utils/HydrateUtils.js

@@ -41,7 +41,6 @@ class HydrateUtils {
                 continue;
             }
             const relMeta = relManyData[key];
-            //  console.log({relMeta});
             const relationEnabled = !RelationUtils_1.RelationUtils.checkRelDisabled(model, relMeta.key);
             if (relationEnabled) {
                 model[relMeta.key] = await relMeta.inversionModel.findBy({

package/dist/models/utils/ModelUtils.js

@@ -6,8 +6,15 @@ class ModelUtils {
     static async getModelAnnotations(constructor) {
         const annotationsData = {};
         const metadataKeys = Reflect.getMetadataKeys(constructor.prototype);
+        const filteredMetaKeys = metadataKeys.filter((metaKey) => {
+            const [annotationType, annotatedField] = metaKey.split(':');
+            if (annotationType === 'TrackType' && annotatedField === 'id' && metadataKeys.includes('IdType:' + annotatedField)) {
+                return false;
+            }
+            return true;
+        });
         // Process all metadata keys and collect promises
-        const metadataPromises = metadataKeys.map(async (fullKey) => {
+        const metadataPromises = filteredMetaKeys.map(async (fullKey) => {
             const [annotationType, propertyKey] = fullKey.split(':');
             const metadata = Reflect.getMetadata(fullKey, constructor.prototype);
             if (metadata) {

package/dist/models/utils/PaginationUtils.js

@@ -3,12 +3,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.PaginationUtils = void 0;
 class PaginationUtils {
     static async paginate(paginationParams = { page: 0, per_page: 50 }, findParams = {}) {
-        var _a, _b, _c, _d, _e;
-        const conditions = (_a = findParams === null || findParams === void 0 ? void 0 : findParams.conditions) !== null && _a !== void 0 ? _a : {};
-        const ordering = (_b = findParams === null || findParams === void 0 ? void 0 : findParams.ordering) !== null && _b !== void 0 ? _b : null;
-        const fields = (_c = findParams === null || findParams === void 0 ? void 0 : findParams.fields) !== null && _c !== void 0 ? _c : null;
-        const allowRelations = (_d = findParams === null || findParams === void 0 ? void 0 : findParams.allowRelations) !== null && _d !== void 0 ? _d : true;
-        const fullData = (_e = findParams === null || findParams === void 0 ? void 0 : findParams.fullData) !== null && _e !== void 0 ? _e : false;
+        const 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 {

package/dist/services/DBService.js

@@ -8,10 +8,12 @@ const client_1 = require("@prisma/client");
 const mongodb_1 = require("mongodb");
 const chalk_1 = __importDefault(require("chalk"));
 class DBService {
+    configService;
+    client;
+    opts = null;
+    connected = false;
     constructor(configService) {
         this.configService = configService;
-        this.opts = null;
-        this.connected = false;
     }
     connectToDB(opts = null) {
         if (opts) {
@@ -50,15 +52,13 @@ class DBService {
         return client;
     }
     async createBaseMongoClient() {
-        var _a;
-        const dbUrl = ((_a = this.opts) === null || _a === void 0 ? void 0 : _a.dbUrl) || this.configService.get('db_url');
+        const dbUrl = this.opts?.dbUrl || this.configService.get('db_url');
         const client = DBService.baseClientConstruct(dbUrl);
         await client.connect();
         return client;
     }
     async createBaseMongoClientDB() {
-        var _a;
-        const dbName = ((_a = this.opts) === null || _a === void 0 ? void 0 : _a.dbName) || this.configService.get('db_name');
+        const dbName = this.opts?.dbName || this.configService.get('db_name');
         const client = await this.createBaseMongoClient();
         return [client, client.db(dbName)];
     }
@@ -151,8 +151,7 @@ class DBService {
         return retData;
     }
     async collectionExists(collection_name) {
-        var _a;
-        const dbUrl = ((_a = this.opts) === null || _a === void 0 ? void 0 : _a.dbUrl) || this.configService.get('db_url');
+        const dbUrl = this.opts?.dbUrl || this.configService.get('db_url');
         const client = new mongodb_1.MongoClient(dbUrl);
         try {
             await client.connect();

package/exec/console.js

@@ -15,8 +15,6 @@ const getCachedPath = (key) => path.resolve(rwsCliConfigDir, key);
 
 const currentCwd = path.resolve(__dirname);
 
-console.log({params})
-
 
 const commandString = `npx webpack --config db.rws.webpack.config.js --output-path ./build ${process.cwd()} ${params[2]}`;
 function needsCacheWarming(){

package/package.json

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

package/src/decorators/IdType.ts

@@ -8,7 +8,16 @@ export interface IIdMetaOpts extends IIdTypeOpts {
   
 function IdType(type: any, opts: IIdTypeOpts | null = null, tags: string[] = []) {   
     const metaOpts: IIdMetaOpts = { type, dbOptions: opts && opts.dbOptions ? opts.dbOptions : null };
-    return function(target: any, key: string) {          
+    
+    if(opts && opts.dbOptions){
+        metaOpts.dbOptions = opts.dbOptions;
+    }
+
+    if(opts && opts.noAuto){
+        metaOpts.noAuto = opts.noAuto;
+    }
+
+    return function(target: any, key: string) {                  
         Reflect.defineMetadata(`IdType:${key}`, metaOpts, target);
     };
 }

package/src/decorators/InverseRelation.ts

@@ -64,8 +64,8 @@ function InverseRelation(inversionModel: () => OpModelType<RWSModel<any>>, sourc
                 foreignKey: relationOptions && relationOptions.foreignKey ? relationOptions.foreignKey : guessForeignKey(model, source, decoratorsData),
                 // Generate a unique relation name if one is not provided
                 relationName: relationOptions && relationOptions.relationName ?
-                    relationOptions.relationName.toLowerCase() :
-                    `${model._collection}_${key}_${source._collection}`.toLowerCase()
+                    relationOptions.relationName :
+                    null
             };
 
             return metaOpts;

package/src/decorators/Relation.ts

@@ -20,13 +20,15 @@ export interface IRelationOpts {
     }
 }
 
-const _DEFAULTS: Partial<IRelationOpts> = { required: false, many: false, embed: false, cascade: { onDelete: 'SetNull', onUpdate: 'Cascade' }};
+const _DEFAULT_CASCADE = { onDelete: 'SetNull', onUpdate: 'Cascade' };
+
+const _DEFAULTS: Partial<IRelationOpts> = { required: false, many: false, embed: false, cascade: null};
   
 function Relation(theModel: () => OpModelType<RWSModel<any>>, relationOptions: Partial<IRelationOpts> = _DEFAULTS) {
     return function(target: any, key: string) {     
         // Store the promise in metadata immediately
         
-        const metadataPromise = Promise.resolve().then(() => {            
+        const metadataPromise = Promise.resolve().then(() => {          
             const relatedTo = theModel();
 
             const metaOpts: IRelationOpts = {
@@ -37,8 +39,8 @@ function Relation(theModel: () => OpModelType<RWSModel<any>>, relationOptions: P
                 key,
                 // Generate a unique relation name if one is not provided
                 relationName: relationOptions.relationName ? 
-                  relationOptions.relationName.toLowerCase() : 
-                  `${target.constructor.name.toLowerCase()}_${key}_${relatedTo._collection.toLowerCase()}`
+                  relationOptions.relationName : 
+                  null
             };  
             
             if(relationOptions.required){

package/src/helper/DbHelper.ts

@@ -101,7 +101,7 @@ export class DbHelper {
     /**
      * Convert a JavaScript type to a Prisma schema type
      */
-    static toConfigCase(modelType: any, dbType: string = 'mongodb'): string {
+    static toConfigCase(modelType: any, dbType: IDbConfigParams['db_type'] = 'mongodb'): string {
         return TypeConverter.toConfigCase(modelType, dbType);
     }
 

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

@@ -15,7 +15,8 @@ import { RelationManager } from './relation-manager';
 import { ITrackerMetaOpts } from '../../decorators/TrackType';
 import { IDbOpts } from '../../models/interfaces/IDbOpts';
 
-const log = console.log;
+const _EXECUTE_PRISMA_CMD = true;
+const _REMOVE_SCHEMA_FILE = true;
 
 /**
  * Handles Prisma schema generation
@@ -57,13 +58,28 @@ datasource db {
         const dbType = configService.get('db_type') || 'mongodb';
         const modelName: string = (model as any)._collection;
 
-        section += `model ${modelName} {\n`;       
+        section += `model ${modelName} {\n`;               
+
+        let hasIdType = false;  
+        let idFieldName: string;
+
+        for(const someModelMetaKey in modelMetadatas){
+            const isIdTyped = modelMetadatas[someModelMetaKey].annotationType === 'IdType';
+            if(isIdTyped){
+                hasIdType = true;
+                idFieldName = someModelMetaKey;
+            }
+        }
+
+        let idGenerated = false;      
+            
 
         if(
-            !model._NO_ID            
-        ){
-            section += `\t${DbUtils.generateId(dbType, modelMetadatas)}\n`;
-        }              
+            !model._NO_ID && !hasIdType            
+        ){                     
+            section += `\t${DbUtils.generateId(dbType, modelMetadatas)}\n`;     
+            idGenerated = true;
+        }                        
 
         for (const key in modelMetadatas) {
             const modelMetadata = modelMetadatas[key].metadata;
@@ -72,16 +88,15 @@ datasource db {
 
             let indexedId = false;
 
-            if(model._NO_ID){
+            if(model._NO_ID || hasIdType){
                 indexedId = true;
                 requiredString = '';
-            }
-                   
+            }                         
 
             if (key === 'id' && !indexedId) {
                 continue;
             }
-
+              
             if (annotationType === 'Relation') {
                 const relationMeta = modelMetadata as IRelationOpts;
 
@@ -101,8 +116,9 @@ datasource db {
                 const relationKey = [modelName, relatedModelName].join('_');
                 
                 const relationIndex = RelationManager.getRelationCounter(relationKey);
-                const relationName = RelationManager.getShortenedRelationName(modelName, relatedModelName, relationIndex);
-                const mapName = relationName; 
+                const relationName = relationMeta.relationName ? relationMeta.relationName : null;
+
+                const mapName = relationMeta.mappingName ? relationMeta.mappingName : null; 
 
                 const relatedModelMetadatas: Record<string, { annotationType: string, metadata: ITrackerMetaOpts }> = await RWSModel.getModelAnnotations(relatedModel);
                 const relationFieldName = modelMetadata.relationField ? modelMetadata.relationField  : key.toLowerCase() + '_' + modelMetadata.relationField.toLowerCase();
@@ -112,17 +128,19 @@ datasource db {
                 
                 if(modelMetadata.required === false){
                     requiredString = '?';
-                }
+                }               
+
+                const cascadeStr = cascadeOpts.length ? `, ${cascadeOpts.join(', ')}` : '' ;
 
                 if (isMany) {
                     // Add an inverse field to the related model if it doesn't exist
-                    section += `\t${key} ${relatedModel._collection}[] @relation("${relationName}", fields: [${relationFieldName}], references: [${relatedToField}], map: "${mapName}", ${cascadeOpts.join(', ')})\n`;
-                } else {                    
-                    section += `\t${key} ${relatedModel._collection}${requiredString} @relation("${relationName}", fields: [${relationFieldName}], references: [${relatedToField}], map: "${mapName}", ${cascadeOpts.join(', ')})\n`;
+                    section += `\t${key} ${relatedModel._collection}[] @relation(${relationName ? `"${relationName}", ` : ''}fields: [${relationFieldName}], references: [${relatedToField}]${mapName ? `, map: "${mapName}"` : ''}${cascadeStr})\n`;
+                } 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){
+                        if(!relatedFieldMeta.metadata.required){                     
                             requiredString = '';
                         }
                         
@@ -162,10 +180,15 @@ datasource db {
                 const relationKey = [relatedModelName, modelName].join('_');
                 const relationIndex = RelationManager.getRelationCounter(relationKey, true);
 
-                const relationName = RelationManager.getShortenedRelationName(relatedModelName, modelName, relationIndex);
-                const mapName = relationName; 
+                const relationName = RelationManager.getShortenedRelationName(relatedModelName, modelName, relationIndex);                
+
+                let relationTag = '';
+
+                if(relationMeta.relationName){
+                    relationTag = ` @relation("${relationMeta.relationName}")`;
+                }
 
-                section += `\t${key} ${relationMeta.inversionModel._collection}[] @relation("${relationName}", map: "${mapName}")\n`;
+                section += `\t${key} ${relationMeta.inversionModel._collection}[]${relationTag}\n`;
                 
                 RelationManager.completeRelation(relationKey, relationIndex, true);
             } else if (annotationType === 'InverseTimeSeries') {
@@ -180,14 +203,22 @@ datasource db {
                 } else {
                     section += `\t${key} String[]\n`;
                 }
-            } else if (annotationType === 'TrackType') {
+            } else {
                 const trackMeta = modelMetadata as ITrackerMetaOpts;
-                const tags: string[] = trackMeta.tags.map((item: string) => '@' + item);  
-                
-                if(key === 'id' && model._NO_ID && !model._SUPER_TAGS.some(tag => tag.tagType === 'id' && tag.fields.includes('id'))){
+                const trackTags = trackMeta.tags || [];
+                const tags: string[] = trackTags.map((item: string) => '@' + item);  
+                             
+                const isNoIdBehavior = model._NO_ID || idFieldName;
+                const isOverrideBehavior = (hasIdType && annotationType === 'IdType' && key === 'id' && idFieldName === 'id') 
+                    || 
+                    (model._NO_ID && model._SUPER_TAGS.some(a => a.fields.includes('id')) && key === 'id');
+                                                                
+                if(key === 'id' && 
+                    isNoIdBehavior && !isOverrideBehavior               
+                ){                  
                     continue;
                 }
-       
+
                 if(trackMeta.unique){
                     const fieldDetail: string | null = typeof trackMeta.unique === 'string' ? trackMeta.unique : null;
                     tags.push(`@unique(${fieldDetail ? `map: "${fieldDetail}"` : ''})`);
@@ -204,24 +235,60 @@ datasource db {
                 if(model._SUPER_TAGS.some(tag => tag.tagType === 'id' && tag.fields.includes(key))){
                     requiredString = '';
                 }
-
+               
                 // Process any database-specific options from the metadata
                 const dbSpecificTags = TypeConverter.processTypeOptions(trackMeta as { tags: string[], dbOptions: IDbOpts['dbOptions'] }, dbType);
                 tags.push(...dbSpecificTags);
+         
+                const isIdTypeField = modelMetadatas[key].annotationType === 'IdType';                         
+                const fieldInUniqueSuperTag = model._SUPER_TAGS.some(st => st.tagType === 'unique' && st.fields.includes(key));
 
-                if(modelName === 'category_translation' && key === 'meta_keywords'){
-                    console.log({requiredString, trackMeta});
-                }
+                if(isIdTypeField){
+                    requiredString = '';
+                }        
+
+                let trackField = `${key} ${TypeConverter.toConfigCase(trackMeta, dbType, key === 'id', isOverrideBehavior)}${requiredString} ${tags.join(' ')}`;
 
-                section += `\t${key} ${TypeConverter.toConfigCase(trackMeta, dbType, key === 'id')}${requiredString} ${tags.join(' ')}\n`;
+                if(isIdTypeField){
+                    trackField += DbUtils.addIdPart(dbType, DbUtils.doesUseUuid(modelMetadatas), trackMeta.noAuto);
+                    idGenerated = true;                                   
+                }          
+
+                section += `\t${trackField}\n`;
             }
         }
 
+        if(model._SUPER_TAGS.length){
+            section += '\n';
+        }
+
         for(const superTag of model._SUPER_TAGS){
 
             const mapStr = superTag.map ? `, map: "${superTag.map}"` : '';
 
-            section += `\t@@${superTag.tagType}([${superTag.fields.join(', ')}]${mapStr})\n`;
+            const superFields = [];
+        
+            for(const superField of superTag.fields){
+                const fieldMetadata = modelMetadatas[superField]['metadata'];
+       
+    
+                let pushed = false;
+
+                if(fieldMetadata.dbOptions && fieldMetadata.dbOptions.mysql && fieldMetadata.dbOptions.mysql.useType){                        
+                    switch(fieldMetadata.dbOptions.mysql.useType){
+                        case 'db.LongText': 
+                            superFields.push(`${superField}(length: 255)`);                                    
+                            pushed = true;
+                        break;
+                    }                    
+                }
+
+                if(!pushed){
+                    superFields.push(superField);
+                }
+            }
+            
+            section += `\t@@${superTag.tagType}([${superFields.join(', ')}]${mapStr})\n`;
         }
 
         section += '}\n';
@@ -280,7 +347,7 @@ datasource db {
 
                 template += '\n\n' + modelSection;
 
-                log(chalk.green('[RWS]'), chalk.blue('Building DB Model'), model.name);
+                console.log(chalk.green('[RWS]'), chalk.blue('Building DB Model'), model.name);
             }
 
             const [schemaDir, schemaPath] = DbUtils.getSchemaDir();
@@ -295,13 +362,14 @@ datasource db {
 
             fs.writeFileSync(schemaPath, template);
 
+            if(_EXECUTE_PRISMA_CMD)
             await rwsShell.runCommand(`${DbUtils.detectInstaller()} prisma generate --schema=${schemaPath}`, process.cwd());
 
-            leaveFile = false;
-            log(chalk.green('[RWS Init]') + ' prisma schema generated from ', schemaPath);
+            
+            console.log(chalk.green('[RWS Init]') + ' prisma schema generated from ', schemaPath);
 
-            if (!leaveFile) {
-                // fs.unlinkSync(schemaPath);
+            if (_REMOVE_SCHEMA_FILE) {
+                fs.unlinkSync(schemaPath);
             }
         }
     }

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

@@ -1,6 +1,8 @@
 import { IDbOpts } from '../../models/interfaces/IDbOpts';
 import { ITrackerMetaOpts } from '../../models/_model';
 import { IIdMetaOpts } from 'src/decorators/IdType';
+import { DbUtils } from './utils';
+import { IDbConfigParams } from 'src/types/DbConfigHandler';
 
 /**
  * Handles type conversion for database schema generation
@@ -9,14 +11,35 @@ export class TypeConverter {
     /**
      * Convert a JavaScript type to a Prisma schema type
      */
-    static toConfigCase(modelType: ITrackerMetaOpts | IIdMetaOpts, dbType: string = 'mongodb', isId: boolean = false): string {
+    static toConfigCase(modelType: ITrackerMetaOpts | IIdMetaOpts, dbType: IDbConfigParams['db_type'] = 'mongodb', isId: boolean = false, isIdOverride: boolean = false): string {
         const type = modelType.type;
         let input = type.name;    
             
 
         // Handle basic types
         if (input == 'Number') {
-            input = 'Int';
+            let numberOverride = false;
+            if(modelType.dbOptions && modelType.dbOptions.mysql){
+                if(modelType.dbOptions.mysql.useType){
+                    if(['db.Float'].includes(modelType.dbOptions.mysql.useType)){
+                        input = 'Float';
+                        numberOverride = true;
+                    }
+
+                    if(['db.Decimal'].includes(modelType.dbOptions.mysql.useType)){
+                        input = 'Decimal';
+                        numberOverride = true;
+                    }
+                }
+            }
+            
+            if(!numberOverride){
+                input = 'Int';
+            }            
+        }
+
+        if (input == 'BigInt') {
+            input = 'BigInt';
         }
 
         if (input == 'Object') {
@@ -46,9 +69,9 @@ export class TypeConverter {
         const restOfString = input.slice(1);
         let resultField = firstChar + restOfString;
 
-        if(isId){
-            return dbType === 'mongodb' ? 'String' : 'Int';
-        }
+        if(isId && !isIdOverride){
+            return DbUtils.getDefaultPrismaType(dbType, false);
+        }      
 
         const trackerModelType = modelType as ITrackerMetaOpts;
 
@@ -64,7 +87,7 @@ export class TypeConverter {
             } else {
                 resultField += '[]';
             }
-        }
+        }        
 
         return resultField;
     }
@@ -83,10 +106,20 @@ export class TypeConverter {
         if (metadata.dbOptions) {
             // Handle MySQL-specific options
             if (dbType === 'mysql' && metadata.dbOptions.mysql) {
+                let tag = null;
+
+                if (metadata.dbOptions.mysql.useType && !metadata.dbOptions.mysql.useText) {
+                    const tagName = metadata.dbOptions.mysql.useType === 'VarChar' ?  'db.' + metadata.dbOptions.mysql.useType : metadata.dbOptions.mysql.useType;                    
+                    let tagParams = tagName === 'db.VarChar' && metadata.dbOptions.mysql.maxLength ? metadata.dbOptions.mysql.maxLength : (metadata.dbOptions.mysql?.params?.join(', ') || '');                    
+                    tag = `@${tagName}(${tagParams})`;                    
+                }
+
                 if (metadata.dbOptions.mysql.useText) {
                     tags.push('@db.Text');
-                } else if (metadata.dbOptions.mysql.maxLength) {
-                    tags.push(`@db.VarChar(${metadata.dbOptions.mysql.maxLength})`);
+                }
+
+                if(tag){
+                    tags.push(tag);
                 }
 
                 if (metadata.dbOptions.mysql.useUuid && metadata.tags?.includes('id')) {