@rws-framework/db 2.4.6 → 3.0.0

package/src/helper/DbHelper.ts

@@ -1,223 +1,133 @@
-import { rwsShell, rwsPath } from '@rws-framework/console';
-import chalk from 'chalk';
-import path from 'path';
-import fs from 'fs';
-
-import { IDbConfigHandler, IDbConfigParams, IdGeneratorOptions } from '../types/DbConfigHandler';
-import { IMetaOpts, OpModelType, RWSModel } from '../models/_model';
-// import TimeSeriesModel from '../models/core/TimeSeriesModel';
-import { DBService } from '../services/DBService';
-import { IRelationOpts } from '../decorators/Relation';
-import { InverseRelationOpts } from '../decorators/InverseRelation';
-
-const log = console.log;
-const workspaceRoot = rwsPath.findRootWorkspacePath();
-const moduleDir = path.resolve(workspaceRoot, 'node_modules', '@rws-framework', 'db');
-
-export class DbHelper {
-    static dbUrlVarName: string = 'PRISMA_DB_URL';
-
-    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 = `generator client {\n
-        provider = "prisma-client-js"\n
-    }\n\n`;
-
-        template += `\ndatasource db {\n
-        provider = "${dbType}"\n
-        url = env("${this.dbUrlVarName}")\n
-    }\n\n`;
-
-        const dbModels: OpModelType<unknown>[] | null = configService.get('db_models');       
-
-        if(dbModels){
-
-            for (const model of dbModels){ 
-                const modelSection = await DbHelper.generateModelSections(model, configService);
-
-                template += '\n\n' + modelSection;  
-
-                log(chalk.green('[RWS]'), chalk.blue('Building DB Model'), model.name);
-            
-                // if(RWSModel.isSubclass(model as any, TimeSeriesModel)){    
-                //     dbService.collectionExists(model._collection).then((exists: boolean) => {
-                //         if (exists){
-                //             return;
-                //         }
-
-                //         log(chalk.green('[RWS Init]') + ` creating TimeSeries type collection from ${model} model`);
-
-                //         dbService.createTimeSeriesCollection(model._collection);    
-                //     });
-                // }
-            }
-
-            const schemaDir = path.join(moduleDir, 'prisma');
-            const schemaPath = path.join(schemaDir, 'schema.prisma');
-
-            if(!fs.existsSync(schemaDir)){
-                fs.mkdirSync(schemaDir);
-            }
-
-            if(fs.existsSync(schemaPath)){
-                fs.unlinkSync(schemaPath);
-            }            
-
-            fs.writeFileSync(schemaPath, template);  
-            process.env = { ...process.env, [this.dbUrlVarName]: dbUrl }        
-            
-            await rwsShell.runCommand(`${this.detectInstaller()} prisma generate --schema="${schemaPath}"`, process.cwd());
-
-            leaveFile = false;
-            log(chalk.green('[RWS Init]') + ' prisma schema generated from ', schemaPath);
-
-            if(!leaveFile){
-                fs.unlinkSync(schemaPath);
-            }    
-        }
-    }
-
-    static generateId(
-        dbType: IDbConfigParams['db_type'], 
-        options: IdGeneratorOptions = {}
-    ): string {
-        const { useUuid = false, customType } = options;
-    
-        if (customType) {
-            return `id ${customType} @id`;
-        }
-    
-        switch(dbType) {
-            case 'mongodb':
-                return 'id String @id @default(auto()) @map("_id") @db.ObjectId';
-                
-            case 'mysql':
-                return useUuid 
-                    ? 'id String @id @default(uuid())'
-                    : 'id Int @id @default(autoincrement())';
-                
-            case 'sqlite':
-                return 'id Int @id @default(autoincrement())';
-                
-            default:
-                throw new Error('Kurwa, nieobsługiwany typ bazy danych!');
-        }
-    }
-
-    static detectInstaller(): string
-    {
-        
-        if (fs.existsSync(path.join(workspaceRoot, 'yarn.lock'))){                
-            return 'yarn';
-        }
-
-        return 'npx';
-    }
-
-    static async pushDBModels(configService: IDbConfigHandler, dbService: DBService, leaveFile = false){
-        process.env = { ...process.env, [this.dbUrlVarName]: configService.get('db_url') }
-        
-        const schemaPath = path.join(workspaceRoot, 'node_modules', '.prisma', 'client','schema.prisma');
-    
-        await rwsShell.runCommand(`${this.detectInstaller()} prisma db push --schema="${schemaPath}"`, process.cwd());
-
-    }
-
-    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 modelName: string = (model as any)._collection;
-        
-        section += `model ${modelName} {\n`;
-        section += `\t${this.generateId(configService.get('db_type'))}\n`;
-     
-        for (const key in modelMetadatas) {
-            const modelMetadata = modelMetadatas[key].metadata;            
-            let requiredString = modelMetadata.required ? '' : '?';  
-            const annotationType: string = modelMetadatas[key].annotationType;
-    
-            if(key === 'id'){
-                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}`);
-                }
-      
-                if (isMany) {
-                    // Handle many-to-many or one-to-many relation
-                    section += `\t${key} ${relatedModel._collection}[] @relation("${modelName}_${relatedModel._collection}")\n`;
-                } else {
-                    // Handle one-to-one or many-to-one relation
-                    section += `\t${key} ${relatedModel._collection}${requiredString} @relation("${modelName}_${relatedModel._collection}", fields: [${modelMetadata.relationField}], references: [${modelMetadata.relatedToField || 'id'}], ${cascadeOpts.join(', ')})\n`;
-                    section += `\t${modelMetadata.relationField} String${requiredString} @db.ObjectId\n`;
-                }
-            } else if (annotationType === 'InverseRelation'){   
-                const relationMeta = modelMetadata as InverseRelationOpts;
-     
-                // Handle inverse relation (one-to-many or one-to-one)
-                section += `\t${key} ${relationMeta.inversionModel._collection}[] @relation("${ relationMeta.relationName ? relationMeta.relationName : `${relationMeta.inversionModel._collection}_${modelName}`}")\n`;
-            } else if (annotationType === 'InverseTimeSeries'){        
-                section += `\t${key} String[] @db.ObjectId\n`;      
-            } else if (annotationType === 'TrackType'){        
-                const tags: string[] = modelMetadata.tags.map((item: string) => '@' + item);             
-
-                if(modelMetadata.isArray || modelMetadata.type.name === 'Array'){
-                    requiredString = '';
-                }       
-                section += `\t${key} ${DbHelper.toConfigCase(modelMetadata)}${requiredString} ${tags.join(' ')}\n`;
-            }
-        }
-        
-        section += '}\n';
-        return section;
-    }
-    
-    static toConfigCase(modelType: IMetaOpts): string {
-        const type = modelType.type;
-        let input = type.name;    
-        
-    
-        if(input == 'Number'){
-            input = 'Int';
-        }
-    
-        if(input == 'Object'){
-            input = 'Json';
-        }
-    
-        if(input == 'Date'){
-            input = 'DateTime';
-        }
-
-        if(input == 'Array'){
-            input = 'Json[]';
-        }
-    
-        const firstChar = input.charAt(0).toUpperCase();
-        const restOfString = input.slice(1);
-        let resultField = firstChar + restOfString;
-
-        if(modelType.isArray){
-            resultField += '[]';
-        }
-
-        return resultField;
-    }
-}
+import { IDbConfigHandler, IDbConfigParams, IdGeneratorOptions } from '../types/DbConfigHandler';
+import { OpModelType } from '../models/_model';
+import { DBService } from '../services/DBService';
+
+import {
+    DbUtils,
+    TypeConverter,
+    RelationManager,
+    SchemaGenerator
+} from './db';
+import { IIdMetaOpts, IIdTypeOpts } from '../decorators/IdType';
+
+/**
+ * Database helper class
+ * 
+ * This class provides a facade for the database helper modules.
+ * It delegates to the specialized modules for specific functionality.
+ */
+export class DbHelper {
+    /**
+     * The environment variable name for the Prisma database URL
+     */
+    static dbUrlVarName: string = SchemaGenerator.dbUrlVarName;
+
+    /**
+     * 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> {
+        return SchemaGenerator.installPrisma(configService, dbService, leaveFile);
+    }
+
+    /**
+     * 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> {
+        return SchemaGenerator.pushDBModels(configService, dbService, leaveFile);
+    }
+
+    /**
+     * 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> {
+        return SchemaGenerator.generateModelSections(model, configService);
+    }
+
+    /**
+     * 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 {
+        return SchemaGenerator.generateBaseSchema(dbType, dbUrl);
+    }
+
+    /**
+     * Get the directory and path for the Prisma schema file
+     */
+    static getSchemaDir(): [string, string] {
+        return DbUtils.getSchemaDir();
+    }
+
+    /**
+     * Detect the package installer (yarn or npx)
+     */
+    static detectInstaller(): string {
+        return DbUtils.detectInstaller();
+    }
+
+    /**
+     * Generate an ID field based on the database type
+     */
+    static generateId(
+        dbType: IDbConfigParams['db_type'],
+        modelMeta: Record<string, { annotationType: string, metadata: IIdMetaOpts }>
+    ): string {
+        return DbUtils.generateId(dbType, modelMeta);
+    }
+
+    /**
+     * Convert a JavaScript type to a Prisma schema type
+     */
+    static toConfigCase(modelType: any, dbType: string = 'mongodb'): string {
+        return TypeConverter.toConfigCase(modelType, dbType);
+    }
+
+    /**
+     * Process type functions metadata to extract database-specific options
+     */
+    static processTypeOptions(metadata: any, dbType: string): string[] {
+        return TypeConverter.processTypeOptions(metadata, dbType);
+    }
+
+    /**
+     * Mark a relation between two models
+     */
+    static markRelation(relationKey: string, inverse: boolean = false): void {
+        RelationManager.markRelation(relationKey, inverse);
+    }
+
+    /**
+     * Complete a relation between two models
+     */
+    static completeRelation(relationKey: string, index: number, inverse: boolean = false): void {
+        RelationManager.completeRelation(relationKey, index, inverse);
+    }
+
+    /**
+     * Get a unique counter for a relation between two models
+     */
+    static getRelationCounter(relationKey: string, inverse: boolean = false): number {
+        return RelationManager.getRelationCounter(relationKey, inverse);
+    }
+
+    /**
+     * Generate a shortened relation name to stay within database limits
+     */
+    static getShortenedRelationName(modelName: string, relatedModelName: string, index: number): string {
+        return RelationManager.getShortenedRelationName(modelName, relatedModelName, index);
+    }
+}

package/src/helper/FieldsHelper.ts

@@ -1,35 +1,35 @@
-export class FieldsHelper {
-    private constructor(){
-        throw new Error(`Class ${this.constructor.name} cannot be instanced.`)
-    }
-    
-    static getAllClassFields(target: any): string[] {
-        // Get instance properties
-        const instanceFields = Object.getOwnPropertyNames(target.prototype);
-        
-        // Get static properties
-        const staticFields = Object.getOwnPropertyNames(target);
-        
-        // Get decorated properties using Reflect metadata if available
-        const decoratedFields = Reflect.getMetadataKeys(target.prototype) || [];
-        
-        // Combine all fields and remove duplicates and methods
-        const allFields = new Set([
-            ...instanceFields,
-            ...staticFields,
-            ...decoratedFields
-        ]);
-    
-        // Filter out constructor and methods
-        return Array.from(allFields).filter(field => {
-            // Remove constructor
-            if (field === 'constructor') return false;
-            
-            // Remove methods
-            const descriptor = Object.getOwnPropertyDescriptor(target.prototype, field);
-            if (descriptor && typeof descriptor.value === 'function') return false;
-            
-            return true;
-        });
-    };
+export class FieldsHelper {
+    private constructor(){
+        throw new Error(`Class ${this.constructor.name} cannot be instanced.`)
+    }
+    
+    static getAllClassFields(target: any): string[] {
+        // Get instance properties
+        const instanceFields = Object.getOwnPropertyNames(target.prototype);
+        
+        // Get static properties
+        const staticFields = Object.getOwnPropertyNames(target);
+        
+        // Get decorated properties using Reflect metadata if available
+        const decoratedFields = Reflect.getMetadataKeys(target.prototype) || [];
+        
+        // Combine all fields and remove duplicates and methods
+        const allFields = new Set([
+            ...instanceFields,
+            ...staticFields,
+            ...decoratedFields
+        ]);
+    
+        // Filter out constructor and methods
+        return Array.from(allFields).filter(field => {
+            // Remove constructor
+            if (field === 'constructor') return false;
+            
+            // Remove methods
+            const descriptor = Object.getOwnPropertyDescriptor(target.prototype, field);
+            if (descriptor && typeof descriptor.value === 'function') return false;
+            
+            return true;
+        });
+    };
 }

package/src/helper/db/index.ts

@@ -0,0 +1,10 @@
+/**
+ * Database helper modules
+ * 
+ * This module exports all the database helper classes for use in the application.
+ */
+
+export { DbUtils, workspaceRootPath, moduleDirPath } from './utils';
+export { TypeConverter } from './type-converter';
+export { RelationManager } from './relation-manager';
+export { SchemaGenerator } from './schema-generator';

package/src/helper/db/relation-manager.ts

@@ -0,0 +1,119 @@
+/**
+ * Manages database relations for schema generation
+ */
+export class RelationManager {
+    private static allRelations = new Map<string, {base: boolean | null, inversion: boolean | null}[]>();
+
+    /**
+     * Mark a relation between two models
+     * @param relationKey A unique key for the relation
+     * @param inverse Whether this is an inverse relation
+     */
+    static markRelation(relationKey: string, inverse: boolean = false): void {
+        if (!this.allRelations.has(relationKey)) {
+            this.allRelations.set(relationKey, []);
+        }        
+
+        const modelRelations = this.allRelations.get(relationKey);
+
+        let marked = false;
+
+        for(const relationInfo of modelRelations){   
+            if((relationInfo.base !== null && !inverse) || (relationInfo.inversion !== null && inverse)){   
+                continue;
+            }
+
+            if(inverse){
+                relationInfo.inversion = false;
+                marked = true;                
+            }else{                
+                relationInfo.base = false;
+                marked = true;                
+            }                
+            return;
+        }
+
+        if(!marked){
+            modelRelations.push({base: inverse ? null : false, inversion: inverse ? false : null});
+        }                  
+    }
+
+    /**
+     * Complete a relation between two models
+     * @param relationKey A unique key for the relation
+     * @param index The index of the relation
+     * @param inverse Whether this is an inverse relation
+     */
+    static completeRelation(relationKey: string, index: number, inverse: boolean = false): void {
+        const modelRelations = this.allRelations.get(relationKey);
+
+        if(inverse){
+            modelRelations[index].inversion = true;
+        }else{
+            modelRelations[index].base = true;
+        }        
+    }
+
+    /**
+     * Get a unique counter for a relation between two models
+     * @param relationKey A unique key for the relation
+     * @param inverse Whether this is an inverse relation
+     * @returns A unique counter for this relation
+     */
+    static getRelationCounter(relationKey: string, inverse: boolean = false): number {
+        let counter = 0;            
+
+        for(const relationInfo of this.allRelations.get(relationKey)) {            
+            if((relationInfo.base === true && !inverse) || (relationInfo.inversion === true && inverse)) {                
+                counter++;
+            }            
+        }
+
+        return counter;
+    }
+
+    /**
+     * Generate a shortened relation name to stay within database limits
+     * @param modelName The name of the model
+     * @param relatedModelName The name of the related model
+     * @param index The index of the relation
+     * @returns A shortened relation name
+     */
+    static getShortenedRelationName(modelName: string, relatedModelName: string, index: number): string {
+        const fullRelationName = `${modelName}_${relatedModelName}_${index}`.toLowerCase();
+        
+        if (fullRelationName.length <= 64) {
+            return fullRelationName;
+        }        
+        
+        const extraChars = 2 + String(index).length; 
+        const availableChars = 64 - extraChars;
+        
+        const modelNameLength = modelName.length;
+        const relatedModelNameLength = relatedModelName.length;
+        const totalLength = modelNameLength + relatedModelNameLength;
+        
+        const modelNameMaxLength = Math.floor(availableChars * (modelNameLength / totalLength));
+        const relatedModelNameMaxLength = availableChars - modelNameMaxLength;
+        
+        const shortenedModelName = modelName.substring(0, Math.max(3, modelNameMaxLength));
+        const shortenedRelatedModelName = relatedModelName.substring(0, Math.max(3, relatedModelNameMaxLength));
+        
+        // Create the new relation name
+        return `${shortenedModelName}_${shortenedRelatedModelName}_${index}`.toLowerCase();
+    }
+
+    /**
+     * Reset all relations (useful for testing)
+     */
+    static resetRelations(): void {
+        this.allRelations.clear();
+    }
+
+    /**
+     * Get all relations (useful for debugging)
+     */
+    static getAllRelations(): Map<string, {base: boolean | null, inversion: boolean | null}[]> {
+        return this.allRelations;
+    }
+}