@rws-framework/db 2.2.0 → 2.2.3

package/README.md

@@ -10,34 +10,38 @@ import User from "./User";
 
 export const models = [ User, ApiKey];
 ```
-
-
 ## Example user model
 
 ```typescript
-    import { RWSannotations, RWSModel } from '@rws-framework/server';
+    import { TrackType, InverseRelation, RWSCollection, RWSModel } from '@rws-framework/db';
 
-import IUser from './interfaces/IUser';
-import 'reflect-metadata';
+    import IUser from './interfaces/IUser';
+    import 'reflect-metadata';
 
-import ApiKey from './ApiKey';
-import IApiKey from './interfaces/IApiKey';
-const { RWSTrackType, InverseRelation } = RWSannotations.modelAnnotations;
+    import ApiKey from './ApiKey';
+    import IApiKey from './interfaces/IApiKey';
 
+@RWSCollection('users', { 
+    relations: {
+        transcriptions: true,
+        apiKeys: true
+    },
+    ignored_keys: ['passwd']
+})
 class User extends RWSModel<User> implements IUser {
-    @RWSTrackType(String)
+    @TrackType(String)
     username: string;
 
-    @RWSTrackType(String) // Can also handle Object and Number
+    @TrackType(String) // Can also handle Object and Number
     passwd: string;
 
-    @RWSTrackType(Boolean)
+    @TrackType(Boolean)
     active: boolean;
 
-    @RWSTrackType(Date, { required: true })
+    @TrackType(Date, { required: true })
     created_at: Date;
   
-    @RWSTrackType(Date)
+    @TrackType(Date)
     updated_at: Date;
 
     /**
@@ -47,25 +51,12 @@ class User extends RWSModel<User> implements IUser {
     @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);
     }
 }
 

package/package.json

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

package/dist/models/utils/RelationUtils copy.d.ts

@@ -1,13 +0,0 @@
-import { RelOneMetaType, RelManyMetaType } from '../types/RelationTypes';
-import { IRWSModel } from '../../types/IRWSModel';
-export declare class RelationUtils {
-    static getRelationOneMeta(model: any, classFields: string[]): Promise<RelOneMetaType<IRWSModel>>;
-    static getRelationManyMeta(model: any, classFields: string[]): Promise<RelManyMetaType<IRWSModel>>;
-    static bindRelation(relatedModel: any): {
-        connect: {
-            id: string;
-        };
-    };
-    static hasRelation(model: any, key: string): boolean;
-    static checkRelEnabled(model: any, key: string): boolean;
-}

package/dist/models/utils/RelationUtils copy.js

@@ -1,65 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RelationUtils = void 0;
-class RelationUtils {
-    static async getRelationOneMeta(model, classFields) {
-        const relIds = {};
-        const relationFields = classFields
-            .filter((item) => item.indexOf('Relation') === 0 && !item.includes('Inverse'))
-            .map((item) => item.split(':').at(-1));
-        for (const key of relationFields) {
-            const metadataKey = `Relation:${key}`;
-            const metadata = Reflect.getMetadata(metadataKey, model);
-            if (metadata && metadata.promise) {
-                const resolvedMetadata = await metadata.promise;
-                if (!relIds[key]) {
-                    relIds[key] = {
-                        key: resolvedMetadata.key,
-                        required: resolvedMetadata.required,
-                        model: resolvedMetadata.relatedTo,
-                        hydrationField: resolvedMetadata.relationField,
-                        foreignKey: resolvedMetadata.relatedToField
-                    };
-                }
-            }
-        }
-        return relIds;
-    }
-    static async getRelationManyMeta(model, classFields) {
-        const relIds = {};
-        const inverseFields = classFields
-            .filter((item) => item.indexOf('InverseRelation') === 0)
-            .map((item) => item.split(':').at(-1));
-        for (const key of inverseFields) {
-            const metadataKey = `InverseRelation:${key}`;
-            const metadata = Reflect.getMetadata(metadataKey, model);
-            if (metadata && metadata.promise) {
-                const resolvedMetadata = await metadata.promise;
-                if (!relIds[key]) {
-                    relIds[key] = {
-                        key: resolvedMetadata.key,
-                        inversionModel: resolvedMetadata.inversionModel,
-                        foreignKey: resolvedMetadata.foreignKey
-                    };
-                }
-            }
-        }
-        return relIds;
-    }
-    static bindRelation(relatedModel) {
-        return {
-            connect: {
-                id: relatedModel.id
-            }
-        };
-    }
-    static hasRelation(model, key) {
-        // Check if the property exists and is an object with an id property
-        return !!model[key] && typeof model[key] === 'object' && model[key] !== null && 'id' in model[key];
-    }
-    static checkRelEnabled(model, key) {
-        return Object.keys(model.constructor._RELATIONS).includes(key) &&
-            model.constructor._RELATIONS[key] === true;
-    }
-}
-exports.RelationUtils = RelationUtils;