dbm-graph-api 1.0.0

package/index.js

@@ -0,0 +1 @@
+export * as default from "./src/dbm-graph-api/index.js";

package/package.json

@@ -0,0 +1,18 @@
+{
+  "name": "dbm-graph-api",
+  "version": "1.0.0",
+  "main": "index.js",
+  "type": "module",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "MIT",
+  "description": "",
+  "dependencies": {
+    "@aws-sdk/client-s3": "^3.693.0",
+    "@aws-sdk/s3-request-presigner": "^3.693.0",
+    "ws": "^8.18.0"
+  }
+}

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

@@ -0,0 +1,72 @@
+import { WebSocketServer } from 'ws';
+import Dbm from "dbm";
+
+import WebSocketConnection from "./WebSocketConnection.js";
+
+export default class Api extends Dbm.core.BaseObject {
+    _construct() {
+        super._construct();
+
+        this._server = null;
+        this._webSocketServer = null;
+
+        this.item.setValue("controller", this);
+        this.item.setValue("connections", []);
+
+        this._callback_connectionBound = this._callback_connection.bind(this);
+    }
+
+    setup(aServer, aPath = "/ws/") {
+
+        this._webSocketServer = new WebSocketServer({"server": aServer, "path": aPath});
+
+        this._webSocketServer.on('connection', this._callback_connectionBound);
+
+        return this;
+    }
+
+    _callback_connection(aWebSocket, aRequest) {
+        let newWebSocketConnection = new WebSocketConnection();
+
+        newWebSocketConnection.item.setValue("api", this.item);
+
+        newWebSocketConnection.setWebSocket(aWebSocket);
+        newWebSocketConnection.addListeners();
+
+        let connections = [].concat(this.item.connections);
+        connections.push(newWebSocketConnection.item);
+        this.item.setValue("connections", connections);
+
+        let hasUserCookie = false;
+        if(aRequest.headers.cookie) {
+            let cookies = aRequest.headers.cookie.split(";");
+            let currentArray = cookies;
+            let currentArrayLength = currentArray.length;
+            for(let i = 0; i < currentArrayLength; i++) {
+                let [key, value] = currentArray[i].split("=");
+                if(key === "dbm_session" || key === " dbm_session") {
+                    let userId = 1*value.split(":")[1];
+                    let user = Dbm.getInstance().repository.getItem("graphDatabase").controller.getUser(userId);
+    
+                    user.verifySession(value).then(function(aIsValidSession) {
+                        console.log("verifySession", aIsValidSession);
+    
+                        if(aIsValidSession) {
+                            newWebSocketConnection.setInitialUser(userId);
+                        }
+                        else {
+                            newWebSocketConnection.setInitialUser(0);
+                        }
+                        
+                    });
+                    hasUserCookie = true;
+                    break;
+                }
+            }
+        }
+        
+        if(!hasUserCookie) {
+            newWebSocketConnection.setInitialUser(0);
+        }
+    }
+}

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

@@ -0,0 +1,258 @@
+import Dbm from "dbm";
+import DbmGraphApi from "../../index.js";
+
+export default class WebSocketConnection extends Dbm.core.BaseObject {
+    _construct() {
+        super._construct();
+        this._webSocket = null;
+
+        this._callback_errorBound = this._callback_error.bind(this);
+        this._callback_messageBound = this._callback_message.bind(this);
+    }
+
+    setWebSocket(aWebSocket) {
+        this._webSocket = aWebSocket;
+
+        return this;
+    }
+
+    async _applyChanges(aObject, aChanges, aRequest) {
+        let currentArray = aChanges;
+        let currentArrayLength = currentArray.length;
+        for(let i = 0; i < currentArrayLength; i++) {
+            let currentData = currentArray[i];
+            let currentType = currentData["type"];
+            let changeData = currentData["data"];
+
+            let changeItem = Dbm.getInstance().repository.getItemIfExists("graphApi/admin/edit/" + currentType);
+            if(changeItem) {
+                await changeItem.controller.performChange(aObject, changeData, aRequest);
+            }
+        }
+    }
+
+    async _callback_message(aDataString) {
+        console.log('received: %s', aDataString);
+    
+        let data;
+
+        try{
+            data = JSON.parse(aDataString);
+        }
+        catch(theError) {
+            return;
+        }
+
+        let request = {}; //METODO
+
+        request.connection = this;
+
+        let type = data["type"];
+        switch(type) {
+            case "range":
+                let selectQuery = new DbmGraphApi.range.Query();
+                
+                let ids = [];
+
+                {
+                    let hasSelection = false;
+                    let currentArray = data.select;
+                    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);
+                        }
+                    }
+
+                    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 {
+                        //METODO: log error
+                    }
+                    
+                }
+                
+                {
+                    let encodeSession = new DbmGraphApi.range.EncodeSession();
+                    encodeSession.outputController = this;
+
+                    let currentArray = data.encode;
+                    let currentArrayLength = currentArray.length;
+                    for(let i = 0; i < currentArrayLength; i++) {
+                        let currentType = currentArray[i];
+                        
+                        await encodeSession.encode(ids, currentType);
+                    }
+
+                    encodeSession.destroy();
+                }
+                
+                this._webSocket.send(JSON.stringify({"type": "range/response", "ids": ids, "requestId": data["requestId"]}));
+                break;
+            case "data":
+                {
+                    let encodeSession = new DbmGraphApi.range.EncodeSession();
+                    encodeSession.outputController = this;
+
+                    let dataFunctionItem = Dbm.getInstance().repository.getItemIfExists("graphApi/data/" + data['functionName']);
+                    
+                    let returnData = null;
+                    if(dataFunctionItem) {
+                        returnData = await dataFunctionItem.controller.getData(data['data'], encodeSession);
+                    }
+
+                    this._webSocket.send(JSON.stringify({"type": "data/response", "data": returnData, "requestId": data["requestId"]}));
+                }
+                break;
+            case "item":
+                {
+                    let id = data['id'];
+                    //METODO: check visibility in database
+
+                    let encodeSession = new DbmGraphApi.range.EncodeSession();
+                    encodeSession.outputController = this;
+
+                    await encodeSession.encodeSingleWithTypes(id, data.encode);
+
+                    encodeSession.destroy();
+
+                    this._webSocket.send(JSON.stringify({"type": "item/response", "id": id, "requestId": data["requestId"]}));
+                }
+                break;
+            case "url":
+                {
+                    let url = data['url'];
+                    if(url[url.length-1] !== "/") {
+                        url += "/";
+                    }
+                    //METODO: check visibility in database
+
+                    
+
+                    let database = Dbm.getInstance().repository.getItem("graphDatabase").controller;
+                    let urlObject = await database.getObjectByUrl(url);
+
+                    if(urlObject) {
+                        let encodeSession = new DbmGraphApi.range.EncodeSession();
+                        encodeSession.outputController = this;
+
+                        await encodeSession.encodeSingleWithTypes(urlObject.id, ["urlRequest"]);
+                        encodeSession.destroy();
+                        this._webSocket.send(JSON.stringify({"type": "url/response", "id": urlObject.id, "requestId": data["requestId"]}));
+                    }
+                    else {
+                        this._webSocket.send(JSON.stringify({"type": "url/response", "id": 0, "requestId": data["requestId"]}));
+                    }
+                }
+                break;
+            case "admin/createObject":
+                {
+                    let types = data['types'];
+                    let database = Dbm.getInstance().repository.getItem("graphDatabase").controller;
+                    let visibility = data['visibility'] ? data['visibility'] : 'draft';
+
+                    let draftVisibility = await database.getVisibilityType(visibility);
+
+		            let newObject = await database.createObject(draftVisibility, types);
+
+                    if(data.changes) {
+                        await this._applyChanges(newObject, data.changes, request);
+                    }
+                    
+                    if(data.encode) {
+
+                        let encodeSession = new DbmGraphApi.range.EncodeSession();
+                        encodeSession.outputController = this;
+
+                        await encodeSession.encodeSingleWithTypes(newObject.id, data.encode);
+
+                        encodeSession.destroy();
+                    }
+                    
+                    this._webSocket.send(JSON.stringify({"type": "item/response", "id": newObject.id, "requestId": data["requestId"]}));
+                }
+                break;
+            case "admin/editObject":
+                {
+                    let database = Dbm.getInstance().repository.getItem("graphDatabase").controller;
+
+                    let theObject = database.getObject(data.id);
+
+                    if(data.changes) {
+                        await this._applyChanges(theObject, data.changes, request);
+                    }
+                    
+                    if(data.encode) {
+
+                        let encodeSession = new DbmGraphApi.range.EncodeSession();
+                        encodeSession.outputController = this;
+
+                        await encodeSession.encodeSingleWithTypes(theObject.id, data.encode);
+
+                        encodeSession.destroy();
+                    }
+                    
+                    this._webSocket.send(JSON.stringify({"type": "item/response", "id": theObject.id, "requestId": data["requestId"]}));
+                }
+                break;
+            case "user/signInWithToken":
+                {
+                    let database = Dbm.getInstance().repository.getItem("graphDatabase").controller;
+
+                    let user = database.getUser(1*data.token.split(":")[1]);
+
+                    let isVerified = await user.verifySignedSessionToken(data.token);
+
+                    let userId = 0;
+                    if(isVerified) {
+                        //METODO: set user for connection
+                        userId = user.id;
+                    }
+
+                    this._webSocket.send(JSON.stringify({"type": "currentUser/response", "id": userId, "requestId": data["requestId"]}));
+                    
+                }
+                break;
+        }	
+    }
+
+    _callback_error(aMessage) {
+        console.error(aMessage);
+    }
+
+    addListeners() {
+
+        this._webSocket.on('error', this._callback_error);
+        this._webSocket.on('message', this._callback_messageBound);
+
+        return this;
+    }
+
+    outputEncodedData(aId, aData, aEncoding) {
+        console.log("WebSocketConnection::outputEncodedData");
+
+        this._webSocket.send(JSON.stringify({"type": "updateEncodedObject", "id": aId, "data": aData, "encoding": aEncoding}));
+        
+    }
+
+    setInitialUser(aId) {
+
+        //METODO: set the user for connection
+
+        this._webSocket.send(JSON.stringify({"type": "connectionReady", "user": aId}));
+    }
+}

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

@@ -0,0 +1,12 @@
+import Dbm from "dbm";
+import EditBaseObject from "./EditBaseObject.js";
+
+export default class AddIncomigRelation extends EditBaseObject {
+    _construct() {
+        super._construct();
+    }
+
+    performChange(aObject, aData, aRequest) {
+        aObject.addIncomingRelation(aData["value"], aData["type"]);
+    }
+}

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

@@ -0,0 +1,12 @@
+import Dbm from "dbm";
+import EditBaseObject from "./EditBaseObject.js";
+
+export default class AddOutgoingRelation extends EditBaseObject {
+    _construct() {
+        super._construct();
+    }
+
+    performChange(aObject, aData, aRequest) {
+        aObject.addOutgoingRelation(aData["value"], aData["type"]);
+    }
+}

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

@@ -0,0 +1,11 @@
+import Dbm from "dbm";
+
+export default class EditBaseObject extends Dbm.core.BaseObject {
+    _construct() {
+        super._construct();
+    }
+
+    performChange(aObject, aData, aRequest) {
+        //MENOTE: should be overridden
+    }
+}

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

@@ -0,0 +1,12 @@
+import Dbm from "dbm";
+import EditBaseObject from "./EditBaseObject.js";
+
+export default class SetField extends EditBaseObject {
+    _construct() {
+        super._construct();
+    }
+
+    performChange(aObject, aData, aRequest) {
+        aObject.updateField(aData["field"], aData["value"]);
+    }
+}

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

@@ -0,0 +1,29 @@
+import DbmGraphApi from "../../../../index.js";
+export {default as EditBaseObject} from "./EditBaseObject.js";
+
+export {default as SetField} from "./SetField.js";
+export {default as AddIncomingRelation} from "./AddIncomingRelation.js";
+export {default as AddOutgoingRelation} from "./AddOutgoingRelation.js";
+
+let fullSetup = function() {
+    let prefix = "graphApi/admin/edit/";
+    {
+        let name = "setField";
+        let currentSelect = new DbmGraphApi.admin.edit.SetField();
+        currentSelect.item.register(prefix + name);
+    }
+
+    {
+        let name = "addIncomingRelation";
+        let currentSelect = new DbmGraphApi.admin.edit.AddIncomingRelation();
+        currentSelect.item.register(prefix + name);
+    }
+
+    {
+        let name = "addOutgoingRelation";
+        let currentSelect = new DbmGraphApi.admin.edit.AddOutgoingRelation();
+        currentSelect.item.register(prefix + name);
+    }
+}
+
+export {fullSetup};

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

@@ -0,0 +1 @@
+export * as edit from "./edit/index.js";

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

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

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

@@ -0,0 +1,67 @@
+import Dbm from "dbm";
+import crypto from "node:crypto";
+
+import { PutObjectCommand } from "@aws-sdk/client-s3";
+import { getSignedUrl } from "@aws-sdk/s3-request-presigner";
+
+export default class UploadS3 extends Dbm.core.BaseObject {
+    _construct() {
+        super._construct();
+
+        this.item.requireProperty("client");
+        this.item.requireProperty("bucketName");
+        this.item.requireProperty("path", "content/{year}/{month}/{date}/{generatedId}/");
+        this.item.requireProperty("publicPath", "");
+        this.item.requireProperty("acl", "public-read");
+    }
+
+    async getData(aData, aEncodeSession) {
+        let returnObject = {};
+
+        let fileName = aData["fileName"].toLowerCase();
+        let mimeType = aData["mimeType"];
+
+        fileName = fileName.replace(/[åäã]/gi, 'a');
+        fileName = fileName.replace(/[ö]/gi, 'o');
+        fileName = fileName.replace(/ /gi, '-');
+        fileName = fileName.replace(/[\(\),\*']/gi, '');
+        fileName = fileName.replace(/[^a-z0-9\-_\.]/gi, '-');
+        fileName = fileName.replace(/\-+/gi, '-');
+
+        let date = new Date();
+
+        let month = (date.getMonth()+1);
+        if(month < 10) month = "0" + month;
+
+        let dateDay = (date.getDate());
+        if(dateDay < 10) dateDay = "0" + dateDay;
+
+        let generatedId = crypto.randomBytes(6).toString('base64url');
+
+        let fullPath = this.item.path;
+        fullPath = fullPath.split("{year}").join(date.getFullYear());
+        fullPath = fullPath.split("{month}").join(month);
+        fullPath = fullPath.split("{date}").join(dateDay);
+        fullPath = fullPath.split("{generatedId}").join(generatedId);
+
+        //METODO: add to database
+
+        fileName = fullPath + fileName;
+        let acl = this.item.acl;
+
+        let command = new PutObjectCommand({
+            Bucket: this.item.bucketName,
+            Key: fileName,
+            ContentType: mimeType,
+            ACL: acl,
+        });
+
+        let presignedUrl = await getSignedUrl(this.item.client, command, { expiresIn: 360 });
+
+        returnObject["url"] = presignedUrl;
+        returnObject["publicUrl"] = this.item.publicPath + fileName;
+        returnObject["acl"] = acl;
+
+        return returnObject;
+    }
+}

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

@@ -0,0 +1,30 @@
+export {default as Example} from "./Example.js";
+export {default as UploadS3} from "./UploadS3.js";
+
+import UploadS3 from "./UploadS3.js";
+
+import { S3Client } from "@aws-sdk/client-s3";
+
+export let createDigitalOceanSpacesUpload = function(aKeyId, aSecret, aRegion, aBucketName, aPublicPath = null) {
+
+    if(aPublicPath === null) {
+        aPublicPath = "https://" + aBucketName + "." + aRegion + ".cdn.digitaloceanspaces.com/";
+    }
+
+    let client = new S3Client({
+        endpoint: "https://" + aRegion + ".digitaloceanspaces.com",
+        forcePathStyle: false,
+        region: aRegion,
+        credentials: {
+            accessKeyId: aKeyId,
+            secretAccessKey: aSecret
+        }
+    });
+
+    let newUploadS3 = new UploadS3();
+    newUploadS3.item.client = client;
+    newUploadS3.item.bucketName = aBucketName;
+    newUploadS3.item.publicPath = aPublicPath;
+
+    return newUploadS3;
+}

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

@@ -0,0 +1,183 @@
+import Dbm from "dbm";
+import crypto from "node:crypto";
+
+import DbmGraphApi from "../../index.js";
+import Api from "./Api.js";
+
+export {Api};
+
+export * as range from "./range/index.js";
+export * as admin from "./admin/index.js";
+export * as data from "./data/index.js";
+
+let fullSelectSetup = function() {
+    let selectPrefix = "graphApi/range/select/";
+    {
+        let name = "idSelection";
+        let currentSelect = new DbmGraphApi.range.select.IdSelection();
+        currentSelect.item.register(selectPrefix + name);
+    }
+}
+
+export {fullSelectSetup};
+
+let fullEncodeSetup = function() {
+    let encodePrefix = "graphApi/range/encode/";
+    {
+        let name = "example";
+        let currentEncode = new DbmGraphApi.range.encode.Example();
+        currentEncode.item.register(encodePrefix + name);
+        currentEncode.item.setValue("encodingType", name);
+    }
+
+    {
+        let name = "identifier";
+        let currentEncode = new DbmGraphApi.range.encode.Identifier();
+        currentEncode.item.register(encodePrefix + name);
+        currentEncode.item.setValue("encodingType", name);
+    }
+
+    {
+        let name = "name";
+        let currentEncode = new DbmGraphApi.range.encode.Name();
+        currentEncode.item.register(encodePrefix + name);
+        currentEncode.item.setValue("encodingType", name);
+    }
+
+    {
+        let name = "content";
+        let currentEncode = new DbmGraphApi.range.encode.Content();
+        currentEncode.item.register(encodePrefix + name);
+        currentEncode.item.setValue("encodingType", name);
+    }
+
+    {
+        let name = "title";
+        let currentEncode = new DbmGraphApi.range.encode.Title();
+        currentEncode.item.register(encodePrefix + name);
+        currentEncode.item.setValue("encodingType", name);
+    }
+
+    {
+        let name = "urlRequest";
+        let currentEncode = new DbmGraphApi.range.encode.UrlRequest();
+        currentEncode.item.register(encodePrefix + name);
+        currentEncode.item.setValue("encodingType", name);
+    }
+}
+
+export {fullEncodeSetup};
+
+export let registerDataFunction = function(aName, aDataFunction) {
+
+    aDataFunction.item.register("graphApi/data/" + aName);
+    aDataFunction.item.setValue("functionName", aName);
+
+    return aDataFunction;
+}
+
+let fullDataSetup = function() {
+    registerDataFunction("example", new DbmGraphApi.data.Example());
+}
+
+export {fullDataSetup};
+
+let fullSetup = function() {
+
+    fullSelectSetup();
+    fullEncodeSetup();
+    fullDataSetup();
+    
+    DbmGraphApi.admin.edit.fullSetup();
+}
+
+export {fullSetup};
+
+let setupEndpoints = function(aServer) {
+    aServer.post('/api/user/login', async function handler (aRequest, aReply) {
+
+		let username = aRequest.body['username'];
+
+		let user = await Dbm.getInstance().repository.getItem("graphDatabase").controller.getUserByUsername(username);
+
+		if(!user) {
+			//METODO: get user by email
+		}
+
+		if(!user) {
+			return { success: false, error: "noUserFound", message: "No user found"};
+		}
+
+		let isCorrectPassword = await user.verifyPassword(aRequest.body['password']);
+
+		if(isCorrectPassword) {
+			let sessionId = await user.createSession();
+
+            let tempArray = sessionId.split(":");
+            let sessionDatabaseId = 1*tempArray[0];
+			let expiresTime = 1*tempArray[2];
+			let expiresDate = (new Date(expiresTime)).toUTCString();
+
+			aReply.header("Set-Cookie", "dbm_session=" +sessionId + "; Path=/; Expires=" + expiresDate + "; HttpOnly;");
+
+            let wsToken = crypto.randomBytes(32).toString('base64');
+            let expiryLength = 60;
+            let hashedWsToken = await user.generateSignedSessionToken(sessionDatabaseId, (new Date()).valueOf()+expiryLength*1000, wsToken, sessionId)
+
+			return { success: true, data: {id: user.id, "wsToken": hashedWsToken}};
+		}
+
+		return { success: false, error: "incorrect", message: "Incorrect details"};
+	});
+
+    aServer.get('/api/user/me', async function handler (aRequest, aReply) {
+        let cookies = aRequest.headers.cookie ? aRequest.headers.cookie.split(";") : [];
+        let currentArray = cookies;
+        let currentArrayLength = currentArray.length;
+        for(let i = 0; i < currentArrayLength; i++) {
+            let [key, value] = currentArray[i].split("=");
+            if(key === "dbm_session" || key === " dbm_session") {
+                let userId = 1*value.split(":")[1];
+                let user = Dbm.getInstance().repository.getItem("graphDatabase").controller.getUser(userId);
+
+                let isValidSession = await user.verifySession(value);
+                if(isValidSession) {
+                    return {success: true, data: {id: userId}};
+                }
+            }
+        }
+
+        return {success: false, data: null};
+    });
+
+	aServer.post('/api/user/logout', async function handler (aRequest, aReply) {
+		console.log(aRequest.body);
+
+		//METODO: clear session from database
+		//METODO: clear cookie
+	});
+
+	aServer.post('/api/user/renewSession', async function handler (aRequest, aReply) {
+		console.log(aRequest.body);
+
+		//METODO: clear session from database
+		//METODO: clear cookie
+	});
+
+    //METODO: setup ranges
+    //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 };
+	});
+
+    aServer.get('/api/*', async function handler (aRequest, aResponse) {
+        aResponse.code(404);
+		return { success: false, error: "notFound", message: "Not found" };
+	});
+}
+
+export {setupEndpoints};

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

@@ -0,0 +1,99 @@
+import Dbm from "dbm";
+
+export default class EncodeSession extends Dbm.core.BaseObject {
+    _construct() {
+        super._construct();
+
+        this._encodings = {};
+        this.outputController = null;
+    }
+
+    _readyToEncode(aId, aType) {
+        let encodings = this._encodings[aId];
+        if(!encodings) {
+            encodings = this._encodings[aId] = {};
+        }
+
+        if(encodings[aType]) {
+            return false;
+        }
+
+        return (encodings[aType] = true);
+    }
+
+    _encodeSingleNoAwait(aId, aType) {
+        console.log("_encodeSingleNoAwait");
+        
+        let shouldEncode = this._readyToEncode(aId, aType);
+        console.log(shouldEncode, aId, aType);
+        if(shouldEncode) {
+            let encoding = Dbm.getInstance().repository.getItemIfExists("graphApi/range/encode/" + aType);
+            if(encoding) {
+                return encoding.controller.encodeSingle(aId, this);
+            }
+        }
+    }
+
+    async encodeSingle(aId, aType) {
+        console.log("encodeSingle");
+
+        await this._encodeSingleNoAwait(aId, aType);
+    }
+
+    async encodeSingleWithTypes(aId, aTypes) {
+        let currentArray = aTypes;
+        let currentArrayLength = currentArray.length;
+        let promises = new Array(currentArrayLength);
+        for(let i = 0; i < currentArrayLength; i++) {
+            promises[i] = this._encodeSingleNoAwait(aId, currentArray[i]);
+        }
+
+        await Promise.all(promises);
+    }
+
+    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];
+            promises[i] = this._encodeSingleNoAwait(id, aType);
+        }
+
+        await Promise.all(promises);
+
+        return ids;
+    }
+
+    async encodeObjectOrNull(aObject, aType) {
+        if(!aObject) {
+            return 0;
+        }
+
+        await this.encodeSingle(aObject.id, aType);
+        return aObject.id;
+    }
+
+    async encodeObjects(aObjects, aType) {
+        let currentArray = aObjects;
+        let currentArrayLength = currentArray.length;
+        let ids = new Array(currentArrayLength);
+        let promises = new Array(currentArrayLength);
+        for(let i = 0; i < currentArrayLength; i++) {
+            let object = currentArray[i];
+            ids[i] = object.id;
+            promises[i] = this._encodeSingleNoAwait(object.id, aType);
+        }
+
+        await Promise.all(promises);
+
+        return ids;
+    }
+
+    outputEncodedData(aId, aData, aEncoding) {
+        //console.log("EncodeSession::outputEncodedData");
+
+        this.outputController.outputEncodedData(aId, aData, aEncoding);
+    }
+}

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

@@ -0,0 +1,56 @@
+import Dbm from "dbm";
+
+export default class Query extends Dbm.core.BaseObject {
+    _construct() {
+        super._construct();
+
+        this._includeOnly = null;
+        this._visibilities = ["public"];
+    }
+
+    includeOnly(aIds) {
+        if(!this._includeOnly) {
+            this._includeOnly = aIds;
+        }
+        else {
+            this._includeOnly = this._includeOnly.filter(value => aIds.includes(value));
+        }
+
+        return this;
+    }
+
+    includeNone() {
+        this._includeOnly = [];
+    }
+
+    async getIds() {
+        let database = Dbm.getInstance().repository.getItem("graphDatabase").controller;
+        
+        let query = "SELECT Objects.id as id FROM Objects";
+        
+        let whereStatements = [];
+        if(this._includeOnly !== null) {
+            if(this._includeOnly.length === 0) {
+                return [];
+            }
+            whereStatements.push("Objects.id IN (" + this._includeOnly.join(",") + ")");
+        }
+
+        //METODO: include visibility
+
+        if(whereStatements.length) {
+            query += " WHERE " + whereStatements.join(" AND ");
+        }
+
+        let result = await database.connection.query(query);
+        let currentArray = result[0];
+        let currentArrayLength = currentArray.length;
+        let returnArray = new Array(currentArrayLength);
+        for(let i = 0; i < currentArrayLength; i++) {
+            returnArray[i] = currentArray[i]["id"];
+        }
+
+
+        return returnArray;
+    }
+}

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

@@ -0,0 +1,20 @@
+import Dbm from "dbm";
+import EncodeBaseObject from "./EncodeBaseObject.js";
+
+export default class Content 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["content"] = fields["content"] ? fields["content"] : null;
+
+        return returnObject;
+    }
+}

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

@@ -0,0 +1,36 @@
+import Dbm from "dbm";
+
+export default class EncodeBaseObject extends Dbm.core.BaseObject {
+    _construct() {
+        super._construct();
+    }
+
+    async encode(aIds, aEncodingSession) {
+
+        let encodingPromises = [];
+
+        let currentArray = aIds;
+        let currentArrayLength = currentArray.length;
+        for(let i = 0; i < currentArrayLength; i++) {
+            let currentId = currentArray[i];
+            encodingPromises.push(this.encodeSingle(currentId, aEncodingSession));
+        }
+
+        await Promise.all(encodingPromises);
+    }
+
+    async encodeSingle(aId, aEncodingSession) {
+        //console.log("EncodeBaseObject::encodeSingle");
+
+        let data = await this.getEncodedData(aId, aEncodingSession);
+        aEncodingSession.outputEncodedData(aId, data, this.item.encodingType);       
+    }
+
+    async getEncodedData(aId, aRequest) {
+        //console.log("EncodeBaseObject::encodeSingle");
+
+        //MENOTE: should be overridden
+
+        return {};
+    }
+}

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

@@ -0,0 +1,17 @@
+import Dbm from "dbm";
+import EncodeBaseObject from "./EncodeBaseObject.js";
+
+export default class Example extends EncodeBaseObject {
+    _construct() {
+        super._construct();
+    }
+
+    async getEncodedData(aId, aEncodingSession) {
+
+        let returnObject = {};
+
+        returnObject["example"] = "This is an example";
+
+        return returnObject;
+    }
+}

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

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

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

@@ -0,0 +1,20 @@
+import Dbm from "dbm";
+import EncodeBaseObject from "./EncodeBaseObject.js";
+
+export default class Name 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["name"] = fields["name"] ? fields["name"] : null;
+
+        return returnObject;
+    }
+}

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

@@ -0,0 +1,20 @@
+import Dbm from "dbm";
+import EncodeBaseObject from "./EncodeBaseObject.js";
+
+export default class Title 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["title"] = fields["title"] ? fields["title"] : null;
+
+        return returnObject;
+    }
+}

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

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

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

@@ -0,0 +1,8 @@
+export {default as EncodeBaseObject} from "./EncodeBaseObject.js";
+
+export {default as Example} from "./Example.js";
+export {default as Identifier} from "./Identifier.js";
+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";

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

@@ -0,0 +1,5 @@
+export {default as Query} from "./Query.js";
+export {default as EncodeSession} from "./EncodeSession.js";
+
+export * as select from "./select/index.js";
+export * as encode from "./encode/index.js";

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

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

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

@@ -0,0 +1,15 @@
+import Dbm from "dbm";
+
+export default class SelectBaseObject extends Dbm.core.BaseObject {
+    _construct() {
+        super._construct();
+    }
+
+    async select(aQuery, aData, aRequest) {
+
+    }
+
+    async filter(aIds, aData, aRequest) {
+        return aIds;
+    }
+}

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

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