dbm 1.4.6 → 1.4.8

package/core/BaseObject.js

@@ -20,4 +20,39 @@ export default class BaseObject extends Dbm.core.LifeCycleObject {
 
         return this;
     }
+
+    _getScopedCallFunctionCommand(aFunction, aArguments = []) {
+        let CallFunction = Dbm.objectPath(Dbm.getRepositoryItem("library"), "Dbm/commands/CallFunction");
+        let command = new CallFunction();
+        command.item.scopeObject = this;
+        command.item.callFunction = aFunction;
+        command.item.callArguments = aArguments;
+
+        return command;
+    }
+
+    _propertyOrName(aPropertyOrName) {
+        if(typeof(aPropertyOrName) === "string") {
+            return this.item.properties[aPropertyOrName];
+        }
+
+        return aPropertyOrName;
+    }
+
+    addUpdateCall(aPropertyOrName, aFunction, aArguments = []) {
+        this._propertyOrName(aPropertyOrName).addUpdate(this._getScopedCallFunctionCommand(aFunction, aArguments));
+    }
+
+    addUpdateCallWhenMatched(aPropertyOrName, aMatchValue, aFunction, aArguments = []) {
+        console.log(this._propertyOrName(aPropertyOrName), aPropertyOrName, this);
+        this._propertyOrName(aPropertyOrName).addUpdateWhenMatched(aMatchValue, this._getScopedCallFunctionCommand(aFunction, aArguments));
+    }
+
+    destroy() {
+        if(this._item) {
+            //METODO: destroy item
+        }
+        this._item = null;
+        super.destroy();
+    }
 }

package/core/LifeCycleObject.js

@@ -19,7 +19,19 @@ export default class LifeCycleObject {
 
     }
 
-    destroy() {
+    retain() {
+        //METODO
+
+        return this;
+    }
+
+    release() {
         //METODO
     }
+
+    destroy() {
+        if(process.env.NODE_ENV === "development") {
+            this._debugId = null;
+        }
+    }
 }

package/dbm.js

@@ -6,7 +6,6 @@ export const setupGlobalInstance = function(aObject, aPath) {
     }
 }
 
-
 export const getInstance = function() {
     return globalThis.dbm;
 }
@@ -114,4 +113,5 @@ export * as startup from "./startup/index.js";
 export * as site from "./site/index.js";
 export * as tracking from "./tracking/index.js";
 export * as ecommerce from "./ecommerce/index.js";
-export * as node from "./node/index.js";
+export * as node from "./node/index.js";
+export * as form from "./form/index.js";

package/flow/ExternalObjectUpdater.js

@@ -0,0 +1,65 @@
+import Dbm from "../index.js";
+
+export default class ExternalObjectUpdater extends Dbm.core.BaseObject {
+    _construct() {
+        super._construct();
+
+        this.item.requireProperty("object", null);
+        this.item.requireProperty("updateFunctions", []);
+        this.item.requireProperty("running", true);
+
+        this.addUpdateCallWhenMatched("running", true, this.start);
+        this.addUpdateCallWhenMatched("running", false, this.stop);
+
+    }
+
+    get object() {
+        return this.item.object;
+    }
+
+    addProperty(aName, aValue, aPath = null) {
+        if(!aPath) {
+            aPath = aName;
+        }
+
+        let property = this.item.requireProperty(aName, null);
+        property.setOrConnect(aValue);
+        let updateFunction = Dbm.flow.updatefunctions.basic.setProperty(this.item.properties.object, aPath, property);
+        this.item.setValue("update/" + aName, updateFunction);
+        this.item.addToArray("updateFunctions", updateFunction);
+
+        if(this.item.running) {
+            updateFunction.output.properties.value.startUpdating();
+        }
+        
+        return property;
+    }
+
+    start() {
+        let currentArray = this.item.updateFunctions;
+        let currentArrayLength = currentArray.length;
+        for(let i = 0; i < currentArrayLength; i++) {
+            let updateFunction = currentArray[i];
+            updateFunction.output.properties.value.startUpdating();
+        }
+
+        return this;
+    }
+
+    stop() {
+        let currentArray = this.item.updateFunctions;
+        let currentArrayLength = currentArray.length;
+        for(let i = 0; i < currentArrayLength; i++) {
+            let updateFunction = currentArray[i];
+            updateFunction.output.properties.value.stopUpdating();
+        }
+
+        return this;
+    }
+
+    destroy() {
+        this.stop();
+
+        super.destroy();
+    }
+}

package/flow/FlowProperty.js

@@ -137,12 +137,12 @@ export default class FlowProperty extends Dbm.flow.FlowBaseObject {
     }
 
     startUpdating() {
-        Dbm.getInstance().repository.getItem("propertyUpdater").controller.addProperty(this);
+        Dbm.getRepositoryItem("propertyUpdater").controller.addProperty(this);
         return this;
     }
 
     stopUpdating() {
-        Dbm.getInstance().repository.getItem("propertyUpdater").controller.removeProperty(this);
+        Dbm.getRepositoryItem("propertyUpdater").controller.removeProperty(this);
         return this;
     }
 
@@ -155,4 +155,42 @@ export default class FlowProperty extends Dbm.flow.FlowBaseObject {
             this._upstreamConnection = null;
         }
     }
+
+    addUpdate(aCommand) {
+        let addUpdateCommand = Dbm.objectPath(Dbm.getRepositoryItem("library"), "Dbm/flow/addUpdateCommand");
+        addUpdateCommand(this, aCommand);
+
+        return this;
+    }
+
+    addUpdateWhenMatched(aMatchValue, aCommand) {
+        let addUpdateCommandWhenMatched = Dbm.objectPath(Dbm.getRepositoryItem("library"), "Dbm/flow/addUpdateCommandWhenMatched");
+        addUpdateCommandWhenMatched(this, aMatchValue, aCommand);
+
+        return this;
+    }
+
+    createCondition(aMatchValue, aCompareType = "===") {
+        let UpdateFunctionClass = Dbm.objectPath(Dbm.getRepositoryItem("library"), "Dbm/flow/updatefunctions/logic/Condition");
+        let updateFunction = new UpdateFunctionClass();
+        updateFunction.input.properties.input1.connectInput(this);
+        updateFunction.input.input2 = aMatchValue;
+        updateFunction.input.operation = aCompareType;
+
+        return updateFunction.output.properties.result;
+    }
+
+    createSwitch(aDefaultValue, aValues) {
+        let UpdateFunctionClass = Dbm.objectPath(Dbm.getRepositoryItem("library"), "Dbm/flow/updatefunctions/logic/Switch");
+        let updateFunction = new UpdateFunctionClass();
+        updateFunction.input.properties.value.connectInput(this);
+        updateFunction.setDefaultValue(aDefaultValue);
+
+        //METODO: do better normalization
+        for(let objectName in aValues) {
+            updateFunction.addCase(objectName, aValues[objectName]);
+        }
+
+        return updateFunction.output.properties.value;
+    }
 }

package/flow/index.js

@@ -7,6 +7,7 @@ export {default as UpdateFunctionInputs} from "./UpdateFunctionInputs.js";
 export {default as UpdateFunctionOutputs} from "./UpdateFunctionOutputs.js";
 export {default as DirtyCommands} from "./DirtyCommands.js";
 export {default as FlowPropertyWithExternalInput} from "./FlowPropertyWithExternalInput.js";
+export {default as ExternalObjectUpdater} from "./ExternalObjectUpdater.js";
 
 export * as updatefunctions from "./updatefunctions/index.js";
 export * as controllers from "./controllers/index.js";
@@ -17,7 +18,7 @@ export const addUpdateCommand = function(aProperty, aCommand) {
     updateFunction.input.command = aCommand;
     updateFunction.noFirstTriggger();
     
-    let updatePropertyCommand = Dbm.commands.callFunction(Dbm.getInstance().repository.getItem("propertyUpdater").controller.addSinglePropertyUpdateBound, [Dbm.core.source.staticObject(updateFunction.output.properties.value)]);
+    let updatePropertyCommand = Dbm.commands.callFunction(Dbm.repository.getControllerIfExists("propertyUpdater").addSinglePropertyUpdateBound, [Dbm.core.source.staticObject(updateFunction.output.properties.value)]);
 
     let dirtyCommands = new Dbm.flow.DirtyCommands();
     updateFunction.output.properties.value.connectOutput(dirtyCommands);
@@ -42,13 +43,13 @@ export const addDirectUpdateCommand = function(aProperty, aCommand) {
 }
 
 export const addUpdateCommandWhenMatched = function(aProperty, aMatchValue, aCommand) {
-	let whenMatched = Dbm.flow.updatefunctions.logic.whenMatched(aProperty, aMatchValue);
+	let matchUpdateFunction = Dbm.flow.updatefunctions.logic.whenMatched(aProperty, aMatchValue);
 	
-	let updateData = Dbm.flow.addUpdateCommand(whenMatched.output.properties.value, aCommand);
+	let updateData = Dbm.flow.addUpdateCommand(matchUpdateFunction.output.properties.value, aCommand);
 	
-	updateData["whenMatched"] = whenMatched;
+	updateData["matchUpdateFunction"] = matchUpdateFunction;
 	
-	return whenMatched;
+	return updateData;
 }
 
 export const runWhenMatched = function(aProperty, aMatchValue, aCommand) {
@@ -83,4 +84,12 @@ export const animateValue = function(aValue, aTime = 0.5, aEasing = null) {
 	returnObject.setValue("updateCommand", updateCommand);
 	
 	return returnObject;
+}
+
+export const externalObject = function(aObject) {
+    let returnObject = new Dbm.flow.ExternalObjectUpdater();
+
+    returnObject.item.properties.object.setOrConnect(aObject);
+
+    return returnObject;
 }

package/flow/updatefunctions/basic/SetProperty.js

@@ -0,0 +1,30 @@
+import Dbm from "../../../index.js";
+
+export default class SetProperty extends Dbm.flow.FlowUpdateFunction {
+
+    _construct() {
+        super._construct();
+        
+        this.input.register("value", "");
+        this.input.register("object", null);
+        this.input.register("propertyName", null);
+
+        this.output.register("value", null);
+    }
+
+    _update() {
+        //console.log("_update");
+
+        let value = this.input.value;
+
+        let propertyName = this.input.propertyName;
+        let object = this.input.object;
+
+        if(propertyName && object) {
+            Dbm.setAtObjectPath(object, propertyName, value);
+        }
+        
+        
+        this.output.value = value;
+    }
+}

package/flow/updatefunctions/basic/index.js

@@ -7,6 +7,7 @@ export {default as PropertyOf} from "./PropertyOf.js";
 export {default as PropertyOfWithDefault} from "./PropertyOfWithDefault.js";
 export {default as MappedList} from "./MappedList.js";
 export {default as Translation} from "./Translation.js";
+export {default as SetProperty} from "./SetProperty.js";
 
 export const runCommand = function(aValue, aCommand) {
 	let updateFunction = new Dbm.flow.updatefunctions.basic.RunCommand();
@@ -123,4 +124,15 @@ export const translationProperty = function(aId, aDefaultValue = null, aPath = n
 	let updateFunction = translation(aId, aDefaultValue, aPath, aAdditionalPath, aTranslations);
 
 	return updateFunction.output.properties.value;
+}
+
+export const setProperty = function(aObject, aPropertyName, aValue = null) {
+	let updateFunction = new Dbm.flow.updatefunctions.basic.SetProperty();
+
+	let properties = updateFunction.input.properties;
+	properties.value.setOrConnect(aValue);
+	properties.object.setOrConnect(aObject);
+	properties.propertyName.setOrConnect(aPropertyName);
+
+	return updateFunction;
 }

package/form/Field.js

@@ -0,0 +1,76 @@
+import Dbm from "../index.js";
+
+export default class Field extends Dbm.core.BaseObject {
+    _construct() {
+        super._construct();
+
+        let changeCommand = this._getScopedCallFunctionCommand(this._changed);
+        let focusChangedCommand = this._getScopedCallFunctionCommand(this._focusChanged);
+        let validationChangedCommand = this._getScopedCallFunctionCommand(this._validationActiveChange);
+
+        this.item.requireProperty("value", null).addUpdate(changeCommand);
+
+        let validation = new Dbm.form.validation.Validation();
+        validation.item.field = this.item;
+        validation.item.properties.active.addUpdate(validationChangedCommand);
+        validation.item.properties.validationFunction.addUpdate(validationChangedCommand);
+
+        this.item.requireProperty("validation", validation.item);
+        this.item.requireProperty("editing", false).addUpdate(focusChangedCommand);
+        this.item.requireProperty("valid", true);
+        this.item.requireProperty("validationState", "notValidated");
+        this.item.requireProperty("validationMode", null);
+        this.item.requireProperty("focusMode", "reset");
+    }
+
+    validate() {
+        if(this.item.validation.active) {
+            let newState = this.item.valid ? "valid" : "invalid";
+            this.item.validationState = newState;
+        }
+        else {
+            this.item.valid = true;
+            this.item.validationState = "notValidated";
+        }
+
+        return this.item.valid;
+    }
+
+    getValue() {
+        return this.item.value;
+    }
+
+    _validationActiveChange() {
+        //console.log("_validationActiveChange");
+        if(this.item.validation.active) {
+            this._changed();
+        }
+        else {
+            this.item.valid = true;
+            this.item.validationState = "notValidated";
+        }
+    }
+
+    _changed() {
+        //console.log("_changed");
+        this.item.valid = this.item.validation.controller.validate();
+
+        if(this.item.validationMode === "onChange") {
+            this.validate();
+        }
+    }
+
+    _focusChanged() {
+        //console.log("_focus");
+        if(this.item.editing) {
+            if(this.item.focusMode === "reset") {
+                this.item.validationState = "notValidated";
+            }
+        }
+        else {
+            if(this.item.validationMode === "onBlur") {
+                this.validate();
+            }
+        }
+    }
+}

package/form/Form.js

@@ -0,0 +1,87 @@
+import Dbm from "../index.js";
+
+export default class Form extends Dbm.core.BaseObject {
+    _construct() {
+        super._construct();
+
+        let all = Dbm.flow.updatefunctions.logic.all();
+        this.item.requireProperty("all", all);
+
+        this.item.requireProperty("valid", true).connectInput(all.output.properties.value);
+        this.item.requireProperty("fields", new Dbm.repository.Item());
+        this.item.requireProperty("fieldNames", []);
+        this.item.requireProperty("defaultValidationMode", "onBlur");
+    }
+
+    addExistingField(aName, aField) {
+        this.item.fields.setValue(aName, aField.item);
+        this.item.all.addCheck(aField.item.properties.valid);
+        this.item.addToArray("fieldNames", aName);
+
+        return this;
+    }
+
+    createField(aName, aValue = null, aValidationFunction = null, aValidationActive = null) {
+
+        if(this.item.fields[aName]) {
+            console.error("Field " + aName + " already exists");
+            return this.item.fields[aName].controller;
+        }
+
+        let newField = new Dbm.form.Field();
+        newField.item.value = aValue;
+        newField.item.validationMode = this.item.defaultValidationMode;
+        if(aValidationFunction) {
+            newField.item.validation.validationFunction = aValidationFunction;
+        }
+        if(aValidationActive) {
+            newField.item.validation.properties.active.setOrConnect(aValidationActive);
+        }
+
+        this.addExistingField(aName, newField);
+
+        return newField;
+    }
+
+    createGroup(aName) {
+        let newForm = new Dbm.form.Form();
+        newForm.item.defaultValidationMode = this.item.defaultValidationMode;
+
+        this.addExistingField(aName, newForm);
+
+        return newForm;
+    }
+
+    validate() {
+        console.log("validate");
+
+        let currentArray = this.item.fieldNames;
+        let currentArrayLength = currentArray.length;
+        for(let i = 0; i < currentArrayLength; i++) {
+            let currentName = currentArray[i];
+
+            let result = this.item.fields[currentName].controller.validate();
+
+            if(!result) {
+                console.log("Field " + currentName + " is not valid.", this.item.fields[currentName]);
+            }
+            //METODO: return the result in some format
+        }
+
+        return this.item.valid;
+    }
+
+    getValue() {
+        let returnObject = {};
+
+        let currentArray = this.item.fieldNames;
+        let currentArrayLength = currentArray.length;
+        for(let i = 0; i < currentArrayLength; i++) {
+            let currentName = currentArray[i];
+
+            returnObject[currentName] = this.item.fields[currentName].controller.getValue();
+        }
+
+        return returnObject;
+    }
+}

package/form/index.js

@@ -0,0 +1,6 @@
+import Dbm from "../index.js";
+
+export * as validation from "./validation/index.js";
+
+export {default as Form} from "./Form.js";
+export {default as Field} from "./Field.js";

package/form/validation/Validation.js

@@ -0,0 +1,23 @@
+import Dbm from "../../index.js";
+
+export default class Validation extends Dbm.core.BaseObject {
+    _construct() {
+        super._construct();
+
+        this.item.requireProperty("field", null);
+        this.item.requireProperty("active", true);
+        this.item.requireProperty("validationFunction", Dbm.form.validation.ValidationFunctions.noValidation);
+    }
+
+    validate() {
+        if(!this.item.active) {
+            return true;
+        }
+        let validationFunction = this.item.validationFunction;
+        return validationFunction(this.item);
+    }
+
+    static noValidation(aValidation) {
+        return true;
+    }
+}

package/form/validation/ValidationFunctions.js

@@ -0,0 +1,23 @@
+import Dbm from "../../index.js";
+
+export const noValidation = function(aValidation) {
+    return true;
+}
+
+export const notEmpty = function(aValidation) {
+    //console.log("notEmpty");
+
+    if(aValidation.field.value && aValidation.field.value.length > 0) {
+        return true;
+    }
+    return false;
+}
+
+export const checked = function(aValidation) {
+    //console.log("notEmpty");
+
+    if(aValidation.field.value) {
+        return true;
+    }
+    return false;
+}

package/form/validation/index.js

@@ -0,0 +1,4 @@
+import Dbm from "../../index.js";
+
+export {default as Validation} from "./Validation.js";
+export * as ValidationFunctions from "./ValidationFunctions.js";

package/graphapi/webclient/WebSocketConnection.js

@@ -294,7 +294,9 @@ export default class WebSocketConnection extends Dbm.core.BaseObject {
                 {
                     let item = repository.getItem(data["requestId"]);
                     if(data["id"]) {
-                        item.setValue("user", repository.getItem(data["id"]));
+                        let userItem = repository.getItem(data["user"]);
+                        userItem.setValue("roles", data["roles"]);
+                        item.setValue("user", userItem);
                     }
                     else {
                         item.setValue("user", null);
@@ -307,7 +309,9 @@ export default class WebSocketConnection extends Dbm.core.BaseObject {
             case "connectionReady": 
                 {
                     if(data["user"]) {
-                        repository.getItem("site").currentUser = repository.getItem(data["user"]);
+                        let userItem = repository.getItem(data["user"]);
+                        userItem.setValue("roles", data["roles"]);
+                        repository.getItem("site").currentUser = userItem;
                     }
                     else {
                         repository.getItem("site").currentUser = null;

package/loading/FontLoader.js

@@ -0,0 +1,47 @@
+import Dbm from "../index.js";
+
+export default class FontLoader extends Dbm.core.BaseObject {
+    constructor() {
+        super();
+
+        this._url = null;
+        this._fontName = null;
+        this._element = null;
+        this._promise = null;
+
+        this.item.setValue("status", Dbm.loading.LoadingStatus.NOT_STARTED);
+    }
+
+    setUrl(aUrl) {
+        this._url = aUrl;
+        return this;
+    }
+
+    setFontName(aFontName) {
+        this._fontName = aFontName;
+        return this;
+    }
+
+    load() {
+
+        if(!this._element) {
+            this.item.setValue("status", Dbm.loading.LoadingStatus.LOADING);
+
+            let element = document.createElement("link");
+            element.href = this._url;
+            element.rel = "stylesheet";
+
+            this._element = element;
+
+            document.head.appendChild(element);
+
+            this._promise = document.fonts.load("16px " + JSON.stringify(this._fontName));
+            this._promise.then(() => {
+                this.item.setValue("status", Dbm.loading.LoadingStatus.LOADED);
+            });
+            
+        }
+        
+        return this;
+    }
+}

package/loading/index.js

@@ -4,6 +4,7 @@ export {default as ScriptLoader} from "./ScriptLoader.js";
 export {default as JsonLoader} from "./JsonLoader.js";
 export {default as ImageLoader} from "./ImageLoader.js";
 export {default as LoadingSequence} from "./LoadingSequence.js";
+export {default as FontLoader} from "./FontLoader.js";
 
 export * as LoadingStatus from "./LoadingStatus.js";
 
@@ -52,5 +53,25 @@ export const loadImage = function(aUrl) {
     let loader = getImageLoader(aUrl);
     loader.load();
 
+    return loader;
+}
+
+export const loadFont = function(aUrl, aFontName) {
+    let loaderName = "loader-" + aUrl;
+    let loaderItem = Dbm.getInstance().repository.getItemIfExists(loaderName);
+    
+    let loader;
+    if(!loaderItem) {
+        loader = new Dbm.loading.FontLoader();
+        loader.item.register(loaderName);
+        loader.setUrl(aUrl);
+        loader.setFontName(aFontName);
+    }
+    else {
+        loader = loaderItem.controller;
+    }
+
+    loader.load();
+
     return loader;
 }

package/node/communication/PostmarkApiClient.js

@@ -33,6 +33,11 @@ export default class PostmarkApiClient extends Dbm.core.BaseObject {
 			TextBody: aMessageItem.textContent,
         };
 
+		let replyTo = Dbm.objectPath(aMessageItem, "additionalData.replyTo");
+		if(replyTo) {
+			emailData["ReplyTo"] = replyTo;
+		}
+
         let response = await fetch('https://api.postmarkapp.com/email', {
             method: 'POST',
             headers: {

package/node/communication/index.js

@@ -1,4 +1,6 @@
 import Dbm from "../../index.js";
+import fs from "node:fs";
+
 export {default as PostmarkApiClient} from "./PostmarkApiClient.js";
 export {default as EmailMessage} from "./EmailMessage.js";
 
@@ -22,17 +24,59 @@ export const createEmailAction = async function(aTo, aSubject, aHtmlContent, aTe
     return action;
 }
 
-export const sendUnformattedEmail = async function(aTo, aSubject, aBody, aFrom = null, aAdditionalData = null) {
+export const sendUnformattedEmail = function(aTo, aSubject, aBody, aFrom = null, aAdditionalData = null) {
     return createEmailAction(aTo, aSubject, null, aBody, aFrom, aAdditionalData);
 }
 
-export const sendEmail = async function(aTo, aSubject, aBody, aFrom = null, aAdditionalData = null) {
-
-    let textBody = aBody; //METODO: strip tags
+export const sendEmail = function(aTo, aSubject, aBody, aFrom = null, aAdditionalData = null) {
 
+    let textBody = null;
+    let textConverter = Dbm.repository.getControllerIfExists("htmlToTextConverter");
+    if(textConverter) {
+        textBody = textConverter.convertToText(aBody);
+    }
+    
     return createEmailAction(aTo, aSubject, aBody, textBody, aFrom, aAdditionalData);
 }
 
+export const sendEmailTemplate = async function(aTemplateIdentifer, aTo, aKeywordReplace, aLanguage = "default", aDesignFilePath = null, aFrom = null, aAdditionalData = null) {
+    let emailTemplate = await Dbm.node.getDatabase().getIdentifiableObjectIfExists("emailTemplate", aTemplateIdentifer);
+
+    if(emailTemplate) {
+        await Dbm.node.forAll(emailTemplate.loadFields(), emailTemplate.loadFieldTranslations("title", "content"));
+
+        let subject = aKeywordReplace.replaceKeywords(emailTemplate.getTranslatedFieldValue("title", aLanguage));
+        let content = aKeywordReplace.replaceKeywords(emailTemplate.getTranslatedFieldValue("content", aLanguage));
+
+        if(!aDesignFilePath) {
+            aDesignFilePath = Dbm.repository.getValueIfExists("emailDesigns", "default/" + aLanguage);
+
+            if(!aDesignFilePath && (aLanguage !== "default")) {
+                aDesignFilePath = Dbm.repository.getValueIfExists("emailDesigns", "default/default");
+            }
+        }
+
+        if(aDesignFilePath) {
+            //let assetsDir = Dbm.getInstance().repository.getItem("site").assetsDir;
+            let mailContent = await fs.promises.readFile(aDesignFilePath, 'utf8');
+
+            let designKeywordReplace = new Dbm.utils.KeywordReplace();
+            designKeywordReplace.addKeyword("subject", subject);
+            designKeywordReplace.addKeyword("content", content);
+            designKeywordReplace.addKeyword("language", (aLanguage !== "default") ? aLanguage : ""); //MENOTE: get default language
+
+            //MENOTE: should we have keywords from settings here
+
+            content = designKeywordReplace.replaceKeywords(mailContent);
+        }
+        
+        await sendEmail(aTo, subject, content, aFrom, aAdditionalData);
+    }
+    else {
+        console.warn("No email template " + aTemplateIdentifer);
+    }
+}
+
 export const createPostmarkClient = function(aToken, aDefaultFromEmail = null) {
     let client = new Dbm.node.communication.PostmarkApiClient();
 

package/node/index.js

@@ -4,3 +4,7 @@ export * as communication from "./communication/index.js";
 export const getDatabase = function() {
     return Dbm.getRepositoryItem("graphDatabase").controller;
 }
+
+export const forAll = function(...aPromises) {
+    return Promise.all(aPromises);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dbm",
-  "version": "1.4.6",
+  "version": "1.4.8",
   "main": "index.js",
   "type": "module",
   "exports": {

package/react/BaseObject.js

@@ -227,6 +227,33 @@ export default class BaseObject extends Component {
 
         return createElement.apply(null, callArray);
     }
+
+    _getScopedCallFunctionCommand(aFunction, aArguments = []) {
+        let CallFunction = Dbm.objectPath(Dbm.getRepositoryItem("library"), "Dbm/commands/CallFunction");
+        let command = new CallFunction();
+        command.item.scopeObject = this;
+        command.item.callFunction = aFunction;
+        command.item.callArguments = aArguments;
+
+        return command;
+    }
+
+    _propertyOrName(aPropertyOrName) {
+        if(typeof(aPropertyOrName) === "string") {
+            return this.item.properties[aPropertyOrName];
+        }
+
+        return aPropertyOrName;
+    }
+
+    addUpdateCall(aPropertyOrName, aFunction, aArguments = []) {
+        this._propertyOrName(aPropertyOrName).addUpdate(this._getScopedCallFunctionCommand(aFunction, aArguments));
+    }
+
+    addUpdateCallWhenMatched(aPropertyOrName, aMatchValue, aFunction, aArguments = []) {
+        console.log(this._propertyOrName(aPropertyOrName), aPropertyOrName);
+        this._propertyOrName(aPropertyOrName).addUpdateWhenMatched(aMatchValue, this._getScopedCallFunctionCommand(aFunction, aArguments));
+    }
 }
 
 BaseObject.contextType = Context;

package/react/area/SwitchableArea.js

@@ -27,7 +27,7 @@ export default class SwitchableArea extends Dbm.react.BaseObject {
             slotElement = mainChildren;
         }
 
-        this.item.element = React.createElement(React.Fragment, {key: slotElement}, slotElement);
+        this.item.element = React.createElement(React.Fragment, {key: area}, slotElement);
     }
 
     _renderMainElement() {

package/react/area/index.js

@@ -29,4 +29,15 @@ export const centeredFlexDiv = function(aChildren) {
     return React.createElement("div", {className: "flex-row justify-center"}, 
         React.createElement("div", {className: "flex-row-item"}, aChildren)
     );
+}
+
+export const processStateElement = function(aState, aIdleElement, aProcessingElement, aCompletedElement) {
+    let updateFunction = Dbm.flow.updatefunctions.logic.switchValue(aState);
+    updateFunction.setDefaultValue(aIdleElement);
+    updateFunction.addCase(Dbm.loading.LoadingStatus.LOADING, aProcessingElement);
+    updateFunction.addCase(Dbm.loading.LoadingStatus.LOADED, aCompletedElement);
+
+    let element = React.createElement(Dbm.react.area.InsertElement, {"element": updateFunction.output.properties.value});
+
+    return updateFunction;
 }

package/react/blocks/index.js

@@ -591,7 +591,25 @@ export let registerAllBlocks = function() {
         pageEditors.push(newEditor);
     }
 
+{
+        let objectTypeEditor = Dbm.getInstance().repository.getItem("admin/objectTypeEditors/emailTemplate");
+        if(!objectTypeEditor.editors) {
+            objectTypeEditor.setValue("editors", []);
+        }
+
+        let newArray = [].concat(objectTypeEditor.editors);
+        newArray.push(Dbm.getInstance().repository.getItem("admin/itemEditors/name"));
+        newArray.push(Dbm.getInstance().repository.getItem("admin/itemEditors/identifier"));
+        newArray.push(Dbm.getInstance().repository.getItem("admin/itemEditors/title"));
 
+        {
+            let itemEditor = new Dbm.repository.Item();
+            itemEditor.setValue("element", createElement(Dbm.react.admin.objects.itemeditors.RichTextFieldWithTranslations, {"label": "Content", "fieldName": "content"}));
+            newArray.push(itemEditor);
+        }
+        
+        objectTypeEditor.editors = newArray;
+    }
 
     admin.pageEditors = pageEditors;
 

package/react/form/FormField.js

@@ -6,9 +6,12 @@ export default class FormField extends Dbm.react.BaseObject {
         super._construct();
 
         this.getDynamicProp("value", "");
+        this.getDynamicPropWithoutState("editing", false);
         this.state["formUpdate"] = 0;
 
         this._callback_changeBound = this._callback_change.bind(this);
+        this._callback_focusBound = this._callback_focus.bind(this);
+        this._callback_blurBound = this._callback_blur.bind(this);
     }
 
     _callback_change(aEvent) {
@@ -21,11 +24,25 @@ export default class FormField extends Dbm.react.BaseObject {
         this.setState({"formUpdate": this.state.formUpdate}); //MENOTE: trigger change direct to not lose focus on input
     }
 
+    _callback_focus(aEvent) {
+        //console.log("_callback_focus");
+        //console.log(aEvent);
+
+        this.getDynamicProp("editing").getMostUpstreamProperty().setValue(true);
+    }
+
+    _callback_blur(aEvent) {
+        //console.log("_callback_blur");
+        //console.log(aEvent);
+
+        this.getDynamicProp("editing").getMostUpstreamProperty().setValue(false);
+    }
+
     _renderMainElement() {
 
         let value = this.getDynamicProp("value").value;
 
-        return this._createMainElement("input", {"value": value, onChange: this._callback_changeBound});
+        return this._createMainElement("input", {"value": value, onChange: this._callback_changeBound, onFocus: this._callback_focusBound, onBlur: this._callback_blurBound});
     }
 }
 

package/react/form/index.js

@@ -1,3 +1,6 @@
+import Dbm from "../../index.js";
+import React from "react";
+
 export {default as Checkbox} from "./Checkbox.js";
 export {default as FormField} from "./FormField.js";
 export {default as LabelledArea} from "./LabelledArea.js";
@@ -12,4 +15,26 @@ export {default as EditObjectProperty} from "./EditObjectProperty.js";
 export {default as Form} from "./Form.js";
 export {default as Option} from "./Option.js";
 export {default as Dropdown} from "./Dropdown.js";
-export {default as GraphApiObjectOptions} from "./GraphApiObjectOptions.js";
+export {default as GraphApiObjectOptions} from "./GraphApiObjectOptions.js";
+
+export const validationStateClassName = function(aChildren) {
+    return React.createElement(Dbm.react.AddProps, {className: Dbm.react.source.contextVariable("field.properties.validationState")},
+        aChildren
+    )
+}
+
+export const fieldWithValidation = function(aFieldName, aPlaceHolderText = null, aClasses = "standard-field standard-field-padding full-width") {
+    let returnElement = React.createElement(Dbm.react.context.AddItemToContext, {item: Dbm.react.source.contextVariable("form.fields." + aFieldName), as: "field"},
+        validationStateClassName(
+            React.createElement(Dbm.react.form.FormField, {
+                value: Dbm.react.source.contextVariable("field.properties.value"),
+                editing: Dbm.react.source.contextVariable("field.properties.editing"),
+                className: aClasses,
+                placeholder: aPlaceHolderText
+            })
+        )
+    )
+
+    return returnElement;
+}
+

package/repository/index.js

@@ -1,2 +1,25 @@
+import Dbm from "../index.js";
+
 export {default as Item} from "./Item.js";
-export {default as Repository} from "./Repository.js";
+export {default as Repository} from "./Repository.js";
+
+export const getItem = function(aName) {
+    return Dbm.getInstance().repository.getItem(aName);
+}
+
+export const getItemIfExists = function(aName) {
+    return Dbm.getInstance().repository.getItemIfExists(aName);
+}
+
+export const getValueIfExists = function(aObjectName, aPropertyName) {
+    let object = getItemIfExists(aObjectName);
+    if(!object) {
+        return null;
+    }
+
+    return Dbm.objectPath(object, aPropertyName);
+}
+
+export const getControllerIfExists = function(aObjectName) {
+    return getValueIfExists(aObjectName, "controller");
+}

package/startup/index.js

@@ -3,7 +3,7 @@ import Dbm from "../index.js";
 export {default as Runner} from "./Runner.js";
 export {default as Controller} from "./Controller.js";
 
-export let runStartup = function(aGlobalScope = "dbmstartup", aModulesName = "modules") {
+export const runStartup = function(aGlobalScope = "dbmstartup", aModulesName = "modules") {
     if(!window[aGlobalScope][aModulesName].isSetup) {
         let controller = new Dbm.startup.Controller();
 
@@ -25,4 +25,14 @@ export let runStartup = function(aGlobalScope = "dbmstartup", aModulesName = "mo
 
         currentArray.splice(0, currentArrayLength);
     }
+}
+
+export const setupLibrary = function() {
+    let library = Dbm.getRepositoryItem("library");
+    library.setValue("Dbm/commands/CallFunction", Dbm.commands.CallFunction);
+    library.setValue("Dbm/flow/addUpdateCommand", Dbm.flow.addUpdateCommand);
+    library.setValue("Dbm/flow/addUpdateCommandWhenMatched", Dbm.flow.addUpdateCommandWhenMatched);
+    library.setValue("Dbm/flow/updatefunctions/logic/Condition", Dbm.flow.updatefunctions.logic.Condition);
+    library.setValue("Dbm/flow/updatefunctions/logic/Switch", Dbm.flow.updatefunctions.logic.Switch);
+    
 }

package/tracking/Controller.js

@@ -120,7 +120,7 @@ export default class Controller extends Dbm.core.BaseObject {
         }
     }
 
-    trackEvent(aEventName, aData) {
+    trackEvent(aEventName, aData, aDataStructure = null) {
         console.log("trackEvent");
         console.log(aEventName, aData);
 
@@ -128,7 +128,7 @@ export default class Controller extends Dbm.core.BaseObject {
             let currentArray = this.item.trackers;
             let currentArrayLength = currentArray.length;
             for(let i = 0; i < currentArrayLength; i++) {
-                currentArray[i].controller.trackEvent(aEventName, aData);
+                currentArray[i].controller.trackEvent(aEventName, aData, aDataStructure);
             }
         }
 
@@ -184,7 +184,7 @@ export default class Controller extends Dbm.core.BaseObject {
             items: items
         }
 
-        this.trackEvent("Product view", data);
+        this.trackEvent("Product view", data, "ecommerce");
     }
 
     trackAddedToCart(aProductOrProducts) {
@@ -196,7 +196,7 @@ export default class Controller extends Dbm.core.BaseObject {
             items: items
         }
 
-        this.trackEvent("Added to cart", data);
+        this.trackEvent("Added to cart", data, "ecommerce");
 
     }
 
@@ -209,7 +209,7 @@ export default class Controller extends Dbm.core.BaseObject {
             items: items
         }
 
-        this.trackEvent("Checkout started", data);
+        this.trackEvent("Checkout started", data, "ecommerce");
     }
 
     trackAddShipping(aProductOrProducts) {
@@ -221,7 +221,7 @@ export default class Controller extends Dbm.core.BaseObject {
             items: items
         }
 
-        this.trackEvent("Add shipping", data);
+        this.trackEvent("Add shipping", data, "ecommerce");
     }
 
     trackAddPayment(aProductOrProducts) {
@@ -233,7 +233,7 @@ export default class Controller extends Dbm.core.BaseObject {
             items: items
         }
 
-        this.trackEvent("Add payment", data);
+        this.trackEvent("Add payment", data, "ecommerce");
     }
 
     trackPurchase(aTransactionId, aProductOrProducts) {
@@ -246,7 +246,7 @@ export default class Controller extends Dbm.core.BaseObject {
             items: items
         }
 
-        this.trackEvent("Purchase", data);
+        this.trackEvent("Purchase", data, "ecommerce");
     }
 
     createProductItemData(aId, aName, aPrice, aQuantity = 1, aAddtionalData = {}) {

package/tracking/DataLayerTracker.js

@@ -6,6 +6,9 @@ export default class DataLayerTracker extends Dbm.core.BaseObject {
 
 		this._statisticsTracking = false;
 		this._marketingTracking = false;
+
+		this.item.setValue("ecommerceDataWrapper", null);
+		this.item.setValue("eventNameMap", new Dbm.repository.Item());
     }
 
     addToDataLayer(aData) {
@@ -67,18 +70,34 @@ export default class DataLayerTracker extends Dbm.core.BaseObject {
 		return this;
 	}
 
-    trackEvent(aEventName, aData) {
+    trackEvent(aEventName, aData, aDataStructure = null) {
         console.log("trackEvent");
-        console.log(aEventName, aData);
+        console.log(aEventName, aData, aDataStructure);
+
+		let translatedEventName = this.item.eventNameMap[aEventName];
+		if(translatedEventName) {
+			aEventName = translatedEventName;
+		}
 
 		if(this._statisticsTracking) {
 			this.addToDataLayer({"event": "trackEvent", "value": {"name": aEventName, "data": aData}});
-			this._gtag("event", aEventName, aData);
+			if(aDataStructure === "ecommerce" && this.item.ecommerceDataWrapper) {
+				this.addToDataLayer({"event": aEventName, [this.item.ecommerceDataWrapper]: aData});
+			}
+			else {
+				this._gtag("event", aEventName, aData);
+			}
+			
 		}
 
         if(this._marketingTracking) {
 			this.addToDataLayer({"event": "trackMarketingEvent", "value": {"name": aEventName, "data": aData}});
-			this._gtag("event", "Marketing / " + aEventName, aData);
+			if(aDataStructure === "ecommerce" && this.item.ecommerceDataWrapper) {
+				this.addToDataLayer({"event": "Marketing / " + aEventName, [this.item.ecommerceDataWrapper]: aData});
+			}
+			else {
+				this._gtag("event", "Marketing / " + aEventName, aData);
+			}
 		}
     }
 

package/tracking/index.js

@@ -14,22 +14,24 @@ export const setup = function() {
     controller.start();
 
     let dataLayerTracker = new Dbm.tracking.DataLayerTracker();
+    dataLayerTracker.item.register("tracking/dataLayerTracker");
     controller.addTracker(dataLayerTracker.item);
 }
 
 export const addMetaPixel = function(aPixelId) {
     let tracker = new Dbm.tracking.MetaPixelTracker();
     tracker.item.pixelId = aPixelId;
-    Dbm.getInstance().repository.getItem("trackingController").controller.addTracker(tracker.item);
+    tracker.item.register("tracking/metaPixelTracker");
+    Dbm.getRepositoryItem("trackingController").controller.addTracker(tracker.item);
 }
 
 export const setCurrency = function(aCurrency) {
-    Dbm.getInstance().repository.getItem("trackingController").currency = aCurrency;
+    Dbm.getRepositoryItem("trackingController").currency = aCurrency;
 }
 
 export const addTagManagerTracking = function(aId) {
     //console.log("addTagManagerTracking");
     let tracker = new Dbm.tracking.TagManagerTracker();
     tracker.item.tagManagerId = aId;
-    Dbm.getInstance().repository.getItem("trackingController").controller.addTracker(tracker.item);
+    Dbm.getRepositoryItem("trackingController").controller.addTracker(tracker.item);
 }

package/utils/KeywordReplace.js

@@ -0,0 +1,102 @@
+import Dbm from "../index.js";
+
+export default class KeywordReplace extends Dbm.core.BaseObject {
+    
+    _construct() {
+		super._construct();
+
+        this.item.setValue("keywordStart", "{{");
+        this.item.setValue("keywordMatch", "[^\\{\\}]*");
+        this.item.setValue("keywordEnd", "}}");
+
+        this.item.setValue("keywordProviders", []);
+        this.addKeywordProvider("default", {});
+		
+		return this;
+	}
+	
+	addKeyword(aKeyword, aValue) {
+        this.item["keywordProvider/default"][aKeyword.toLowerCase()] = aValue;
+
+        return this;
+    }
+
+    addKeywordProvider(aName, aKeywordProvider) {
+        this.item.addToArray("keywordProviders", aKeywordProvider);
+        this.item.setValue("keywordProvider/" + aName.toLowerCase(), aKeywordProvider);
+
+        return this;
+    }
+
+    escapeRegex(aText) {
+        return aText.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    }
+
+    _getRegex() {
+        let keywordStart = this.escapeRegex(this.item.keywordStart);
+        let keywordEnd = this.escapeRegex(this.item.keywordEnd);
+
+        let regex = new RegExp(keywordStart + "\\s*(" + this.item.keywordMatch + ")\\s*" + keywordEnd, "g");
+
+        return regex;
+    }
+
+    _trimRegexKey(aRegexResult) {
+        let normalizedKey = aRegexResult[1].replace(/\s+/g, "").toLowerCase();
+        return normalizedKey;
+    }
+
+    findKeywords(aText) {
+
+        let regex = this._getRegex();
+
+        let keywords =  [...regex].map(this._trimRegexKey);
+
+        return keywords;
+    }
+
+    getKeywordValue(aKeyword) {
+
+        let index = aKeyword.indexOf(":");
+        if(index === -1) {
+            let currentArray = this.item.keywordProviders;
+            let currentArrayLength = currentArray.length;
+            for(let i = 0; i < currentArrayLength; i++) {
+                let provider = currentArray[i];
+                let value = Dbm.objectPath(provider, aKeyword);
+                if(value !== undefined) {
+                    return value;
+                }
+            }
+        }
+        else {
+            let group = aKeyword.substring(0, index);
+            let keyword = aKeyword.substring(index+1);
+
+            let value = Dbm.objectPath(this.item["keywordProvider/" + group.toLowerCase()], keyword.toLowerCase());
+            if(value !== undefined) {
+                return value;
+            }
+        }
+
+        return null;
+    }
+
+    _regexReplaceKeyword(aFullMatch, aKey) {
+        let normalizedKey = aKey.replace(/\s+/g, "");
+
+        let newValue = this.getKeywordValue(normalizedKey);
+        if(newValue) {
+            return newValue;
+        }
+
+        return aFullMatch;
+    }
+
+    replaceKeywords(aText) {
+        let newText = aText.replace(this._getRegex(), this._regexReplaceKeyword.bind(this));
+
+        console.log(newText);
+        return newText;
+    }
+}

package/utils/index.js

@@ -9,6 +9,7 @@ export * as ObjectFunctions from "./ObjectFunctions.js";
 
 export {default as MultidimensionalArrayHolder} from "./MultidimensionalArrayHolder.js";
 export {default as ArrayOperationResult} from "./ArrayOperationResult.js";
+export {default as KeywordReplace} from "./KeywordReplace.js";
 
 export * as thirdparty from "./thirdparty/index.js";
 export * as svg from "./svg/index.js";