dbm-graph-api 1.1.1 → 1.1.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dbm-graph-api",
-  "version": "1.1.1",
+  "version": "1.1.2",
   "main": "index.js",
   "type": "module",
   "scripts": {
@@ -13,7 +13,7 @@
   "dependencies": {
     "@aws-sdk/client-s3": "^3.741.0",
     "@aws-sdk/s3-request-presigner": "^3.741.0",
-    "dbm": "^1.1.0",
+    "dbm": "^1.1.1",
     "ws": "^8.18.0"
   },
   "optionalDependencies": {

package/src/dbm-graph-api/UrlRequest.js

@@ -118,6 +118,20 @@ export default class UrlRequest extends Dbm.core.BaseObject {
 
 		this._responseData = returnData;
 	}
+
+	async performAction(aFunctionName, aData) {
+		let encodeSession = new DbmGraphApi.range.EncodeSession();
+		encodeSession.outputController = this;
+
+		let dataFunctionItem = Dbm.getInstance().repository.getItemIfExists("graphApi/action/" + aFunctionName);
+		
+		let returnData = null;
+		if(dataFunctionItem) {
+			returnData = await dataFunctionItem.controller.performAction(aData, encodeSession);
+		}
+
+		this._responseData = returnData;
+	}
 	
     outputEncodedData(aId, aData, aEncoding) {
         //console.log("UrlRequest::outputEncodedData");

package/src/dbm-graph-api/WebSocketConnection.js

@@ -123,6 +123,21 @@ export default class WebSocketConnection extends Dbm.core.BaseObject {
                     this._webSocket.send(JSON.stringify({"type": "data/response", "data": returnData, "requestId": data["requestId"]}));
                 }
                 break;
+            case "action":
+                {
+                    let encodeSession = new DbmGraphApi.range.EncodeSession();
+                    encodeSession.outputController = this;
+
+                    let dataFunctionItem = Dbm.getInstance().repository.getItemIfExists("graphApi/action/" + data['functionName']);
+                    
+                    let returnData = null;
+                    if(dataFunctionItem) {
+                        returnData = await dataFunctionItem.controller.performAction(data['data'], encodeSession);
+                    }
+
+                    this._webSocket.send(JSON.stringify({"type": "data/response", "data": returnData, "requestId": data["requestId"]}));
+                }
+                break;
             case "item":
                 {
                     let id = data['id'];

package/src/dbm-graph-api/action/Example.js

@@ -0,0 +1,15 @@
+import Dbm from "dbm";
+
+export default class Example extends Dbm.core.BaseObject {
+    _construct() {
+        super._construct();
+    }
+
+    async performAction(aData, aEncodeSession) {
+        let returnObject = {};
+
+        returnObject["example"] = "This is an example of an action";
+
+        return returnObject;
+    }
+}

package/src/dbm-graph-api/action/IncomingWebhook.js

@@ -0,0 +1,35 @@
+import Dbm from "dbm";
+
+export default class IncomingWebhook extends Dbm.core.BaseObject {
+    _construct() {
+        super._construct();
+    }
+
+    async performAction(aData, aEncodeSession) {
+        let returnObject = {};
+
+        let type = aData['type'];
+        let data = aData;
+
+        let database = Dbm.getInstance().repository.getItem("graphDatabase").controller;
+                
+        let webhookType = await database.getTypeObject("type/webhookType", type);
+
+        let incomingWebhook = await database.createObject("private", ["incomingWebhook"]);
+        await incomingWebhook.updateField("data", data);
+        await incomingWebhook.addIncomingRelation(webhookType, "for");
+        
+        let actionType = await database.getTypeObject("type/actionType", "incomingWebhook/" + type);
+        let actionStatus = await database.getTypeObject("status/actionStatus", "readyToProcess");
+        
+        let action = await database.createObject("private", ["action"]);
+        await action.addIncomingRelation(actionType, "for");
+        await action.addIncomingRelation(incomingWebhook, "from");
+        await action.addIncomingRelation(actionStatus, "for");
+
+        returnObject["id"] = incomingWebhook.id;
+        returnObject["action"] = action.id;
+
+        return returnObject;
+    }
+}

package/src/dbm-graph-api/action/cron/ProcessActions.js

@@ -0,0 +1,49 @@
+import Dbm from "dbm";
+
+export default class ProcessActions extends Dbm.core.BaseObject {
+    _construct() {
+        super._construct();
+    }
+
+    async performAction(aData, aEncodeSession) {
+        let returnObject = {};
+
+        let database = Dbm.getInstance().repository.getItem("graphDatabase").controller;
+
+        let actionStatus = await database.getTypeObject("status/actionStatus", "readyToProcess");
+        let actions = await actionStatus.objectRelationQuery("out:for:action");
+
+        if(actions.length) {
+            let action = actions[0];
+            returnObject["processed"] = action.id;
+
+            let processingActionStatus = await database.getTypeObject("status/actionStatus", "processing");
+            await action.replaceIncomingRelation(processingActionStatus, "for", "status/actionStatus");
+
+            let actionType = await (await action.singleObjectRelationQuery("in:for:type/actionType")).getIdentifier();
+            console.log(actionType);
+            
+            let processActionItem = Dbm.getInstance().repository.getItemIfExists("graphApi/procesAction/" + actionType);
+
+            if(processActionItem) {
+
+                await processActionItem.controller.process(action);
+
+                let doneActionStatus = await database.getTypeObject("status/actionStatus", "done");
+                await action.replaceIncomingRelation(doneActionStatus, "for", "status/actionStatus");
+            }
+            else {
+                let doneActionStatus = await database.getTypeObject("status/actionStatus", "noAction");
+                await action.replaceIncomingRelation(doneActionStatus, "for", "status/actionStatus");
+            }
+
+            returnObject["remaining"] = actions.length-1;
+        }
+        else {
+            returnObject["processed"] = 0;
+            returnObject["remaining"] = 0;
+        }
+
+        return returnObject;
+    }
+}

package/src/dbm-graph-api/action/cron/index.js

@@ -0,0 +1 @@
+export {default as ProcessActions} from "./ProcessActions.js";

package/src/dbm-graph-api/action/index.js

@@ -0,0 +1,4 @@
+export {default as Example} from "./Example.js";
+export {default as IncomingWebhook} from "./IncomingWebhook.js";
+
+export * as cron from "./cron/index.js";

package/src/dbm-graph-api/admin/edit/AddIncomingRelation.js

@@ -6,7 +6,7 @@ export default class AddIncomigRelation extends EditBaseObject {
         super._construct();
     }
 
-    performChange(aObject, aData, aRequest) {
-        aObject.addIncomingRelation(aData["value"], aData["type"]);
+    async performChange(aObject, aData, aRequest) {
+        await aObject.addIncomingRelation(aData["value"], aData["type"]);
     }
 }

package/src/dbm-graph-api/admin/edit/AddOutgoingRelation.js

@@ -6,7 +6,7 @@ export default class AddOutgoingRelation extends EditBaseObject {
         super._construct();
     }
 
-    performChange(aObject, aData, aRequest) {
-        aObject.addOutgoingRelation(aData["value"], aData["type"]);
+    async performChange(aObject, aData, aRequest) {
+        await aObject.addOutgoingRelation(aData["value"], aData["type"]);
     }
 }

package/src/dbm-graph-api/admin/edit/EditBaseObject.js

@@ -5,7 +5,7 @@ export default class EditBaseObject extends Dbm.core.BaseObject {
         super._construct();
     }
 
-    performChange(aObject, aData, aRequest) {
+    async performChange(aObject, aData, aRequest) {
         //MENOTE: should be overridden
     }
 }

package/src/dbm-graph-api/admin/edit/PurgeCache.js

@@ -0,0 +1,13 @@
+import Dbm from "dbm";
+import EditBaseObject from "./EditBaseObject.js";
+
+export default class PurgeCache extends EditBaseObject {
+    _construct() {
+        super._construct();
+    }
+
+    async performChange(aObject, aData, aRequest) {
+        let url = await aObject.getUrl();
+        console.log(url);
+    }
+}

package/src/dbm-graph-api/admin/edit/SetField.js

@@ -6,7 +6,7 @@ export default class SetField extends EditBaseObject {
         super._construct();
     }
 
-    performChange(aObject, aData, aRequest) {
-        aObject.updateField(aData["field"], aData["value"]);
+    async performChange(aObject, aData, aRequest) {
+        await aObject.updateField(aData["field"], aData["value"]);
     }
 }

package/src/dbm-graph-api/admin/edit/SetUrl.js

@@ -6,7 +6,7 @@ export default class SetUrl extends EditBaseObject {
         super._construct();
     }
 
-    performChange(aObject, aData, aRequest) {
-        aObject.setUrl(aData["value"]);
+    async performChange(aObject, aData, aRequest) {
+        await aObject.setUrl(aData["value"]);
     }
 }

package/src/dbm-graph-api/data/SeoSummary.js

@@ -0,0 +1,58 @@
+import Dbm from "dbm";
+
+export default class SeoSummary extends Dbm.core.BaseObject {
+    _construct() {
+        super._construct();
+    }
+
+    async getData(aData, aEncodeSession) {
+        let returnObject = {};
+
+        let content = aData["value"];
+        returnObject["content"] = content;
+
+        let database = Dbm.getInstance().repository.getItem("graphDatabase").controller;
+        let item = await database.createObject("private", ["aiGeneratedSeoSummary"]);
+        await item.updateField("content", content);
+        returnObject["id"] = item.id;
+
+        let contentString = JSON.stringify(content);
+
+        let instructions = "Generate an seo description for the page data provided by the user, with a max character count of 155. {additionalInstructions} Respond with only a json object {seoSummary: string}, no markdown.";
+        instructions = instructions.split("{data}").join(contentString);
+        
+        let additionalInstructions = "";
+        instructions = instructions.split("{additionalInstructions}").join(additionalInstructions);
+
+        let body = {
+            "model": "gpt-4o-mini",
+            "messages": [
+               {"role":"system","content": instructions},
+               {"role": "user", "content": contentString}
+           ],
+            "temperature": 0.7
+       }
+
+        let headers = {
+            "Content-Type": "application/json",
+            'Authorization': 'Bearer ' + Dbm.getInstance().repository.getItem("openAi").token
+        }
+        
+        let response = await fetch('https://api.openai.com/v1/chat/completions', {
+            method: "POST",
+            headers: headers,
+            body: JSON.stringify(body),
+        });
+
+        let data = await response.json();
+        await item.updateField("response", data);
+
+        let message = data.choices[0].message;
+        let responseContent = JSON.parse(message.content);
+        console.log(responseContent);
+        
+        returnObject["seoSummary"] = responseContent["seoSummary"];
+        
+        return returnObject;
+    }
+}

package/src/dbm-graph-api/data/index.js

@@ -1,6 +1,7 @@
 export {default as Example} from "./Example.js";
 export {default as UploadS3} from "./UploadS3.js";
 export {default as FreeUrl} from "./FreeUrl.js";
+export {default as SeoSummary} from "./SeoSummary.js";
 
 import UploadS3 from "./UploadS3.js";
 

package/src/dbm-graph-api/index.js

@@ -1,5 +1,6 @@
 import Dbm from "dbm";
 import crypto from "node:crypto";
+import url from "node:url";
 
 import DbmGraphApi from "../../index.js";
 import Api from "./Api.js";
@@ -10,6 +11,8 @@ export {Api};
 export * as range from "./range/index.js";
 export * as admin from "./admin/index.js";
 export * as data from "./data/index.js";
+export * as action from "./action/index.js";
+export * as processAction from "./processAction/index.js";
 
 let fullSelectSetup = function() {
     let selectPrefix = "graphApi/range/select/";
@@ -24,6 +27,12 @@ let fullSelectSetup = function() {
         let currentSelect = new DbmGraphApi.range.select.ByObjectType();
         currentSelect.item.register(selectPrefix + name);
     }
+
+    {
+        let name = "includePrivate";
+        let currentSelect = new DbmGraphApi.range.select.IncludePrivate();
+        currentSelect.item.register(selectPrefix + name);
+    }
 }
 
 export {fullSelectSetup};
@@ -92,6 +101,13 @@ let fullEncodeSetup = function() {
         currentEncode.item.register(encodePrefix + name);
         currentEncode.item.setValue("encodingType", name);
     }
+
+    {
+        let name = "type";
+        let currentEncode = new DbmGraphApi.range.encode.Type();
+        currentEncode.item.register(encodePrefix + name);
+        currentEncode.item.setValue("encodingType", name);
+    }
 }
 
 export {fullEncodeSetup};
@@ -107,15 +123,48 @@ export let registerDataFunction = function(aName, aDataFunction) {
 let fullDataSetup = function() {
     registerDataFunction("example", new DbmGraphApi.data.Example());
     registerDataFunction("admin/freeUrl", new DbmGraphApi.data.FreeUrl());
+    registerDataFunction("admin/seoSummary", new DbmGraphApi.data.SeoSummary());
 }
 
 export {fullDataSetup};
 
+export let registerActionFunction = function(aName, aDataFunction) {
+
+    aDataFunction.item.register("graphApi/action/" + aName);
+    aDataFunction.item.setValue("functionName", aName);
+
+    return aDataFunction;
+}
+
+let fullActionSetup = function() {
+    registerActionFunction("example", new DbmGraphApi.action.Example());
+    registerActionFunction("incomingWebhook", new DbmGraphApi.action.IncomingWebhook());
+    registerActionFunction("cron/processActions", new DbmGraphApi.action.cron.ProcessActions());
+}
+
+export {fullActionSetup};
+
+export let registerProcessActionFunction = function(aName, aDataFunction) {
+
+    aDataFunction.item.register("graphApi/processAction/" + aName);
+    aDataFunction.item.setValue("functionName", aName);
+
+    return aDataFunction;
+}
+
+let fullProcessActionSetup = function() {
+    registerProcessActionFunction("example", new DbmGraphApi.processAction.Example());
+}
+
+export {fullProcessActionSetup};
+
 let fullSetup = function() {
 
     fullSelectSetup();
     fullEncodeSetup();
     fullDataSetup();
+    fullActionSetup();
+    fullProcessActionSetup()
     
     DbmGraphApi.admin.edit.fullSetup();
 }
@@ -245,18 +294,46 @@ let setupEndpoints = function(aServer) {
         return request.getResponse();
     });
 
-    aServer.get('/api/data/:functionName', async function handler (aRequest, aReply) {
+    aServer.get('/api/data/*', async function handler (aRequest, aReply) {
+        let params = {...aRequest.query};
+        let request = new UrlRequest();
+
+        let currentUrl = url.parse(aRequest.url);
+        let functionName = currentUrl.pathname.substring("/api/data/".length);
+
+        await request.requestData(functionName, params);
+
+        return request.getResponse();
+    });
+
+    aServer.get('/api/action/*', async function handler (aRequest, aReply) {
+        
         let params = {...aRequest.query};
         let request = new UrlRequest();
 
-        await request.requestData(aRequest.params.functionName, params);
+        let currentUrl = url.parse(aRequest.url);
+        let functionName = currentUrl.pathname.substring("/api/action/".length);
+
+        await request.performAction(functionName, params);
 
         return request.getResponse();
     });
 
+    aServer.post('/api/action/*', async function handler (aRequest, aReply) {
+        let params = {...aRequest.body};
+        let request = new UrlRequest();
+
+        let currentUrl = url.parse(aRequest.url);
+        let functionName = currentUrl.pathname.substring("/api/action/".length);
+
+        await request.performAction(functionName, params);
+
+        return request.getResponse();
+    });
+
+    //METODO: setup raw data posts
+
     //METODO: setup edit
-    //METODO: setup actions
-    //METODO: setup cron
 
     aServer.get('/api/', async function handler (aRequest, aResponse) {
 		return { version: Dbm.getInstance().repository.getItem("site").version };

package/src/dbm-graph-api/processAction/Example.js

@@ -0,0 +1,11 @@
+import Dbm from "dbm";
+
+export default class Example extends Dbm.core.BaseObject {
+    _construct() {
+        super._construct();
+    }
+
+    async process(aAction) {
+        
+    }
+}

package/src/dbm-graph-api/processAction/index.js

@@ -0,0 +1 @@
+export {default as Example} from "./Example.js";

package/src/dbm-graph-api/range/EncodeSession.js

@@ -6,6 +6,8 @@ export default class EncodeSession extends Dbm.core.BaseObject {
 
         this._encodings = {};
         this.outputController = null;
+
+        //METODO: add cache of database objects
     }
 
     _readyToEncode(aId, aType) {
@@ -54,7 +56,6 @@ export default class EncodeSession extends Dbm.core.BaseObject {
     async encode(aIds, aType) {
         let currentArray = aIds;
         let currentArrayLength = currentArray.length;
-        let ids = new Array(currentArrayLength);
         let promises = new Array(currentArrayLength);
         for(let i = 0; i < currentArrayLength; i++) {
             let id = currentArray[i];
@@ -63,7 +64,7 @@ export default class EncodeSession extends Dbm.core.BaseObject {
 
         await Promise.all(promises);
 
-        return ids;
+        return aIds;
     }
 
     async encodeObjectOrNull(aObject, aType) {

package/src/dbm-graph-api/range/Query.js

@@ -8,6 +8,7 @@ export default class Query extends Dbm.core.BaseObject {
         this._whereStatements = [];
         this._includeOnly = null;
         this._visibilities = ["public"];
+        this._skipVisibility = false;
     }
 
     async setObjectType(aName) {
@@ -38,6 +39,44 @@ export default class Query extends Dbm.core.BaseObject {
         return this;
     }
 
+    includePrivate() {
+        this._visibilities.push("private");
+
+        return this;
+    }
+
+    includeDraft() {
+        this._visibilities.push("draft");
+
+        return this;
+    }
+
+    includeAnyStatus() {
+        this._skipVisibility = true;
+
+        return this;
+    }
+
+    addFieldQuery(aKey, aValue) {
+
+        let database = Dbm.getInstance().repository.getItem("graphDatabase").controller;
+
+        this._joins.push("INNER JOIN Fields ON Objects.id = Fields.object");
+        this._whereStatements.push("Fields.name = " + database.connection.escape(aKey));
+        this._whereStatements.push("Fields.value = " + database.connection.escape(JSON.stringify(aValue)));
+
+        return this;
+    }
+
+    withIdentifier(aIdentifier) {
+        let database = Dbm.getInstance().repository.getItem("graphDatabase").controller;
+
+        this._joins.push("INNER JOIN Identifiers ON Objects.id = Identifiers.object");
+        this._whereStatements.push("Identifiers.identifier = " + database.connection.escape(aIdentifier));
+
+        return this;
+    }
+
     async getIds() {
         let database = Dbm.getInstance().repository.getItem("graphDatabase").controller;
         
@@ -55,7 +94,17 @@ export default class Query extends Dbm.core.BaseObject {
             whereStatements.push("Objects.id IN (" + this._includeOnly.join(",") + ")");
         }
 
-        //METODO: include visibility
+        if(!this._skipVisibility) {
+            let visibilityIds = [];
+            let currentArray = this._visibilities;
+            let currentArrayLength = currentArray.length;
+            for(let i = 0; i < currentArrayLength; i++) {
+                let currentId = await database.getVisibilityType(currentArray[i]);
+                visibilityIds.push(currentId);
+            }
+
+            whereStatements.push("Objects.visibility IN (" + visibilityIds.join(",") + ")");
+        }
 
         if(whereStatements.length) {
             query += " WHERE " + whereStatements.join(" AND ");
@@ -79,4 +128,16 @@ export default class Query extends Dbm.core.BaseObject {
 
         return database.getObjects(ids);
     }
+
+    async getObject() {
+        let database = Dbm.getInstance().repository.getItem("graphDatabase").controller;
+        let ids = await this.getIds();
+
+        if(ids.length) {
+            //METODO: warning if more than 1
+            return database.getObject(ids[0]);
+        }
+
+        return null;
+    }
 }

package/src/dbm-graph-api/range/encode/Type.js

@@ -0,0 +1,20 @@
+import Dbm from "dbm";
+import EncodeBaseObject from "./EncodeBaseObject.js";
+
+export default class Type extends EncodeBaseObject {
+    _construct() {
+        super._construct();
+    }
+
+    async getEncodedData(aId, aEncodingSession) {
+
+        let returnObject = {};
+
+        let object = Dbm.getInstance().repository.getItem("graphDatabase").controller.getObject(aId);
+
+        await aEncodingSession.encodeSingle(aId, "identifier");
+        await aEncodingSession.encodeSingle(aId, "name");
+
+        return returnObject;
+    }
+}

package/src/dbm-graph-api/range/encode/index.js

@@ -8,4 +8,5 @@ export {default as Title} from "./Title.js";
 export {default as UrlRequest} from "./UrlRequest.js";
 export {default as Url} from "./Url.js";
 export {default as Breadcrumb} from "./Breadcrumb.js";
-export {default as NavigationName} from "./NavigationName.js";
+export {default as NavigationName} from "./NavigationName.js";
+export {default as Type} from "./Type.js";

package/src/dbm-graph-api/range/select/ByObjectType.js

@@ -8,6 +8,11 @@ export default class ByObjectType extends SelectBaseObject {
     }
 
     async select(aQuery, aData, aRequest) {
+
+        if(!aData["objectType"]) {
+            throw("Parameter objectType not set");
+        }
+
         await aQuery.setObjectType(aData["objectType"]);
     }
 

package/src/dbm-graph-api/range/select/IdSelection.js

@@ -8,7 +8,7 @@ export default class IdSelection extends SelectBaseObject {
     }
 
     async select(aQuery, aData, aRequest) {
-        aQuery.includeOnly(aData["ids"]);
+        aQuery.includeOnly(Dbm.utils.ArrayFunctions.arrayOrSeparatedString(aData["ids"]));
     }
 
     async filter(aIds, aData, aRequest) {

package/src/dbm-graph-api/range/select/IncludePrivate.js

@@ -0,0 +1,18 @@
+import Dbm from "dbm";
+
+import SelectBaseObject from "./SelectBaseObject.js";
+
+export default class IncludePrivate extends SelectBaseObject {
+    _construct() {
+        super._construct();
+    }
+
+    async select(aQuery, aData, aRequest) {
+        //METODO: check that we are allowed
+        aQuery.includePrivate();
+    }
+
+    async filter(aIds, aData, aRequest) {
+        return aIds;
+    }
+}

package/src/dbm-graph-api/range/select/index.js

@@ -1,3 +1,4 @@
 export {default as SelectBaseObject} from "./SelectBaseObject.js";
 export {default as IdSelection} from "./IdSelection.js";
-export {default as ByObjectType} from "./ByObjectType.js";
+export {default as ByObjectType} from "./ByObjectType.js";
+export {default as IncludePrivate} from "./IncludePrivate.js";