@rws-framework/db 1.0.1 → 2.0.1

package/README.md

@@ -77,12 +77,11 @@ export default User;
 
 ***Basic many to one relation***
 ```typescript
-import { RWSannotations, RWSModel } from '@rws-framework/server';
+import { RWSModel, TrackType, Relation } from '@rws-framework/db';
 
 import 'reflect-metadata';
 import User from './User';
 import IApiKey from './interfaces/IApiKey';
-const { RWSTrackType, Relation } = RWSannotations.modelAnnotations;
 
 class ApiKey extends RWSModel<ApiKey> implements IApiKey {
     static _RELATIONS = {
@@ -92,13 +91,13 @@ class ApiKey extends RWSModel<ApiKey> implements IApiKey {
     @Relation(() => User, true) // second attribute is required = false
     user: User;
 
-    @RWSTrackType(Object)
+    @TrackType(Object)
     keyval: string;
 
-    @RWSTrackType(Date, { required: true })
+    @TrackType(Date, { required: true })
     created_at: Date;
   
-    @RWSTrackType(Date)
+    @TrackType(Date)
     updated_at: Date;
 
     static _collection = 'api_keys';
@@ -121,7 +120,8 @@ export default ApiKey;
 
 ```typescript
 import 'reflect-metadata';
-import Model, { OpModelType } from '../_model';
+
+import { RWSModel, OpModelType } from '@rws-framework/db';
 
 interface IRelationOpts {
     required?: boolean
@@ -131,7 +131,7 @@ interface IRelationOpts {
     relatedTo: OpModelType<Model<any>>
 }
   
-function Relation(theModel: () => OpModelType<Model<any>>, required: boolean = false, relationField: string = null, relatedToField: string = 'id') {
+function Relation(theModel: () => OpModelType<RWSModel<any>>, required: boolean = false, relationField: string = null, relatedToField: string = 'id') {
     return function(target: any, key: string) {     
         // Store the promise in metadata immediately
         const metadataPromise = Promise.resolve().then(() => {
@@ -162,15 +162,15 @@ export {IRelationOpts};
 ***Inverse relation decorator*** (one-to-many)
 ```typescript
 import 'reflect-metadata';
-import Model, { OpModelType } from '../_model';
+import { RWSModel, OpModelType } from '@rws-framework/db';
 
 interface InverseRelationOpts{
     key: string,
-    inversionModel: OpModelType<Model<any>>,
+    inversionModel: OpModelType<RWSModel<any>>,
     foreignKey: string    
   }
 
-  function InverseRelation(inversionModel: () => OpModelType<Model<any>>, sourceModel: () => OpModelType<Model<any>>, foreignKey: string = null) {    
+  function InverseRelation(inversionModel: () => OpModelType<RWSModel<any>>, sourceModel: () => OpModelType<RWSModel<any>>, foreignKey: string = null) {    
     return function(target: any, key: string) {     
         // Store the promise in metadata immediately
         const metadataPromise = Promise.resolve().then(() => {
@@ -201,14 +201,116 @@ export {InverseRelationOpts};
 
 ## RWS Model to prisma conversion
 
+### Init helper class
+
+**This needs to be run either from the package or CLI - it changes models to prisma schema and registers it.**
+
+*IDbConfigHandler* - An interface for config bag for DBService
+
+```typescript
+    import { OpModelType } from "../models/_model";
+
+    export interface IDbConfigParams {
+        mongo_url?: string;
+        mongo_db?: string;
+        db_models?: OpModelType<any>[]
+    }
+
+    export interface IDbConfigHandler {
+        get<K extends keyof IDbConfigParams>(key: K): IDbConfigParams[K];
+    }
+```
+
+**Helper prisma install example**
+
+```typescript
+class Config implements IDbConfigHandler {
+    private data: IDbConfigParams = {
+        db_models: [],
+        mongo_db: null,
+        mongo_url: null
+    };
+
+    private modelsDir: string;
+    private cliExecRoot: string;
+    private static _instance: Config = null;
+
+    private constructor(){}
+
+    static async getInstance(): Promise<Config>
+    {
+        if(!this._instance){
+        this._instance = new Config();
+        }    
+
+        await this._instance.fill();
+
+        return this._instance;
+    }
+
+    
+    async fill(): Promise<void>
+    {
+        this.data.mongo_url = args[0];
+        this.data.mongo_db = args[1];    
+        
+
+        this.modelsDir = args[2];    
+        this.cliExecRoot = args[3]; 
+
+        this.data.db_models = (await import('@V/index')).default;      
+    }
+
+    getModelsDir(): string
+    {
+        return this.modelsDir
+    }
+
+    getCliExecRoot(): string
+    {
+        return this.cliExecRoot
+    }
+
+    get<K extends keyof IDbConfigParams>(key: K): IDbConfigParams[K] {
+        return this.data[key];  
+    }
+    }
+
+    async function main(): Promise<void>
+    {
+        console.log('INSTALL PRISMA');
+        const cfg = await Config.getInstance();
+        DbHelper.installPrisma(cfg, new DBService(cfg), false);
+    }
+```
 
 ### Init CLI
-Basic CLI command that executes **generateModelSections()** from conversion script is 
+Basic CLI command that executes **generateModelSections()** from conversion script is:
+
+**rws-db [DB_URL] [DB_NAME] [MODELS_DIRECTORY]**
+
+The exec file.
+```
+/exec/src/console.js
+```
+
+```bash
+#npm
+
+npx rws-db "mongodb://user:pass@localhost:27017/databaseName?authSource=admin&replicaSet=rs0" databaseName src/models
+```
 
 ```bash
-yarn rws init
+#yarn
+
+yarn rws-db "mongodb://user:pass@localhost:27017/databaseName?authSource=admin&replicaSet=rs0" databaseName src/models
 ```
 
+```bash
+#bun
+
+bunx rws-db "mongodb://user:pass@localhost:27017/databaseName?authSource=admin&replicaSet=rs0" databaseName src/models
+```
 
 Code for RWS to prisma conversion from "@rws-framework/server" package:
 

package/exec/console.js

@@ -0,0 +1,111 @@
+#!/usr/bin/env node
+
+const { rwsShell, rwsPath } = require('@rws-framework/console');
+const chalk = require('chalk');
+const crypto = require('crypto');
+const path = require('path');
+const fs = require('fs');
+
+const params = process.argv.splice(2);
+let paramsString = params.length ? (' ' + params.join(' ')) : '';
+
+const appRoot = process.cwd();
+const rwsCliConfigDir = path.resolve(appRoot, 'node_modules', '.rws', 'cli');
+const getCachedPath = (key) => path.resolve(rwsCliConfigDir, key);
+
+const currentCwd = path.resolve(__dirname);
+
+console.log({params})
+
+
+const commandString = `npx webpack --config db.rws.webpack.config.js --output-path ./build ${process.cwd()} ${params[2]}`;
+function needsCacheWarming(){
+
+    if(!fs.existsSync(getCachedPath('paths')) || !fs.existsSync(getCachedPath('checksum'))){
+        return true;
+    }
+    
+    const fileList = fs.readFileSync(getCachedPath('paths'), 'utf-8').split('\n');    
+
+    if(fileList.length){
+        const fileContents = [];
+        for(const filePath of fileList){
+            if(fs.existsSync(filePath)){
+                fileContents.push(fs.readFileSync(filePath, 'utf-8'));
+            }
+        }
+        const finalMD5 = crypto.createHash('md5').update(fileContents.join('\n')).digest('hex');
+        const cachedMD5 = fs.readFileSync(getCachedPath('checksum'), 'utf-8');
+
+        if(finalMD5 === cachedMD5){            
+            return false;
+        }
+    }        
+
+    return true;
+}
+
+async function main()
+{
+    const hasRebuild = paramsString.split(' ').pop().indexOf('--rebuild') > -1;
+    const doWarmCache = needsCacheWarming() || hasRebuild;  
+    
+    if(!((params[0] || false) && (params[1] || false) && (params[2] || false))){
+        throw new Error(`CLI command MUST have 3 parameters: {DB_URL, DB_NAME, MODELS_DIR}`);
+    }
+
+    if(doWarmCache){
+        console.log(chalk.yellow('[RWS DB CLI] Building CLI client...'));
+
+        const cacheTypes = ['paths', 'checksum'];
+
+        for(const type of cacheTypes){
+            if(fs.existsSync(getCachedPath(type))){
+                fs.unlinkSync(getCachedPath(type));
+            }
+        }
+
+        await tsc();
+
+        await rwsShell.runCommand(commandString, currentCwd);      
+       
+        
+    }else{
+        console.log(chalk.blue('[RWS CLI CACHE] Starting command from built CLI client.'));
+    }    
+
+    let startSlice = hasRebuild ? -1 : paramsString.split(' ').length;
+    let endSlice = hasRebuild ? -1 : null ;
+
+    paramsString = [
+        ...paramsString.split(' ').slice(0, startSlice), 
+        currentCwd, 
+        endSlice ? 
+            paramsString.split(' ').at(endSlice) 
+        : null
+    ].filter((item) => item !== null).join(' ');
+
+    await rwsShell.runCommand(`node ${path.join(currentCwd, 'build', 'main.cli.rws.js')}${paramsString}`, process.cwd());
+}
+
+async function tsc (){
+    const tempConfigContent = {
+        "extends": "./tsconfig.json",
+        "include": [
+            path.join(process.cwd(), params[2], 'index.ts')
+        ],           
+    };
+            
+    const tempConfigPath = path.join(currentCwd, '.tmp.gitignore.json');
+    fs.writeFileSync(tempConfigPath, JSON.stringify(tempConfigContent, null, 2));
+    
+    
+    await rwsShell.runCommand(`tsc -p ${tempConfigPath}`, currentCwd);                
+    fs.unlinkSync(tempConfigPath);        
+}
+
+main().then((data) => {
+    console.log(chalk.green('[RWS DB CLI] Command complete.'));
+}).catch((e) => {
+    console.error(e.message);
+});

package/exec/db.rws.webpack.config.js

@@ -0,0 +1,168 @@
+const path = require('path');
+const chalk = require('chalk');
+const webpackFilters = require('./webpackFilters');
+const webpack = require('webpack');
+const { rwsPath } = require('@rws-framework/console');
+// Get CLI arguments
+const args = process.argv.slice(2);
+const fs = require('fs');
+const appRootPath = args[4] || process.cwd();
+const modelsDir = args[5] || '';
+
+const internalCwd = process.cwd()
+const rootPackageNodeModules = path.resolve(rwsPath.findRootWorkspacePath(), 'node_modules');
+const thisPackage = path.resolve(__dirname, '..');
+const WEBPACK_PLUGINS = [new webpack.optimize.ModuleConcatenationPlugin()];
+
+const modules_setup = [rootPackageNodeModules, appRootPath];
+const isDev = true;
+
+function prettyLog(data){
+  for(const key of Object.keys(data)){
+    const valObject = data[key];
+
+    console.log(`${chalk.yellow('[Log]')} ${chalk.blue(key)}:`, valObject)
+  }
+}
+
+
+
+const mainEntry = './' + path.relative(appRootPath, path.join(internalCwd, '/src/cli.ts'));
+const vPath = path.relative(__dirname, path.join(__dirname, '../build/vendors'));
+
+prettyLog({ buildPaths:{
+  thisPackage,
+  rootPackageNodeModules,
+  appRootPath,
+  internalCwd,
+  vPath  
+}});
+
+if(!fs.existsSync(path.join(appRootPath, modelsDir, 'index.ts'))){
+  console.log(`${chalk.red('[RWS Structure Error] ')} ${chalk.blue(`
+    No index.ts in "${path.join(appRootPath, modelsDir)}"\n
+    RWS DB requires "index.ts" that has default export with array of your models:\n
+
+    ${chalk.blue('import')} RWSModel${chalk.blue(',')} OpModelType ${chalk.blue('from')}  ${chalk.green('./src/models/user.model.ts')}${chalk.blue(';')}
+
+    RWSModel<ModelDataInterface> is instance type and
+    OpModelType<ModelDataInterface> is type for static methods that navigate through db to populate instanced models.`)}\n
+     
+    Example: \n
+
+    ${chalk.blue('import')} User ${chalk.blue('from')} ${chalk.green('\'./src/models/user.model.ts\'')}${chalk.blue(';')}
+    ${chalk.blue('import')} ApiKey ${chalk.blue('from')} ${chalk.green('\'./src/models/apiKey.model.ts\'')}${chalk.blue(';')}
+
+    ${chalk.blue('export')} default ${chalk.magenta('[')}
+      User${chalk.blue(',')}
+      ApiKey
+    ${chalk.magenta(']')}${chalk.blue(';')}
+  `);
+
+  throw new Error("Build stopped.")
+}
+
+const cfgExport = {
+  context: appRootPath,
+  entry: mainEntry,
+  mode: isDev ? 'development' : 'production',
+  target: 'node',
+  devtool: isDev ? 'source-map' : false,
+  output: {
+    path: path.resolve(internalCwd, 'build'), // Resolve output path relative to config directory
+    filename: '[name].cli.rws.js',
+    sourceMapFilename: '[file].map',
+    chunkFilename: "[name].chunk.js",
+    libraryTarget: 'commonjs2',
+    clean: false
+  },
+  resolve: {
+    extensions: ['.ts', '.js'],
+    modules: modules_setup,
+    alias: {       
+      '@V': vPath,
+      'src': path.resolve(appRootPath, 'src'), // Add explicit resolution for src directory
+    },    
+    fallback: {
+      "kerberos": false,
+      "mongodb-client-encryption": false
+    }
+  },
+  module: {
+    rules: [
+      {
+        test: /\.(ts)$/,
+        use: [                       
+          {
+            loader: 'ts-loader',
+            options: {
+              transpileOnly: true,
+              configFile: path.resolve(__dirname, 'tsconfig.json'),
+              compilerOptions: {
+                outDir: path.resolve(internalCwd, 'build'),       
+              }             
+            }
+          }
+        ],
+        include: [
+          path.resolve(appRootPath),
+          path.resolve(thisPackage),
+          path.resolve(rootPackageNodeModules, '@rws-framework')                
+        ],
+        exclude: [
+          /node_modules\/(?!(@rws-framework)\/).*/,
+          /\.d\.ts$/
+        ]
+      },       
+      {
+        test: /\.node$/,
+        use: 'node-loader',
+      }        
+    ],
+  },
+  plugins: [
+    ...WEBPACK_PLUGINS,
+    new webpack.DefinePlugin({
+      'process.env.APP_ROOT': JSON.stringify(appRootPath),
+      'process.env.DB_CLI': JSON.stringify(1)
+    }),
+    new webpack.IgnorePlugin({
+      resourceRegExp: /^kerberos$/,
+    }),
+    new webpack.NormalModuleReplacementPlugin(
+      /.*\/build\/Debug\/kerberos\.node$/,
+      '@rws-framework/db/src/empty.js'
+    )
+  ],
+  ignoreWarnings: webpackFilters,
+  optimization: {      
+    minimize: false
+  },
+  experiments: {
+    topLevelAwait: true, // Enable top-level await if needed
+  }  
+  // stats: 'verbose'
+
+};
+
+cfgExport.externals = {
+  '@nestjs/common': 'commonjs @nestjs/common',
+  '@nestjs/core': 'commonjs @nestjs/core',  
+  '@nestjs/config': 'commonjs @nestjs/config',  
+  '@anthropic-ai/sdk': 'commonjs @anthropic-ai/sdk',
+  '@zip.js/zip.js': 'commonjs @zip.js/zip.js',
+  'mongodb-client-encryption': 'commonjs mongodb-client-encryption',
+  'uuid': 'commonjs uuid',
+  'source-map-support': 'commonjs source-map-support'
+};
+
+cfgExport.plugins.push(
+  new webpack.BannerPlugin({
+    banner: 'require("source-map-support").install();',
+    raw: true
+  })
+);
+
+// console.log('Final config', cfgExport);
+
+module.exports = cfgExport;

package/exec/src/cli.ts

@@ -0,0 +1,73 @@
+import 'reflect-metadata';
+
+const args: string[] = process.argv.slice(2).filter(cmd => cmd !== '--rebuild');
+import fs from 'fs';
+import path from 'path';
+import { DbHelper, DBService, OpModelType, RWSModel } from '../../src';
+import { IDbConfigHandler, IDbConfigParams } from '../../src/types/DbConfigHandler';
+import chalk from 'chalk';
+
+class Config implements IDbConfigHandler {
+  private data: IDbConfigParams = {
+    db_models: [],
+    mongo_db: null,
+    mongo_url: null
+  };
+
+  private modelsDir: string;
+  private cliExecRoot: string;
+  private static _instance: Config = null;
+
+  private constructor(){}
+
+  static async getInstance(): Promise<Config>
+  {
+    if(!this._instance){
+      this._instance = new Config();
+    }    
+
+    await this._instance.fill();
+
+    return this._instance;
+  }
+
+  
+  async fill(): Promise<void>
+  {
+    this.data.mongo_url = args[0];
+    this.data.mongo_db = args[1];    
+    
+
+    this.modelsDir = args[2];    
+    this.cliExecRoot = args[3]; 
+
+    console.log({args})
+
+    // this.data.db_models = (await import('@V/index')).default;      
+  }
+
+  getModelsDir(): string
+  {
+    return this.modelsDir
+  }
+
+  getCliExecRoot(): string
+  {
+    return this.cliExecRoot
+  }
+
+  get<K extends keyof IDbConfigParams>(key: K): IDbConfigParams[K] {
+    return this.data[key];  
+  }
+}
+
+async function main(): Promise<void>
+{
+  console.log('INSTALL PRISMA');
+  const cfg = await Config.getInstance();
+  DbHelper.installPrisma(cfg, new DBService(cfg), false);
+}
+
+console.log(chalk.bgGreen('[RWS DB CLI] Starting systems...'));
+
+main();

package/{tsconfig.json → exec/tsconfig.json}

@@ -1,8 +1,9 @@
 {
-  "compilerOptions": {
-    "baseUrl": "./",
+  "compilerOptions": {  
+    "baseUrl": "./",  
     "experimentalDecorators": true,
     "emitDecoratorMetadata": true,
+    "emitDeclarationOnly": false,
     "target": "ES2018",
     "module": "commonjs",
     "moduleResolution": "node",
@@ -14,11 +15,18 @@
     "allowSyntheticDefaultImports": true,
     "sourceMap": true,
     "declaration": true, 
+    "outDir": "build/vendors",
+    "preserveWatchOutput": true,
+    "allowJs": true,
+    "paths": {
+      "@V/*": ["./build/vendors/*"]      
+    }
   },
   "include": [
-    "src"
+    "src/cli.ts",
+    "../src/*"    
   ],
   "exclude": [  
     "node_modules"  
   ]
-}
+}

package/exec/webpackFilters.js

@@ -0,0 +1,18 @@
+module.exports = [
+    /aws-crt/,
+    /express\/lib\/view/,
+    /mongodb-client-encryption\/lib\/providers\/gcp/,
+    /mongodb/,
+    /nest-commander/,
+    /snappy/,
+    /mongodb-js\/zstd/,
+    /puppeteer/,
+    /kerberos/,
+    /@zip\.js\/zip.js/,
+    /Module not found: Error: Can't resolve 'fsevents' in/,
+    /Critical dependency: the request of a dependency is an expression/,
+    /Module not found: Error: Can't resolve 'aws4'/,
+    /Critical dependency: require function is used in a way in which dependencies cannot be statically extracted/,
+    /Can't resolve .* in '.*kerberos.*'/,
+    /Can't resolve .* in '.*mongodb-client-encryption.*'/
+];

package/package.json

@@ -1,19 +1,30 @@
 {
   "name": "@rws-framework/db",
   "private": false,
-  "version": "1.0.1",
+  "version": "2.0.1",
   "description": "",
   "main": "src/index.ts",
   "scripts": {},
   "author": "papablack",
   "license": "ISC",
+  "bin": {
+    "rws-db": "./exec/console.js"
+  },
   "dependencies": {
     "@rws-framework/console": "*",
     "@prisma/client": "^5.1.1",
     "@mongodb-js/zstd": "^1.2.0",
     "mongodb": "^6.8.1",
     "mongodb-client-encryption": "^6.1.1",
-    "xml2js": "^0.6.2"
+    "xml2js": "^0.6.2",
+    "crypto": "^1.0.1",
+    "source-map-support": "^0.5.21",
+    "tsconfig-paths": "^4.2.0",
+    "tsconfig-paths-webpack-plugin": "^4.1.0",
+    "webpack": "^5.97.1",    
+    "webpack-cli": "^6.0.1",
+    "webpack-bundle-analyzer": "^4.10.2",
+    "webpack-node-externals": "^3.0.0"
   },
   "devDependencies": {
     "@types/xml2js": "^0.4.14"

package/src/helper/DbHelper.ts

@@ -60,7 +60,7 @@ export class DbHelper {
 
             if(fs.existsSync(schemaPath)){
                 fs.unlinkSync(schemaPath);
-            }
+            }            
 
             fs.writeFileSync(schemaPath, template);  
             process.env.DB_URL = dbUrl;