@rws-framework/db 2.3.1 → 2.3.4

package/README.md

@@ -218,8 +218,9 @@ export {InverseRelationOpts};
 class Config implements IDbConfigHandler {
     private data: IDbConfigParams = {
         db_models: [],
-        mongo_db: null,
-        mongo_url: null
+        db_name: null,
+        db_url: null,
+        db_type: null
     };
 
     private modelsDir: string;
@@ -242,14 +243,13 @@ class Config implements IDbConfigHandler {
     
     async fill(): Promise<void>
     {
-        this.data.mongo_url = args[0];
-        this.data.mongo_db = args[1];    
+        this.data.db_url = args[0];
+        this.data.db_name = args[1];    
+        this.data.db_type = args[2];
         
 
-        this.modelsDir = args[2];    
-        this.cliExecRoot = args[3]; 
-
-        this.data.db_models = (await import('@V/index')).default;      
+        this.modelsDir = args[3];    
+        this.cliExecRoot = args[4]; 
     }
 
     getModelsDir(): string
@@ -285,58 +285,85 @@ The exec file.
 /exec/src/console.js
 ```
 
+dbType can be any prisma db driver - mongodb by default
+
 ```bash
 #npm
 
-npx rws-db "mongodb://user:pass@localhost:27017/databaseName?authSource=admin&replicaSet=rs0" databaseName src/models
+npx rws-db "mongodb://user:pass@localhost:27017/databaseName?authSource=admin&replicaSet=rs0" databaseName dbType src/models
 ```
 
 ```bash
 #yarn
 
-yarn rws-db "mongodb://user:pass@localhost:27017/databaseName?authSource=admin&replicaSet=rs0" databaseName src/models
+yarn rws-db "mongodb://user:pass@localhost:27017/databaseName?authSource=admin&replicaSet=rs0" databaseName dbType src/models
 ```
 
 ```bash
 #bun
 
-bunx rws-db "mongodb://user:pass@localhost:27017/databaseName?authSource=admin&replicaSet=rs0" databaseName src/models
+bunx rws-db "mongodb://user:pass@localhost:27017/databaseName?authSource=admin&replicaSet=rs0" databaseName dbType src/models
 ```
 
 Code for RWS to prisma conversion from "@rws-framework/server" package:
 
 ```typescript
-async function generateModelSections<T extends Model<T>>(model: OpModelType<T>): Promise<string> {
+static async generateModelSections(model: OpModelType<any>): Promise<string> {
     let section = '';
-    const modelMetadatas: Record<string, {annotationType: string, metadata: any}> = await Model.getModelAnnotations(model);    
+    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';
- 
+    
     for (const key in modelMetadatas) {
-        const modelMetadata: IMetaOpts = modelMetadatas[key].metadata;            
-        const requiredString = modelMetadata.required ? '' : '?';  
+        const modelMetadata = modelMetadatas[key].metadata;            
+        let requiredString = modelMetadata.required ? '' : '?';  
         const annotationType: string = modelMetadatas[key].annotationType;
 
         if(key === 'id'){
             continue;
         }
+
         
         if(annotationType === 'Relation'){
-            const relatedModel = modelMetadata.relatedTo as OpModelType<T>;        
-            // Handle direct relation (many-to-one or one-to-one)
-            section += `\t${key} ${relatedModel._collection}${requiredString} @relation("${modelName}_${relatedModel._collection}", fields: [${modelMetadata.relationField}], references: [${modelMetadata.relatedToField}], onDelete: Cascade)\n`;      
-            section += `\t${modelMetadata.relationField} String${requiredString} @db.ObjectId\n`;
-        } else if (annotationType === 'InverseRelation'){        
+            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} ${modelMetadata.inversionModel._collection}[] @relation("${modelMetadata.inversionModel._collection}_${modelName}")\n`;
+            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);          
-            section += `\t${key} ${toConfigCase(modelMetadata)}${requiredString} ${tags.join(' ')}\n`;
+            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`;
         }
     }
     
@@ -344,25 +371,35 @@ async function generateModelSections<T extends Model<T>>(model: OpModelType<T>):
     return section;
 }
 
-function toConfigCase(modelType: any): string {
+static toConfigCase(modelType: IMetaOpts): string {
     const type = modelType.type;
-    const input = type.name;  
+    let input = type.name;    
+    
 
     if(input == 'Number'){
-        return 'Int';
+        input = 'Int';
     }
 
     if(input == 'Object'){
-        return 'Json';
+        input = 'Json';
     }
 
     if(input == 'Date'){
-        return 'DateTime';
+        input = 'DateTime';
     }
 
+    if(input == 'Array'){
+        input = 'Json[]';
+    }
 
     const firstChar = input.charAt(0).toUpperCase();
     const restOfString = input.slice(1);
-    return firstChar + restOfString;
+    let resultField = firstChar + restOfString;
+
+    if(modelType.isArray){
+        resultField += '[]';
+    }
+
+    return resultField;
 }
 ```

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

@@ -14,19 +14,19 @@ const workspaceRoot = console_1.rwsPath.findRootWorkspacePath();
 const moduleDir = path_1.default.resolve(workspaceRoot, 'node_modules', '@rws-framework', 'db');
 class DbHelper {
     static async installPrisma(configService, dbService, leaveFile = false) {
-        const dbUrl = configService.get('mongo_url');
-        const dbType = 'mongodb';
+        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("DATABASE_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,8 @@ 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 };
+            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) {
@@ -60,13 +57,42 @@ 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 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());
+    }
+    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 +165,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/services/DBService.d.ts

@@ -2,7 +2,7 @@ import { Collection, Db, MongoClient } from 'mongodb';
 import { ITimeSeries } from '../types/ITimeSeries';
 import { IModel } from '../models/interfaces/IModel';
 import { IDbConfigHandler } from '../types/DbConfigHandler';
-import { IPaginationParams } from 'src/types/FindParams';
+import { IPaginationParams } from '../types/FindParams';
 interface IDBClientCreate {
     dbUrl?: string;
     dbName?: string;

package/dist/services/DBService.js

@@ -19,8 +19,8 @@ class DBService {
         }
         else {
             this.opts = {
-                dbUrl: this.configService.get('mongo_url'),
-                dbName: this.configService.get('mongo_db'),
+                dbUrl: this.configService.get('db_url'),
+                dbName: this.configService.get('db_name'),
             };
         }
         if (!this.opts.dbUrl) {
@@ -51,14 +51,14 @@ class DBService {
     }
     async createBaseMongoClient() {
         var _a;
-        const dbUrl = ((_a = this.opts) === null || _a === void 0 ? void 0 : _a.dbUrl) || this.configService.get('mongo_url');
+        const dbUrl = ((_a = this.opts) === null || _a === void 0 ? void 0 : _a.dbUrl) || this.configService.get('db_url');
         const client = DBService.baseClientConstruct(dbUrl);
         await client.connect();
         return client;
     }
     async createBaseMongoClientDB() {
         var _a;
-        const dbName = ((_a = this.opts) === null || _a === void 0 ? void 0 : _a.dbName) || this.configService.get('mongo_db');
+        const dbName = ((_a = this.opts) === null || _a === void 0 ? void 0 : _a.dbName) || this.configService.get('db_name');
         const client = await this.createBaseMongoClient();
         return [client, client.db(dbName)];
     }
@@ -152,11 +152,11 @@ class DBService {
     }
     async collectionExists(collection_name) {
         var _a;
-        const dbUrl = ((_a = this.opts) === null || _a === void 0 ? void 0 : _a.dbUrl) || this.configService.get('mongo_url');
+        const dbUrl = ((_a = this.opts) === null || _a === void 0 ? void 0 : _a.dbUrl) || this.configService.get('db_url');
         const client = new mongodb_1.MongoClient(dbUrl);
         try {
             await client.connect();
-            const db = client.db(this.configService.get('mongo_db'));
+            const db = client.db(this.configService.get('db_name'));
             const collections = await db.listCollections().toArray();
             const existingCollectionNames = collections.map((collection) => collection.name);
             return existingCollectionNames.includes(collection_name);

package/dist/types/DbConfigHandler.d.ts

@@ -1,9 +1,14 @@
 import { OpModelType } from "../models/interfaces/OpModelType";
 export interface IDbConfigParams {
-    mongo_url?: string;
-    mongo_db?: string;
+    db_url?: string;
+    db_name?: 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/dist/types/IRWSModel.d.ts

@@ -1,3 +1,3 @@
 export interface IRWSModel {
-    id?: string;
+    id?: string | number;
 }

package/exec/src/cli.ts

@@ -34,12 +34,13 @@ class Config implements IDbConfigHandler {
   
   async fill(): Promise<void>
   {
-    this.data.mongo_url = args[0];
-    this.data.mongo_db = args[1];    
+    this.data.db_url = args[0];
+    this.data.db_name = args[1];    
+    this.data.db_type = args[2];
     
 
-    this.modelsDir = args[2];    
-    this.cliExecRoot = args[3]; 
+    this.modelsDir = args[3];    
+    this.cliExecRoot = args[4]; 
 
     console.log({args})
 
@@ -65,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.3.1",
+  "version": "2.3.4",
   "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,10 +15,12 @@ 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('mongo_url');      
-        const dbType = 'mongodb';
+        const dbUrl = configService.get('db_url');      
+        const dbType = configService.get('db_type') || 'mongodb';
 
         let template: string = `generator client {\n
         provider = "prisma-client-js"\n
@@ -26,7 +28,7 @@ export class DbHelper {
 
         template += `\ndatasource db {\n
         provider = "${dbType}"\n
-        url = env("DATABASE_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,9 @@ 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 }        
+            
+            await rwsShell.runCommand(`${this.detectInstaller()} prisma generate --schema="${schemaPath}"`, process.cwd());
 
             leaveFile = false;
             log(chalk.green('[RWS Init]') + ' prisma schema generated from ', schemaPath);
@@ -81,14 +80,60 @@ 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 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 += '\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 +220,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/services/DBService.ts

@@ -4,7 +4,7 @@ import {ITimeSeries} from '../types/ITimeSeries';
 import { IModel } from '../models/interfaces/IModel';
 import chalk from 'chalk';
 import { IDbConfigHandler } from '../types/DbConfigHandler';
-import { IPaginationParams } from 'src/types/FindParams';
+import { IPaginationParams } from '../types/FindParams';
 
 interface IDBClientCreate {
   dbUrl?: string;
@@ -23,8 +23,8 @@ class DBService {
             this.opts = opts;
         }else{
             this.opts = {
-                dbUrl: this.configService.get('mongo_url'),        
-                dbName: this.configService.get('mongo_db'),
+                dbUrl: this.configService.get('db_url'),        
+                dbName: this.configService.get('db_name'),
             };
         }
 
@@ -65,7 +65,7 @@ class DBService {
 
     public async createBaseMongoClient(): Promise<MongoClient>
     {
-        const dbUrl = this.opts?.dbUrl || this.configService.get('mongo_url');
+        const dbUrl = this.opts?.dbUrl || this.configService.get('db_url');
         const client = DBService.baseClientConstruct(dbUrl);
     
         await client.connect();
@@ -76,7 +76,7 @@ class DBService {
 
     public async createBaseMongoClientDB(): Promise<[MongoClient, Db]>
     {
-        const dbName = this.opts?.dbName || this.configService.get('mongo_db');
+        const dbName = this.opts?.dbName || this.configService.get('db_name');
         const client = await this.createBaseMongoClient();
         return [client, client.db(dbName)];
     }
@@ -215,13 +215,13 @@ class DBService {
 
     async collectionExists(collection_name: string): Promise<boolean>
     {
-        const dbUrl = this.opts?.dbUrl || this.configService.get('mongo_url');
+        const dbUrl = this.opts?.dbUrl || this.configService.get('db_url');
         const client = new MongoClient(dbUrl);
 
         try {
             await client.connect();    
 
-            const db = client.db(this.configService.get('mongo_db'));
+            const db = client.db(this.configService.get('db_name'));
 
             const collections = await db.listCollections().toArray();
             const existingCollectionNames = collections.map((collection) => collection.name);

package/src/types/DbConfigHandler.ts

@@ -1,11 +1,17 @@
 import { OpModelType } from "../models/interfaces/OpModelType";
 
 export interface IDbConfigParams {
-    mongo_url?: string;
-    mongo_db?: string;
+    db_url?: string;
+    db_name?: 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];
 }

package/src/types/IRWSModel.ts

@@ -1,3 +1,3 @@
 export interface IRWSModel {
-    id?: string
+    id?: string | number
 }