godprotocol 1.2.19 → 1.2.21

package/repos/fs.js

@@ -1,114 +1,122 @@
-import fs from 'fs'
-import { copy_object } from 'generalised-datastore/utils/functions.js'
-import Repository from 'godprotocol/Objects/Repository.js';
+import fs from "fs";
+import { copy_object } from "generalised-datastore/utils/functions.js";
+import Repository from "godprotocol/Objects/Repository.js";
 import { post_request } from "godprotocol/utils/services.js";
 
-class Fs extends Repository{
-  constructor(options={}){
-    super()
-    
+class Fs extends Repository {
+  constructor(options = {}) {
+    super();
+
     this._fs = fs;
     this.__dirname = options.__dirname;
     this.remote = options.remote;
     this.name = options.name;
 
-    this.type = 'fs'
+    this.type = "fs";
     this.cache = new Object();
   }
 
-  parse_path = async(path)=>{
-    path = path.split('/')
-    let addr = path.slice(0,-1).join('/')
-    if (!this._fs.existsSync(addr)){
-      this._fs.mkdirSync(addr, {recursive: true})
+  parse_path = async (path) => {
+    path = path.split("/");
+    let addr = path.slice(0, -1).join("/");
+    if (!this._fs.existsSync(addr)) {
+      this._fs.mkdirSync(addr, { recursive: true });
     }
-  }
+  };
 
-  call = async payload=>{
+  call = async (payload) => {
     let result;
-    switch(payload.op){
-      case 'write':
-        result = await this.write(payload.path, payload.data)
-        break
-      case 'read':
-        result = await this.read(payload.path)
+    switch (payload.op) {
+      case "write":
+        result = await this.write(payload.path, payload.data);
+        break;
+      case "read":
+        result = await this.read(payload.path);
         break;
     }
     return result;
-  }
-
-  fetch = async payload=>{
-    let res = await post_request({
-      options: {
-        ...this.remote,
-        path: '/oracle'
-      },
-      data: JSON.stringify({method: 'fs', arg: {payload, name: this.name}})
-    })
+  };
+
+  fetch = async (payload) => {
+    let res;
+    if (this.remote) {
+      res = await post_request({
+        options: {
+          ...this.remote,
+          path: "/oracle",
+        },
+        data: JSON.stringify({
+          method: "fs",
+          arg: { payload, name: this.name },
+        }),
+      });
+    } else {
+      res = await this.call(payload);
+    }
 
     return res;
-  }
+  };
 
-  write_file = async(path, data)=>{
-    path = this.path(path)
+  write_file = async (path, data) => {
+    path = this.path(path);
+    console.log(path, data);
 
-    await this.fetch({path, data, op: 'write'})
-  }
+    await this.fetch({ path, data, op: "write" });
+  };
 
-  write = async(path, data) => {
-    await this.parse_path(path)
-    this._fs.writeFileSync(path, data)
-    
-    this.cache[path] = data
-  }
+  write = async (path, data) => {
+    await this.parse_path(path);
+    this._fs.writeFileSync(path, data);
 
-  read = async(path)=>{
+    this.cache[path] = data;
+  };
+
+  read = async (path) => {
     let data;
-    try{
-      data = this.cache[path]
-      if (!data){
-        await this.parse_path(path)
-        data = this._fs.readFileSync(path, {encoding: 'utf-8'})
-      }else {
-        data = copy_object(data)
+    try {
+      data = this.cache[path];
+      if (!data) {
+        await this.parse_path(path);
+        data = this._fs.readFileSync(path, { encoding: "utf-8" });
+      } else {
+        data = copy_object(data);
       }
-      
-    }catch(e){
-      console.log(e.message)
+    } catch (e) {
+      console.log(e.message);
     }
 
     return data;
-  }
+  };
 
-  read_file = async(path)=>{
-    path = this.path(path)
+  read_file = async (path) => {
+    path = this.path(path);
+
+    let data = await this.fetch({ path, op: "read" });
 
-    let data = await this.fetch({path, op: 'read'})
-    
     return data;
-  }
+  };
 
-  path = pth=>{
-    return `${this.__dirname}/${pth}`
-  }
+  path = (pth) => {
+    return `${this.__dirname}/${pth}`;
+  };
 
-  mkdir = async(path)=>{
+  mkdir = async (path) => {
     let done;
-    try{
-      this._fs.mkdirSync(this.path(path), {recursive: true})
-      done = true
-    }catch(e){
-      done = false
+    try {
+      this._fs.mkdirSync(this.path(path), { recursive: true });
+      done = true;
+    } catch (e) {
+      done = false;
     }
 
     return done;
-  }
+  };
 
-  exists = async(path)=>{
-    path = this.path(path)
-    
-    return !!this.cache[path] || this._fs.existsSync(path)
-  }
+  exists = async (path) => {
+    path = this.path(path);
+
+    return !!this.cache[path] || this._fs.existsSync(path);
+  };
 }
 
-export default Fs
+export default Fs;

package/utils/create_server.js

@@ -1,116 +1,133 @@
-import { set_page } from '../html/index.js';
-import { generate_random_string } from 'generalised-datastore/utils/functions.js';
+import { set_page } from "../html/index.js";
+import { generate_random_string } from "generalised-datastore/utils/functions.js";
 
-let PORT = Number(process.env.PORT) || 1408, account_uids = {};
+let PORT = Number(process.env.PORT) || 1408,
+  account_uids = {};
 
 export const handle_routes = async (req, res, manager, app) => {
   try {
     // CORS
-    res.setHeader('Access-Control-Allow-Origin', '*');
-    res.setHeader('Access-Control-Allow-Methods', 'GET, POST, PUT, DELETE, OPTIONS');
-    res.setHeader('Access-Control-Allow-Headers', '*');
-
-    if (req.method === 'OPTIONS') {
+    res.setHeader("Access-Control-Allow-Origin", "*");
+    res.setHeader(
+      "Access-Control-Allow-Methods",
+      "GET, POST, PUT, DELETE, OPTIONS"
+    );
+    res.setHeader("Access-Control-Allow-Headers", "*");
+
+    if (req.method === "OPTIONS") {
       res.writeHead(204);
       return res.end();
     }
 
     // GET pages
-    if (req.method === 'GET') {
-      if (req.url === '/') {
-        res.writeHead(200, { 'Content-Type': 'text/html' });
+    if (req.method === "GET") {
+      if (req.url === "/") {
+        res.writeHead(200, { "Content-Type": "text/html" });
         return res.end(set_page(req.url, manager));
       }
 
-      if (['/create_account', '/load', '/run', '/parse', '/oracle'].includes(req.url)) {
-        res.writeHead(200, { 'Content-Type': 'text/html' });
+      if (
+        ["/create_account", "/load", "/run", "/parse", "/oracle"].includes(
+          req.url
+        )
+      ) {
+        res.writeHead(200, { "Content-Type": "text/html" });
         return res.end(set_page(req.url.slice(1), manager));
       }
 
       // hand over untouched
-      return app ? app(req, res) : res.writeHead(404).end('Not Found');
+      return app ? app(req, res) : res.writeHead(404).end("Not Found");
     }
 
     // Only custom POST endpoints handled here
-    if (['/create_account', '/load', '/run', '/parse', '/oracle'].includes(req.url)) {
-      let body = '';
-      req.on('data', chunk => { body += chunk; });
-      await new Promise(resolve => req.on('end', resolve));
+    if (
+      ["/create_account", "/load", "/run", "/parse", "/oracle"].includes(
+        req.url
+      )
+    ) {
+      let body = "";
+      req.on("data", (chunk) => {
+        body += chunk;
+      });
+      await new Promise((resolve) => req.on("end", resolve));
 
       if (!body) {
-        res.writeHead(400, { 'Content-Type': 'application/json' });
-        return res.end(JSON.stringify({ error: 'Request body cannot be empty' }));
+        res.writeHead(400, { "Content-Type": "application/json" });
+        return res.end(
+          JSON.stringify({ error: "Request body cannot be empty" })
+        );
       }
 
       const data = JSON.parse(body);
       let result;
 
       switch (req.url) {
-        case '/create_account': {
+        case "/create_account": {
           let acc = await manager.get_account(data.name);
           if (acc) {
-            if (!await acc.verify(data.password)) {
-              result = { message: 'Incorrect password.' };
+            if (!(await acc.verify(data.password))) {
+              result = { message: "Incorrect password." };
             } else {
-              const uid = generate_random_string(16, 'alnum');
+              const uid = generate_random_string(16, "alnum");
               account_uids[uid] = data.name;
-              result = { uid, message: 'Account signed-in successfully.' };
+              result = { uid, message: "Account signed-in successfully." };
             }
           } else {
-            let newAcc = await manager.add_account(data.name, { password: data.password });
-            if (newAcc) {
-              const uid = generate_random_string(16, 'alnum');
+            let new_acc = await manager.add_account(data.name, {
+              password: data.password,
+            });
+            if (new_acc) {
+              const uid = generate_random_string(16, "alnum");
               account_uids[uid] = data.name;
-              result = { uid, message: 'Account created successfully.' };
+              result = { uid, message: "Account created successfully." };
             } else {
-              result = { message: 'Account creation failed.' };
+              result = { message: "Account creation failed." };
             }
           }
           break;
         }
 
-        case '/oracle':
+        case "/oracle":
           result = await manager.oracle.call(data);
           break;
 
-        case '/load':
-        case '/run':
-        case '/parse': {
+        case "/load":
+        case "/run":
+        case "/parse": {
           const accountName = account_uids[data.account];
           if (!accountName) {
             result = { message: `Account ${data.account} not found` };
           } else {
             const accountObj = await manager.get_account(accountName);
-            if (req.url === '/load') result = await accountObj.load(data);
-            if (req.url === '/run') result = await accountObj.run(data);
-            if (req.url === '/parse') result = await accountObj.parse(data);
+            if (req.url === "/load") result = await accountObj.load(data);
+            if (req.url === "/run") result = await accountObj.run(data);
+            if (req.url === "/parse") result = await accountObj.parse(data);
           }
           break;
         }
       }
 
-      res.writeHead(200, { 'Content-Type': 'application/json' });
+      res.writeHead(200, { "Content-Type": "application/json" });
       return res.end(JSON.stringify(result));
     }
 
     // Everything else → forward to express app
-    return app ? app(req, res) : res.writeHead(404).end('Not Found');
-
+    return app ? app(req, res) : res.writeHead(404).end("Not Found");
   } catch (err) {
-    console.error('Handler error:', err);
-    res.writeHead(500, { 'Content-Type': 'application/json' });
+    console.error("Handler error:", err);
+    res.writeHead(500, { "Content-Type": "application/json" });
     return res.end(JSON.stringify({ error: err.message }));
   }
 };
 
-
 const create_server = (settings) => {
   settings = settings || {};
   let { port, manager } = settings;
 
   port = port || PORT;
-  
-  let handler = async (req, res) => await handle_routes(req, res, manager, manager.options.app);
+
+  let handler = async (req, res) =>
+    await handle_routes(req, res, manager, manager.options.app);
 
   return handler;
 };