autobee 1.0.2 → 1.0.3

package/encoding/compat.js

@@ -0,0 +1,341 @@
+const path = require('path')
+
+module.exports = function buildAutobaseSchema(schema, DIR) {
+  const autobase = schema.namespace('autobase-compat')
+
+  autobase.require(path.join(DIR, 'legacy.js'))
+
+  autobase.register({
+    name: 'checkout',
+    compact: true,
+    fields: [
+      {
+        name: 'key',
+        type: 'fixed32',
+        required: true
+      },
+      {
+        name: 'length',
+        type: 'uint',
+        required: true
+      }
+    ]
+  })
+
+  autobase.register({
+    name: 'clock',
+    array: true,
+    compact: true,
+    type: '@autobase-compat/checkout'
+  })
+
+  autobase.register({
+    name: 'index-checkpoint',
+    compact: true,
+    fields: [
+      {
+        name: 'signature',
+        type: 'fixed64',
+        required: true
+      },
+      {
+        name: 'length',
+        type: 'uint',
+        required: true
+      }
+    ]
+  })
+
+  autobase.register({
+    name: 'boot-record-v0',
+    external: 'BootRecordV0'
+  })
+
+  autobase.register({
+    name: 'boot-record-raw',
+    fields: [
+      {
+        name: 'key',
+        type: 'fixed32',
+        required: true
+      },
+      {
+        name: 'systemLength',
+        type: 'uint',
+        required: true
+      },
+      {
+        name: 'indexersUpdated',
+        type: 'bool',
+        required: false
+      },
+      {
+        name: 'fastForwarding',
+        type: 'bool',
+        required: false
+      },
+      {
+        name: 'recoveries',
+        type: 'uint',
+        required: false
+      }
+    ]
+  })
+
+  autobase.register({
+    name: 'boot-record',
+    versions: [
+      {
+        version: 0,
+        type: '@autobase-compat/boot-record-v0'
+      },
+      {
+        version: 3,
+        type: '@autobase-compat/boot-record-raw'
+      }
+    ]
+  })
+
+  autobase.register({
+    name: 'checkpointer',
+    compact: true,
+    fields: [
+      {
+        name: 'checkpointer',
+        type: 'uint',
+        required: false
+      },
+      {
+        name: 'checkpoint',
+        type: '@autobase-compat/index-checkpoint',
+        required: false
+      }
+    ]
+  })
+
+  autobase.register({
+    name: 'checkpoint',
+    compact: false,
+    fields: [
+      {
+        name: 'system',
+        type: '@autobase-compat/checkpointer',
+        required: false
+      },
+      {
+        name: 'encryption',
+        type: '@autobase-compat/checkpointer',
+        required: false
+      },
+      {
+        name: 'user',
+        type: '@autobase-compat/checkpointer',
+        array: true,
+        required: false
+      }
+    ]
+  })
+
+  autobase.register({
+    name: 'digest',
+    compact: false,
+    fields: [
+      {
+        name: 'pointer',
+        type: 'uint',
+        required: false
+      },
+      {
+        name: 'key',
+        type: 'fixed32',
+        required: false
+      }
+    ]
+  })
+
+  autobase.register({
+    name: 'node',
+    compact: true,
+    fields: [
+      {
+        name: 'heads',
+        type: '@autobase-compat/clock',
+        required: true
+      },
+      {
+        name: 'batch',
+        type: 'uint',
+        required: true
+      },
+      {
+        name: 'value',
+        type: 'buffer',
+        required: true
+      }
+    ]
+  })
+
+  autobase.register({
+    name: 'user-view-trace',
+    compact: true,
+    fields: [
+      {
+        name: 'view',
+        type: 'uint',
+        required: true
+      },
+      {
+        name: 'blocks',
+        type: 'uint',
+        array: true,
+        required: true
+      }
+    ]
+  })
+
+  autobase.register({
+    name: 'trace',
+    compact: false,
+    fields: [
+      {
+        name: 'system',
+        type: 'uint',
+        array: true,
+        required: true
+      },
+      {
+        name: 'encryption',
+        type: 'uint',
+        array: true,
+        required: true
+      },
+      {
+        name: 'user',
+        type: '@autobase-compat/user-view-trace',
+        array: true,
+        required: true
+      }
+    ]
+  })
+
+  autobase.register({
+    name: 'oplog-message-v0',
+    external: 'OplogMessageV0'
+  })
+
+  autobase.register({
+    name: 'oplog-message-v1',
+    external: 'OplogMessageV1'
+  })
+
+  autobase.register({
+    name: 'oplog-message-v2',
+    compact: false,
+    fields: [
+      {
+        name: 'node',
+        type: '@autobase-compat/node',
+        required: true
+      },
+      {
+        name: 'checkpoint',
+        type: '@autobase-compat/checkpoint',
+        required: false
+      },
+      {
+        name: 'digest',
+        type: '@autobase-compat/digest',
+        required: false
+      },
+      {
+        name: 'optimistic',
+        type: 'bool',
+        required: false
+      },
+      {
+        name: 'trace',
+        type: '@autobase-compat/trace',
+        required: false
+      }
+    ]
+  })
+
+  autobase.register({
+    name: 'info-v1',
+    fields: [
+      {
+        name: 'members',
+        type: 'uint',
+        required: true
+      },
+      {
+        name: 'pendingIndexers',
+        type: 'fixed32',
+        array: true,
+        required: true
+      },
+      {
+        name: 'indexers',
+        type: '@autobase-compat/clock',
+        required: true
+      },
+      {
+        name: 'heads',
+        type: '@autobase-compat/clock',
+        required: true
+      },
+      {
+        name: 'views',
+        type: '@autobase-compat/clock',
+        required: true
+      }
+    ]
+  })
+
+  autobase.register({
+    name: 'info-v2',
+    fields: [
+      {
+        name: 'members',
+        type: 'uint',
+        required: true
+      },
+      {
+        name: 'pendingIndexers',
+        type: 'fixed32',
+        array: true,
+        required: true
+      },
+      {
+        name: 'indexers',
+        type: '@autobase-compat/clock',
+        required: true
+      },
+      {
+        name: 'heads',
+        type: '@autobase-compat/clock',
+        required: true
+      },
+      {
+        name: 'views',
+        type: '@autobase-compat/clock',
+        required: true
+      },
+      {
+        name: 'encryptionLength',
+        type: 'uint',
+        required: true
+      },
+      {
+        name: 'entropy',
+        type: 'fixed32',
+        required: false
+      }
+    ]
+  })
+
+  autobase.register({
+    name: 'member',
+    external: 'SystemWriterV0'
+  })
+}

package/encoding/legacy.js

@@ -0,0 +1,317 @@
+const c = require('compact-encoding')
+
+const Checkout = {
+  preencode(state, m) {
+    c.fixed32.preencode(state, m.key)
+    c.uint.preencode(state, m.length)
+  },
+  encode(state, m) {
+    c.fixed32.encode(state, m.key)
+    c.uint.encode(state, m.length)
+  },
+  decode(state) {
+    return {
+      key: c.fixed32.decode(state),
+      length: c.uint.decode(state)
+    }
+  }
+}
+
+const Clock = c.array(Checkout)
+
+const IndexCheckpoint = {
+  preencode(state, m) {
+    c.fixed64.preencode(state, m.signature)
+    c.uint.preencode(state, m.length)
+  },
+  encode(state, m) {
+    c.fixed64.encode(state, m.signature)
+    c.uint.encode(state, m.length)
+  },
+  decode(state) {
+    return {
+      signature: c.fixed64.decode(state),
+      length: c.uint.decode(state)
+    }
+  }
+}
+
+const BootRecordV0 = {
+  preencode() {
+    throw new Error('version 0 records cannot be encoded')
+  },
+  encode() {
+    throw new Error('version 0 records cannot be encoded')
+  },
+  decode(state) {
+    const indexed = Checkout.decode(state)
+    const heads = Clock.decode(state)
+
+    // one cause initial recover is not ff recovery
+    return {
+      version: 0,
+      key: indexed.key,
+      systemLength: indexed.length,
+      indexersUpdated: false,
+      fastForwarding: false,
+      recoveries: 1,
+      migrating: false,
+      heads
+    }
+  }
+}
+
+const Checkpointer = {
+  preencode(state, idx) {
+    c.uint.preencode(state, idx.checkpointer)
+    if (idx.checkpoint !== null) IndexCheckpoint.preencode(state, idx.checkpoint)
+  },
+  encode(state, idx) {
+    c.uint.encode(state, idx.checkpointer)
+    if (idx.checkpoint !== null) IndexCheckpoint.encode(state, idx.checkpoint)
+  },
+  decode(state) {
+    const checkpointer = c.uint.decode(state)
+    const checkpoint = checkpointer ? null : IndexCheckpoint.decode(state)
+
+    return {
+      checkpointer,
+      checkpoint
+    }
+  }
+}
+
+const CheckpointerArray = c.array(Checkpointer)
+
+const Indexer = {
+  preencode(state, m) {
+    c.uint.preencode(state, m.signature)
+    c.fixed32.preencode(state, m.namespace)
+    c.fixed32.preencode(state, m.publicKey)
+  },
+  encode(state, m) {
+    c.uint.encode(state, m.signature)
+    c.fixed32.encode(state, m.namespace)
+    c.fixed32.encode(state, m.publicKey)
+  },
+  decode(state) {
+    return {
+      signature: c.uint.decode(state),
+      namespace: c.fixed32.decode(state),
+      publicKey: c.fixed32.decode(state)
+    }
+  }
+}
+
+const Indexers = c.array(Indexer)
+
+const DigestV0 = {
+  preencode(state, m) {
+    c.uint.preencode(state, m.pointer)
+    if (m.pointer === 0) {
+      Indexers.preencode(state, m.indexers)
+    }
+  },
+  encode(state, m) {
+    c.uint.encode(state, m.pointer)
+    if (m.pointer === 0) {
+      Indexers.encode(state, m.indexers)
+    }
+  },
+  decode(state) {
+    const pointer = c.uint.decode(state)
+    return {
+      pointer,
+      indexers: pointer === 0 ? Indexers.decode(state) : null
+    }
+  }
+}
+
+const Digest = {
+  preencode(state, m) {
+    c.uint.preencode(state, m.pointer)
+    if (m.pointer === 0) {
+      c.fixed32.preencode(state, m.key)
+    }
+  },
+  encode(state, m) {
+    c.uint.encode(state, m.pointer)
+    if (m.pointer === 0) {
+      c.fixed32.encode(state, m.key)
+    }
+  },
+  decode(state) {
+    const pointer = c.uint.decode(state)
+    return {
+      pointer,
+      key: pointer === 0 ? c.fixed32.decode(state) : null
+    }
+  }
+}
+
+const Node = {
+  preencode(state, m) {
+    Clock.preencode(state, m.heads)
+    c.uint.preencode(state, m.batch)
+    c.buffer.preencode(state, m.value)
+  },
+  encode(state, m) {
+    Clock.encode(state, m.heads)
+    c.uint.encode(state, m.batch)
+    c.buffer.encode(state, m.value)
+  },
+  decode(state, m) {
+    return {
+      heads: Clock.decode(state),
+      batch: c.uint.decode(state),
+      value: c.buffer.decode(state)
+    }
+  }
+}
+
+const Additional = {
+  preencode(state, m) {
+    c.uint.preencode(state, m.pointer)
+    if (m.pointer === 0) {
+      AdditionalData.preencode(state, m.data)
+    }
+  },
+  encode(state, m) {
+    c.uint.encode(state, m.pointer)
+    if (m.pointer === 0) {
+      AdditionalData.encode(state, m.data)
+    }
+  },
+  decode(state) {
+    const pointer = c.uint.decode(state)
+    return {
+      pointer,
+      data: pointer === 0 ? AdditionalData.decode(state) : null
+    }
+  }
+}
+
+const AdditionalData = {
+  preencode(state, m) {
+    c.uint.preencode(state, 0)
+  },
+  encode(state, m) {
+    c.uint.encode(state, 0) // empty for now, for the future
+  },
+  decode(state) {
+    const flags = c.uint.decode(state)
+    return {
+      encryptionId: flags & 1 ? c.fixed32.decode(state) : null, // to help validate the encryption key used
+      abi: flags & 2 ? c.uint.decode(state) : 0
+    }
+  }
+}
+
+const OplogMessageV1 = {
+  preencode(state, m) {
+    throw new Error('Encoding not supported')
+  },
+  encode(state, m) {
+    throw new Error('Encoding not supported')
+  },
+  decode(state) {
+    const maxSupportedVersion = c.uint.decode(state)
+
+    const flags = c.uint.decode(state)
+
+    const isCheckpointer = (flags & 1) !== 0
+
+    const chk = isCheckpointer ? CheckpointerArray.decode(state) : null
+    const digest = isCheckpointer ? Digest.decode(state) : null
+
+    const node = Node.decode(state)
+
+    return {
+      version: 1,
+      maxSupportedVersion,
+      digest,
+      checkpoint: chk ? { system: chk[0], encryption: null, user: chk.slice(1) } : null,
+      optimistic: (flags & 2) !== 0,
+      node
+    }
+  }
+}
+
+const OplogMessageV0 = {
+  preencode(state, m) {
+    throw new Error('Encoding not supported')
+  },
+  encode(state, m) {
+    throw new Error('Encoding not supported')
+  },
+  decode(state) {
+    const flags = c.uint.decode(state)
+
+    const isCheckpointer = (flags & 1) !== 0
+
+    if (isCheckpointer) DigestV0.decode(state)
+    const chk = isCheckpointer ? CheckpointerArray.decode(state) : null
+    const node = Node.decode(state)
+    Additional.decode(state)
+    const maxSupportedVersion = state.start < state.end ? c.uint.decode(state) : 0
+
+    return {
+      version: 0,
+      maxSupportedVersion,
+      digest: null,
+      checkpoint: chk ? { system: chk[0], encryption: null, user: chk.slice(1) } : null,
+      optimistic: null,
+      node
+    }
+  }
+}
+
+const SystemWriterV0 = {
+  preencode(state, m) {
+    throw new Error('Encoding not supported')
+  },
+  encode(state, m) {
+    throw new Error('Encoding not supported')
+  },
+  decode(state) {
+    const flags = c.uint.decode(state)
+
+    return {
+      version: 0,
+      isIndexer: flags & 1,
+      isRemoved: flags & 2,
+      length: c.uint.decode(state)
+    }
+  }
+}
+
+function infoLegacyMap(info) {
+  return {
+    version: info.version,
+    members: info.members,
+    pendingIndexers: info.pendingIndexers,
+    indexers: info.indexers,
+    heads: info.heads,
+    views: info.views,
+    encryptionLength: 0,
+    entropy: null
+  }
+}
+
+function memberLegacyMap(m) {
+  return {
+    version: 0,
+    isRemoved: m.isRemoved,
+    weight: m.isIndexer ? 2 : 1,
+    length: m.length
+  }
+}
+
+module.exports = {
+  BootRecordV0,
+  OplogMessageV0,
+  OplogMessageV1,
+  SystemWriterV0,
+  infoLegacyMap,
+  memberLegacyMap
+}