godprotocol 1.2.25 → 1.2.27

package/Objects/Callable.js

@@ -10,17 +10,17 @@ class Callable extends Vm_utils {
   parse_aircode = async (result, { config, chain, id }) => {
     if (result == null) result = "void";
 
-    let loc = config && config.location.split("/").slice(2).join("/")
-    
-    result = result === 'void'? result: JSON.stringify(result)
-    if (result === 'void') return await this.voided()
+    let loc = config && config.location.split("/").slice(2).join("/");
+
+    result = result === "void" ? result : JSON.stringify(result);
+    if (result === "void") return await this.voided();
 
     let res = await this.account.compiler.to_sequence(
       result,
       !loc ? "CONSTANTS" : loc
-    )
+    );
     res = res[0].body[0];
-    
+
     await chain.add_config(res);
     result = await this.execute(res, { chain, id });
 
@@ -28,177 +28,195 @@ class Callable extends Vm_utils {
   };
 
   instantiate = async (config, { chain, value, _id }) => {
-    let chn = await chain.chain(config.location)
-    let folder = await chn.folder()
+    let chn = await chain.chain(config.location);
+    let folder = await chn.folder();
 
-    if (['void', 'boolean'].includes(config.type)){
-      let res = await this.statics(config)
+    if (["void", "boolean"].includes(config.type)) {
+      let res = await this.statics(config);
       return res;
     }
 
     let obj = {
-      _id,
-      type: config.type,
-      created: Date.now(),
-      location: folder.address
-    }, res;
-    
-    if(config.type === 'error'){
-      obj.value = config.payload
-      res = await folder.write(obj)
-      obj._id = res._id
-      
-    } else if (config.type === 'twain'){
-      res = await folder.write(obj)
-      obj._id = res._id
-      obj.created = res.created
-
-      if (value){
-        let val_obj = await this.cloth(value)
-        let obj_obj = await this.cloth_content(obj)
-        obj_obj.address = folder.address
-        await obj_obj.extend(val_obj)
-      }else {
-        for (let key in config.value){
-          let [prop, value] = config.value[key]
-          if(typeof prop === 'string'){
-            prop = await this.execute(await this.read_config(prop), {chain})
+        _id,
+        type: config.type,
+        created: Date.now(),
+        location: folder.address,
+      },
+      res;
+
+    if (config.type === "error") {
+      obj.value = config.payload;
+      res = await folder.write(obj);
+      obj._id = res._id;
+    } else if (config.type === "twain") {
+      res = await folder.write(obj);
+      obj._id = res._id;
+      obj.created = res.created;
+
+      if (value) {
+        let val_obj = await this.cloth(value);
+        let obj_obj = await this.cloth_content(obj);
+        obj_obj.address = folder.address;
+        await obj_obj.extend(val_obj);
+      } else {
+        for (let key in config.value) {
+          let [prop, value] = config.value[key];
+          if (typeof prop === "string") {
+            prop = await this.execute(await this.read_config(prop), { chain });
           }
-          if(typeof value === 'string'){
-            value = await this.execute(await this.read_config(value), {chain})
+          if (typeof value === "string") {
+            value = await this.execute(await this.read_config(value), {
+              chain,
+            });
           }
-          await chn.set({twa: obj, key, prop, value})
+          await chn.set({ twa: obj, key, prop, value });
         }
       }
-      
-      res = await folder.write(obj, {replace: true})
-    }else if (config.type === 'array'){
-      obj.length = 0
-
-      res = await folder.write(obj)
-      obj._id = res._id
-      obj.created = res.created
-      
-      if (value){
-        let val_obj = await this.cloth(value)
-        let obj_obj = await this.cloth_content(obj)
-        obj_obj.address = folder.address
-        await obj_obj.extend(val_obj)
-      }else {
-        for (let i =0; i < config.value.length; i++){
-          let item = config.value[i]
-          if (typeof item === 'string'){
-            item = await this.execute(await this.read_config(item), {chain})
+
+      res = await folder.write(obj, { replace: true });
+    } else if (config.type === "array") {
+      obj.length = 0;
+
+      res = await folder.write(obj);
+      obj._id = res._id;
+      obj.created = res.created;
+
+      if (value) {
+        let val_obj = await this.cloth(value);
+        let obj_obj = await this.cloth_content(obj);
+        obj_obj.address = folder.address;
+        await obj_obj.extend(val_obj);
+      } else {
+        for (let i = 0; i < config.value.length; i++) {
+          let item = config.value[i];
+          if (typeof item === "string") {
+            item = await this.execute(await this.read_config(item), { chain });
           }
-          await chn.insert({arr: obj, item, index: obj.length})
+          await chn.insert({ arr: obj, item, index: obj.length });
         }
       }
-      
-      res = await folder.write(obj, {replace: true})
-    }else if (['string', 'number', 'void', 'boolean'].includes(config.type)){
-      if (value){
-        folder = await this.account.manager.ds.folder(value.value)
-        obj._id = value._id
-      }else {
-        obj.value = config.value
-        res = await folder.write(obj)
-        obj._id = res._id
-        obj.created = res.created
-        obj.address = folder.address
-      } 
+
+      res = await folder.write(obj, { replace: true });
+    } else if (["string", "number", "void", "boolean"].includes(config.type)) {
+      if (value) {
+        folder = await this.account.manager.ds.folder(value.value);
+        obj._id = value._id;
+      } else {
+        obj.value = config.value;
+        res = await folder.write(obj);
+        obj._id = res._id;
+        obj.created = res.created;
+        obj.address = folder.address;
+      }
     }
     res = {
       value: folder.address,
-      type: 'address',
-      _id: obj._id
-    }
+      type: "address",
+      _id: obj._id,
+    };
 
-    return res
+    return res;
   };
 
-  callable_address = async (config, o)=>{
-    let obj = await this.cloth_content(config)
-    obj.address = config.address
+  callable_address = async (config, o) => {
+    let obj = await this.cloth_content(config);
+    obj.address = config.address;
+
+    return o ? obj : await obj.to_address();
+  };
 
-    return o ? obj : await obj.to_address()
-  }
-  
   execute_call = async (call_config, { chain, thread }) => {
     let result;
-    let {identifier, arguments: args, location} = call_config
-    
-    if (location){
-      location = await chain.chain(location)
+    let { identifier, arguments: args, location } = call_config;
+
+    if (location) {
+      location = await chain.chain(location);
     }
 
-    if (identifier.type === 'address'){
+    if (identifier.type === "address") {
       // If call is a reference, such as to a class method
-      let {object, value, config: is_config} = identifier
-      if (object){
-        let spl = this._split_datapath(object)
-        let obj = {value: spl[0], _id: spl[1], type: 'address', config: is_config}
-        obj = await this.cloth(obj)
-        
-        if (value.includes('/')){
-          await obj.run(call_config, {thread, chain})
-        }else{
-          result = await obj.call(value, {chain, call_config, thread})
+      let { object, value, config: is_config } = identifier;
+      if (object) {
+        let spl = this._split_datapath(object);
+        let obj = {
+          value: spl[0],
+          _id: spl[1],
+          type: "address",
+          config: is_config,
+        };
+        obj = await this.cloth(obj);
+
+        if (value.includes("/")) {
+          await obj.run(call_config, { thread, chain });
+        } else {
+          result = await obj.call(value, { chain, call_config, thread });
         }
-      }else {
-        let obj = await this.cloth(identifier)
-        if (['class', 'function', 'instance'].includes(obj.type)){
-
-        }else result = await this.throw_error({type:"TypeError", message: `type ${obj.type} is not callable.`})
+      } else {
+        let obj = await this.cloth(identifier);
+        if (["class", "function", "instance"].includes(obj.type)) {
+        } else
+          result = await this.throw_error({
+            type: "TypeError",
+            message: `type ${obj.type} is not callable.`,
+          });
       }
-    } else if (['function', 'class'].includes(identifier.type)){
-      let call = await this.cloth(identifier)
-      await call.invoke(args, {chain, call_config, thread})
-    } else if (identifier.includes('/')){
+    } else if (["function", "class"].includes(identifier.type)) {
+      let call = await this.cloth(identifier);
+      await call.invoke(args, { chain, call_config, thread });
+    } else if (identifier.includes("/")) {
       // If call is a user-defined address
-      let folder = await this.account.manager.ds.folder(identifier)
-      let payload = await folder.readone()
-
-      if (payload.object){
-        result = await this.execute_call({...call_config, identifier: payload}, {chain, thread})
-      }else {
-        if (payload.config && payload._id === payload.value){
-          result = await this.execute_call({...call_config, identifier: payload._id}, {chain, thread})
-        }else {
-          let call = await this.cloth(payload)
-          await call.invoke(args, {chain, call_config, thread})
+      let folder = await this.account.manager.ds.folder(identifier);
+      let payload = await folder.readone();
+
+      if (payload.object) {
+        result = await this.execute_call(
+          { ...call_config, identifier: payload },
+          { chain, thread }
+        );
+      } else {
+        if (payload.config && payload._id === payload.value) {
+          result = await this.execute_call(
+            { ...call_config, identifier: payload._id },
+            { chain, thread }
+          );
+        } else {
+          let call = await this.cloth(payload);
+          await call.invoke(args, { chain, call_config, thread });
         }
       }
-    } else if (this.datatypes.includes(identifier)){
+    } else if (this.datatypes.includes(identifier)) {
       // If call is Datatype instantiation
- 
-      let _id = call_config.arguments.find(p=>p.identifier === '_id')
-      if (_id){
-        delete _id.identifier
-        _id = await this.cloth({..._id})
-        if (_id.type === 'string')
-          _id = await this.hash(await _id.literal())
-        else _id = null
-      }else _id = null
-      let val = call_config.arguments.find(p=>p.identifier === 'value')
-      val = (val && val.value) || call_config.arguments[0]
-      result = await this.instantiate({type: identifier, location: call_config.location}, {chain, _id, value: val})
-    } else if (this.err_objects.includes(identifier)){
-      let message = await (await this.cloth(args[0])).literal()
-      result = await this.throw_error({message, type: identifier})
+
+      let _id = call_config.arguments.find((p) => p.identifier === "_id");
+      if (_id) {
+        delete _id.identifier;
+        _id = await this.cloth({ ..._id });
+        if (_id.type === "string") _id = await this.hash(await _id.literal());
+        else _id = null;
+      } else _id = null;
+      let val = call_config.arguments.find((p) => p.identifier === "value");
+      val = (val && val.value) || call_config.arguments[0];
+      result = await this.instantiate(
+        { type: identifier, location: call_config.location },
+        { chain, _id, value: val }
+      );
+    } else if (this.err_objects.includes(identifier)) {
+      let message = await (await this.cloth(args[0])).literal();
+      result = await this.throw_error({ message, type: identifier });
     } else {
       // If call is a reserved word.
 
-      let call = await this.callable(identifier)
-      let {callable, config} = call;
-      let data = {}
+      let call = await this.callable(identifier);
+      let { callable, config } = call;
+      let data = {};
       for (let a = 0; a < args.length; a++) {
         let param;
         let arg = args[a];
-        
-        if (arg.identifier) 
-          param = config.parameters.find(p=>p.name === arg.identifier)
-        
-        if(!param) {
+
+        if (arg.identifier)
+          param = config.parameters.find((p) => p.name === arg.identifier);
+
+        if (!param) {
           param = config.parameters[arg.position || a];
           if (!param) {
             let lst_param = config.parameters.slice(-1)[0];
@@ -207,8 +225,8 @@ class Callable extends Vm_utils {
         }
 
         let res = await this.cloth(arg);
-        
-        if (param){
+
+        if (param) {
           if (param.spread) {
             let arr = data[param.name];
             if (!arr) {
@@ -219,16 +237,16 @@ class Callable extends Vm_utils {
           } else data[param.name] = res;
         }
       }
-      
-      result = await callable(data, {vm: this, call_config, chain, thread})
-      
-      if( ['store', 'net'].includes(identifier)){
-        result = await this.voided()
-      } else if(identifier === 'parse' && result){
-      }else if (['Twain', 'folder'].includes(identifier)){
-        result = await result.to_address()
-      } else if(result && ['address', 'function'].includes(result.type)){
-      } else { 
+
+      result = await callable(data, { vm: this, call_config, chain, thread });
+
+      if (["store", "net"].includes(identifier)) {
+        result = await this.voided();
+      } else if (identifier === "parse" && result) {
+      } else if (["Twain", "folder"].includes(identifier)) {
+        result = await result.to_address();
+      } else if (result && ["address", "function"].includes(result.type)) {
+      } else {
         result = await this.parse_aircode(result, {
           config: call_config,
           chain,
@@ -239,25 +257,30 @@ class Callable extends Vm_utils {
     return result;
   };
 
-  resolve_import = async(config, chain)=>{
+  resolve_import = async (config, chain) => {
     let addr = this.resolve_addr(config.address),
       oracle = this.account.manager.oracle;
 
-    for (let i=0; i< config.identifiers.length; i++){
-      let id = config.identifiers[i]
-
-      let conf = await oracle.read(`${oracle.manager.path}/${addr}/${id}`, {config: true})
-
-      await this.execute({
-        type: 'assignment',
-        identifier: id,
-        value: {
-          type: 'address',
-          value: conf.path
-        }
-      }, {chain})
+    for (let i = 0; i < config.identifiers.length; i++) {
+      let id = config.identifiers[i];
+
+      let conf = await oracle.read(`${oracle.manager.path}/${addr}/${id}`, {
+        config: true,
+      });
+
+      await this.execute(
+        {
+          type: "assignment",
+          identifier: id,
+          value: {
+            type: "address",
+            value: conf.path,
+          },
+        },
+        { chain }
+      );
     }
-  }
+  };
 
   callable = async (name) => {
     let object = this.objects[name];
@@ -269,32 +292,30 @@ class Callable extends Vm_utils {
     this.objects[name] = config;
   };
 
-  native_components = async (config, {chain, object}) => {
+  native_components = async (config, { chain, object }) => {
     let props = await this.execute(config.props, { chain, cloth: true });
     let children = new Array();
     for (let c = 0; c < config.children.length; c++) {
       let child = config.children[c];
 
       let res = await this.execute(child, { chain, cloth: true, object });
-      children.push(await res.literal({adm:true}));
+      children.push(await res.literal({ adm: true }));
     }
 
     let obj = {
       name: config.name,
-      props: await props.literal({adm:true}),
+      props: await props.literal({ adm: true }),
       children,
       _id: props.config._id,
-      path: props.path
+      path: props.path,
     };
 
-    let result = await this.parse_aircode(obj, {config, chain})
+    let result = await this.parse_aircode(obj, { config, chain });
 
     return result;
   };
 
-  rerender = async(object)=>{
-
-  }
+  rerender = async (object) => {};
 }
 
 export default Callable;

package/Objects/Manager.js

@@ -372,22 +372,20 @@ class Manager {
         app: this.options.app,
       });
 
-      this.handler = (req, res, cb) => {
+      this.handler = async (req, res, cb) => {
         handle(req, res);
 
         if (this.options.oracle && !this.served) {
           this.served = true;
           this.oracle = this.options.oracle;
-          this.oracle.sync(this).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();
-            }
-          });
+          if (this.options.init_account) {
+            await this.add_account(this.options.init_account.name, {
+              password: this.options.init_account.password,
+              init: true,
+            });
+
+            cb && cb();
+          }
         }
       };
     }