@rws-framework/db 3.1.0 → 3.2.0

package/dist/decorators/Relation.js

@@ -1,7 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 require("reflect-metadata");
-const _DEFAULTS = { required: false, many: false, embed: false, cascade: { onDelete: 'SetNull', onUpdate: 'Cascade' } };
+const _DEFAULT_CASCADE = { onDelete: 'SetNull', onUpdate: 'Cascade' };
+const _DEFAULTS = { required: false, many: false, embed: false, cascade: null };
 function Relation(theModel, relationOptions = _DEFAULTS) {
     return function (target, key) {
         // Store the promise in metadata immediately

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

@@ -11,7 +11,6 @@ const _model_1 = require("../../models/_model");
 const utils_1 = require("./utils");
 const type_converter_1 = require("./type-converter");
 const relation_manager_1 = require("./relation-manager");
-const log = console.log;
 /**
  * Handles Prisma schema generation
  */
@@ -84,12 +83,13 @@ 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`;
+                    section += `\t${key} ${relatedModel._collection}[] @relation("${relationName}", fields: [${relationFieldName}], references: [${relatedToField}], map: "${mapName}"${cascadeStr})\n`;
                 }
                 else {
-                    section += `\t${key} ${relatedModel._collection}${requiredString} @relation("${relationName}", fields: [${relationFieldName}], references: [${relatedToField}], map: "${mapName}", ${cascadeOpts.join(', ')})\n`;
+                    section += `\t${key} ${relatedModel._collection}${requiredString} @relation("${relationName}", fields: [${relationFieldName}], references: [${relatedToField}], map: "${mapName}"${cascadeStr})\n`;
                     if (!bindingFieldExists) {
                         const relatedFieldMeta = relatedModelMetadatas[relatedToField];
                         if (!relatedFieldMeta.metadata.required) {
@@ -173,15 +173,31 @@ datasource db {
                 // Process any database-specific options from the metadata
                 const dbSpecificTags = type_converter_1.TypeConverter.processTypeOptions(trackMeta, dbType);
                 tags.push(...dbSpecificTags);
-                if (modelName === 'category_translation' && key === 'meta_keywords') {
-                    console.log({ requiredString, trackMeta });
-                }
                 section += `\t${key} ${type_converter_1.TypeConverter.toConfigCase(trackMeta, dbType, key === 'id')}${requiredString} ${tags.join(' ')}\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';
         return section;
@@ -224,7 +240,7 @@ datasource db {
             for (const model of dbModels) {
                 const modelSection = await SchemaGenerator.generateModelSections(model, configService);
                 template += '\n\n' + modelSection;
-                log(chalk_1.default.green('[RWS]'), chalk_1.default.blue('Building DB Model'), model.name);
+                console.log(chalk_1.default.green('[RWS]'), chalk_1.default.blue('Building DB Model'), model.name);
             }
             const [schemaDir, schemaPath] = utils_1.DbUtils.getSchemaDir();
             if (!fs_1.default.existsSync(schemaDir)) {
@@ -236,7 +252,7 @@ datasource db {
             fs_1.default.writeFileSync(schemaPath, template);
             await console_1.rwsShell.runCommand(`${utils_1.DbUtils.detectInstaller()} prisma generate --schema=${schemaPath}`, process.cwd());
             leaveFile = false;
-            log(chalk_1.default.green('[RWS Init]') + ' prisma schema generated from ', schemaPath);
+            console.log(chalk_1.default.green('[RWS Init]') + ' prisma schema generated from ', schemaPath);
             if (!leaveFile) {
                 // fs.unlinkSync(schemaPath);
             }

package/dist/helper/db/type-converter.js

@@ -13,7 +13,22 @@ class TypeConverter {
         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 == 'Object') {
             input = 'Json';
@@ -66,20 +81,26 @@ class TypeConverter {
      * @returns Array of tags to apply to the field
      */
     static processTypeOptions(metadata, dbType) {
-        var _a, _b;
+        var _a, _b, _c, _d;
         const tags = [...(metadata.tags || [])];
         // Extract any database-specific options from the metadata
         // and convert them to appropriate Prisma schema tags
         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 : (((_b = (_a = metadata.dbOptions.mysql) === null || _a === void 0 ? void 0 : _a.params) === null || _b === void 0 ? void 0 : _b.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 && ((_a = metadata.tags) === null || _a === void 0 ? void 0 : _a.includes('id'))) {
+                if (metadata.dbOptions.mysql.useUuid && ((_c = metadata.tags) === null || _c === void 0 ? void 0 : _c.includes('id'))) {
                     tags.push('default(uuid())');
                 }
             }
@@ -88,7 +109,7 @@ class TypeConverter {
                 if (metadata.dbOptions.postgres.useText) {
                     tags.push('@db.Text');
                 }
-                if (metadata.dbOptions.postgres.useUuid && ((_b = metadata.tags) === null || _b === void 0 ? void 0 : _b.includes('id'))) {
+                if (metadata.dbOptions.postgres.useUuid && ((_d = metadata.tags) === null || _d === void 0 ? void 0 : _d.includes('id'))) {
                     tags.push('@default(uuid())');
                     tags.push('@db.Uuid');
                 }

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/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/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.2.0",
   "description": "",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

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 = {

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

@@ -15,7 +15,6 @@ import { RelationManager } from './relation-manager';
 import { ITrackerMetaOpts } from '../../decorators/TrackType';
 import { IDbOpts } from '../../models/interfaces/IDbOpts';
 
-const log = console.log;
 
 /**
  * Handles Prisma schema generation
@@ -114,11 +113,13 @@ datasource db {
                     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`;
+                    section += `\t${key} ${relatedModel._collection}[] @relation("${relationName}", fields: [${relationFieldName}], references: [${relatedToField}], map: "${mapName}"${cascadeStr})\n`;
                 } else {                    
-                    section += `\t${key} ${relatedModel._collection}${requiredString} @relation("${relationName}", fields: [${relationFieldName}], references: [${relatedToField}], map: "${mapName}", ${cascadeOpts.join(', ')})\n`;
+                    section += `\t${key} ${relatedModel._collection}${requiredString} @relation("${relationName}", fields: [${relationFieldName}], references: [${relatedToField}], map: "${mapName}"${cascadeStr})\n`;
                     if(!bindingFieldExists){
                         const relatedFieldMeta = relatedModelMetadatas[relatedToField];
 
@@ -204,24 +205,47 @@ 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);
-
-                if(modelName === 'category_translation' && key === 'meta_keywords'){
-                    console.log({requiredString, trackMeta});
-                }
+         
 
                 section += `\t${key} ${TypeConverter.toConfigCase(trackMeta, dbType, key === 'id')}${requiredString} ${tags.join(' ')}\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 +304,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();
@@ -298,7 +322,7 @@ datasource db {
             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);

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

@@ -16,7 +16,24 @@ export class TypeConverter {
 
         // 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 == 'Object') {
@@ -64,7 +81,7 @@ export class TypeConverter {
             } else {
                 resultField += '[]';
             }
-        }
+        }        
 
         return resultField;
     }
@@ -83,10 +100,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')) {

package/src/models/interfaces/IDbOpts.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/src/models/utils/HydrateUtils.ts

@@ -53,8 +53,6 @@ export class HydrateUtils {
                  }
      
                  const relMeta = relManyData[key];  
-
-                //  console.log({relMeta});
          
                  const relationEnabled = !RelationUtils.checkRelDisabled(model, relMeta.key);
                  if (relationEnabled) {