godprotocol 1.2.14 → 1.2.16

package/Objects/Manager.js

@@ -331,7 +331,7 @@ class Manager {
       else this.options.server_domain = this.options.server.hostname
       let handle = create_server({manager: this, ...this.options.server, app: this.options.app })
 
-      this.handler = (req, res)=>{
+      this.handler = (req, res, cb)=>{
         
         handle(req,res)
 
@@ -342,6 +342,8 @@ class Manager {
             .then(async()=>{
               if (this.options.init_account){
                 await this.add_account(this.options.init_account.name, {password: this.options.init_account.password, init: true})
+
+                cb && cb()
               }
             })
         }

package/Objects/Oracle.js

@@ -153,8 +153,10 @@ class Oracle extends Handlers{
       let repo = this.repos[r]
 
       if (!repo.filter || address.match(repo.filter)){
-        await repo.repo.write_file(address, content, args)
-        res = await repo.repo.objectify()
+        res = await repo.repo.write_file(address, content, args)
+        if (!args.just_exists){
+          res = await repo.repo.objectify()
+        }
         if (counted && !count) break;
         count --
       }

package/Objects/Repository.js

@@ -1,5 +1,6 @@
 class Repository{
-  constructor(){
+  constructor(type){
+    this.type = type;
   }
 
   objectify = ()=>{
@@ -16,6 +17,10 @@ class Repository{
 
     return obj
   }
+
+  match = async()=>{
+    return false
+  }
 }
 
 export default Repository;

package/Objects/Utils.js

@@ -11,13 +11,20 @@ class Utils{
     await this.load({address: address.slice(this.physical_address.length+1), sequence: res, compiler: true, from_reload: true})
   }
 
-  get_from_repo = async(address) =>{
-    address = `${this.physical_address}/${address}/__literal__`
-    let content = await this.manager.oracle.get_from_repo(address, {count: 1})
+  get_from_repo = async(address, options) =>{
+    address = `./storage/${this.physical_address}/${address}/__literal__`
+    let content = await this.manager.oracle.get_from_repos(address, {count: 1, args: options})
 
     return content && JSON.parse(content)
   }
 
+  set_to_repo =  async(address, content, options) =>{
+    address = `./storage/${this.physical_address}/${address}/__literal__`
+    let response = await this.manager.oracle.set_to_repos(address, JSON.stringify(content), {count: 1, args: options})
+
+    return response
+  }
+
   read_file = async(address) =>{
     let content = await this.manager.oracle.read(address, {account: this.physical_address})
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "godprotocol",
-  "version": "1.2.14",
+  "version": "1.2.16",
   "description": "A distributed computing environment",
   "main": "Index.js",
   "scripts": {

package/repos/github.js

@@ -17,13 +17,14 @@ class Github extends Repository{
   });
 
   // Write (create or update) a file
-  write_file = async (file_path, content) => {
+  write_file = async (file_path, content, options={}) => {
     const url = `${this.base_url}/repos/${this.owner}/${this.repo}/contents/${file_path}`;
-    let sha = null;
+    let sha = null, exists;
 
     // Check if file exists, get its SHA
     try{
-      const exists = await this.file_exists(file_path);
+      exists = await this.file_exists(file_path);
+      
       if (exists) {
         const res = await fetch(url, { headers: this.get_headers() });
         if (res.ok) {
@@ -31,26 +32,36 @@ class Github extends Repository{
           sha = data.sha;
         }
       }
+      if (options.just_exists) return exists
     }catch(e){
       console.log(e.message)
       return 
     }
-    
 
     // Build payload
-    const body = {
+    let body;
+    try{
+      body = {
       message: exists ? 'Update file' : 'Create file',
       content: Buffer.from(content).toString('base64'),
       ...(sha && { sha }),
     };
+    }catch(e){
 
-    const response = await fetch(url, {
-      method: 'PUT',
-      headers: this.get_headers(),
-      body: JSON.stringify(body),
-    });
+    }
 
-    return response.json();
+    try{
+      const response = await fetch(url, {
+        method: 'PUT',
+        headers: this.get_headers(),
+        body: JSON.stringify(body),
+      });
+
+      return response.json();
+    }catch(e){
+      console.log(e.message)
+    }
+    
   };
 
   // Read a file
@@ -60,15 +71,15 @@ class Github extends Repository{
     let response;
     try{
       response = await fetch(url, { headers: this.get_headers() })
+
+      if (!response.ok) return null;
+
+      const fileData = await response.json();
+      return Buffer.from(fileData.content, 'base64').toString('utf-8');
     }catch(e){
-      console.log(e)
+      console.log(e.message)
       return;
     }
-    ;
-    if (!response.ok) return null;
-
-    const fileData = await response.json();
-    return Buffer.from(fileData.content, 'base64').toString('utf-8');
   };
 
   // Check if file exists

package/utils/create_server.js

@@ -3,11 +3,9 @@ import { generate_random_string } from 'generalised-datastore/utils/functions.js
 
 let PORT = Number(process.env.PORT) || 1408, account_uids = {};
 
-export const handle_routes =  async (req, res, manager, app) => {
-  let body = '';
-
+export const handle_routes = async (req, res, manager, app) => {
   try {
-    // Handle CORS preflight
+    // CORS
     res.setHeader('Access-Control-Allow-Origin', '*');
     res.setHeader('Access-Control-Allow-Headers', 'Content-Type');
     res.setHeader('Access-Control-Allow-Methods', 'POST, GET, OPTIONS');
@@ -17,7 +15,7 @@ export const handle_routes =  async (req, res, manager, app) => {
       return res.end();
     }
 
-    // GET requests for pages
+    // GET pages
     if (req.method === 'GET') {
       if (req.url === '/') {
         res.writeHead(200, { 'Content-Type': 'text/html' });
@@ -29,70 +27,74 @@ export const handle_routes =  async (req, res, manager, app) => {
         return res.end(set_page(req.url.slice(1), manager));
       }
 
-      return app ? app(req,res) : res.writeHead(404).end('Not Found');
+      // hand over untouched
+      return app ? app(req, res) : res.writeHead(404).end('Not Found');
     }
 
-    // Accumulate POST body
-    req.on('data', chunk => { body += chunk; });
-    await new Promise(resolve => req.on('end', resolve));
-
-    let data = body ? JSON.parse(body) : null;
+    // 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 (!data) {
-      res.writeHead(400, { 'Content-Type': 'application/json' });
-      return res.end(JSON.stringify({ error: 'Request body cannot be empty' }));
-    }
+      if (!body) {
+        res.writeHead(400, { 'Content-Type': 'application/json' });
+        return res.end(JSON.stringify({ error: 'Request body cannot be empty' }));
+      }
 
-    // POST route handling
-    let result;
-    switch (req.url) {
-      case '/create_account':
-        let acc = await manager.get_account(data.name);
-        if (acc) {
-          if (!await acc.verify(data.password)) {
-            result = { message: 'Incorrect password.' };
-          } else {
-            const uid = generate_random_string(16, 'alnum');
-            account_uids[uid] = data.name;
-            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');
-            account_uids[uid] = data.name;
-            result = { uid, message: 'Account created successfully.' };
+      const data = JSON.parse(body);
+      let result;
+
+      switch (req.url) {
+        case '/create_account': {
+          let acc = await manager.get_account(data.name);
+          if (acc) {
+            if (!await acc.verify(data.password)) {
+              result = { message: 'Incorrect password.' };
+            } else {
+              const uid = generate_random_string(16, 'alnum');
+              account_uids[uid] = data.name;
+              result = { uid, message: 'Account signed-in successfully.' };
+            }
           } else {
-            result = { message: 'Account creation failed.' };
+            let newAcc = await manager.add_account(data.name, { password: data.password });
+            if (newAcc) {
+              const uid = generate_random_string(16, 'alnum');
+              account_uids[uid] = data.name;
+              result = { uid, message: 'Account created successfully.' };
+            } else {
+              result = { message: 'Account creation failed.' };
+            }
           }
+          break;
         }
-        break;
-
-      case '/oracle':
-        result = await manager.oracle.call(data);
-        break;
-      default:
-        let account_name = account_uids[data.account], account_obj;
-        if (!account_name){
-          if (['load', 'run', 'parse'].includes(req.url.slice(1))){
-            return res.end(JSON.stringify({ message: `Account ${data.account} not found` }));
+
+        case '/oracle':
+          result = await manager.oracle.call(data);
+          break;
+
+        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);
           }
-        }else account_obj = await manager.get_account(account_name);
-
-        if (req.url === '/load'){
-          result = await account_obj.load(data);
-        }else if (req.url === '/run'){
-          result = await account_obj.run(data);
-        }else if (req.url === '/parse'){
-          result = await account_obj.parse(data);
-        }else {
-          return app? app(req,res): res.writeHead(404).end('Not Found');
+          break;
         }
-        break;
+      }
+
+      res.writeHead(200, { 'Content-Type': 'application/json' });
+      return res.end(JSON.stringify(result));
     }
 
-    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');
 
   } catch (err) {
     console.error('Handler error:', err);
@@ -108,10 +110,10 @@ const create_server = (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;
 };
 
 export default create_server;
-export { PORT };
+export { PORT };