@rws-framework/db 2.4.5 → 3.0.0

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

@@ -0,0 +1,302 @@
+import { rwsShell } from '@rws-framework/console';
+import chalk from 'chalk';
+import fs from 'fs';
+import path from 'path';
+
+import { IDbConfigHandler } from '../../types/DbConfigHandler';
+import { OpModelType, RWSModel } from '../../models/_model';
+import { DBService } from '../../services/DBService';
+import { IRelationOpts } from '../../decorators/Relation';
+import { InverseRelationOpts } from '../../decorators/InverseRelation';
+
+import { DbUtils } from './utils';
+import { TypeConverter } from './type-converter';
+import { RelationManager } from './relation-manager';
+import { ITrackerMetaOpts } from '../../decorators/TrackType';
+import { IDbOpts } from '../../models/interfaces/IDbOpts';
+
+const log = console.log;
+
+/**
+ * Handles Prisma schema generation
+ */
+export class SchemaGenerator {
+    static dbUrlVarName: string = 'PRISMA_DB_URL';
+
+    /**
+     * Generate the base schema for Prisma
+     * @param dbType The database type
+     * @param dbUrl The database URL
+     * @returns The base schema
+     */
+    static generateBaseSchema(dbType: string, dbUrl: string): string {
+        process.env = { ...process.env, [this.dbUrlVarName]: dbUrl };
+
+        return `generator client {
+    provider = "prisma-client-js"
+}
+
+datasource db {
+    provider = "${dbType}"
+    url = env("${this.dbUrlVarName}")
+}`;
+    }
+
+    /**
+     * Generate model sections for the schema
+     * @param model The model to generate a section for
+     * @param configService The configuration service
+     * @returns The model section
+     */
+    static async generateModelSections(
+        model: OpModelType<any>,
+        configService: IDbConfigHandler
+    ): Promise<string> {
+        let section = '';
+        const modelMetadatas: Record<string, { annotationType: string, metadata: any }> = await RWSModel.getModelAnnotations(model);
+        const dbType = configService.get('db_type') || 'mongodb';
+        const modelName: string = (model as any)._collection;
+
+        section += `model ${modelName} {\n`;       
+
+        if(
+            !model._NO_ID            
+        ){
+            section += `\t${DbUtils.generateId(dbType, modelMetadatas, false)}\n`;
+        }              
+
+        for (const key in modelMetadatas) {
+            const modelMetadata = modelMetadatas[key].metadata;
+            let requiredString = modelMetadata.required ? '' : '?';
+            const annotationType: string = modelMetadatas[key].annotationType;
+
+            let indexedId = false;
+
+            if(model._NO_ID){
+                indexedId = true;
+                requiredString = '';
+            }
+                   
+
+            if (key === 'id' && !indexedId) {
+                continue;
+            }
+
+            if (annotationType === 'Relation') {
+                const relationMeta = modelMetadata as IRelationOpts;
+
+                const relatedModel = relationMeta.relatedTo as OpModelType<any>;
+                const isMany = relationMeta.many;
+                const cascadeOpts = [];
+
+                if (relationMeta.cascade?.onDelete) {
+                    cascadeOpts.push(`onDelete: ${relationMeta.cascade.onDelete}`);
+                }
+
+                if (relationMeta.cascade?.onUpdate) {
+                    cascadeOpts.push(`onUpdate: ${relationMeta.cascade.onUpdate}`);
+                }
+
+                const relatedModelName = relatedModel._collection;
+                const relationKey = [modelName, relatedModelName].join('_');
+                
+                const relationIndex = RelationManager.getRelationCounter(relationKey);
+                const relationName = RelationManager.getShortenedRelationName(modelName, relatedModelName, relationIndex);
+                const mapName = relationName; 
+
+                const relatedModelMetadatas: Record<string, { annotationType: string, metadata: ITrackerMetaOpts }> = await RWSModel.getModelAnnotations(relatedModel);
+                const relationFieldName = modelMetadata.relationField ? modelMetadata.relationField  : key.toLowerCase() + '_' + modelMetadata.relationField.toLowerCase();
+
+                const relatedToField = modelMetadata.relatedToField || 'id';
+                const bindingFieldExists = !!modelMetadatas[relationFieldName];          
+
+                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`;
+                    if(!bindingFieldExists){
+                        const relatedFieldMeta = relatedModelMetadatas[relatedToField];
+
+                        if(!relatedFieldMeta.metadata.required){
+                            requiredString = '';
+                        }
+                        
+                        let relatedFieldType = TypeConverter.toConfigCase(relatedFieldMeta.metadata, dbType, true);
+        
+                        if(relatedToField === 'id' && dbType !== 'mongodb'){
+                            relatedFieldType = 'Int';
+                        }                                       
+                    
+                        // Add relation field with appropriate type based on database
+                        if (dbType === 'mongodb') {
+                            section += `\t${relationFieldName} String${requiredString} @db.ObjectId\n`;
+                        } else if (dbType === 'mysql') {
+                            // For MySQL, determine the type based on the related model's ID type
+                            section += `\t${relationFieldName} ${relatedFieldType}${requiredString}\n`;
+                        } else if (dbType === 'postgresql' || dbType === 'postgres') {
+                            if (relatedFieldType === 'String') {
+                                section += `\t${relationFieldName} ${relatedFieldType}${requiredString} @db.Uuid\n`;
+                            } else {
+                                section += `\t${relationFieldName} ${relatedFieldType}${requiredString}\n`;
+                            }
+                        } else {                        
+                            section += `\t${relationFieldName} String${requiredString}\n`;
+                        }
+                    }
+                }
+
+                RelationManager.completeRelation(relationKey, relationIndex);
+            } else if (annotationType === 'InverseRelation') {
+                const relationMeta = modelMetadata as InverseRelationOpts;
+
+                // Check if we need a custom relation name (if there are multiple relations to the same model)
+                const relatedModelName = relationMeta.inversionModel._collection;
+
+                // Generate a very short relation name using a counter
+                // Use a consistent key for both sides of the relation to ensure the same name is used
+                const relationKey = [relatedModelName, modelName].join('_');
+                const relationIndex = RelationManager.getRelationCounter(relationKey, true);
+
+                const relationName = RelationManager.getShortenedRelationName(relatedModelName, modelName, relationIndex);
+                const mapName = relationName; 
+
+                section += `\t${key} ${relationMeta.inversionModel._collection}[] @relation("${relationName}", map: "${mapName}")\n`;
+                
+                RelationManager.completeRelation(relationKey, relationIndex, true);
+            } else if (annotationType === 'InverseTimeSeries') {
+                if (dbType === 'mongodb') {
+                    section += `\t${key} String[] @db.ObjectId\n`;
+                } else if (dbType === 'mysql') {
+                    // For MySQL, we need a different approach for arrays
+                    section += `\t${key} Json\n`;
+                } else if (dbType === 'postgresql' || dbType === 'postgres') {
+                    // PostgreSQL supports arrays natively
+                    section += `\t${key} String[]\n`;
+                } else {
+                    section += `\t${key} String[]\n`;
+                }
+            } else if (annotationType === 'TrackType') {
+                const trackMeta = modelMetadata as ITrackerMetaOpts;
+                const tags: string[] = trackMeta.tags.map((item: string) => '@' + item);                           
+       
+                if(trackMeta.unique){
+                    const fieldDetail: string | null = typeof trackMeta.unique === 'string' ? trackMeta.unique : null;
+                    tags.push(`@unique(${fieldDetail ? `map: "${fieldDetail}"` : ''})`);
+                }
+
+                if (trackMeta.isArray || trackMeta.type.name === 'Array') {
+                    requiredString = '';
+                }
+
+                // Process any database-specific options from the metadata
+                const dbSpecificTags = TypeConverter.processTypeOptions(trackMeta as { tags: string[], dbOptions: IDbOpts['dbOptions'] }, dbType);
+                tags.push(...dbSpecificTags);
+
+                section += `\t${key} ${TypeConverter.toConfigCase(trackMeta, dbType, key === 'id')}${requiredString} ${tags.join(' ')}\n`;
+            }
+        }
+
+        for(const superTag of model._SUPER_TAGS){
+
+            const mapStr = superTag.map ? `, map: "${superTag.map}"` : '';
+
+            section += `\t@@${superTag.tagType}([${superTag.fields.join(', ')}]${mapStr})\n`;
+        }
+
+        section += '}\n';
+        return section;
+    }
+
+    /**
+     * Install Prisma with the generated schema
+     * @param configService The configuration service
+     * @param dbService The database service
+     * @param leaveFile Whether to leave the schema file after generation
+     */
+    static async installPrisma(configService: IDbConfigHandler, dbService: DBService, leaveFile = false): Promise<void> {
+        const dbUrl = configService.get('db_url');
+        const dbType = configService.get('db_type') || 'mongodb';
+
+        let template: string = this.generateBaseSchema(dbType, dbUrl);
+
+        const dbModels: OpModelType<unknown>[] | null = configService.get('db_models');
+
+        if (dbModels) {   
+            for (const model of dbModels) {
+                const modelName = (model as any)._collection;
+                const modelMetadatas: Record<string, { annotationType: string, metadata: any }> = await RWSModel.getModelAnnotations(model);
+                
+                for (const key in modelMetadatas) {
+                    const annotationType: string = modelMetadatas[key].annotationType;
+
+                    if (annotationType === 'Relation') {
+                        const relationMeta = modelMetadatas[key].metadata as IRelationOpts;
+                        
+                        const relatedModel = relationMeta.relatedTo as OpModelType<any>;
+                        const relatedModelName = relatedModel._collection;
+
+                        const relationKey = [modelName, relatedModelName].join('_');                      
+
+                        // Add this relation to the map
+                        RelationManager.markRelation(relationKey);                                  
+                    }
+                    
+                    if(annotationType === 'InverseRelation'){
+                        const relationMeta = modelMetadatas[key].metadata as InverseRelationOpts;
+                        const relatedModel = relationMeta.inversionModel as OpModelType<any>;
+                        
+                        const relatedModelName = relatedModel._collection;
+            
+                        const relationKey = [relatedModelName, modelName].join('_');                      
+                        RelationManager.markRelation(relationKey, true);
+                    }
+                }
+            }            
+
+            // Now generate the model sections with all relations
+            for (const model of dbModels) {
+                const modelSection = await SchemaGenerator.generateModelSections(model, configService);
+
+                template += '\n\n' + modelSection;
+
+                log(chalk.green('[RWS]'), chalk.blue('Building DB Model'), model.name);
+            }
+
+            const [schemaDir, schemaPath] = DbUtils.getSchemaDir();
+
+            if (!fs.existsSync(schemaDir)) {
+                fs.mkdirSync(schemaDir);
+            }
+
+            if (fs.existsSync(schemaPath)) {
+                fs.unlinkSync(schemaPath);
+            }
+
+            fs.writeFileSync(schemaPath, template);
+
+            await rwsShell.runCommand(`${DbUtils.detectInstaller()} prisma generate --schema=${schemaPath}`, process.cwd());
+
+            leaveFile = false;
+            log(chalk.green('[RWS Init]') + ' prisma schema generated from ', schemaPath);
+
+            if (!leaveFile) {
+                // fs.unlinkSync(schemaPath);
+            }
+        }
+    }
+
+    /**
+     * Push database models to the database
+     * @param configService The configuration service
+     * @param dbService The database service
+     * @param leaveFile Whether to leave the schema file after generation
+     */
+    static async pushDBModels(configService: IDbConfigHandler, dbService: DBService, leaveFile = false): Promise<void> {
+        process.env = { ...process.env, [this.dbUrlVarName]: configService.get('db_url') };
+
+        const [_, schemaPath] = DbUtils.getSchemaDir();
+
+        await rwsShell.runCommand(`${DbUtils.detectInstaller()} prisma db push --schema=${schemaPath}`, process.cwd());
+    }
+}

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

@@ -0,0 +1,119 @@
+import { IDbOpts } from '../../models/interfaces/IDbOpts';
+import { ITrackerMetaOpts } from '../../models/_model';
+import { IIdMetaOpts } from 'src/decorators/IdType';
+
+/**
+ * Handles type conversion for database schema generation
+ */
+export class TypeConverter {
+    /**
+     * Convert a JavaScript type to a Prisma schema type
+     */
+    static toConfigCase(modelType: ITrackerMetaOpts | IIdMetaOpts, dbType: string = 'mongodb', isId: boolean = false): string {
+        const type = modelType.type;
+        let input = type.name;    
+            
+
+        // Handle basic types
+        if (input == 'Number') {
+            input = 'Int';
+        }
+
+        if (input == 'Object') {
+            input = 'Json';
+        }
+
+        if (input == 'Date') {
+            input = 'DateTime';
+        }
+
+        if (input == 'Boolean') {
+            // Ensure Boolean is properly handled for all database types
+            input = 'Boolean';
+        }
+
+        if (input == 'Array') {
+            // Handle arrays differently based on database type
+            if (dbType === 'mysql') {
+                // MySQL doesn't support native arrays, use Json instead
+                input = 'Json';
+            } else {
+                input = 'Json[]';
+            }
+        }
+
+        const firstChar = input.charAt(0).toUpperCase();
+        const restOfString = input.slice(1);
+        let resultField = firstChar + restOfString;
+
+        if(isId){
+            return dbType === 'mongodb' ? 'String' : 'Int';
+        }
+
+        const trackerModelType = modelType as ITrackerMetaOpts;
+
+        if (trackerModelType.isArray) {
+            // Handle arrays differently based on database type
+            if (dbType === 'mysql') {
+                // For MySQL, we don't append [] as it doesn't support native arrays
+                // Instead, we'll store arrays as JSON
+                resultField = 'Json';
+            } else if (dbType === 'postgresql' || dbType === 'postgres') {
+                // PostgreSQL supports arrays natively
+                resultField += '[]';
+            } else {
+                resultField += '[]';
+            }
+        }
+
+        return resultField;
+    }
+
+    /**
+     * Process type functions metadata to extract database-specific options
+     * @param metadata The metadata from a type function
+     * @param dbType The database type
+     * @returns Array of tags to apply to the field
+     */
+    static processTypeOptions(metadata: { tags: string[], dbOptions: IDbOpts['dbOptions'] }, dbType: string): string[] {
+        const tags: string[] = [...(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) {
+                if (metadata.dbOptions.mysql.useText) {
+                    tags.push('@db.Text');
+                } else if (metadata.dbOptions.mysql.maxLength) {
+                    tags.push(`@db.VarChar(${metadata.dbOptions.mysql.maxLength})`);
+                }
+
+                if (metadata.dbOptions.mysql.useUuid && metadata.tags?.includes('id')) {
+                    tags.push('default(uuid())');
+                }
+            }
+
+            // Handle PostgreSQL-specific options
+            if ((dbType === 'postgresql' || dbType === 'postgres') && metadata.dbOptions.postgres) {
+                if (metadata.dbOptions.postgres.useText) {
+                    tags.push('@db.Text');
+                }
+
+                if (metadata.dbOptions.postgres.useUuid && metadata.tags?.includes('id')) {
+                    tags.push('@default(uuid())');
+                    tags.push('@db.Uuid');
+                }
+            }
+
+            // Handle MongoDB-specific options
+            if (dbType === 'mongodb' && metadata.dbOptions.mongodb) {
+                if (metadata.dbOptions.mongodb.customType) {
+                    tags.push(`@db.${metadata.dbOptions.mongodb.customType}`);
+                }
+            }
+        }
+
+        return tags;
+    }
+}

package/src/helper/db/utils.ts

@@ -0,0 +1,120 @@
+import { rwsPath } from '@rws-framework/console';
+import path from 'path';
+import fs from 'fs';
+import { IDbConfigParams } from '../../types/DbConfigHandler';
+import { IIdMetaOpts, IIdTypeOpts } from '../../decorators/IdType';
+import { TypeConverter } from './type-converter';
+import { IDbOpts } from '../../models/interfaces/IDbOpts';
+
+const workspaceRoot = rwsPath.findRootWorkspacePath();
+const moduleDir = path.resolve(workspaceRoot, 'node_modules', '@rws-framework', 'db');
+
+/**
+ * Utility functions for database operations
+ */
+export class DbUtils {
+    /**
+     * Get the directory and path for the Prisma schema file
+     */
+    static getSchemaDir(): [string, string] {
+        const schemaDir = path.join(moduleDir, 'prisma');
+        const schemaPath = path.join(schemaDir, 'schema.prisma');
+
+        return [schemaDir, schemaPath];
+    }
+
+    /**
+     * Detect the package installer (yarn or npx)
+     */
+    static detectInstaller(): string {
+        if (fs.existsSync(path.join(workspaceRoot, 'yarn.lock'))) {
+            return 'yarn';
+        }
+
+        return 'npx';
+    }
+
+    /**
+     * Generate an ID field based on the database type
+     */
+    static generateId(
+        dbType: IDbConfigParams['db_type'],
+        modelMeta: Record<string, { annotationType: string, metadata: IIdMetaOpts }>,
+        debug = false
+    ): string {        
+        let useUuid = false;
+        let field = 'id';
+        const tags: string[] = [];        
+
+        for (const key in modelMeta) {
+            const modelMetadata: IIdMetaOpts = modelMeta[key].metadata;            
+            const annotationType: string = modelMeta[key].annotationType;            
+
+            if(key !== 'id'){
+                if(annotationType == 'IdType'){     
+                    const dbSpecificTags = TypeConverter.processTypeOptions({ tags: [], dbOptions: modelMetadata.dbOptions }, dbType);
+                    tags.push(...dbSpecificTags);
+                    if(debug){                                     
+                        console.log({modelMetadata: modelMetadata.dbOptions});
+                    }          
+                             
+                    field = key;
+
+                    if(modelMetadata.dbOptions?.mysql?.useUuid){
+                        useUuid = true;
+                    }
+
+                    if(modelMetadata.dbOptions?.postgres?.useUuid){
+                        useUuid = true;
+                    }
+
+                    if(modelMetadata.type.name === 'String'){
+                        useUuid = true;
+                    }
+                }
+            }
+        }
+
+        let idString: string;
+
+        switch (dbType) {
+            case 'mongodb':
+                idString = `${field} String @id @default(auto()) @map("_id") @db.ObjectId`;
+                break;
+
+            case 'mysql':
+                idString = useUuid
+                    ? `${field} String @id @default(uuid())`
+                    : `${field} Int @id @default(autoincrement())`;
+                break;
+
+            case 'postgresql':
+            case 'postgres':
+                idString = useUuid
+                    ? `${field} String @id @default(uuid())`
+                    : `${field} Int @id @default(autoincrement())`;
+                    break;    
+
+            case 'sqlite':
+                idString = `${field} Int @id @default(autoincrement())`;            
+                break;
+        }
+
+        if(tags.length){
+            idString += ' '+tags.join(' ');
+        }
+
+        if(!idString){
+            throw new Error(`DB type "${dbType}" is not supported!`);
+        }
+
+        if(debug){                                     
+            console.log({idString, useUuid});
+        }          
+
+        return idString;
+    }
+}
+
+export const workspaceRootPath = workspaceRoot;
+export const moduleDirPath = moduleDir;

package/src/index.ts

@@ -1,38 +1,47 @@
-import { DBService } from "./services/DBService";
-import { RWSModel, OpModelType } from "./models/_model";
-// import TimeSeriesModel from './models/core/TimeSeriesModel';
-import { InverseRelation, Relation, TrackType, InverseTimeSeries, IMetaOpts } from './decorators';
-
-import { DbHelper } from './helper/DbHelper';
-import { FieldsHelper } from './helper/FieldsHelper';
-
-import type  { FindByType } from './types/FindParams';
-import type  { ITimeSeries } from './types/ITimeSeries';
-import type { IDbConfigHandler, IDbConfigParams } from './types/DbConfigHandler';
-import type { IRWSModel } from './types/IRWSModel';
-import { RWSCollection, IRWSCollectionMeta, IRWSCollectionOpts } from "./decorators/RWSCollection";
-
-export type {
-   IRWSCollectionMeta, IRWSCollectionOpts,
-   IRWSModel,
-   IMetaOpts,
-   OpModelType,
-   IDbConfigHandler,
-   IDbConfigParams,
-   ITimeSeries,
-}
-
-export {       
-   RWSModel,  
-   RWSCollection,
-   
-   DBService,
-
-   FindByType, 
-   // TimeSeriesModel,   
-
-   InverseRelation, Relation, TrackType, InverseTimeSeries,
-
-   DbHelper,
-   FieldsHelper
-};
+import { DBService } from "./services/DBService";
+import { RWSModel, OpModelType } from "./models/_model";
+// import TimeSeriesModel from './models/core/TimeSeriesModel';
+import { 
+  InverseRelation, 
+  Relation, 
+  TrackType, 
+  IdType,
+  InverseTimeSeries, 
+  ITrackerMetaOpts,
+  ITrackerOpts
+} from './decorators';
+
+import { DbHelper } from './helper/DbHelper';
+import { FieldsHelper } from './helper/FieldsHelper';
+
+import type  { FindByType } from './types/FindParams';
+import type  { ITimeSeries } from './types/ITimeSeries';
+import type { IDbConfigHandler, IDbConfigParams } from './types/DbConfigHandler';
+import type { IRWSModel } from './types/IRWSModel';
+import { RWSCollection, IRWSCollectionMeta, IRWSCollectionOpts } from "./decorators/RWSCollection";
+
+export type {
+   IRWSCollectionMeta, IRWSCollectionOpts,
+   IRWSModel,
+   ITrackerMetaOpts,
+   ITrackerOpts,
+   OpModelType,
+   IDbConfigHandler,
+   IDbConfigParams,
+   ITimeSeries,
+}
+
+export {       
+   RWSModel,  
+   RWSCollection,
+   
+   DBService,
+
+   FindByType, 
+   // TimeSeriesModel,   
+
+   InverseRelation, Relation, TrackType, InverseTimeSeries, IdType,
+
+   DbHelper,
+   FieldsHelper
+};

package/src/models/_model.ts

@@ -1,30 +1,30 @@
-/**
- * @deprecated This file is deprecated. Import from 'models' directory instead.
- */
-
-import {
-    IModel,
-    IRWSModelServices,
-    OpModelType,
-    RelationBindType,
-    RelOneMetaType,
-    RelManyMetaType,
-    RWSModel,
-    TrackType,
-    IMetaOpts
-} from './index';
-
-export {
-    RWSModel,
-    TrackType
-};
-
-export type {
-    IModel,
-    IRWSModelServices,
-    OpModelType,
-    RelationBindType,
-    RelOneMetaType,
-    RelManyMetaType,    
-    IMetaOpts
+/**
+ * @deprecated This file is deprecated. Import from 'models' directory instead.
+ */
+
+import {
+    IModel,
+    IRWSModelServices,
+    OpModelType,
+    RelationBindType,
+    RelOneMetaType,
+    RelManyMetaType,
+    RWSModel,
+    TrackType,
+    ITrackerMetaOpts
+} from './index';
+
+export {
+    RWSModel,
+    TrackType
+};
+
+export type {
+    IModel,
+    IRWSModelServices,
+    OpModelType,
+    RelationBindType,
+    RelOneMetaType,
+    RelManyMetaType,    
+    ITrackerMetaOpts
 };