dbm-graph-api 1.0.3 → 1.1.1

package/package.json

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

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

@@ -49,7 +49,7 @@ export default class Api extends Dbm.core.BaseObject {
                     let user = Dbm.getInstance().repository.getItem("graphDatabase").controller.getUser(userId);
     
                     user.verifySession(value).then(function(aIsValidSession) {
-                        console.log("verifySession", aIsValidSession);
+                        //console.log("verifySession", aIsValidSession);
     
                         if(aIsValidSession) {
                             newWebSocketConnection.setInitialUser(userId);
@@ -69,4 +69,15 @@ export default class Api extends Dbm.core.BaseObject {
             newWebSocketConnection.setInitialUser(0);
         }
     }
+	
+	connectionClosed(aConnection) {
+		//console.log("connectionClosed");
+		let connections = [].concat(this.item.connections);
+		let index = connections.indexOf(aConnection.item);
+		if(index >= 0) {
+			connections.splice(index, 1);
+		}
+		
+		this.item.setValue("connections", connections);
+	}
 }

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,25 +31,102 @@ 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;
 	}
 	
     outputEncodedData(aId, aData, aEncoding) {
-        console.log("UrlRequest::outputEncodedData");
+        //console.log("UrlRequest::outputEncodedData");
 		
 		this._encodedObjects.push({"id": aId, "data": aData, "encoding": aEncoding});
 		
     }
 	
 	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

@@ -8,6 +8,7 @@ export default class WebSocketConnection extends Dbm.core.BaseObject {
 
         this._callback_errorBound = this._callback_error.bind(this);
         this._callback_messageBound = this._callback_message.bind(this);
+		this._callback_closeBound = this._callback_close.bind(this);
     }
 
     setWebSocket(aWebSocket) {
@@ -32,7 +33,7 @@ export default class WebSocketConnection extends Dbm.core.BaseObject {
     }
 
     async _callback_message(aDataString) {
-        console.log('received: %s', aDataString);
+        //console.log('received: %s', aDataString);
     
         let data;
 
@@ -53,6 +54,7 @@ export default class WebSocketConnection extends Dbm.core.BaseObject {
                 let selectQuery = new DbmGraphApi.range.Query();
                 
                 let ids = [];
+                let logs = [];
 
                 {
                     let hasSelection = false;
@@ -66,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) {
@@ -81,7 +86,7 @@ export default class WebSocketConnection extends Dbm.core.BaseObject {
                         }
                     }
                     else {
-                        //METODO: log error
+                        logs.push("No valid selections");
                     }
                     
                 }
@@ -101,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":
                 {
@@ -225,25 +230,52 @@ export default class WebSocketConnection extends Dbm.core.BaseObject {
 
                     this._webSocket.send(JSON.stringify({"type": "currentUser/response", "id": userId, "requestId": data["requestId"]}));
                     
+                }
+                break;
+            case "heartbeat":
+                {
+                    this._webSocket.send(JSON.stringify({"type": "heartbeat/response"}));
+                    
                 }
                 break;
         }	
     }
 
     _callback_error(aMessage) {
+		console.log("_callback_error");
         console.error(aMessage);
     }
+	
+    _callback_close() {
+		//console.log("_callback_close");
+		
+		if(this._webSocket) {
+			this._webSocket.off('error', this._callback_error);
+			this._webSocket.off('message', this._callback_messageBound);
+			this._webSocket.off('close', this._callback_closeBound);
+			this._webSocket = null;
+		}
+		
+		this._callback_errorBound = null;
+		this._callback_messageBound = null;
+		this._callback_closeBound = null;
+		
+		this.item.api.controller.connectionClosed(this);
+		this.item.setValue("api", null);
+		this.item.setValue("controller", null);
+	}
 
     addListeners() {
 
         this._webSocket.on('error', this._callback_error);
         this._webSocket.on('message', this._callback_messageBound);
+		this._webSocket.on('close', this._callback_closeBound);
 
         return this;
     }
 
     outputEncodedData(aId, aData, aEncoding) {
-        console.log("WebSocketConnection::outputEncodedData");
+        //console.log("WebSocketConnection::outputEncodedData");
 
         this._webSocket.send(JSON.stringify({"type": "updateEncodedObject", "id": aId, "data": aData, "encoding": aEncoding}));
         

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

@@ -26,6 +26,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

@@ -18,6 +18,12 @@ 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);
+    }
 }
 
 export {fullSelectSetup};
@@ -72,6 +78,20 @@ 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);
+    }
 }
 
 export {fullEncodeSetup};
@@ -191,9 +211,50 @@ 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/:functionName', async function handler (aRequest, aReply) {
+        let params = {...aRequest.query};
+        let request = new UrlRequest();
+
+        await request.requestData(aRequest.params.functionName, params);
+
+        return request.getResponse();
+    });
+
     //METODO: setup edit
-    //METODO: setup data
     //METODO: setup actions
     //METODO: setup cron
 

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

@@ -22,10 +22,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 +35,7 @@ export default class EncodeSession extends Dbm.core.BaseObject {
     }
 
     async encodeSingle(aId, aType) {
-        console.log("encodeSingle");
+        //console.log("encodeSingle");
 
         await this._encodeSingleNoAwait(aId, aType);
     }

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

@@ -4,10 +4,23 @@ export default class Query extends Dbm.core.BaseObject {
     _construct() {
         super._construct();
 
+        this._joins = [];
+        this._whereStatements = [];
         this._includeOnly = null;
         this._visibilities = ["public"];
     }
 
+    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) {
         if(!this._includeOnly) {
             this._includeOnly = aIds;
@@ -21,14 +34,20 @@ export default class Query extends Dbm.core.BaseObject {
 
     includeNone() {
         this._includeOnly = [];
+
+        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 [];
@@ -53,4 +72,11 @@ 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);
+    }
 }

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/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,6 @@ 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";

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

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

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

@@ -1,2 +1,3 @@
 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";