@rws-framework/db 2.4.1 → 2.4.2

package/dist/helper/DbHelper.d.ts

@@ -1,8 +1,12 @@
-import { IDbConfigHandler } from '../types/DbConfigHandler';
+import { IDbConfigHandler, IDbConfigParams, IdGeneratorOptions } from '../types/DbConfigHandler';
 import { IMetaOpts, OpModelType } from '../models/_model';
 import { DBService } from '../services/DBService';
 export declare class DbHelper {
+    static dbUrlVarName: string;
     static installPrisma(configService: IDbConfigHandler, dbService: DBService, leaveFile?: boolean): Promise<void>;
-    static generateModelSections(model: OpModelType<any>): Promise<string>;
+    static generateId(dbType: IDbConfigParams['db_type'], options?: IdGeneratorOptions): string;
+    static detectInstaller(): string;
+    static pushDBModels(configService: IDbConfigHandler, dbService: DBService, leaveFile?: boolean): Promise<void>;
+    static generateModelSections(model: OpModelType<any>, configService: IDbConfigHandler): Promise<string>;
     static toConfigCase(modelType: IMetaOpts): string;
 }

package/dist/helper/DbHelper.js

@@ -21,12 +21,12 @@ class DbHelper {
     }\n\n`;
         template += `\ndatasource db {\n
         provider = "${dbType}"\n
-        url = env("PRISMA_DB_URL")\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);
+                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)){    
@@ -48,11 +48,25 @@ class DbHelper {
                 fs_1.default.unlinkSync(schemaPath);
             }
             fs_1.default.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 console_1.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_1.default.join(workspaceRoot, 'node_modules', '.bin', 'npx');
+            const prismaPath = path_1.default.join(workspaceRoot, 'node_modules', '.bin', 'prisma');
+            try {
+                // Try using npx with the full path
+                await console_1.rwsShell.runCommand(`"${npxPath}" prisma generate --schema="${schemaPath}"`, process.cwd());
+            }
+            catch (error) {
+                // If that fails, try using the prisma binary directly
+                try {
+                    await console_1.rwsShell.runCommand(`"${prismaPath}" generate --schema="${schemaPath}"`, process.cwd());
+                }
+                catch (innerError) {
+                    // If both fail, try using node to run prisma
+                    const nodePrismaPath = path_1.default.join(workspaceRoot, 'node_modules', 'prisma', 'build', 'index.js');
+                    await console_1.rwsShell.runCommand(`node "${nodePrismaPath}" generate --schema="${schemaPath}"`, process.cwd());
+                }
+            }
             leaveFile = false;
             log(chalk_1.default.green('[RWS Init]') + ' prisma schema generated from ', schemaPath);
             if (!leaveFile) {
@@ -60,13 +74,46 @@ class DbHelper {
             }
         }
     }
-    static async generateModelSections(model) {
+    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!');
+        }
+    }
+    static detectInstaller() {
+        if (fs_1.default.existsSync(path_1.default.join(workspaceRoot, 'yarn.lock'))) {
+            return 'yarn';
+        }
+        return 'npx';
+    }
+    static async pushDBModels(configService, dbService, leaveFile = false) {
+        process.env = { ...process.env, [this.dbUrlVarName]: configService.get('db_url') };
+        const schemaDir = path_1.default.join(moduleDir, 'prisma');
+        const schemaPath = path_1.default.join(schemaDir, 'schema.prisma');
+        // Use npx directly with the full path to prisma
+        const execCmdPath = path_1.default.join(workspaceRoot, 'node_modules', '.bin', 'yarn.cmd');
+        const execPrismaPath = path_1.default.join(workspaceRoot, 'node_modules', '.bin', 'yarn.cmd');
+        await console_1.rwsShell.runCommand(`${this.detectInstaller()} prisma db push --schema="${schemaPath}"`, process.cwd());
+    }
+    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 += '\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;
             let requiredString = modelMetadata.required ? '' : '?';
@@ -139,3 +186,4 @@ class DbHelper {
     }
 }
 exports.DbHelper = DbHelper;
+DbHelper.dbUrlVarName = 'PRISMA_DB_URL';

package/dist/index.d.ts

@@ -5,8 +5,8 @@ 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 } from './types/DbConfigHandler';
+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, ITimeSeries, };
+export type { IRWSCollectionMeta, IRWSCollectionOpts, IRWSModel, IMetaOpts, OpModelType, IDbConfigHandler, IDbConfigParams, ITimeSeries, };
 export { RWSModel, RWSCollection, DBService, FindByType, InverseRelation, Relation, TrackType, InverseTimeSeries, DbHelper, FieldsHelper };

package/dist/models/core/RWSModel.d.ts

@@ -6,13 +6,13 @@ import { DBService } from '../../services/DBService';
 declare class RWSModel<T> implements IModel {
     static services: IRWSModelServices;
     [key: string]: any;
-    id: string;
+    id: string | number;
     static _collection: string;
     static _RELATIONS: {};
     static _BANNED_KEYS: string[];
     static allModels: OpModelType<any>[];
     static _CUT_KEYS: string[];
-    constructor(data: any);
+    constructor(data?: any);
     checkForInclusionWithThrow(): void;
     static checkForInclusionWithThrow(this: OpModelType<any>, checkModelType: string): void;
     checkForInclusion(): boolean;
@@ -21,7 +21,7 @@ declare class RWSModel<T> implements IModel {
     protected hasRelation(key: string): boolean;
     protected bindRelation(key: string, relatedModel: RWSModel<any>): {
         connect: {
-            id: string;
+            id: string | number;
         };
     };
     _asyncFill(data: any, fullDataMode?: boolean, allowRelations?: boolean): Promise<T>;

package/dist/models/core/RWSModel.js

@@ -16,7 +16,7 @@ const RelationUtils_1 = require("../utils/RelationUtils");
 const TimeSeriesUtils_1 = require("../utils/TimeSeriesUtils");
 const ModelUtils_1 = require("../utils/ModelUtils");
 class RWSModel {
-    constructor(data) {
+    constructor(data = null) {
         if (!this.getCollection()) {
             throw new Error('Model must have a collection defined');
         }
@@ -396,5 +396,5 @@ RWSModel.allModels = [];
 RWSModel._CUT_KEYS = [];
 __decorate([
     (0, decorators_1.TrackType)(String),
-    __metadata("design:type", String)
+    __metadata("design:type", Object)
 ], RWSModel.prototype, "id", void 0);

package/dist/models/interfaces/IModel.d.ts

@@ -2,7 +2,7 @@ import { IDbConfigHandler } from '../../types/DbConfigHandler';
 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/dist/models/utils/RelationUtils.d.ts

@@ -6,7 +6,7 @@ export declare class RelationUtils {
     static getRelationManyMeta(model: RWSModel<any>, classFields: string[]): Promise<RelManyMetaType<IRWSModel>>;
     static bindRelation(relatedModel: RWSModel<any>): {
         connect: {
-            id: string;
+            id: string | number;
         };
     };
     static hasRelation(model: RWSModel<any>, key: string): boolean;

package/dist/types/DbConfigHandler.d.ts

@@ -2,9 +2,13 @@ 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;
+    customType?: string;
+}
 export interface IDbConfigHandler {
     get<K extends keyof IDbConfigParams>(key: K): IDbConfigParams[K];
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@rws-framework/db",
   "private": false,
-  "version": "2.4.1",
+  "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 = env("PRISMA_DB_URL")\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];
 }