@webtypen/webframez-core 0.2.13 → 0.2.15

package/README.md

@@ -28,9 +28,7 @@ Alternatively, a function can be specified directly or a previously imported one
 
 ```ts
 // Directly
-Route.get("/", (req: Request, res: Response) =>
-  res.send({ status: "success" })
-);
+Route.get("/", (req: Request, res: Response) => res.send({ status: "success" }));
 
 // Imported
 import { myFunction } from "./myfunction";
@@ -43,10 +41,10 @@ Middleware functions are also registered in `app/Kernel.ts.` A middleware functi
 
 Middleware functions are usually created under `app/Middleware`. A middleware function is called with the parameters (next, abort, req and res):
 
-- `next`: Function that signals when called that the request may be continued
-- `abort`: Function that aborts the request when called. An HTTP status code can be specified in the first parameter and a request body (usually text or JSON) in the second.
-- `req`: The Request-Object
-- `res`: The Response-Object
+-   `next`: Function that signals when called that the request may be continued
+-   `abort`: Function that aborts the request when called. An HTTP status code can be specified in the first parameter and a request body (usually text or JSON) in the second.
+-   `req`: The Request-Object
+-   `res`: The Response-Object
 
 Alternatively, middleware functions can also be defined directly in Kernel.ts:
 
@@ -73,7 +71,7 @@ Route.get("/auth-data", "AuthController@authData", { middleware: ["auth"] });
 
 With the grouping of routes, the code of the application can be significantly reduced and kept clear. Here's how the following configurations can be used with a multiple route definition:
 
-- `prefix`: A route path prefix used for all routes in this group:
+-   `prefix`: A route path prefix used for all routes in this group:
 
 ```ts
 Route.group({ prefix: "/admin", () => {
@@ -82,7 +80,7 @@ Route.group({ prefix: "/admin", () => {
 }});
 ```
 
-- `middleware`: An array of middleware-keys used for all routes in this group:
+-   `middleware`: An array of middleware-keys used for all routes in this group:
 
 ```ts
 Route.group({ middleware: ["auth"], () => {
@@ -100,12 +98,12 @@ Nesting of the route groups is also possible:
 
 ```ts
 Route.group({ prefix: "/test" }, () => {
-  Route.get("/", "TestController@test"); // Path: /test/
-  Route.get("/test2", "TestController@test"); // Path: /test2/
+    Route.get("/", "TestController@test"); // Path: /test/
+    Route.get("/test2", "TestController@test"); // Path: /test2/
 
-  Route.group({ middleware: ["auth"], prefix: "/auth" }, () => {
-    Route.get("/data", "AuthController@data"); // Path: /test/auth/data; Middleware: auth
-  });
+    Route.group({ middleware: ["auth"], prefix: "/auth" }, () => {
+        Route.get("/data", "AuthController@data"); // Path: /test/auth/data; Middleware: auth
+    });
 });
 ```
 
@@ -117,7 +115,7 @@ The application can handle multiple database connections, but one is defined as
 
 The connections are configured in the `config/database.ts` file. Each connection is given a unique key in the `connections` object and uses a driver. The following drivers are currently available:
 
-- MongoDB Driver
+-   MongoDB Driver
 
 Depending on the driver, the database connection must be configured with different parameters.
 
@@ -125,13 +123,13 @@ Depending on the driver, the database connection must be configured with differe
 
 ```ts
 export default {
-  defaultConnection: "default",
-  connections: {
-    ["default"]: {
-      driver: "mongodb",
-      url: "mongodb://...",
+    defaultConnection: "default",
+    connections: {
+        ["default"]: {
+            driver: "mongodb",
+            url: "mongodb://...",
+        },
     },
-  },
 };
 ```
 
@@ -140,9 +138,59 @@ export default {
 Models are usually placed under `app/Models`. Each model class inherits from `Model` and must store the table / collection name, in which the models data sets are stored, in the `__table` attribute.
 
 ```ts
-import { Model } from "@webtypen/webframez-core";
-
-export class Test extends Model {
-  __table = "test_table";
+import { Model, hasMany, QueryBuilder } from "@webtypen/webframez-core";
+import { File } from "./File";
+import { Session } from "./Session";
+
+export class User extends Model {
+    __table = "users";
+
+    /**
+     * @param File                 Dependency Model
+     * @param foreignKey
+     * @param localKey             (optional)
+     * @param queryBuilderFunction (optional) customize the query
+     **/
+    @hasOne(() => File, "_user_avatar", "_id", (query: QueryBuilder) => {
+        query.where("status", "=", "uploaded");
+    })
+    avatar!: () => File;
+
+    /**
+     * @param File                 Dependency Model
+     * @param foreignKey
+     * @param localKey             (optional)
+     * @param queryBuilderFunction (optional) customize the query
+     **/
+    @hasMany(() => Session, "_user")
+    sessions!: () => Session[];
 }
 ```
+
+### Load a model
+
+```ts
+import { User } from "../Models/User";
+
+const users = await User.where("is_active", "=", true).get();
+const testUser = await User.where("email", "=", "test@test.de").where("is_active", "=", true).first();
+```
+
+#### Dependency Injection
+
+```ts
+const sessions = await testUser.session();
+const avatarUrl = await testUser.avatar()?.url;
+```
+
+##### Disable cache / force dependency-reload:
+
+```ts
+const refreshedData = await testUser.session({ force: true });
+```
+
+##### Get dependency-query:
+
+```ts
+const oldSessions = await testUser.session({ query: true }).where("date", "<", moment().subtract(30, "days").format("YYYY-MM-DD")).get();
+```

package/dist/Database/Model.d.ts

@@ -2,12 +2,15 @@ import { QueryBuilder } from "./QueryBuilder";
 type ObjectIDType = {
     noExceptions?: Boolean;
 };
+export declare function hasOne(modelGetter: () => any, foreignKey: string, localKey?: string, queryFunction?: Function): (target: any, propertyKey: string, v2?: any) => void;
+export declare function hasMany(modelGetter: () => any, foreignKey: string, localKey?: string, queryFunction?: Function): (target: any, propertyKey: string) => void;
 export declare class Model {
     [key: string]: any | undefined;
     __primaryKey: string;
     __table: string;
     __connection: string | undefined;
     __hidden: string[];
+    __dependencies: any;
     __unmapped: string[];
     __unmappedSystem: string[];
     static objectId(val?: any, options?: ObjectIDType): Promise<any>;
@@ -52,6 +55,7 @@ export declare class Model {
      * @returns any
      */
     static aggregate(aggregation: any, options?: any, collection?: string): Promise<any>;
+    buildRelationship(model: any, foreignKey: string, localKey?: string): any;
     /**
      * Returns the model-data without system- and unmapped-fields (new js-object)
      * @returns object

package/dist/Database/Model.js

@@ -9,17 +9,91 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Model = void 0;
+exports.Model = exports.hasMany = exports.hasOne = void 0;
 const DBConnection_1 = require("./DBConnection");
 const QueryBuilder_1 = require("./QueryBuilder");
+function hasOne(modelGetter, foreignKey, localKey, queryFunction) {
+    return function (target, propertyKey, v2) {
+        Object.defineProperty(target, propertyKey, {
+            value: function (options) {
+                return __awaiter(this, void 0, void 0, function* () {
+                    if ((!options || !options.force) && this.__dependencies && this.__dependencies[propertyKey] !== undefined) {
+                        return this.__dependencies[propertyKey];
+                    }
+                    const model = modelGetter();
+                    if (!model) {
+                        throw new Error(`Model for foreignKey "${foreignKey}" konnte nicht aufgelöst werden.`);
+                    }
+                    if (!this.__dependencies) {
+                        this.__dependencies = {};
+                    }
+                    const query = this.buildRelationship(model, localKey !== null && localKey !== void 0 ? localKey : "_id", foreignKey);
+                    if (queryFunction && typeof queryFunction === "function") {
+                        queryFunction(query);
+                    }
+                    if (options && options.query) {
+                        return query;
+                    }
+                    this.__dependencies[propertyKey] = yield query.first();
+                    return this.__dependencies[propertyKey];
+                });
+            },
+            writable: false,
+            configurable: true,
+        });
+    };
+}
+exports.hasOne = hasOne;
+function hasMany(modelGetter, foreignKey, localKey, queryFunction) {
+    return function (target, propertyKey) {
+        Object.defineProperty(target, propertyKey, {
+            value: function (options) {
+                return __awaiter(this, void 0, void 0, function* () {
+                    if ((!options || !options.force) && this.__dependencies && this.__dependencies[propertyKey] !== undefined) {
+                        return this.__dependencies[propertyKey];
+                    }
+                    const model = modelGetter();
+                    if (!model) {
+                        throw new Error(`Model for foreignKey "${foreignKey}" konnte nicht aufgelöst werden.`);
+                    }
+                    if (!this.__dependencies) {
+                        this.__dependencies = {};
+                    }
+                    const query = this.buildRelationship(model, foreignKey, localKey);
+                    if (queryFunction && typeof queryFunction === "function") {
+                        queryFunction(query);
+                    }
+                    if (options && options.query) {
+                        return query;
+                    }
+                    this.__dependencies[propertyKey] = yield query.get();
+                    return this.__dependencies[propertyKey];
+                });
+            },
+            writable: false,
+            configurable: true,
+        });
+    };
+}
+exports.hasMany = hasMany;
 class Model {
     constructor() {
         this.__primaryKey = "_id";
         this.__table = "";
         this.__connection = undefined;
         this.__hidden = [];
+        this.__dependencies = {};
         this.__unmapped = [];
-        this.__unmappedSystem = ["__primaryKey", "__table", "__connection", "__unmapped", "__unmappedSystem", "__is_deleted", "__hidden"];
+        this.__unmappedSystem = [
+            "__primaryKey",
+            "__table",
+            "__connection",
+            "__unmapped",
+            "__unmappedSystem",
+            "__is_deleted",
+            "__hidden",
+            "__dependencies",
+        ];
     }
     static objectId(val, options) {
         return __awaiter(this, void 0, void 0, function* () {
@@ -141,9 +215,12 @@ class Model {
                 type: "aggregation",
                 table: collection ? collection : model ? model.__table : undefined,
                 aggregation: aggregation,
-            }, model.__connection, options);
+            }, model.__connection);
         });
     }
+    buildRelationship(model, foreignKey, localKey) {
+        return model.where(foreignKey, "=", this[localKey !== null && localKey !== void 0 ? localKey : "_id"]);
+    }
     /**
      * Returns the model-data without system- and unmapped-fields (new js-object)
      * @returns object

package/dist/Datatable/Datatable.d.ts

@@ -18,6 +18,8 @@ export declare class Datatable {
     perPage: number;
     onRow?: Function;
     onAttributes?: Function;
+    autoApplyFilter: boolean;
+    autoApplySearch: boolean;
     getInit(req: Request): Promise<any>;
     getAggregation(req: Request): Promise<any>;
     getSubAggregation(req: Request): Promise<any>;

package/dist/Datatable/Datatable.js

@@ -22,6 +22,8 @@ class Datatable {
         this.onPressLink = null;
         this.exports = null;
         this.perPage = 25;
+        this.autoApplyFilter = true;
+        this.autoApplySearch = false;
     }
     getInit(req) {
         return __awaiter(this, void 0, void 0, function* () {
@@ -62,7 +64,14 @@ class Datatable {
     }
     getAggregation(req) {
         return __awaiter(this, void 0, void 0, function* () {
-            return typeof this.aggregation === "function" ? yield this.aggregation(req) : this.aggregation;
+            const aggr = typeof this.aggregation === "function" ? yield this.aggregation(req) : this.aggregation;
+            if (this.autoApplyFilter && req.body.filter && typeof req.body.filter === "object") {
+                return [{ $match: Object.assign({}, this.getFilterMatch(req, req.body.filter)) }];
+            }
+            else if (this.autoApplySearch && req.body.search && typeof req.body.search === "object") {
+                return [{ $match: Object.assign({}, this.getFilterMatch(req, req.body.search)) }];
+            }
+            return aggr;
         });
     }
     getSubAggregation(req) {
@@ -317,6 +326,28 @@ class Datatable {
                         }
                         break;
                 }
+                if (value !== undefined && filterEl && filterEl.cast) {
+                    if (typeof filterEl.cast === "function") {
+                        value = yield filterEl.cast(value, entry, req);
+                    }
+                    else if (filterEl.cast === "string") {
+                        value = value.toString();
+                    }
+                    else if (filterEl.cast === "objectId") {
+                        if (value.length === 12 || value.length === 24) {
+                            value = yield DBConnection_1.DBConnection.objectId(value);
+                        }
+                    }
+                    else if (filterEl.cast === "integer") {
+                        value = parseInt(value);
+                    }
+                    else if (filterEl.cast === "float") {
+                        value = parseFloat(value);
+                    }
+                    else if (filterEl.cast === "boolean") {
+                        value = value === true || value === 1 || value.toString() === "1" || value.toString() === "true" ? true : false;
+                    }
+                }
                 if (value !== undefined) {
                     out[filterEl && filterEl.mapping && filterEl.mapping.trim() !== "" ? filterEl.mapping : key] = value;
                 }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@webtypen/webframez-core",
-    "version": "0.2.13",
+    "version": "0.2.15",
     "description": "The core package of the typescript based webframez (web-framework) by webtypen.de",
     "homepage": "https://webtypen.de/",
     "license": "MIT",

package/src/Database/Model.ts

@@ -5,14 +5,92 @@ type ObjectIDType = {
     noExceptions?: Boolean;
 };
 
+export function hasOne(modelGetter: () => any, foreignKey: string, localKey?: string, queryFunction?: Function) {
+    return function (target: any, propertyKey: string, v2?: any) {
+        Object.defineProperty(target, propertyKey, {
+            value: async function (options?: any) {
+                if ((!options || !options.force) && this.__dependencies && this.__dependencies[propertyKey] !== undefined) {
+                    return this.__dependencies[propertyKey];
+                }
+
+                const model = modelGetter();
+                if (!model) {
+                    throw new Error(`Model for foreignKey "${foreignKey}" konnte nicht aufgelöst werden.`);
+                }
+
+                if (!this.__dependencies) {
+                    this.__dependencies = {};
+                }
+
+                const query = this.buildRelationship(model, localKey ?? "_id", foreignKey);
+                if (queryFunction && typeof queryFunction === "function") {
+                    queryFunction(query);
+                }
+
+                if (options && options.query) {
+                    return query;
+                }
+                this.__dependencies[propertyKey] = await query.first();
+                return this.__dependencies[propertyKey];
+            },
+            writable: false,
+            configurable: true,
+        });
+    };
+}
+
+export function hasMany(modelGetter: () => any, foreignKey: string, localKey?: string, queryFunction?: Function) {
+    return function (target: any, propertyKey: string) {
+        Object.defineProperty(target, propertyKey, {
+            value: async function (options?: any) {
+                if ((!options || !options.force) && this.__dependencies && this.__dependencies[propertyKey] !== undefined) {
+                    return this.__dependencies[propertyKey];
+                }
+
+                const model = modelGetter();
+                if (!model) {
+                    throw new Error(`Model for foreignKey "${foreignKey}" konnte nicht aufgelöst werden.`);
+                }
+
+                if (!this.__dependencies) {
+                    this.__dependencies = {};
+                }
+
+                const query = this.buildRelationship(model, foreignKey, localKey);
+                if (queryFunction && typeof queryFunction === "function") {
+                    queryFunction(query);
+                }
+
+                if (options && options.query) {
+                    return query;
+                }
+                this.__dependencies[propertyKey] = await query.get();
+                return this.__dependencies[propertyKey];
+            },
+            writable: false,
+            configurable: true,
+        });
+    };
+}
+
 export class Model {
     [key: string]: any | undefined; // allow-custom-properties
     __primaryKey = "_id";
     __table: string = "";
     __connection: string | undefined = undefined;
     __hidden: string[] = [];
+    __dependencies: any = {};
     __unmapped: string[] = [];
-    __unmappedSystem: string[] = ["__primaryKey", "__table", "__connection", "__unmapped", "__unmappedSystem", "__is_deleted", "__hidden"];
+    __unmappedSystem: string[] = [
+        "__primaryKey",
+        "__table",
+        "__connection",
+        "__unmapped",
+        "__unmappedSystem",
+        "__is_deleted",
+        "__hidden",
+        "__dependencies",
+    ];
 
     static async objectId(val?: any, options?: ObjectIDType) {
         const model = new this();
@@ -124,7 +202,7 @@ export class Model {
      * @param aggregation
      * @returns any
      */
-    static async aggregate(aggregation: any, options?: any,collection?: string) {
+    static async aggregate(aggregation: any, options?: any, collection?: string) {
         const model = new this();
         return await DBConnection.execute(
             {
@@ -132,11 +210,14 @@ export class Model {
                 table: collection ? collection : model ? model.__table : undefined,
                 aggregation: aggregation,
             },
-            model.__connection,
-            options
+            model.__connection
         );
     }
 
+    buildRelationship(model: any, foreignKey: string, localKey?: string): any {
+        return model.where(foreignKey, "=", this[localKey ?? "_id"]);
+    }
+
     /**
      * Returns the model-data without system- and unmapped-fields (new js-object)
      * @returns object

package/src/Datatable/Datatable.ts

@@ -13,6 +13,8 @@ export class Datatable {
     perPage: number = 25;
     onRow?: Function;
     onAttributes?: Function;
+    autoApplyFilter = true;
+    autoApplySearch = false;
 
     async getInit(req: Request) {
         const out: any = { table: req.body._table };
@@ -60,7 +62,13 @@ export class Datatable {
     }
 
     async getAggregation(req: Request) {
-        return typeof this.aggregation === "function" ? await this.aggregation(req) : this.aggregation;
+        const aggr = typeof this.aggregation === "function" ? await this.aggregation(req) : this.aggregation;
+        if (this.autoApplyFilter && req.body.filter && typeof req.body.filter === "object") {
+            return [{ $match: { ...this.getFilterMatch(req, req.body.filter) } }];
+        } else if (this.autoApplySearch && req.body.search && typeof req.body.search === "object") {
+            return [{ $match: { ...this.getFilterMatch(req, req.body.search) } }];
+        }
+        return aggr;
     }
 
     async getSubAggregation(req: Request) {
@@ -331,6 +339,24 @@ export class Datatable {
                     break;
             }
 
+            if (value !== undefined && filterEl && filterEl.cast) {
+                if (typeof filterEl.cast === "function") {
+                    value = await filterEl.cast(value, entry, req);
+                } else if (filterEl.cast === "string") {
+                    value = value.toString();
+                } else if (filterEl.cast === "objectId") {
+                    if (value.length === 12 || value.length === 24) {
+                        value = await DBConnection.objectId(value);
+                    }
+                } else if (filterEl.cast === "integer") {
+                    value = parseInt(value);
+                } else if (filterEl.cast === "float") {
+                    value = parseFloat(value);
+                } else if (filterEl.cast === "boolean") {
+                    value = value === true || value === 1 || value.toString() === "1" || value.toString() === "true" ? true : false;
+                }
+            }
+
             if (value !== undefined) {
                 out[filterEl && filterEl.mapping && filterEl.mapping.trim() !== "" ? filterEl.mapping : key] = value;
             }

package/tsconfig.json

@@ -10,7 +10,8 @@
         "declaration": true,
         "outDir": "dist",
         "rootDir": "src",
-        "strict": true
+        "strict": true,
+        "experimentalDecorators": true
     },
     "exclude": ["dist", "node_modules", "src/**/*.spec.ts"],
     "include": ["src"]