@webtypen/webframez-core 0.1.16 → 0.2.0

package/dist/DataBuilder/DataBuilder.d.ts

@@ -0,0 +1,82 @@
+import { Request } from "../Router/Request";
+export type DataBuilderSchema = {
+    version: string;
+    collection?: string;
+    primaryKey?: string;
+    primaryKeyPlain?: boolean;
+    beforeSave?: any;
+    afterSave?: any;
+    getAggregation?: any;
+    events?: {
+        [key: string]: any;
+    };
+    fields: {
+        [key: string]: any;
+    };
+};
+export type DataBuilderType = {
+    key: string;
+    singular: string;
+    plural: string;
+    schema: DataBuilderSchema;
+    forms?: {
+        [key: string]: any;
+    };
+};
+export type DataBuilderFieldType = {
+    key: string;
+    type: "api-autocomplete";
+    onSave: (value: any, payload?: any) => void;
+    onSearch: (query: string, req: Request) => void;
+} | {
+    key: string;
+    type: "object";
+    onSave: (value: any, payload?: any) => void;
+    onSearch?: never;
+};
+export declare class DataBuilder {
+    private types;
+    private fieldTypes;
+    getType(key: string): DataBuilderType | null;
+    registerType(typeObj: DataBuilderType): this;
+    registerFieldType(key: string, options?: any): this;
+    registerModelType(key: string, model: any): this;
+    getFieldType(key: string): DataBuilderFieldType | null;
+    getFieldTypesFrontend(): any;
+    getFieldsFrontend(fields: any, payload?: any): Promise<any>;
+    getTypeFromRequest(req: any): DataBuilderType;
+    validateFields(fields: any, data: any, errors?: any, path?: string): Promise<any>;
+    typeForFrontend(type: any, req: any): Promise<any>;
+    loadType(req: Request): Promise<{
+        status: string;
+        data: any;
+    }>;
+    applyFields(fields: any, element: any, data: any, payload: any, path?: string): Promise<any>;
+    getAggregation(type: any, req: Request): Promise<{
+        $match: {
+            [x: number]: any;
+        };
+    }[]>;
+    save(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;
+    details(db: any, req: any): Promise<{
+        status: string;
+        data: any;
+    }>;
+    apiAutoComplete(req: any): Promise<{
+        status: string;
+        data: void;
+    }>;
+}

package/dist/DataBuilder/DataBuilder.js

@@ -0,0 +1,420 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataBuilder = void 0;
+const lodash_1 = __importDefault(require("lodash"));
+const Model_1 = require("../Database/Model");
+class DataBuilder {
+    constructor() {
+        this.types = {};
+        this.fieldTypes = {};
+    }
+    getType(key) {
+        return this.types[key] && this.types[key].key ? this.types[key] : null;
+    }
+    registerType(typeObj) {
+        this.types[typeObj.key] = typeObj;
+        return this;
+    }
+    registerFieldType(key, options) {
+        this.fieldTypes[key] = Object.assign(Object.assign({}, options), { key: key });
+        return this;
+    }
+    registerModelType(key, model) {
+        if (model &&
+            typeof model.__schema === "object" &&
+            model.__schema.fields &&
+            (Object.keys(model.__schema.fields).length > 0 || typeof model.__schema.fields === "function")) {
+            this.registerType({
+                key: key,
+                singular: model.__singular,
+                plural: model.__plural,
+                schema: Object.assign(Object.assign({}, model.__schema), { collection: key }),
+                forms: model.__forms,
+            });
+        }
+        return this;
+    }
+    getFieldType(key) {
+        return this.fieldTypes[key] && this.fieldTypes[key].key ? this.fieldTypes[key] : null;
+    }
+    getFieldTypesFrontend() {
+        const fieldtypes = {};
+        for (let key in this.fieldTypes) {
+            fieldtypes[key] = {
+                key: key,
+                type: this.fieldTypes[key].type,
+            };
+        }
+        return fieldtypes;
+    }
+    getFieldsFrontend(fields, payload) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const out = {};
+            for (let key in fields) {
+                if (fields[key].type === "object") {
+                    out[key] =
+                        typeof fields[key].schema === "object" && Object.keys(fields[key].schema).length > 0
+                            ? Object.assign({}, (yield this.getFieldsFrontend(fields[key].schema, payload))) : fields[key];
+                }
+                else {
+                    out[key] =
+                        typeof fields[key].schema === "object" && Object.keys(fields[key].schema).length > 0
+                            ? Object.assign(Object.assign({}, fields[key]), { schema: yield this.getFieldsFrontend(fields[key].schema, payload) }) : fields[key];
+                }
+                if (out[key].type === "option" && typeof fields[key].options === "function") {
+                    out[key].options = yield fields[key].options(payload);
+                }
+                if (out[key].disabled && typeof out[key].disabled === "function") {
+                    out[key].disabled = yield out[key].disabled(payload);
+                }
+            }
+            return out;
+        });
+    }
+    getTypeFromRequest(req) {
+        const type = req.body && req.body.__builder_type
+            ? this.getType(req.body.__builder_type)
+            : req.__builder_type
+                ? this.getType(req.__builder_type)
+                : null;
+        if (!type) {
+            throw new Error("Missing builder-type '" + (req.body && req.body.__builder_type ? req.body.__builder_type : req.__builder_type) + "' ...");
+        }
+        return type;
+    }
+    validateFields(fields, data, errors, path) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!errors) {
+                errors = {};
+            }
+            if (!fields || typeof fields !== "object") {
+                return errors;
+            }
+            for (let key in fields) {
+                const fieldPath = (path ? path + "." : "") + key;
+                const value = lodash_1.default.get(data, fieldPath);
+                if (fields[key].required) {
+                    let check = true;
+                    if (typeof fields[key].required === "function") {
+                        check = yield fields[key].required(data);
+                    }
+                    if (check) {
+                        if (value === null ||
+                            value === false ||
+                            value === undefined ||
+                            (Array.isArray(value) && value.length < 1) ||
+                            (!Array.isArray(value) && value.toString().trim() === "")) {
+                            errors[fieldPath] = "Dieses Feld muss ausgefüllt werden.";
+                            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);
+                        }
+                    }
+                }
+                if (fields[key].validation && fields[key].validation.trim() !== "") {
+                    // @ToDo
+                }
+            }
+            return errors;
+        });
+    }
+    typeForFrontend(type, req) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const newData = {};
+            for (let key in type) {
+                if (key === "forms") {
+                    newData.forms = {};
+                    if (typeof type.forms === "function") {
+                        newData.forms = yield type.forms(req);
+                    }
+                    for (let form in type.forms) {
+                        if (!type.forms[form] || !type.forms[form].fields || type.forms[form].fields.length < 1) {
+                            continue;
+                        }
+                        newData.forms[form] = {};
+                        if (typeof type.forms[form].pageActions === "function") {
+                            newData.forms[form].pageActions = yield type.forms[form].pageActions(req);
+                        }
+                        else if (type.forms[form].pageActions) {
+                            newData.forms[form].pageActions = JSON.parse(JSON.stringify(type.forms[form].pageActions));
+                        }
+                        if (typeof type.forms[form].backLink === "function") {
+                            newData.forms[form].backLink = yield type.forms[form].backLink(req);
+                        }
+                        if (typeof type.forms[form].fields === "function") {
+                            newData.forms[form].fields = yield type.forms[form].fields(req);
+                        }
+                        else if (type.forms[form].fields) {
+                            newData.forms[form].fields = JSON.parse(JSON.stringify(type.forms[form].fields));
+                        }
+                    }
+                }
+                else {
+                    newData[key] = type[key];
+                }
+            }
+            return newData;
+        });
+    }
+    loadType(req) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const type = this.getTypeFromRequest(req);
+            const data = Object.assign(Object.assign({}, (yield this.typeForFrontend(type, req))), { fieldtypes: this.getFieldTypesFrontend() });
+            return {
+                status: "success",
+                data: Object.assign(Object.assign({}, data), { schema: Object.assign(Object.assign({}, (data.schema ? data.schema : {})), { fields: yield this.getFieldsFrontend(type.schema
+                            ? typeof type.schema.fields === "function"
+                                ? yield type.schema.fields(req)
+                                : type.schema.fields
+                            : typeof type.fields === "function"
+                                ? yield type.fields(req)
+                                : type.fields, req) }) }),
+            };
+        });
+    }
+    applyFields(fields, element, data, payload, path) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (typeof fields !== "object" || !fields) {
+                return element;
+            }
+            for (let key in fields) {
+                if (!fields[key] || fields[key].unmapped) {
+                    continue;
+                }
+                const fieldPath = (path ? path + "." : "") + key;
+                const value = lodash_1.default.get(data, fieldPath);
+                const customType = this.getFieldType(fields[key].type);
+                if (typeof fields[key].schema === "object" && fields[key].type === "array") {
+                    lodash_1.default.set(element, fieldPath, []);
+                    if (value && value.length > 0) {
+                        for (let i in value) {
+                            const entryPath = fieldPath + "[" + i + "]";
+                            this.applyFields(fields[key].schema, element, data, payload, entryPath);
+                        }
+                    }
+                    if (customType && typeof customType.onSave === "function") {
+                        lodash_1.default.set(element, fieldPath, yield customType.onSave(lodash_1.default.get(element, fieldPath), Object.assign(Object.assign({}, payload), fields[key].payload)));
+                    }
+                }
+                else {
+                    lodash_1.default.set(element, fieldPath, value === undefined || value === null || (typeof value === "string" && value.trim() === "")
+                        ? null
+                        : customType && typeof customType.onSave === "function"
+                            ? yield customType.onSave(value, Object.assign(Object.assign({}, payload), fields[key].payload))
+                            : fields[key].type === "currency" || fields[key].type === "float"
+                                ? parseFloat(value.toString().replace(",", "."))
+                                : fields[key].type === "integer"
+                                    ? parseInt(value)
+                                    : value);
+                }
+            }
+            return element;
+        });
+    }
+    getAggregation(type, req) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return [
+                {
+                    $match: {
+                        [type.schema.primaryKey ? type.schema.primaryKey : "_id"]: type.schema.primaryKeyPlain
+                            ? req.body.__builder_id
+                            : yield Model_1.Model.objectId(req.body.__builder_id),
+                    },
+                },
+            ];
+        });
+    }
+    save(db, req) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!req || !req.body || typeof req.body !== "object" || !req.body.__builder_id || req.body.__builder_id.toString().trim() === "") {
+                throw new Error("Missing id ...");
+            }
+            if (typeof req.body.data !== "object") {
+                throw new Error("Missing id ...");
+            }
+            const type = this.getTypeFromRequest(req.body);
+            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 collection = type.schema && type.schema.collection ? type.schema.collection : undefined;
+            if (!collection || collection.trim() === "") {
+                throw new Error("Missing collection ...");
+            }
+            let element = null;
+            let updateId = null;
+            if (req.body.__builder_id === "new") {
+                element = {};
+                if (type.schema.primaryKey && type.schema.primaryKey.trim() !== "" && type.schema.primaryKey !== "_id") {
+                    element[type.schema.primaryKey] = type.schema.primaryKeyPlain
+                        ? req.body.__builder_id
+                        : yield Model_1.Model.objectId(req.body.builder_id);
+                }
+                element.__builder = {
+                    created_at: new Date(),
+                };
+            }
+            else {
+                const result = yield db
+                    .collection(collection)
+                    .aggregate(type.schema && typeof type.schema.getAggregation === "function"
+                    ? yield type.schema.getAggregation(yield this.getAggregation(type, req), req)
+                    : yield this.getAggregation(type, req), collection)
+                    .toArray();
+                if (!result || !result[0] || !result[0][type.schema.primaryKey ? type.schema.primaryKey : "_id"]) {
+                    throw new Error("Element '" + req.body.__builder_id + "' not found ...");
+                }
+                element = result[0];
+                updateId = result[0][type.schema.primaryKey ? type.schema.primaryKey : "_id"];
+            }
+            element = yield this.applyFields(schemaFields, element, req.body.data, req.body.payload);
+            if (!element.__builder) {
+                element.__builder = {};
+            }
+            element.__builder.version = type.schema.version;
+            element.__builder.collection = type.schema.collection;
+            element.__builder.updated_at = new Date();
+            try {
+                if (typeof type.schema.beforeSave === "function") {
+                    yield type.schema.beforeSave(element, req);
+                }
+            }
+            catch (e) {
+                throw e;
+            }
+            try {
+                if (typeof type.schema.afterSave === "function") {
+                    yield type.schema.afterSave(element, req);
+                }
+            }
+            catch (e) {
+                throw e;
+            }
+            let changedId = null;
+            if (updateId) {
+                delete element[type.schema.primaryKey ? type.schema.primaryKey : "_id"];
+                const status = yield db.collection(collection).updateOne({
+                    _id: type.schema.primaryKeyPlain ? updateId.toString() : yield Model_1.Model.objectId(updateId),
+                }, { $set: Object.assign({}, element) });
+                if (status && status.matchedCount) {
+                    changedId = updateId;
+                    element[type.schema.primaryKey ? type.schema.primaryKey : "_id"] = type.schema.primaryKeyPlain
+                        ? changedId.toString()
+                        : changedId;
+                }
+            }
+            else {
+                const status = yield db
+                    .collection(collection)
+                    .insertOne(Object.assign(Object.assign({}, element), { [type.schema.primaryKey ? type.schema.primaryKey : "_id"]: undefined }));
+                if (status && status.insertedId) {
+                    changedId = status.insertedId;
+                    element[type.schema.primaryKey ? type.schema.primaryKey : "_id"] = type.schema.primaryKeyPlain
+                        ? changedId.toString()
+                        : changedId;
+                }
+            }
+            let redirect = undefined;
+            if (type.forms && type.forms.main && type.forms.main.onSaveRedirect && typeof type.forms.main.onSaveRedirect === "function") {
+                redirect = yield type.forms.main.onSaveRedirect(element, req);
+            }
+            return {
+                status: "success",
+                data: {
+                    _id: changedId,
+                    redirect: redirect,
+                },
+            };
+        });
+    }
+    getField(req, type, path) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!path || path.trim() === "") {
+                return null;
+            }
+            const schemaFields = typeof type.schema.fields === "function" ? yield type.schema.fields(req) : type.schema.fields;
+            const field = lodash_1.default.get(schemaFields, this.removeArrayIndicators(path));
+            return field && field.type ? field : null;
+        });
+    }
+    removeArrayIndicators(str) {
+        return str.replace(/\[\d+\]/g, ".schema");
+    }
+    details(db, req) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!req.body.__builder_id || req.body.__builder_id.toString().trim() === "") {
+                throw new Error("Missing id ...");
+            }
+            const type = this.getTypeFromRequest(req);
+            if (!type || !type.schema || !type.schema.fields) {
+                throw new Error("Missing schema fields ...");
+            }
+            const collection = type.schema && type.schema.collection ? type.schema.collection : undefined;
+            let element = null;
+            try {
+                element = yield db
+                    .collection(collection)
+                    .aggregate(type.schema && typeof type.schema.getAggregation === "function"
+                    ? yield type.schema.getAggregation(yield this.getAggregation(type, req), req)
+                    : yield this.getAggregation(type, req), collection)
+                    .toArray();
+            }
+            catch (e) {
+                console.error(e);
+                throw e;
+            }
+            if (!element || !element[0] || !element[0][type.schema.primaryKey ? type.schema.primaryKey : "_id"]) {
+                throw new Error("Element '" + req.body.__builder_id + "' not found ...");
+            }
+            return {
+                status: "success",
+                data: element[0],
+            };
+        });
+    }
+    apiAutoComplete(req) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const type = this.getTypeFromRequest(req);
+            const field = req.body.__builder_field ? yield this.getField(req, type, req.body.__builder_field) : null;
+            if (!field) {
+                throw new Error("Invalid autocomplete field ...");
+            }
+            const fieldType = this.getFieldType(field.type);
+            if (!fieldType || !fieldType.key || fieldType.type !== "api-autocomplete" || !fieldType.onSearch) {
+                throw new Error("Invalid autocomplete field type '" + field.type + "' ...");
+            }
+            req.body.payload = Object.assign(Object.assign({}, req.body.payload), field.payload);
+            req.field = field;
+            return {
+                status: "success",
+                data: yield fieldType.onSearch(req.body.query, req),
+            };
+        });
+    }
+}
+exports.DataBuilder = DataBuilder;

package/dist/DataBuilder/DataBuilderController.d.ts

@@ -0,0 +1,9 @@
+import { Controller } from "../Controller/Controller";
+import { Request } from "../Router/Request";
+import { Response } from "../Router/Response";
+import { DataBuilder } from "./DataBuilder";
+export declare class DataBuilderController extends Controller {
+    builder: DataBuilder;
+    constructor(builder?: DataBuilder);
+    restApi(req: Request, res: Response): Promise<Response>;
+}

package/dist/DataBuilder/DataBuilderController.js

@@ -0,0 +1,43 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataBuilderController = void 0;
+const Controller_1 = require("../Controller/Controller");
+const DBConnection_1 = require("../Database/DBConnection");
+const DataBuilder_1 = require("./DataBuilder");
+class DataBuilderController extends Controller_1.Controller {
+    constructor(builder) {
+        super();
+        this.builder = builder ? builder : new DataBuilder_1.DataBuilder();
+    }
+    restApi(req, res) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const db = yield DBConnection_1.DBConnection.getConnection();
+            if (req.body.__builder_rest_api === "api-autocomplete") {
+                return res.send(yield this.builder.apiAutoComplete(req));
+            }
+            else if (req.body.__builder_rest_api === "details") {
+                return res.send(yield this.builder.details(db.client.db(null), req));
+            }
+            else if (req.body.__builder_rest_api === "save") {
+                return res.send(yield this.builder.save(db.client.db(null), req));
+            }
+            else if (req.body.__builder_rest_api === "type") {
+                return res.send(yield this.builder.loadType(req));
+            }
+            return res.status(404).send({
+                status: "error",
+                message: "Api-Endpoint not found ...",
+            });
+        });
+    }
+}
+exports.DataBuilderController = DataBuilderController;

package/dist/Database/DBConnection.d.ts

@@ -1,4 +1,7 @@
 import { QueryBuilder } from "./QueryBuilder";
+type ObjectIDType = {
+    noExceptions?: Boolean;
+};
 declare class DBConnectionFacade {
     connections: {
         [key: string]: any;
@@ -11,6 +14,7 @@ declare class DBConnectionFacade {
     }): Promise<any>;
     execute(data: any, connectionName?: string): Promise<any>;
     getDriver(connectionName?: string): Promise<any>;
+    objectId(val?: any, connectionName?: string, options?: ObjectIDType): Promise<any>;
     mapDataToModel(model: any, data: any): any;
 }
 export declare const DBConnection: DBConnectionFacade;

package/dist/Database/DBConnection.js

@@ -25,10 +25,7 @@ class DBConnectionFacade {
         if (!connection) {
             connection = dbconfig.defaultConnection;
         }
-        if (!connection ||
-            !dbconfig ||
-            !dbconfig.connections ||
-            !dbconfig.connections[connection]) {
+        if (!connection || !dbconfig || !dbconfig.connections || !dbconfig.connections[connection]) {
             throw new Error("No connection given ...");
         }
         return dbconfig.connections[connection];
@@ -55,8 +52,7 @@ class DBConnectionFacade {
             if (!connectionName) {
                 return null;
             }
-            if (this.connections[connectionName] &&
-                this.connections[connectionName].driver) {
+            if (this.connections[connectionName] && this.connections[connectionName].driver) {
                 // Use cached connection
                 return this.connections[connectionName];
             }
@@ -96,6 +92,22 @@ class DBConnectionFacade {
             return connection.driver;
         });
     }
+    objectId(val, connectionName, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (options && options.noExceptions) {
+                try {
+                    const connection = yield this.getConnection(connectionName);
+                    return yield connection.driver.objectId(val);
+                }
+                catch (e) {
+                    console.error(e);
+                }
+                return null;
+            }
+            const connection = yield this.getConnection(connectionName);
+            return yield connection.driver.objectId(val);
+        });
+    }
     mapDataToModel(model, data) {
         const obj = new model();
         if (data) {

package/dist/Database/Model.d.ts

@@ -1,4 +1,7 @@
 import { QueryBuilder } from "./QueryBuilder";
+type ObjectIDType = {
+    noExceptions?: Boolean;
+};
 export declare class Model {
     [key: string]: any | undefined;
     __primaryKey: string;
@@ -7,6 +10,8 @@ export declare class Model {
     __hidden: string[];
     __unmapped: string[];
     __unmappedSystem: string[];
+    static objectId(val?: any, options?: ObjectIDType): Promise<any>;
+    objectId(val?: any, options?: ObjectIDType): Promise<any>;
     /**
      * Creates a new query-builder object and adds a where-clause
      * @param column
@@ -68,3 +73,4 @@ export declare class Model {
      */
     delete(): Promise<boolean>;
 }
+export {};

package/dist/Database/Model.js

@@ -21,6 +21,17 @@ class Model {
         this.__unmapped = [];
         this.__unmappedSystem = ["__primaryKey", "__table", "__connection", "__unmapped", "__unmappedSystem", "__is_deleted", "__hidden"];
     }
+    static objectId(val, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const model = new this();
+            return yield DBConnection_1.DBConnection.objectId(val, model.__connection, options);
+        });
+    }
+    objectId(val, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield DBConnection_1.DBConnection.objectId(val, this.__connection, options);
+        });
+    }
     /**
      * Creates a new query-builder object and adds a where-clause
      * @param column