@rws-framework/db 2.4.6 → 3.0.0

package/dist/helper/DbHelper.js

@@ -1,168 +1,107 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DbHelper = void 0;
-const console_1 = require("@rws-framework/console");
-const chalk_1 = __importDefault(require("chalk"));
-const path_1 = __importDefault(require("path"));
-const fs_1 = __importDefault(require("fs"));
-const _model_1 = require("../models/_model");
-const log = console.log;
-const workspaceRoot = console_1.rwsPath.findRootWorkspacePath();
-const moduleDir = path_1.default.resolve(workspaceRoot, 'node_modules', '@rws-framework', 'db');
+const db_1 = require("./db");
+/**
+ * Database helper class
+ *
+ * This class provides a facade for the database helper modules.
+ * It delegates to the specialized modules for specific functionality.
+ */
 class DbHelper {
+    /**
+     * 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, dbService, leaveFile = false) {
-        const dbUrl = configService.get('db_url');
-        const dbType = configService.get('db_type') || 'mongodb';
-        let template = `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 = configService.get('db_models');
-        if (dbModels) {
-            for (const model of dbModels) {
-                const modelSection = await DbHelper.generateModelSections(model, configService);
-                template += '\n\n' + modelSection;
-                log(chalk_1.default.green('[RWS]'), chalk_1.default.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_1.default.join(moduleDir, 'prisma');
-            const schemaPath = path_1.default.join(schemaDir, 'schema.prisma');
-            if (!fs_1.default.existsSync(schemaDir)) {
-                fs_1.default.mkdirSync(schemaDir);
-            }
-            if (fs_1.default.existsSync(schemaPath)) {
-                fs_1.default.unlinkSync(schemaPath);
-            }
-            fs_1.default.writeFileSync(schemaPath, template);
-            process.env = { ...process.env, [this.dbUrlVarName]: dbUrl };
-            await console_1.rwsShell.runCommand(`${this.detectInstaller()} prisma generate --schema="${schemaPath}"`, process.cwd());
-            leaveFile = false;
-            log(chalk_1.default.green('[RWS Init]') + ' prisma schema generated from ', schemaPath);
-            if (!leaveFile) {
-                fs_1.default.unlinkSync(schemaPath);
-            }
-        }
+        return db_1.SchemaGenerator.installPrisma(configService, dbService, leaveFile);
     }
-    static generateId(dbType, options = {}) {
-        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!');
-        }
+    /**
+     * 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, dbService, leaveFile = false) {
+        return db_1.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, configService) {
+        return db_1.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, dbUrl) {
+        return db_1.SchemaGenerator.generateBaseSchema(dbType, dbUrl);
+    }
+    /**
+     * Get the directory and path for the Prisma schema file
+     */
+    static getSchemaDir() {
+        return db_1.DbUtils.getSchemaDir();
+    }
+    /**
+     * Detect the package installer (yarn or npx)
+     */
     static detectInstaller() {
-        if (fs_1.default.existsSync(path_1.default.join(workspaceRoot, 'yarn.lock'))) {
-            return 'yarn';
-        }
-        return 'npx';
+        return db_1.DbUtils.detectInstaller();
     }
-    static async pushDBModels(configService, dbService, leaveFile = false) {
-        process.env = { ...process.env, [this.dbUrlVarName]: configService.get('db_url') };
-        const schemaPath = path_1.default.join(workspaceRoot, 'node_modules', '.prisma', 'client', 'schema.prisma');
-        await console_1.rwsShell.runCommand(`${this.detectInstaller()} prisma db push --schema="${schemaPath}"`, process.cwd());
+    /**
+     * Generate an ID field based on the database type
+     */
+    static generateId(dbType, modelMeta) {
+        return db_1.DbUtils.generateId(dbType, modelMeta);
     }
-    static async generateModelSections(model, configService) {
-        var _a, _b;
-        let section = '';
-        const modelMetadatas = await _model_1.RWSModel.getModelAnnotations(model);
-        const modelName = model._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 = modelMetadatas[key].annotationType;
-            if (key === 'id') {
-                continue;
-            }
-            if (annotationType === 'Relation') {
-                const relationMeta = modelMetadata;
-                const relatedModel = relationMeta.relatedTo;
-                const isMany = relationMeta.many;
-                const cascadeOpts = [];
-                if ((_a = relationMeta.cascade) === null || _a === void 0 ? void 0 : _a.onDelete) {
-                    cascadeOpts.push(`onDelete: ${relationMeta.cascade.onDelete}`);
-                }
-                if ((_b = relationMeta.cascade) === null || _b === void 0 ? void 0 : _b.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;
-                // 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 = modelMetadata.tags.map((item) => '@' + item);
-                if (modelMetadata.isArray || modelMetadata.type.name === 'Array') {
-                    requiredString = '';
-                }
-                section += `\t${key} ${DbHelper.toConfigCase(modelMetadata)}${requiredString} ${tags.join(' ')}\n`;
-            }
-        }
-        section += '}\n';
-        return section;
+    /**
+     * Convert a JavaScript type to a Prisma schema type
+     */
+    static toConfigCase(modelType, dbType = 'mongodb') {
+        return db_1.TypeConverter.toConfigCase(modelType, dbType);
+    }
+    /**
+     * Process type functions metadata to extract database-specific options
+     */
+    static processTypeOptions(metadata, dbType) {
+        return db_1.TypeConverter.processTypeOptions(metadata, dbType);
+    }
+    /**
+     * Mark a relation between two models
+     */
+    static markRelation(relationKey, inverse = false) {
+        db_1.RelationManager.markRelation(relationKey, inverse);
+    }
+    /**
+     * Complete a relation between two models
+     */
+    static completeRelation(relationKey, index, inverse = false) {
+        db_1.RelationManager.completeRelation(relationKey, index, inverse);
+    }
+    /**
+     * Get a unique counter for a relation between two models
+     */
+    static getRelationCounter(relationKey, inverse = false) {
+        return db_1.RelationManager.getRelationCounter(relationKey, inverse);
     }
-    static toConfigCase(modelType) {
-        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;
+    /**
+     * Generate a shortened relation name to stay within database limits
+     */
+    static getShortenedRelationName(modelName, relatedModelName, index) {
+        return db_1.RelationManager.getShortenedRelationName(modelName, relatedModelName, index);
     }
 }
 exports.DbHelper = DbHelper;
-DbHelper.dbUrlVarName = 'PRISMA_DB_URL';
+/**
+ * The environment variable name for the Prisma database URL
+ */
+DbHelper.dbUrlVarName = db_1.SchemaGenerator.dbUrlVarName;

package/dist/helper/db/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * 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/dist/helper/db/index.js

@@ -0,0 +1,18 @@
+"use strict";
+/**
+ * Database helper modules
+ *
+ * This module exports all the database helper classes for use in the application.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SchemaGenerator = exports.RelationManager = exports.TypeConverter = exports.moduleDirPath = exports.workspaceRootPath = exports.DbUtils = void 0;
+var utils_1 = require("./utils");
+Object.defineProperty(exports, "DbUtils", { enumerable: true, get: function () { return utils_1.DbUtils; } });
+Object.defineProperty(exports, "workspaceRootPath", { enumerable: true, get: function () { return utils_1.workspaceRootPath; } });
+Object.defineProperty(exports, "moduleDirPath", { enumerable: true, get: function () { return utils_1.moduleDirPath; } });
+var type_converter_1 = require("./type-converter");
+Object.defineProperty(exports, "TypeConverter", { enumerable: true, get: function () { return type_converter_1.TypeConverter; } });
+var relation_manager_1 = require("./relation-manager");
+Object.defineProperty(exports, "RelationManager", { enumerable: true, get: function () { return relation_manager_1.RelationManager; } });
+var schema_generator_1 = require("./schema-generator");
+Object.defineProperty(exports, "SchemaGenerator", { enumerable: true, get: function () { return schema_generator_1.SchemaGenerator; } });

package/dist/helper/db/relation-manager.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Manages database relations for schema generation
+ */
+export declare class RelationManager {
+    private static allRelations;
+    /**
+     * 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): void;
+    /**
+     * 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): void;
+    /**
+     * 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): number;
+    /**
+     * 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;
+    /**
+     * Reset all relations (useful for testing)
+     */
+    static resetRelations(): void;
+    /**
+     * Get all relations (useful for debugging)
+     */
+    static getAllRelations(): Map<string, {
+        base: boolean | null;
+        inversion: boolean | null;
+    }[]>;
+}

package/dist/helper/db/relation-manager.js

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RelationManager = void 0;
+/**
+ * Manages database relations for schema generation
+ */
+class RelationManager {
+    /**
+     * 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, inverse = false) {
+        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, index, inverse = false) {
+        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, inverse = false) {
+        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, relatedModelName, index) {
+        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() {
+        this.allRelations.clear();
+    }
+    /**
+     * Get all relations (useful for debugging)
+     */
+    static getAllRelations() {
+        return this.allRelations;
+    }
+}
+exports.RelationManager = RelationManager;
+RelationManager.allRelations = new Map();

package/dist/helper/db/schema-generator.d.ts

@@ -0,0 +1,37 @@
+import { IDbConfigHandler } from '../../types/DbConfigHandler';
+import { OpModelType } from '../../models/_model';
+import { DBService } from '../../services/DBService';
+/**
+ * Handles Prisma schema generation
+ */
+export declare class SchemaGenerator {
+    static dbUrlVarName: string;
+    /**
+     * 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;
+    /**
+     * 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 generateModelSections(model: OpModelType<any>, configService: IDbConfigHandler): Promise<string>;
+    /**
+     * 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 installPrisma(configService: IDbConfigHandler, dbService: DBService, leaveFile?: boolean): Promise<void>;
+    /**
+     * 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 pushDBModels(configService: IDbConfigHandler, dbService: DBService, leaveFile?: boolean): Promise<void>;
+}