@rws-framework/db 2.4.0 → 2.4.2

package/dist/types/ITimeSeries.js

@@ -1,2 +1,2 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/exec/src/cli.ts

@@ -66,6 +66,7 @@ async function main(): Promise<void>
 {
   console.log('INSTALL PRISMA');
   const cfg = await Config.getInstance();
+  process.env.PRISMA_DB_URL = cfg.get('db_url');
   DbHelper.installPrisma(cfg, new DBService(cfg), false);
 }
 

package/package.json

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

package/src/helper/DbHelper.ts

@@ -3,7 +3,7 @@ import chalk from 'chalk';
 import path from 'path';
 import fs from 'fs';
 
-import { IDbConfigHandler } from '../types/DbConfigHandler';
+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';
@@ -15,6 +15,8 @@ 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');      
@@ -26,7 +28,7 @@ export class DbHelper {
 
         template += `\ndatasource db {\n
         provider = "${dbType}"\n
-        url = ${configService.get('db_models')}\n    
+        url = env("${this.dbUrlVarName}")\n
     }\n\n`;
 
         const dbModels: OpModelType<unknown>[] | null = configService.get('db_models');       
@@ -34,7 +36,7 @@ export class DbHelper {
         if(dbModels){
 
             for (const model of dbModels){ 
-                const modelSection = await DbHelper.generateModelSections(model);
+                const modelSection = await DbHelper.generateModelSections(model, configService);
 
                 template += '\n\n' + modelSection;  
 
@@ -65,12 +67,25 @@ export class DbHelper {
             }            
 
             fs.writeFileSync(schemaPath, template);  
-            process.env.DB_URL = dbUrl;
-            const endPrisma = 'npx prisma';
-
-            // console.log({cwd: process.cwd()})
-            // const clientPath = path.join(rwsPath.findRootWorkspacePath(), 'node_modules', '.prisma', 'client');
-            await rwsShell.runCommand(`${endPrisma} generate --schema=${schemaPath}`, process.cwd());  
+            process.env = { ...process.env, [this.dbUrlVarName]: dbUrl }
+            
+            // Use npx directly with the full path to prisma
+            const npxPath = path.join(workspaceRoot, 'node_modules', '.bin', 'npx');
+            const prismaPath = path.join(workspaceRoot, 'node_modules', '.bin', 'prisma');
+            
+            try {
+                // Try using npx with the full path
+                await rwsShell.runCommand(`"${npxPath}" prisma generate --schema="${schemaPath}"`, process.cwd());
+            } catch (error) {
+                // If that fails, try using the prisma binary directly
+                try {
+                    await rwsShell.runCommand(`"${prismaPath}" generate --schema="${schemaPath}"`, process.cwd());
+                } catch (innerError) {
+                    // If both fail, try using node to run prisma
+                    const nodePrismaPath = path.join(workspaceRoot, 'node_modules', 'prisma', 'build', 'index.js');
+                    await rwsShell.runCommand(`node "${nodePrismaPath}" generate --schema="${schemaPath}"`, process.cwd());
+                }
+            }
 
             leaveFile = false;
             log(chalk.green('[RWS Init]') + ' prisma schema generated from ', schemaPath);
@@ -81,14 +96,64 @@ export class DbHelper {
         }
     }
 
-    static async generateModelSections(model: OpModelType<any>): Promise<string> {
+    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 schemaDir = path.join(moduleDir, 'prisma');
+        const schemaPath = path.join(schemaDir, 'schema.prisma');
+        
+        // Use npx directly with the full path to prisma
+        const execCmdPath = path.join(workspaceRoot, 'node_modules', '.bin', 'yarn.cmd');
+        const execPrismaPath = path.join(workspaceRoot, 'node_modules', '.bin', 'yarn.cmd');
+        
+        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 += '\tid String @map("_id") @id @default(auto()) @db.ObjectId\n';
+        section += `\t${this.generateId(configService.get('db_type'))}\n`;
      
         for (const key in modelMetadatas) {
             const modelMetadata = modelMetadatas[key].metadata;            
@@ -175,4 +240,4 @@ export class DbHelper {
 
         return resultField;
     }
-}
+}

package/src/index.ts

@@ -8,7 +8,7 @@ import { FieldsHelper } from './helper/FieldsHelper';
 
 import type  { FindByType } from './types/FindParams';
 import type  { ITimeSeries } from './types/ITimeSeries';
-import type { IDbConfigHandler } from './types/DbConfigHandler';
+import type { IDbConfigHandler, IDbConfigParams } from './types/DbConfigHandler';
 import type { IRWSModel } from './types/IRWSModel';
 import { RWSCollection, IRWSCollectionMeta, IRWSCollectionOpts } from "./decorators/RWSCollection";
 
@@ -18,6 +18,7 @@ export type {
    IMetaOpts,
    OpModelType,
    IDbConfigHandler,
+   IDbConfigParams,
    ITimeSeries,
 }
 

package/src/models/core/RWSModel.ts

@@ -16,14 +16,14 @@ class RWSModel<T> implements IModel {
     
     [key: string]: any;
     @TrackType(String)
-    id: string;
+    id: string | number;
     static _collection: string = null;
     static _RELATIONS = {};
     static _BANNED_KEYS = ['_collection'];
     static allModels: OpModelType<any>[] = [];
     static _CUT_KEYS: string[] = [];
 
-    constructor(data: any) {    
+    constructor(data: any = null) {    
         if(!this.getCollection()){
             throw new Error('Model must have a collection defined');
         }
@@ -89,7 +89,7 @@ class RWSModel<T> implements IModel {
         return RelationUtils.hasRelation(this, key);
     }
 
-    protected bindRelation(key: string, relatedModel: RWSModel<any>): { connect: { id: string } } {        
+    protected bindRelation(key: string, relatedModel: RWSModel<any>): { connect: { id: string | number } } {        
         return RelationUtils.bindRelation(relatedModel);
     }
 

package/src/models/interfaces/IModel.ts

@@ -3,7 +3,7 @@ import { DBService } from '../../services/DBService';
 
 export interface IModel {
     [key: string]: any;
-    id: string | null;
+    id: string |number | null;
     save: () => void;
     getDb: () => DBService;
     getCollection: () => string | null;

package/src/models/utils/RelationUtils.ts

@@ -56,7 +56,7 @@ export class RelationUtils {
         return relIds;
     }
 
-    static bindRelation(relatedModel: RWSModel<any>): { connect: { id: string } } {
+    static bindRelation(relatedModel: RWSModel<any>): { connect: { id: string | number } } {
         return {
             connect: {
                 id: relatedModel.id

package/src/types/DbConfigHandler.ts

@@ -3,10 +3,15 @@ import { OpModelType } from "../models/interfaces/OpModelType";
 export interface IDbConfigParams {
     db_url?: string;
     db_name?: string;
-    db_type?: string;
+    db_type?: 'mongodb' | 'mysql' | 'sqlite';
     db_models?: OpModelType<any>[]
 }
 
+export interface IdGeneratorOptions {
+    useUuid?: boolean;  // dla MySQL
+    customType?: string;  // dla custom typów
+}
+
 export interface IDbConfigHandler {
     get<K extends keyof IDbConfigParams>(key: K): IDbConfigParams[K];
 }