dbm-graph-api 1.0.4 → 1.1.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dbm-graph-api",
-  "version": "1.0.4",
+  "version": "1.1.2",
   "main": "index.js",
   "type": "module",
   "scripts": {
@@ -11,12 +11,12 @@
   "license": "MIT",
   "description": "",
   "dependencies": {
-    "@aws-sdk/client-s3": "^3.693.0",
-    "@aws-sdk/s3-request-presigner": "^3.693.0",
-    "dbm": "^1.0.4",
+    "@aws-sdk/client-s3": "^3.741.0",
+    "@aws-sdk/s3-request-presigner": "^3.741.0",
+    "dbm": "^1.1.1",
     "ws": "^8.18.0"
   },
   "optionalDependencies": {
-    "bufferutil": "^4.0.8"
+    "bufferutil": "^4.0.9"
   }
 }

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

@@ -5,6 +5,7 @@ export default class UrlRequest extends Dbm.core.BaseObject {
     _construct() {
         super._construct();
 		
+		this._logs = [];
 		this._encodedObjects = [];
 		this._responseData = null;
 	}
@@ -30,15 +31,106 @@ export default class UrlRequest extends Dbm.core.BaseObject {
 	}
 	
 	async requestRange(aSelects, aEncodes, aData) {
-		//METODO
+
+		let request = {}; //METODO
+
+        request.connection = this;
+
+		let selectQuery = new DbmGraphApi.range.Query();
+		
+		let ids = [];
+		let logs = [];
+
+		{
+			let hasSelection = false;
+			let currentArray = aSelects;
+			let currentArrayLength = currentArray.length;
+			for(let i = 0; i < currentArrayLength; i++) {
+				let currentSelectData = currentArray[i];
+				let currentSelectType = currentSelectData["type"];
+				let selection = Dbm.getInstance().repository.getItemIfExists("graphApi/range/select/" + currentSelectType);
+				if(selection) {
+					hasSelection = true;
+					await selection.controller.select(selectQuery, currentSelectData, request);
+				}
+				else {
+					this._logs.push("No selection named " + currentSelectType);
+				}
+			}
+
+			if(hasSelection) {
+				ids = await selectQuery.getIds();
+
+				for(let i = 0; i < currentArrayLength; i++) {
+					let currentSelectData = currentArray[i];
+					let currentSelectType = currentSelectData["type"];
+					let selection = Dbm.getInstance().repository.getItemIfExists("graphApi/range/select/" + currentSelectType);
+					if(selection) {
+						ids = await selection.controller.filter(ids, currentSelectData, request);
+					}
+				}
+			}
+			else {
+				this._logs.push("No valid selections");
+			}
+			
+		}
+				
+		{
+			let encodeSession = new DbmGraphApi.range.EncodeSession();
+			encodeSession.outputController = this;
+
+			let currentArray = aEncodes;
+			let currentArrayLength = currentArray.length;
+			for(let i = 0; i < currentArrayLength; i++) {
+				let currentType = currentArray[i];
+				
+				await encodeSession.encode(ids, currentType);
+			}
+
+			encodeSession.destroy();
+		}
+
+		this._responseData = {"ids": ids};
 	}
 	
 	async requestItem(aId, aEncodes) {
-		//METODO
+		let encodeSession = new DbmGraphApi.range.EncodeSession();
+		encodeSession.outputController = this;
+
+		await encodeSession.encodeSingleWithTypes(aId, aEncodes);
+
+		encodeSession.destroy();
+
+		this._responseData = {"id": aId};
 	}
 	
 	async requestData(aFunctionName, aData) {
-		//METODO
+		let encodeSession = new DbmGraphApi.range.EncodeSession();
+		encodeSession.outputController = this;
+
+		let dataFunctionItem = Dbm.getInstance().repository.getItemIfExists("graphApi/data/" + aFunctionName);
+		
+		let returnData = null;
+		if(dataFunctionItem) {
+			returnData = await dataFunctionItem.controller.getData(aData, encodeSession);
+		}
+
+		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) {
@@ -49,6 +141,6 @@ export default class UrlRequest extends Dbm.core.BaseObject {
     }
 	
 	getResponse() {
-		return {"objects": this._encodedObjects, "data": this._responseData};
+		return {"objects": this._encodedObjects, "data": this._responseData, "logs": this._logs};
 	}
 }

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

@@ -54,6 +54,7 @@ export default class WebSocketConnection extends Dbm.core.BaseObject {
                 let selectQuery = new DbmGraphApi.range.Query();
                 
                 let ids = [];
+                let logs = [];
 
                 {
                     let hasSelection = false;
@@ -67,6 +68,9 @@ export default class WebSocketConnection extends Dbm.core.BaseObject {
                             hasSelection = true;
                             await selection.controller.select(selectQuery, currentSelectData, request);
                         }
+                        else {
+                            logs.push("No selection named " + currentSelectType);
+                        }
                     }
 
                     if(hasSelection) {
@@ -82,7 +86,7 @@ export default class WebSocketConnection extends Dbm.core.BaseObject {
                         }
                     }
                     else {
-                        //METODO: log error
+                        logs.push("No valid selections");
                     }
                     
                 }
@@ -102,7 +106,7 @@ export default class WebSocketConnection extends Dbm.core.BaseObject {
                     encodeSession.destroy();
                 }
                 
-                this._webSocket.send(JSON.stringify({"type": "range/response", "ids": ids, "requestId": data["requestId"]}));
+                this._webSocket.send(JSON.stringify({"type": "range/response", "ids": ids, "requestId": data["requestId"], "logs": logs}));
                 break;
             case "data":
                 {
@@ -119,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/UploadS3.js

@@ -12,7 +12,9 @@ export default class UploadS3 extends Dbm.core.BaseObject {
         this.item.requireProperty("bucketName");
         this.item.requireProperty("path", "content/{year}/{month}/{date}/{generatedId}/");
         this.item.requireProperty("publicPath", "");
+        this.item.requireProperty("publicResizePath", "");
         this.item.requireProperty("acl", "public-read");
+        this.item.requireProperty("additionalHeaders", {});
     }
 
     async getData(aData, aEncodeSession) {
@@ -58,9 +60,12 @@ export default class UploadS3 extends Dbm.core.BaseObject {
 
         let presignedUrl = await getSignedUrl(this.item.client, command, { expiresIn: 360 });
 
+        returnObject["identifier"] = generatedId;
         returnObject["url"] = presignedUrl;
         returnObject["publicUrl"] = this.item.publicPath + fileName;
+        returnObject["publicResizeUrl"] = this.item.publicResizePath + fileName;
         returnObject["acl"] = acl;
+        returnObject["additionalHeaders"] = this.item.additionalHeaders;
 
         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";
 
@@ -26,6 +27,30 @@ export let createDigitalOceanSpacesUpload = function(aKeyId, aSecret, aRegion, a
     newUploadS3.item.client = client;
     newUploadS3.item.bucketName = aBucketName;
     newUploadS3.item.publicPath = aPublicPath;
+    newUploadS3.item.publicResizePath = aPublicPath;
+
+    newUploadS3.item.additionalHeaders = {'x-amz-acl': 'public-read'};
+
+    return newUploadS3;
+}
+
+export let createCloudflareR2Upload = function(aAccountId, aAccessKeyId, aSecretAccessKeyId, aBucketName, aPublicPath) {
+
+    let client = new S3Client({
+        endpoint: "https://" + aAccountId + ".r2.cloudflarestorage.com",
+        forcePathStyle: false,
+        region: "auto",
+        credentials: {
+            accessKeyId: aAccessKeyId,
+            secretAccessKey: aSecretAccessKeyId
+        }
+    });
+
+    let newUploadS3 = new UploadS3();
+    newUploadS3.item.client = client;
+    newUploadS3.item.bucketName = aBucketName;
+    newUploadS3.item.publicPath = aPublicPath;
+    newUploadS3.item.publicResizePath = aPublicPath + "cdn-cgi/image/{scale}/";
 
     return newUploadS3;
 }

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/";
@@ -18,6 +21,18 @@ let fullSelectSetup = function() {
         let currentSelect = new DbmGraphApi.range.select.IdSelection();
         currentSelect.item.register(selectPrefix + name);
     }
+
+    {
+        let name = "byObjectType";
+        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};
@@ -72,6 +87,27 @@ let fullEncodeSetup = function() {
         currentEncode.item.register(encodePrefix + name);
         currentEncode.item.setValue("encodingType", name);
     }
+
+    {
+        let name = "breadcrumb";
+        let currentEncode = new DbmGraphApi.range.encode.Breadcrumb();
+        currentEncode.item.register(encodePrefix + name);
+        currentEncode.item.setValue("encodingType", name);
+    }
+
+    {
+        let name = "navigationName";
+        let currentEncode = new DbmGraphApi.range.encode.NavigationName();
+        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};
@@ -87,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();
 }
@@ -191,11 +260,80 @@ let setupEndpoints = function(aServer) {
 		return request.getResponse();
 	});
 
-    //METODO: setup ranges
+    aServer.get('/api/range/:selects/:encodes', async function handler (aRequest, aReply) {
+
+        let params = {...aRequest.query};
+        let selectIds = aRequest.params.selects.split(",");
+        let selects = new Array(selectIds.length);
+        let encodes = aRequest.params.encodes.split(",");
+
+        {
+            let currentArray = selectIds;
+            let currentArrayLength = currentArray.length;
+            for(let i = 0; i < currentArrayLength; i++) {
+                selects[i] = {...params, type: currentArray[i]};
+            }
+        }
+
+        let request = new UrlRequest();
+
+        await request.requestRange(selects, encodes, params);
+
+        return request.getResponse();
+    });
+
+    aServer.get('/api/item/:id/:encodes', async function handler (aRequest, aReply) {
+        
+        let itemId = 1*aRequest.params.id;
+        let encodes = aRequest.params.encodes.split(",");
+
+        let request = new UrlRequest();
+
+        await request.requestItem(itemId, encodes);
+
+        return request.getResponse();
+    });
+
+    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();
+
+        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 data
-    //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) {
@@ -22,10 +24,10 @@ export default class EncodeSession extends Dbm.core.BaseObject {
     }
 
     _encodeSingleNoAwait(aId, aType) {
-        console.log("_encodeSingleNoAwait");
+        //console.log("_encodeSingleNoAwait");
         
         let shouldEncode = this._readyToEncode(aId, aType);
-        console.log(shouldEncode, aId, aType);
+        //console.log(shouldEncode, aId, aType);
         if(shouldEncode) {
             let encoding = Dbm.getInstance().repository.getItemIfExists("graphApi/range/encode/" + aType);
             if(encoding) {
@@ -35,7 +37,7 @@ export default class EncodeSession extends Dbm.core.BaseObject {
     }
 
     async encodeSingle(aId, aType) {
-        console.log("encodeSingle");
+        //console.log("encodeSingle");
 
         await this._encodeSingleNoAwait(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

@@ -4,8 +4,22 @@ export default class Query extends Dbm.core.BaseObject {
     _construct() {
         super._construct();
 
+        this._joins = [];
+        this._whereStatements = [];
         this._includeOnly = null;
         this._visibilities = ["public"];
+        this._skipVisibility = false;
+    }
+
+    async setObjectType(aName) {
+        let database = Dbm.getInstance().repository.getItem("graphDatabase").controller;
+
+        let objectType = await database.getObjectType(aName);
+
+        this._joins.push("INNER JOIN ObjectTypesLink ON Objects.id = ObjectTypesLink.id");
+        this._whereStatements.push("ObjectTypesLink.type = " + objectType);
+
+        return this;
     }
 
     includeOnly(aIds) {
@@ -21,14 +35,58 @@ export default class Query extends Dbm.core.BaseObject {
 
     includeNone() {
         this._includeOnly = [];
+
+        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;
         
         let query = "SELECT Objects.id as id FROM Objects";
+
+        if(this._joins.length) {
+            query += " " + this._joins.join(" ");
+        }
         
-        let whereStatements = [];
+        let whereStatements = [].concat(this._whereStatements);
         if(this._includeOnly !== null) {
             if(this._includeOnly.length === 0) {
                 return [];
@@ -36,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 ");
@@ -53,4 +121,23 @@ export default class Query extends Dbm.core.BaseObject {
 
         return returnArray;
     }
+
+    async getObjects() {
+        let database = Dbm.getInstance().repository.getItem("graphDatabase").controller;
+        let ids = await this.getIds();
+
+        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/Breadcrumb.js

@@ -0,0 +1,50 @@
+import Dbm from "dbm";
+import EncodeBaseObject from "./EncodeBaseObject.js";
+
+export default class Breadcrumb extends EncodeBaseObject {
+    _construct() {
+        super._construct();
+    }
+
+    async getEncodedData(aId, aEncodingSession) {
+        console.log("Breadcrumb::getEncodedData");
+
+        let returnObject = {};
+
+        let database = Dbm.getInstance().repository.getItem("graphDatabase").controller;
+        let object = database.getObject(aId);
+
+        let url = await object.getUrl();
+        
+        if(url) {
+            let parts = url.split("/");
+            parts.pop(); //MENOTE: remove trailing slash
+            let ids = [];
+    
+            let currentArrayLength = parts.length;
+            for(let i = 0; i < currentArrayLength; i++) {
+                let currentUrl = parts.join("/") + "/";
+    
+                let currentObject = await database.getObjectByUrl(currentUrl);
+                if(currentObject) {
+                    await aEncodingSession.encodeSingle(currentObject.id, "title");
+                    await aEncodingSession.encodeSingle(currentObject.id, "url");
+                    await aEncodingSession.encodeSingle(currentObject.id, "navigationName");
+                    ids.push(currentObject.id);
+                }
+    
+                parts.pop();
+            }
+    
+            ids.reverse();
+    
+            returnObject["breadcrumbs"] = ids;
+        }
+        else {
+            returnObject["breadcrumbs"] = [];
+        }
+        
+
+        return returnObject;
+    }
+}

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

@@ -0,0 +1,20 @@
+import Dbm from "dbm";
+import EncodeBaseObject from "./EncodeBaseObject.js";
+
+export default class NavigationName extends EncodeBaseObject {
+    _construct() {
+        super._construct();
+    }
+
+    async getEncodedData(aId, aEncodingSession) {
+
+        let returnObject = {};
+
+        let object = Dbm.getInstance().repository.getItem("graphDatabase").controller.getObject(aId);
+
+        let fields = await object.getFields();
+        returnObject["navigationName"] = fields["navigationName"] ? fields["navigationName"] : null;
+
+        return returnObject;
+    }
+}

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/UrlRequest.js

@@ -16,6 +16,7 @@ export default class UrlRequest extends EncodeBaseObject {
         await aEncodingSession.encodeSingle(aId, "title");
         await aEncodingSession.encodeSingle(aId, "content");
         await aEncodingSession.encodeSingle(aId, "url");
+        await aEncodingSession.encodeSingle(aId, "navigationName");
 
         let fields = await object.getFields();
         returnObject["meta/description"] = fields["meta/description"] ? fields["meta/description"] : null;

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

@@ -6,4 +6,7 @@ export {default as Name} from "./Name.js";
 export {default as Content} from "./Content.js";
 export {default as Title} from "./Title.js";
 export {default as UrlRequest} from "./UrlRequest.js";
-export {default as Url} from "./Url.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 Type} from "./Type.js";

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

@@ -0,0 +1,22 @@
+import Dbm from "dbm";
+
+import SelectBaseObject from "./SelectBaseObject.js";
+
+export default class ByObjectType extends SelectBaseObject {
+    _construct() {
+        super._construct();
+    }
+
+    async select(aQuery, aData, aRequest) {
+
+        if(!aData["objectType"]) {
+            throw("Parameter objectType not set");
+        }
+
+        await aQuery.setObjectType(aData["objectType"]);
+    }
+
+    async filter(aIds, aData, aRequest) {
+        return aIds;
+    }
+}

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,2 +1,4 @@
 export {default as SelectBaseObject} from "./SelectBaseObject.js";
-export {default as IdSelection} from "./IdSelection.js";
+export {default as IdSelection} from "./IdSelection.js";
+export {default as ByObjectType} from "./ByObjectType.js";
+export {default as IncludePrivate} from "./IncludePrivate.js";