@rws-framework/db 1.0.1

package/.bin/add-v.sh

@@ -0,0 +1,10 @@
+#!/bin/bash
+
+export VERSION=$1
+
+git add .
+git commit -m "v$VERSION"
+git tag $VERSION
+git push
+git push origin $VERSION
+npm publish

package/.bin/emerge.sh

@@ -0,0 +1,11 @@
+#!/bin/bash
+
+if ! command -v emerge >/dev/null 2>&1; then
+   echo "emerge command does not exist. Installing."
+    apt-get install graphviz graphviz-dev
+    pip install emerge-viz
+fi
+
+mkdir -p ./.emerge-vis-output/rws-server
+
+emerge -c ./.emerge-typescript-template.yaml

package/.eslintrc.json

@@ -0,0 +1,53 @@
+{
+    "env": {
+        "browser": false,
+        "es2021": true
+    },   
+    "plugins": ["@typescript-eslint", "unused-imports"],
+    "extends": [
+      "eslint:recommended",
+      "plugin:@typescript-eslint/recommended"
+    ],
+    "parser": "@typescript-eslint/parser",
+    "parserOptions": {
+        "ecmaVersion": "latest",
+        "sourceType": "module",
+        "project": "./tsconfig.json"
+    },
+    "ignorePatterns": ["*.js"],
+    "rules": {
+        "no-unused-vars": "off",         
+        "no-case-declarations": "off",       
+        "no-prototype-builtins": "off",                
+        "unused-imports/no-unused-imports": "error",
+        "unused-imports/no-unused-vars": ["warn", { "vars": "all", "args": "none"}],     
+        "@typescript-eslint/no-var-requires": "off",   
+        "@typescript-eslint/semi": ["error", "always"],
+        "@typescript-eslint/no-unused-vars": "off",
+        "@typescript-eslint/no-explicit-any": "off",
+        "@typescript-eslint/no-this-alias": "off",
+        "@typescript-eslint/type-annotation-spacing": ["error", {
+            "before": false,
+            "after": true,
+            "overrides": {
+              "arrow": {
+                "before": true, // Space before the arrow function's arrow
+                "after": true // Space after the arrow function's arrow
+              }
+            }
+        }],        
+        "indent": [
+            "error",
+            4
+        ],
+        "linebreak-style": [
+            "error",
+            "unix"
+        ],
+        "quotes": [
+            "error",
+            "single"
+        ],
+        "semi": "off"
+    }
+}

package/README.md

@@ -0,0 +1,275 @@
+# Models
+
+RWS models are converted to Prisma schemas and are wrapping around generated PrismaClient providing complete typing and better Relation handling + TimeSeries in future minor versions.
+
+## Models index file
+
+```typescript
+import ApiKey from "./ApiKey";
+import User from "./User";
+
+export const models = [ User, ApiKey];
+```
+
+
+## Example user model
+
+```typescript
+    import { RWSannotations, RWSModel } from '@rws-framework/server';
+
+import IUser from './interfaces/IUser';
+import 'reflect-metadata';
+
+import ApiKey from './ApiKey';
+import IApiKey from './interfaces/IApiKey';
+const { RWSTrackType, InverseRelation } = RWSannotations.modelAnnotations;
+
+class User extends RWSModel<User> implements IUser {
+    @RWSTrackType(String)
+    username: string;
+
+    @RWSTrackType(String) // Can also handle Object and Number
+    passwd: string;
+
+    @RWSTrackType(Boolean)
+    active: boolean;
+
+    @RWSTrackType(Date, { required: true })
+    created_at: Date;
+  
+    @RWSTrackType(Date)
+    updated_at: Date;
+
+    /**
+     * Every relation and inverse relation decorator 
+     * uses arrow function model passing
+     **/
+    @InverseRelation(() => ApiKey, () => User)
+    apiKeys: IApiKey[];
+
+    static _collection = 'user';
+
+    static _RELATIONS = {
+        transcriptions: true,
+        apiKeys: true
+    };
+
+    static _CUT_KEYS = ['passwd'];
+
+    constructor(data?: IUser) {   
+        super(data);    
+
+        if(!this.created_at){
+            this.created_at = new Date();
+        }      
+    }    
+
+    addMessage(message: string){
+        this.messages.push(message);
+    }
+}
+
+//Must export default for automated DI / build work.
+export default User;
+```
+
+## Relations
+
+***Basic many to one relation***
+```typescript
+import { RWSannotations, RWSModel } from '@rws-framework/server';
+
+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 = {
+        user: true,
+    };
+
+    @Relation(() => User, true) // second attribute is required = false
+    user: User;
+
+    @RWSTrackType(Object)
+    keyval: string;
+
+    @RWSTrackType(Date, { required: true })
+    created_at: Date;
+  
+    @RWSTrackType(Date)
+    updated_at: Date;
+
+    static _collection = 'api_keys';
+
+    constructor(data?: IApiKey) {   
+        super(data);    
+
+        if(!this.created_at){
+            this.created_at = new Date();
+        }    
+
+        this.updated_at = new Date();
+    }    
+}
+
+export default ApiKey;
+```
+
+***Relation decorator*** (many-to-one)
+
+```typescript
+import 'reflect-metadata';
+import Model, { OpModelType } from '../_model';
+
+interface IRelationOpts {
+    required?: boolean
+    key?: string
+    relationField?: string
+    relatedToField?: string
+    relatedTo: OpModelType<Model<any>>
+}
+  
+function Relation(theModel: () => OpModelType<Model<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(() => {
+            const relatedTo = theModel();
+            const metaOpts: IRelationOpts = {required, relatedTo, relatedToField};                    
+            if(!relationField){
+                metaOpts.relationField = relatedTo._collection + '_id';
+            } else{
+                metaOpts.relationField = relationField;
+            }  
+            metaOpts.key = key;
+            return metaOpts;
+        });
+
+        // Store both the promise and the key information
+        Reflect.defineMetadata(`Relation:${key}`, {
+            promise: metadataPromise,
+            key
+        }, target);
+    };
+}
+
+
+export default Relation;
+export {IRelationOpts};
+```
+
+***Inverse relation decorator*** (one-to-many)
+```typescript
+import 'reflect-metadata';
+import Model, { OpModelType } from '../_model';
+
+interface InverseRelationOpts{
+    key: string,
+    inversionModel: OpModelType<Model<any>>,
+    foreignKey: string    
+  }
+
+  function InverseRelation(inversionModel: () => OpModelType<Model<any>>, sourceModel: () => OpModelType<Model<any>>, foreignKey: string = null) {    
+    return function(target: any, key: string) {     
+        // Store the promise in metadata immediately
+        const metadataPromise = Promise.resolve().then(() => {
+            const model = inversionModel();
+            const source = sourceModel();
+    
+            const metaOpts: InverseRelationOpts = {
+                key,
+                inversionModel: model,
+                foreignKey: foreignKey ? foreignKey : `${source._collection}_id`
+            };             
+    
+            return metaOpts;
+        });
+
+        // Store both the promise and the key information
+        Reflect.defineMetadata(`InverseRelation:${key}`, {
+            promise: metadataPromise,
+            key
+        }, target);
+    };
+}
+
+export default InverseRelation;
+export {InverseRelationOpts};
+```
+
+
+## RWS Model to prisma conversion
+
+
+### Init CLI
+Basic CLI command that executes **generateModelSections()** from conversion script is 
+
+```bash
+yarn rws init
+```
+
+
+Code for RWS to prisma conversion from "@rws-framework/server" package:
+
+```typescript
+async function generateModelSections<T extends Model<T>>(model: OpModelType<T>): Promise<string> {
+    let section = '';
+    const modelMetadatas: Record<string, {annotationType: string, metadata: any}> = await Model.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 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'){        
+            // Handle inverse relation (one-to-many or one-to-one)
+            section += `\t${key} ${modelMetadata.inversionModel._collection}[] @relation("${modelMetadata.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`;
+        }
+    }
+    
+    section += '}\n';
+    return section;
+}
+
+function toConfigCase(modelType: any): string {
+    const type = modelType.type;
+    const input = type.name;  
+
+    if(input == 'Number'){
+        return 'Int';
+    }
+
+    if(input == 'Object'){
+        return 'Json';
+    }
+
+    if(input == 'Date'){
+        return 'DateTime';
+    }
+
+
+    const firstChar = input.charAt(0).toUpperCase();
+    const restOfString = input.slice(1);
+    return firstChar + restOfString;
+}
+```

package/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "@rws-framework/db",
+  "private": false,
+  "version": "1.0.1",
+  "description": "",
+  "main": "src/index.ts",
+  "scripts": {},
+  "author": "papablack",
+  "license": "ISC",
+  "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"
+  },
+  "devDependencies": {
+    "@types/xml2js": "^0.4.14"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/rws-framework/db.git"
+  }
+}

package/src/decorators/InverseRelation.ts

@@ -0,0 +1,35 @@
+import 'reflect-metadata';
+import { RWSModel, OpModelType } from '../models/_model';
+
+interface InverseRelationOpts{
+    key: string,
+    inversionModel: OpModelType<RWSModel<any>>,
+    foreignKey: string    
+  }
+
+  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(() => {
+            const model = inversionModel();
+            const source = sourceModel();
+    
+            const metaOpts: InverseRelationOpts = {
+                key,
+                inversionModel: model,
+                foreignKey: foreignKey ? foreignKey : `${source._collection}_id`
+            };             
+    
+            return metaOpts;
+        });
+
+        // Store both the promise and the key information
+        Reflect.defineMetadata(`InverseRelation:${key}`, {
+            promise: metadataPromise,
+            key
+        }, target);
+    };
+}
+
+export default InverseRelation;
+export {InverseRelationOpts};

package/src/decorators/InverseTimeSeries.ts

@@ -0,0 +1,22 @@
+import 'reflect-metadata';
+
+interface InverseTimeSeriesOpts{
+    timeSeriesModel: string
+    hydrationField: string
+  }
+  
+function InverseTimeSeries(timeSeriesModel: string, hydrationField: string) {
+
+    const metaOpts: InverseTimeSeriesOpts = {
+        timeSeriesModel: timeSeriesModel,
+        hydrationField: hydrationField
+    };
+
+
+    return function(target: any, key: string) {          
+        Reflect.defineMetadata(`InverseTimeSeries:${key}`, metaOpts, target);
+    };
+}
+
+export default InverseTimeSeries;
+export {InverseTimeSeriesOpts};

package/src/decorators/Relation.ts

@@ -0,0 +1,37 @@
+import 'reflect-metadata';
+import { RWSModel, OpModelType } from '../models/_model';
+
+interface IRelationOpts {
+    required?: boolean
+    key?: string
+    relationField?: string
+    relatedToField?: string
+    relatedTo: OpModelType<RWSModel<any>>
+}
+  
+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(() => {
+            const relatedTo = theModel();
+            const metaOpts: IRelationOpts = {required, relatedTo, relatedToField};                    
+            if(!relationField){
+                metaOpts.relationField = relatedTo._collection + '_id';
+            } else{
+                metaOpts.relationField = relationField;
+            }  
+            metaOpts.key = key;
+            return metaOpts;
+        });
+
+        // Store both the promise and the key information
+        Reflect.defineMetadata(`Relation:${key}`, {
+            promise: metadataPromise,
+            key
+        }, target);
+    };
+}
+
+
+export default Relation;
+export {IRelationOpts};

package/src/decorators/TrackType.ts

@@ -0,0 +1,56 @@
+import 'reflect-metadata';
+import { OpModelType } from '../models/_model';
+
+interface ITrackerOpts{
+    required?: boolean,
+    relationField?: string
+    relatedToField?: string,
+    relatedTo?: OpModelType<any>,
+    inversionModel?: OpModelType<any>,
+    relationName?: string
+  }
+  
+  interface IMetaOpts extends ITrackerOpts{
+    type: any,
+    tags: string[]
+  }
+  
+function TrackType(type: any, opts: ITrackerOpts | null = null, tags: string[] = []) {
+    if(!opts){
+        opts = {
+            required: false
+        };
+    }
+  
+    const required = opts.required;
+  
+    const metaOpts: IMetaOpts = {type, tags, required};
+  
+    if(opts.relatedToField && opts.relatedTo){
+        metaOpts.relatedToField = opts.relatedToField;      
+        metaOpts.relatedTo = opts.relatedTo;
+
+        if(!opts.relationField){
+            metaOpts.relationField = opts.relatedTo + '_id';
+        } else{
+            metaOpts.relationField = opts.relationField;
+        }
+    }     
+  
+    if(opts.inversionModel){
+        metaOpts.inversionModel = opts.inversionModel;  
+    }
+  
+    //const resolvedType = typeof type === 'function' ? type() : type;   
+    
+    if(type._collection){    
+        metaOpts.type = (type as any);
+    }
+  
+    return function(target: any, key: string) {          
+        Reflect.defineMetadata(`TrackType:${key}`, metaOpts, target);
+    };
+}
+
+export default TrackType;
+export {IMetaOpts, ITrackerOpts};

package/src/decorators/index.ts

@@ -0,0 +1,8 @@
+import InverseRelation from './InverseRelation';
+import Relation from './Relation';
+import TrackType, { IMetaOpts } from './TrackType';
+import InverseTimeSeries from './InverseTimeSeries';
+
+export {
+    InverseRelation, Relation, TrackType, InverseTimeSeries, IMetaOpts
+};

package/src/helper/DbHelper.ts

@@ -0,0 +1,138 @@
+import { rwsShell, rwsPath } from '@rws-framework/console';
+import chalk from 'chalk';
+import path from 'path';
+import fs from 'fs';
+
+import { IDbConfigHandler } from '../types/DbConfigHandler';
+import { IMetaOpts, OpModelType, RWSModel } from '../models/_model';
+import TimeSeriesModel from '../models/TimeSeriesModel';
+import { DBService } from '../services/DBService';
+
+const log = console.log;
+const workspaceRoot = rwsPath.findRootWorkspacePath();
+const moduleDir = path.resolve(workspaceRoot, 'node_modules', '@rws-framework', 'db');
+
+export class DbHelper {
+    static async installPrisma(configService: IDbConfigHandler, dbService: DBService, leaveFile = false): Promise<void>
+    {
+        const dbUrl = configService.get('mongo_url');      
+        const dbType = 'mongodb';
+
+        let template: string = `generator client {\n
+        provider = "prisma-client-js"\n
+    }\n\n`;
+
+        template += `\ndatasource db {\n
+        provider = "${dbType}"\n
+        url = env("DATABASE_URL")\n    
+    }\n\n`;
+
+        const dbModels: OpModelType<unknown>[] | null = configService.get('db_models');       
+
+        if(dbModels){
+
+            for (const model of dbModels){ 
+                const modelSection = await DbHelper.generateModelSections(model);
+
+                template += '\n\n' + modelSection;  
+
+                log('RWS SCHEMA BUILD', chalk.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.join(moduleDir, 'prisma');
+            const schemaPath = path.join(schemaDir, 'schema.prisma');
+
+            if(!fs.existsSync(schemaDir)){
+                fs.mkdirSync(schemaDir);
+            }
+
+            if(fs.existsSync(schemaPath)){
+                fs.unlinkSync(schemaPath);
+            }
+
+            fs.writeFileSync(schemaPath, template);  
+            process.env.DB_URL = dbUrl;
+            const endPrisma = 'npx prisma';
+            await rwsShell.runCommand(`${endPrisma} generate --schema=${schemaPath}`, process.cwd());  
+
+            // leaveFile = true;
+            log(chalk.green('[RWS Init]') + ' prisma schema generated from ', schemaPath);
+
+            if(!leaveFile){
+                fs.unlinkSync(schemaPath);
+            }    
+        }
+    }
+
+    static async generateModelSections<T extends unknown>(model: OpModelType<T>): 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';
+     
+        for (const key in modelMetadatas) {
+            const modelMetadata: IMetaOpts = modelMetadatas[key].metadata;            
+            const 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'){        
+                // Handle inverse relation (one-to-many or one-to-one)
+                section += `\t${key} ${modelMetadata.inversionModel._collection}[] @relation("${modelMetadata.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} ${DbHelper.toConfigCase(modelMetadata)}${requiredString} ${tags.join(' ')}\n`;
+            }
+        }
+        
+        section += '}\n';
+        return section;
+    }
+    
+    static toConfigCase(modelType: any): string {
+        const type = modelType.type;
+        const input = type.name;  
+    
+        if(input == 'Number'){
+            return 'Int';
+        }
+    
+        if(input == 'Object'){
+            return 'Json';
+        }
+    
+        if(input == 'Date'){
+            return 'DateTime';
+        }
+    
+    
+        const firstChar = input.charAt(0).toUpperCase();
+        const restOfString = input.slice(1);
+        return firstChar + restOfString;
+    }
+}