@webtypen/webframez-core 0.2.32 → 0.2.34

package/dist/DataBuilder/DataBuilder.d.ts

@@ -16,6 +16,7 @@ export type DataBuilderSchema = {
         [key: string]: any;
     };
     newDataHandler?: Function;
+    canDelete: any;
 };
 export type DataBuilderType = {
     key: string;
@@ -48,7 +49,8 @@ export declare class DataBuilder {
     getFieldTypesFrontend(): any;
     getFieldsFrontend(fields: any, payload?: any): Promise<any>;
     getTypeFromRequest(req: any): DataBuilderType;
-    validateFields(fields: any, data: any, errors?: any, path?: string): Promise<any>;
+    validateFields(db: any, type: any, fields: any, req: Request, errors?: any, path?: string): Promise<any>;
+    handleUnique(db: any, req: any, field: any, type: any): Promise<boolean>;
     typeForFrontend(type: any, req: any): Promise<any>;
     loadType(req: Request): Promise<{
         status: string;
@@ -73,16 +75,11 @@ export declare class DataBuilder {
         errors?: undefined;
     }>;
     delete(db: any, req: any): Promise<{
-        status: string;
-        errors: any;
-        data?: undefined;
-    } | {
         status: string;
         data: {
             _id: any;
             redirect: any;
         };
-        errors?: undefined;
     }>;
     getField(req: Request, type: DataBuilderType, path: string): Promise<any>;
     removeArrayIndicators(str: string): string;

package/dist/DataBuilder/DataBuilder.js

@@ -94,7 +94,7 @@ class DataBuilder {
         }
         return type;
     }
-    validateFields(fields, data, errors, path) {
+    validateFields(db, type, fields, req, errors, path) {
         return __awaiter(this, void 0, void 0, function* () {
             if (!errors) {
                 errors = {};
@@ -104,11 +104,12 @@ class DataBuilder {
             }
             for (let key in fields) {
                 const fieldPath = (path ? path + "." : "") + key;
-                const value = lodash_1.default.get(data, fieldPath);
+                const value = lodash_1.default.get(req.body.data, fieldPath);
+                // Check-Required
                 if (fields[key].required) {
                     let check = true;
                     if (typeof fields[key].required === "function") {
-                        check = yield fields[key].required(data);
+                        check = yield fields[key].required(req.body.data);
                     }
                     if (check) {
                         if (value === null ||
@@ -121,11 +122,25 @@ class DataBuilder {
                         }
                     }
                 }
+                // Check-Unique
+                if (fields[key].unique) {
+                    let isUnique = false;
+                    if (typeof fields[key].unique === "function") {
+                        isUnique = yield fields[key].unique(req.body.data, req);
+                    }
+                    else if (typeof fields[key].unique === "object") {
+                        isUnique = yield this.handleUnique(db, req, fields[key], type);
+                    }
+                    if (isUnique) {
+                        errors[fieldPath] = "Es gibt bereits einen anderen Datensatz mit diesem Wert.";
+                        continue;
+                    }
+                }
                 if (typeof fields[key].schema === "object") {
                     if (value && value.length > 0) {
                         for (let i in value) {
                             const entryPath = fieldPath + "[" + i + "]";
-                            errors = yield this.validateFields(fields[key].schema, data, errors, entryPath);
+                            errors = yield this.validateFields(db, type, fields[key].schema, req.body.data, errors, entryPath);
                         }
                     }
                 }
@@ -136,6 +151,40 @@ class DataBuilder {
             return errors;
         });
     }
+    handleUnique(db, req, field, type) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const match = typeof field.unique.match === "function"
+                ? yield field.unique.match(req)
+                : typeof field.unique.match === "object"
+                    ? field.unique.match
+                    : {};
+            const check = yield db
+                .collection(typeof field.unique.collection === "string" && field.unique.collection.trim() !== ""
+                ? field.unique.collection
+                : type.collection)
+                .aggregate([
+                { $match: match },
+                ...(typeof field.unique.aggregation === "function"
+                    ? yield field.aggregation(req)
+                    : field.aggregation && Array.isArray(field.aggregation)
+                        ? field.aggregation
+                        : []),
+            ])
+                .toArray();
+            if (!check || check.length < 1) {
+                return true;
+            }
+            if (!req.body.__builder_id || req.body.__builder_id === "new") {
+                return false;
+            }
+            for (let el of check) {
+                if (el && el._id && el._id.toString() !== req.body.__builder_id) {
+                    return true;
+                }
+            }
+            return true;
+        });
+    }
     typeForFrontend(type, req) {
         return __awaiter(this, void 0, void 0, function* () {
             const newData = {};
@@ -277,7 +326,7 @@ class DataBuilder {
                 throw new Error("Missing schema fields ...");
             }
             const schemaFields = typeof type.schema.fields === "function" ? yield type.schema.fields(req) : type.schema.fields;
-            const errors = yield this.validateFields(schemaFields, req.body.data);
+            const errors = yield this.validateFields(db, type, schemaFields, req);
             if (errors && Object.keys(errors).length > 0) {
                 return {
                     status: "error",
@@ -387,13 +436,9 @@ class DataBuilder {
             if (!type || !type.schema || !type.schema.fields) {
                 throw new Error("Missing schema fields ...");
             }
-            const schemaFields = typeof type.schema.fields === "function" ? yield type.schema.fields(req) : type.schema.fields;
-            const errors = yield this.validateFields(schemaFields, req.body.data);
-            if (errors && Object.keys(errors).length > 0) {
-                return {
-                    status: "error",
-                    errors: errors,
-                };
+            const canDelete = typeof type.schema.canDelete === "function" ? yield type.schema.canDelete(req) : true;
+            if (!canDelete) {
+                throw new Error("Cannot delete entry ...");
             }
             const collection = type.schema && type.schema.collection ? type.schema.collection : undefined;
             if (!collection || collection.trim() === "") {

package/package.json

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

package/src/DataBuilder/DataBuilder.ts

@@ -15,6 +15,7 @@ export type DataBuilderSchema = {
     events?: { [key: string]: any };
     fields: { [key: string]: any };
     newDataHandler?: Function;
+    canDelete: any;
 };
 
 export type DataBuilderType = {
@@ -132,7 +133,7 @@ export class DataBuilder {
         return type;
     }
 
-    async validateFields(fields: any, data: any, errors?: any, path?: string) {
+    async validateFields(db: any, type: any, fields: any, req: Request, errors?: any, path?: string) {
         if (!errors) {
             errors = {};
         }
@@ -143,11 +144,13 @@ export class DataBuilder {
 
         for (let key in fields) {
             const fieldPath = (path ? path + "." : "") + key;
-            const value = lodash.get(data, fieldPath);
+            const value = lodash.get(req.body.data, fieldPath);
+
+            // Check-Required
             if (fields[key].required) {
                 let check = true;
                 if (typeof fields[key].required === "function") {
-                    check = await fields[key].required(data);
+                    check = await fields[key].required(req.body.data);
                 }
 
                 if (check) {
@@ -164,11 +167,26 @@ export class DataBuilder {
                 }
             }
 
+            // Check-Unique
+            if (fields[key].unique) {
+                let isUnique = false;
+                if (typeof fields[key].unique === "function") {
+                    isUnique = await fields[key].unique(req.body.data, req);
+                } else if (typeof fields[key].unique === "object") {
+                    isUnique = await this.handleUnique(db, req, fields[key], type);
+                }
+
+                if (isUnique) {
+                    errors[fieldPath] = "Es gibt bereits einen anderen Datensatz mit diesem Wert.";
+                    continue;
+                }
+            }
+
             if (typeof fields[key].schema === "object") {
                 if (value && value.length > 0) {
                     for (let i in value) {
                         const entryPath = fieldPath + "[" + i + "]";
-                        errors = await this.validateFields(fields[key].schema, data, errors, entryPath);
+                        errors = await this.validateFields(db, type, fields[key].schema, req.body.data, errors, entryPath);
                     }
                 }
             }
@@ -181,6 +199,45 @@ export class DataBuilder {
         return errors;
     }
 
+    async handleUnique(db: any, req: any, field: any, type: any) {
+        const match: any =
+            typeof field.unique.match === "function"
+                ? await field.unique.match(req)
+                : typeof field.unique.match === "object"
+                ? field.unique.match
+                : {};
+        const check = await db
+            .collection(
+                typeof field.unique.collection === "string" && field.unique.collection.trim() !== ""
+                    ? field.unique.collection
+                    : type.collection
+            )
+            .aggregate([
+                { $match: match },
+                ...(typeof field.unique.aggregation === "function"
+                    ? await field.aggregation(req)
+                    : field.aggregation && Array.isArray(field.aggregation)
+                    ? field.aggregation
+                    : []),
+            ])
+            .toArray();
+
+        if (!check || check.length < 1) {
+            return true;
+        }
+
+        if (!req.body.__builder_id || req.body.__builder_id === "new") {
+            return false;
+        }
+
+        for (let el of check) {
+            if (el && el._id && el._id.toString() !== req.body.__builder_id) {
+                return true;
+            }
+        }
+        return true;
+    }
+
     async typeForFrontend(type: any, req: any) {
         const newData: any = {};
         for (let key in type) {
@@ -348,7 +405,7 @@ export class DataBuilder {
         }
 
         const schemaFields = typeof type.schema.fields === "function" ? await type.schema.fields(req) : type.schema.fields;
-        const errors: any = await this.validateFields(schemaFields, req.body.data);
+        const errors: any = await this.validateFields(db, type, schemaFields, req);
         if (errors && Object.keys(errors).length > 0) {
             return {
                 status: "error",
@@ -473,13 +530,9 @@ export class DataBuilder {
             throw new Error("Missing schema fields ...");
         }
 
-        const schemaFields = typeof type.schema.fields === "function" ? await type.schema.fields(req) : type.schema.fields;
-        const errors: any = await this.validateFields(schemaFields, req.body.data);
-        if (errors && Object.keys(errors).length > 0) {
-            return {
-                status: "error",
-                errors: errors,
-            };
+        const canDelete = typeof type.schema.canDelete === "function" ? await type.schema.canDelete(req) : true;
+        if (!canDelete) {
+            throw new Error("Cannot delete entry ...");
         }
 
         const collection = type.schema && type.schema.collection ? type.schema.collection : undefined;