godprotocol 1.1.32 → 1.2.0

package/Datatypes/twa.js

@@ -1,88 +1,363 @@
-import Storage from "./functions/storage";
+import Storage from "./functions/storage.js";
 
 class Twa extends Storage {
-  constructor(config, manager) {
-    super(manager);
+  constructor(config, account) {
+    super(account);
 
     this.config = config
     this.type = 'twain'
+
+    this.methods = {
+      ...this.methods,
+      
+      extend: {args: [['obj', 'twain']], ret: ['thisobj', 'twain']},
+      zip: {args: [['prop', 'array'], ['value', 'array']], ret: ['obj', 'twain']},
+      unzip: {args: [], ret: ['array_pair', 'array[[], []]']},
+      copy: {args: [], ret: ['obj', 'twain']},
+      clear: {args: [], ret: ['obj', 'twain']},
+      is_empty: {args: [], ret: ['yes', 'boolean']},
+      has: {args: [['prop', 'object']], ret: ['yes', 'boolean']},
+      unset: {args: [['prop', 'object']], ret: ['yes', 'boolean']},
+      keys: {args: [], ret: ['keys', 'array']},
+      values: {args: [], ret: ['values', 'array']},
+      entries: {args: [], ret: ['[[key, value],...pair]', 'array']},
+      get: {args: [['prop', 'string']], ret: ['value', 'object|void']},
+      set: {args: [['prop', 'string'], ['value', 'object']], ret: ['done', 'void']},
+    }
   }
 
-  call = async(name, args, options)=>{
-    let {config, chain} = options
-    let me = await this.statics_()
-    let oracle = this.account.manager.oracle;
-
-    let spli = this.value.value.split('/');
-    let config_hash = spli.slice(-1)[0], store;
-
-    let other = args[0], result;
-
-    switch(name){
-      case 'set':
-
-        me[await oracle.hash(await other.literal(), 'sha1')] = [await this.account.vm.instance_address((await other.statics_())), await this.account.vm.instance_address((await args[1].statics_()))]
-
-        store = true;
-        break;
-      case 'get':
-        other = other && await other.literal();
-        result = me[await oracle.hash(other, 'sha1')]
-        result = result? {type:'address', value: result[1]}:null
-        break;
-      case 'entries':
-        result = new Array()
-        for (let prop in me){
-          let pair = me[prop]
-
-          let res = await this.account.vm.execute({
-            type:'call',
-            identifier: 'array',
-            arguments: [pair],
-            location: `${config.location}/${prop}`
-          }, {chain})
-          result.push(res.value);
-        }
+  __or__ = async(other)=>{
+    if (!this.config.value){
+      return await other.to_address()
+    }
+    return await this.to_address()
+  }
+
+  __and__ = async(other)=>{
+    if (!this.config.value){
+      return await this.to_address()
+    }
+    return await other.to_address()
+  }
+
+  get_ = async(prop)=>{
+    let key = await this.key(prop.literal? await prop.literal(): prop)
+
+    return await (await this.chain()).get({key})
+  }
+
+  set_ = async(prop, args)=>{
+    let value = args[1]
+    let key = await this.key(await prop.literal())
+    prop = await prop.to_address();
+    value = await value.to_address()
+    let chain = await this.chain()
+    await chain.set({twa: this.config, prop, value, key})
+  }
+
+  retrieve = async(entries)=>{
+    delete this.config.entries
+
+    let ds = this.account.manager.ds
+    await (await ds.folder(this.config.location)).write(this.config, {replace: true})
 
-        break;
-      case "keys":
-        result = new Array()
-        for (let prop in me){
-          let pair = me[prop]
-          result.push(pair[0])
+    for (let i=0; i< entries.length; i++){
+      let entry = entries[i]
+
+      let prop = await (await ds.folder(entry.prop.value, {account: this.account.physical_address})).readone({_id: entry.prop._id})
+      let val;
+      if (entry.value.type === 'function'){
+        let res = await this.account.vm.cloth(entry.value, {just_content: true})
+        
+        if (!res){
+          await this.account.reload({address: entry.value.module})
         }
-        break;
-      case "values":
-        result = new Array()
-        for (let prop in me){
-          let pair = me[prop]
-          result.push(pair[1])
+      } else val = await (await ds.folder(entry.value.value, {account: this.account.physical_address})).readone({_id: entry.value._id})
+      
+      if(!val && entry.value.type !== 'function' && entry.value.value.endsWith('/instances')){
+        let adr = entry.value.value.split('/').slice(0,-1).join('/')
+        val = await (await ds.folder(adr, {account: this.account.physical_address})).readone({_id: entry.value._id})
+      }
+      if (val){
+        if (['array', 'twain'].includes(val.type)){
+          await (await this.account.vm.cloth_content(val)).retrieve(val.items || val.entries)
+        } else if(val.type === 'instance'){
+          await this.account.vm.retrieve(val)
+        } else if (val.type === 'function'){
+        } else {
+          await (await ds.folder(entry.value.value)).write(val, {replace: true}) 
         }
-        break;
-      case 'clear':
-        me = {}
-        store = true
-        break;
-      case 'remove':
-        other = other && await other.literal()
-        other = other && await oracle.hash(other, 'sha1')
-        result = Object(me).hasOwnProperty(other)
-        delete me[other]
-        store = true
-        break;
-      case 'copy':
-        result = me;
-        break;
-      case 'is_empty':
-        result = Array.from(Object.keys(me)).length === 0
-        break;
+      }
+      prop && await (await ds.folder(entry.prop.value)).write(prop, {replace: true})
+
+      let pair_folder = await ds.folder(entry.location)
+      await (await pair_folder.folder('__prop__')).write(entry.prop, {replace: true})
+      delete entry.prop
+      delete entry.location
+
+      await pair_folder.write(entry, {replace: true})
+    }
+  }
+
+  store = async({store, thread})=>{
+    let ds = this.account.manager.ds, vm = this.account.vm;
+
+    let addr = this.config.value;
+    let data = {...this.config, entries: []}
+    while(addr){
+      let o = this._split_datapath(addr)
+      let val = await ds.folder(o[0])
+      let pair_value = await val.readone({_id: o[1]})
+
+      let datum = await store({object: await vm.cloth(pair_value.value)}, {vm, thread})
+      if (datum && datum.config){
+        process.exit()
+      }
+      
+      let prop = await this.get_prop(val)
+      let prop_obj = await vm.cloth(prop)
+      await store({object: prop_obj}, {vm, thread})
+      
+      pair_value.prop = prop;
+      pair_value.location = o[0]
+
+      data.entries.push(pair_value)
+
+      addr = pair_value.prev
+    }
+   
+    return data;
+  }
+
+  extend = async(obj)=>{
+    let {vm, manager} = this.account;
+
+    let addr = obj.config.value
+    while(addr){
+      let o = this._split_datapath(addr)
+      o = {value: o[0], _id: o[1], type: 'address'}
+      let val = await vm.cloth(o, {just_content: true})
+
+      let prop_folder = await manager.ds.folder(o.value)
+      let conf = await this.get_prop(prop_folder)
+      let prop_obj = await vm.cloth(conf)
+
+      await this.set_(prop_obj, [null, await vm.cloth_content(val.value)])
+
+      addr = val.prev
+    }
+
+    return await this.to_address()
+  }
+
+  zip = async(prop, args)=>{
+    let {vm} = this.account;
+    for (let i=0; i< prop.config.length; i++){
+      let item = await prop.index(i)
+      let val = await args[1].index(i)
+      await this.set_(await vm.cloth_content(item), [null, await vm.cloth_content(val)])
+    }
+
+    return await this.to_address()
+  }
+
+  unzip = async()=>{
+    let addr = this.config.value, vals = new Array(), props = new Array();
+    let {vm, chain, manager} = this.account;
+
+    while (addr){
+      let o = this._split_datapath(addr)
+      o = {value: o[0], _id: o[1], type: 'address'}
+      let val = await vm.cloth(o, {just_content: true})
+
+      let prop_folder = await manager.ds.folder(o.value)
+      let conf = await this.get_prop(prop_folder)
+      
+      vals.push(val.value)
+      props.push(conf)
+
+      addr= val.prev
+    }
+
+    return await vm.instantiate({
+      type: 'array',
+      value: [
+        await vm.instantiate({value: props, type:'array', location:this.spawn_address()}, {chain}), 
+        await vm.instantiate({value: vals, type:'array', location:this.spawn_address()}, {chain})]
+        ,
+      location: this.spawn_address()
+    }, {chain})
+  }
+
+  copy = async()=>{
+    let addr = this.config.value, tries = new Object();
+    let {vm, chain, manager} = this.account;
+
+    while (addr){
+      let o = this._split_datapath(addr)
+      o = {value: o[0], _id: o[1], type: 'address'}
+      let val = await vm.cloth(o, {just_content: true})
+
+      let prop_folder = await manager.ds.folder(o.value)
+      let conf = await this.get_prop(prop_folder)
+      let prop_obj = await vm.cloth(conf)
+      
+      let pair = [conf, val.value]
+      tries[await this.key(await prop_obj.literal())] = pair
+
+      addr= val.prev
+    }
+
+    return await vm.instantiate({
+      type: 'twain',
+      value: tries,
+      location: this.spawn_address()
+    }, {chain})
+  }
+
+  clear = async()=>{
+    this.config.value = ''
+    let fold = await this._folder()
+    await fold.write(this.config, {replace: true})
+  }
+
+  is_empty = async()=>{
+    return !this.config.value
+  }
+
+  has = async(prop)=>{
+    let folder = await this._folder()
+    let child = await folder.folder(await this.key(await prop.literal()))
+
+    let v = (await child.readone())
+
+    return (v && !v.deleted) || false
+  }
+
+  key = async lit=>{
+    return await this.account.vm.hash(lit, 'sha1')
+  }
+
+  unset = async(prop)=>{
+    let key = await this.key(await prop.literal())
+    
+    let chain = await this.chain()
+
+    return await chain.remove({twa: this.config, key})
+  }
+
+  get_prop = async(folder)=>{
+    return await (await folder.folder('__prop__')).readone()
+  }
+
+  keys = async(func)=>{
+    let addr = this.config.value, kys = new Array();
+    let {vm, chain, manager} = this.account;
+
+    while (addr){
+      let o = this._split_datapath(addr)
+      o = {value: o[0], _id: o[1], type: 'address'}
+      let val = await vm.cloth(o, {just_content: true})
+
+      let prop_folder = await manager.ds.folder(o.value)
+      let conf = await this.get_prop(prop_folder)
+      
+      kys.push(conf)
+
+      addr = val.prev
     }
 
-    if (store){
-      await oracle.write(spli.slice(0,-1).join('/'), {type: this.type, values: me}, {config_hash, config: true})
+    return await vm.instantiate({
+      type: 'array',
+      value: kys,
+      location: this.spawn_address()
+    }, {chain})
+  }
+
+  values = async(func)=>{
+    let addr = this.config.value, tries = new Array();
+    let {vm, chain} = this.account;
+
+    while (addr){
+      let o = this._split_datapath(addr)
+      o = {value: o[0], _id: o[1], type: 'address'}
+      let val = await vm.cloth(o, {just_content: true})
+      
+      tries.push(val.value)
+
+      addr= val.prev
+    }
+
+    return await vm.instantiate({
+      type: 'array',
+      value: tries,
+      location: this.spawn_address()
+    }, {chain})
+  }
+
+  entries = async(func)=>{
+    let addr = this.config.value, tries = new Array();
+    let {vm, chain, manager} = this.account;
+
+    while (addr){
+      let o = this._split_datapath(addr)
+      o = {value: o[0], _id: o[1], type: 'address'}
+      let val = await vm.cloth(o, {just_content: true})
+
+      let prop_folder = await manager.ds.folder(o.value)
+      let conf = await (await prop_folder.folder('__prop__')).readone()
+      
+      let pair = [conf, val.value]
+      pair = await vm.instantiate({
+        type: 'array',
+        value: pair,
+        location: this.spawn_address()
+      }, {chain})
+      tries.push(pair)
+
+      addr= val.prev
+    }
+
+    return await vm.instantiate({
+      type: 'array',
+      value: tries,
+      location: this.spawn_address()
+    }, {chain})
+  }
+
+  literal = async(options={})=>{
+    if (this.value)return this.value;
+
+    let {vm, manager} = this.account;
+
+    this.value = {}
+
+    let addr = this.config.value, val;
+    while (addr){
+      let o = this._split_datapath(addr)
+      o = {value: o[0], _id: o[1], type: 'address'}
+      val = await vm.cloth(o, {just_content: true, })
+      let value = await vm.cloth(val.value)
+
+      let prop_folder = await manager.ds.folder(o.value)
+      let conf = await this.get_prop(prop_folder)
+      let prop = await vm.cloth(conf)
+
+
+      if(!value){ 
+        console.log(val)
+        return
+      }
+
+      this.value[await prop.literal()] = await value.literal()
+      addr= val.prev
     }
 
-    return result;
+    return this.value
+  }
+
+  sync = ()=>{
+    return this
   }
 }
 

package/Datatypes/voi.js

@@ -1,10 +1,15 @@
-import Storage from "./functions/storage";
+import Storage from "./functions/storage.js";
 
 class Voi extends Storage {
-  constructor(config, manager) {
-    super(config, manager);
+  constructor(config, account) {
+    super(account);
 
-    this.value = null;
+    this.config = config
+    this.type = 'void'
+  }
+
+  literal = ()=>{
+    return 'void'
   }
 }
 

package/Index.js

@@ -1,4 +1,4 @@
-import Trinity from "./Objects/Trinity";
+import Trinity from "./Objects/Trinity.js";
 
 let trinity = new Trinity(process.env.Trinity || "GodProtocol");
 

package/Instances/fold.js

@@ -0,0 +1,103 @@
+import store from "godprotocol/callables/functions/store.js";
+import Storage from "godprotocol/Datatypes/functions/storage.js";
+
+class Fold extends Storage{
+  constructor(config, account) {
+    super(account)
+
+    this.config = config
+    this.type = 'folder'
+  }
+
+  child = async(name, opts)=>{
+    return await this.folder(name, {...opts, account: this.account.physical_address})
+  }
+
+  _folder_ = async()=>{
+    let folder = await this.account.manager.ds.folder(this.config.value, {account: this.account.physical_address})
+
+    return folder;
+  }
+
+  get_config = async()=>{
+    let folder = await this._folder_()
+    return folder.config.config
+  }
+
+  total_entries = async()=>{
+    let folder = await this._folder_()
+
+    return folder.config.config.files
+  }
+
+  read = async(query, args, {call_config, chain})=>{
+    let ds = this.account.manager.ds;
+    let folder = await ds.folder(this.config.value, {account: this.account.physical_address})
+    let options = args[1] && await args[1].literal()
+
+    let res = await folder.read(query && await query.literal(), {...options})
+
+    for (let i=0; i< res.length; i++){
+      let item = res[i]
+
+      let fold = await ds.folder(item.address, {account: this.account.physical_address})
+      let value = await fold.readone({_id: item.data_id || item._id})
+
+      let obj = await this.account.vm.retrieve(value)
+
+      res[i] = obj;
+    }
+    
+    return await this.account.vm.instantiate({
+      type: 'array',
+      location: call_config.location,
+      value: res,
+    }, {chain})
+  }
+
+  readone = async(query, args)=>{
+    
+  }
+
+  persist_repo = async(buffer)=>{
+    
+  }
+
+  write = async(data, args, {thread})=>{
+    let _id = await data.get('_id', {raw: true})
+    let options = (args[1] && await args[1].literal()) || {}
+    
+    if (_id && _id.type === 'address'){
+      _id = await (await this.account.vm.cloth(_id)).literal()
+      if (_id) _id = await this.account.vm.hash(_id.toString())
+    } else _id = null
+    
+    let folder = await this.account.manager.ds.folder(this.config.value, {account: this.account.physical_address})
+
+    if (_id && options.replace === false){
+      if (await folder.readone({_id})) return _id
+    }
+    
+    data = await store({object: data}, {chain: this.account.chain, vm: this.account.vm, thread })
+    
+    let res = await folder.write({address: data.location, data_id: data._id, _id: _id || data._id, }, {replace: true, ...options})
+    
+    return res._id;
+  }
+
+  update = async(query, args)=>{
+    
+  }
+
+  remove = async(query, args)=>{
+    
+  }
+
+  literal = async()=>{
+    let folder = await this.account.manager.gds.folder(this.config.value)
+
+    return `[Folder ${folder.name}]`
+  }
+}
+
+export default Fold

package/Instances/folder_queries.js

@@ -0,0 +1,46 @@
+class Folder_queries {
+  write = async(payload, args)=>{
+    if (this.type !== 'folder') return 'READ-ONLY';
+
+    payload = await args[0].literal()
+    let options = args[1] && await args[1].literal()
+
+    let folder = await this._folder()
+
+    return await (await folder.write(payload, options)).to_instance(this.account)
+  }
+
+  read = async(payload, args)=>{
+    payload = await args[0].literal()
+    let options = args[1] && await args[1].literal()
+
+    let folder = await this._folder()
+
+    return await (await folder.read(payload, options)).to_instance(this.account)
+  }
+
+  update = async(payload, args)=>{
+    if (this.type !== 'folder') return 'READ-ONLY';
+
+    payload = await args[0].literal()
+    let options = args[1] && await args[1].literal()
+
+    let folder = await this._folder()
+
+    return await (await folder.update(payload, options)).to_instance(this.account)
+  }
+
+  remove = async(payload, args)=>{
+    if (this.type !== 'folder') return 'READ-ONLY';
+    
+    payload = await args[0].literal()
+    let options = args[1] && await args[1].literal()
+
+    let folder = await this._folder()
+
+    return await (await folder.remove(payload, options)).to_instance(this.account)
+  }
+}
+
+
+export default Folder_queries

package/Instances/response.js

@@ -0,0 +1,31 @@
+import Storage from "godprotocol/Datatypes/functions/storage.js";
+
+class Res extends Storage{
+  constructor(config, account){
+    super(account)
+
+    this.config = config
+  }
+
+  content = async()=>{
+    return await this.literal()
+  }
+
+  literal = async()=>{
+    if (this.value){
+      return this.value
+    }
+
+    this.value = await this.account.vm.execute({
+      type:'address',
+      value: this.config.value,
+    }, {chain: this.account.chain, cloth: true})
+
+
+    this.value = await this.value.literal()
+
+    return this.value
+  }
+}
+
+export default Res