gip-remote 1.0.0 → 1.0.2

package/README.md

@@ -1,6 +1,8 @@
 # gip-remote
 
-Git-in-Pear remote database. Store and replicate Git repositories over Hyperswarm using HyperDB.
+Git-into-Pear remote database. Store and replicate p2p Git repositories [HyperDB](https://github.com/holepunchto/hyperdb).
+
+Git objects are stored raw, and rebuilt to file when needed. Built for the [Git+Pear remote transport](https://github.com/holepunchto/git-remote-punch-transport).
 
 ```
 npm install gip-remote
@@ -15,11 +17,19 @@ const { Remote } = require('gip-remote')
 
 const store = new Corestore('./my-store')
 const swarm = new Hyperswarm()
+swarm.on('connection', (conn) => {
+  store.replicate(conn)
+})
 
-const remote = new Remote({ name: 'my-repo', store, swarm })
+// new remote
+const remote = new Remote(store.namespace('my-repo'), 'my-repo')
 await remote.ready()
 
 console.log(remote.key) // public key
+
+// remote remote!
+const remote2 = new Remote(store.namespace('my-other-repo'), 'git+pear://0.1.iain5rkqfenyjrcod53tb61cq3egpwbk6cnd15ca3pqm39g7wf1y/my-other-repo')
+await remote2.ready()
 ```
 
 ### Push
@@ -38,7 +48,7 @@ const objects = await remote.getRefObjects(commitOid)
 
 ### toDrive
 
-Get a Hyperdrive-compatible interface for a branch. Works with `mirror-drive`.
+Get a Hyperdrive-compatible interface for a branch. Works with [mirror-drive](https://github.com/holepunchto/mirror-drive/).
 
 ```js
 const drive = await remote.toDrive('main')

package/index.js

@@ -1,8 +1,10 @@
 const ReadyResource = require('ready-resource')
 const HyperDB = require('hyperdb')
 const Hyperbee = require('hyperbee2')
+const z32 = require('z32')
 const def = require('./schema/hyperdb/index')
 const RemoteDrive = require('./lib/drive')
+const GitPearLink = require('./lib/link')
 const { parseCommit, walkTree } = require('./lib/git')
 
 class Remote extends ReadyResource {
@@ -11,59 +13,53 @@ class Remote extends ReadyResource {
   _db = null
   _key = null
 
-  constructor(args = {}) {
+  constructor(store, link, opts = {}) {
     super()
 
-    this._name = args.name
-    this._store = args.store
-    this._swarm = args.swarm
-    this._timeout = args.timeout || 240_000
-    this._blind = args.blind
-    this._key = args.key
+    this._link =
+      typeof link === 'string' && link.startsWith('git+pear:') ? GitPearLink.parse(link) : link
+    const config = typeof this._link === 'string' ? { name: this._link } : this._link
 
-    const bee = new Hyperbee(this._store, { key: args.key })
-    this._db = HyperDB.bee2(bee, def)
+    const bee = new Hyperbee(store, config, { autoUpdate: true })
+    this._db = HyperDB.bee2(bee, def, { autoUpdate: true })
 
-    this._onconnection = (conn) => {
-      this._store.replicate(conn)
-      this.emit('connection', conn)
-    }
-
-    this._swarm.on('connection', this._onconnection)
+    this._name = config.name || config.pathname.split('/').slice(1)[0]
+    this._timeout = opts.timeout || 240_000
+    this._blind = opts.blind
   }
 
   async _open() {
     await this._db.ready()
-
-    this._topic = this._swarm.join(this.discoveryKey)
-
-    await this._db.update()
   }
 
   async _close() {
-    this._swarm.off('connection', this._onconnection)
-
-    if (this._topic) await this._topic.destroy()
-
     await this._db.close()
   }
 
   get name() {
     return this._name
   }
+
   get core() {
     return this._db.core
   }
+
   get key() {
     return this._db.core.key
   }
+
   get discoveryKey() {
     return this._db.core.discoveryKey
   }
+
   get availablePeers() {
     return this._db.core.peers.length
   }
 
+  get url() {
+    return `git+pear://${z32.encode(this.key)}/${this.name}`
+  }
+
   // --- Objects ---
 
   async getObject(oid) {
@@ -213,6 +209,7 @@ class Remote extends ReadyResource {
 module.exports = {
   Remote,
   RemoteDrive,
+  GitPearLink,
   parseCommit,
   walkTree
 }

package/lib/link.js

@@ -0,0 +1,23 @@
+const { constructor: PearLink } = require('pear-link')
+
+const protocol = 'git+pear:'
+
+class GitPearLink extends PearLink {
+  serialize(o) {
+    if (o.protocol?.startsWith(protocol) === false) return super.serialize(o)
+    o.protocol = o.protocol.slice(4)
+    o.origin = o.origin.slice(4)
+    return 'git+' + super.serialize(o)
+  }
+  parse(link) {
+    if (link.startsWith(protocol) === false) return super.parse(link)
+    const parsed = super.parse(link.slice(4))
+    parsed.protocol = 'git+' + parsed.protocol
+    parsed.origin = 'git+' + parsed.origin
+    parsed.drive.length = parsed.drive.length ?? -1
+
+    return parsed
+  }
+}
+
+module.exports = new GitPearLink()

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "gip-remote",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "description": "Git+Pear remote DB for handling git data",
   "main": "index.js",
   "scripts": {
     "format": "prettier . --write",
-    "test": "prettier . --check && lunte && brittle-bare test/index.js",
-    "lint": "lunte"
+    "test": "brittle-bare test/all.js",
+    "lint": "prettier . --check && lunte"
   },
   "type": "commonjs",
   "imports": {
@@ -17,19 +17,33 @@
     "path": {
       "bare": "bare-path",
       "default": "path"
+    },
+    "child_process": {
+      "bare": "bare-subprocess",
+      "default": "child_process"
     }
   },
   "exports": {
     "./package": "./package.json",
     ".": {
       "default": "./index.js"
+    },
+    "./git": {
+      "default": "./lib/git.js"
+    },
+    "./schema/hyperdb": {
+      "default": "./schema/hyperdb/index.js"
+    },
+    "./schema/hyperschema": {
+      "default": "./schema/hyperschema/index.js"
     }
   },
   "files": [
     "package.json",
     "index.js",
     "index.d.ts",
-    "lib"
+    "lib",
+    "schema"
   ],
   "keywords": [],
   "repository": {
@@ -43,13 +57,16 @@
   },
   "homepage": "https://github.com/holepunchto/gip-remote",
   "devDependencies": {
+    "b4a": "^1.8.0",
+    "bare-subprocess": "^5.2.3",
     "brittle": "^3.19.1",
     "corestore": "^7.9.2",
     "hyperdht": "^6.29.6",
     "hyperswarm": "^4.17.0",
     "prettier": "^3.8.1",
     "prettier-config-holepunch": "^2.0.0",
-    "test-tmp": "^1.4.0"
+    "test-tmp": "^1.4.0",
+    "z32": "^1.1.0"
   },
   "dependencies": {
     "bare-fs": "^4.5.6",
@@ -57,6 +74,7 @@
     "hyperbee2": "^2.8.0",
     "hyperdb": "^6.3.0",
     "mirror-drive": "^1.13.0",
+    "pear-link": "^4.2.1",
     "ready-resource": "^1.2.0",
     "rebuild-git": "^1.1.1",
     "streamx": "^2.25.0"

package/schema/hyperdb/db.json

@@ -0,0 +1,69 @@
+{
+  "version": 1,
+  "offset": 0,
+  "schema": [
+    {
+      "name": "repos",
+      "namespace": "gip",
+      "id": 0,
+      "type": 1,
+      "version": 1,
+      "versionField": null,
+      "indexes": [],
+      "schema": "@gip/repos",
+      "derived": false,
+      "key": ["name"],
+      "trigger": null
+    },
+    {
+      "name": "branches",
+      "namespace": "gip",
+      "id": 1,
+      "type": 1,
+      "version": 1,
+      "versionField": null,
+      "indexes": [],
+      "schema": "@gip/branches",
+      "derived": false,
+      "key": ["name"],
+      "trigger": null
+    },
+    {
+      "name": "files",
+      "namespace": "gip",
+      "id": 2,
+      "type": 1,
+      "version": 1,
+      "versionField": null,
+      "indexes": ["@gip/files-by-branch"],
+      "schema": "@gip/files",
+      "derived": false,
+      "key": ["branch", "path"],
+      "trigger": null
+    },
+    {
+      "name": "objects",
+      "namespace": "gip",
+      "id": 3,
+      "type": 1,
+      "version": 1,
+      "versionField": null,
+      "indexes": [],
+      "schema": "@gip/objects",
+      "derived": false,
+      "key": ["oid"],
+      "trigger": null
+    },
+    {
+      "name": "files-by-branch",
+      "namespace": "gip",
+      "id": 4,
+      "type": 2,
+      "version": 1,
+      "collection": "@gip/files",
+      "unique": false,
+      "deprecated": false,
+      "key": ["branch"]
+    }
+  ]
+}

package/schema/hyperdb/index.js

@@ -0,0 +1,358 @@
+// This file is autogenerated by the hyperdb compiler
+/* eslint-disable camelcase */
+
+const { IndexEncoder, c, b4a } = require('hyperdb/runtime')
+const { version, getEncoding, setVersion } = require('./messages.js')
+
+const versions = { schema: version, db: 1 }
+
+// '@gip/repos' collection key
+const collection0_key = new IndexEncoder([IndexEncoder.STRING], { prefix: 0 })
+
+function collection0_indexify(record) {
+  const a = record.name
+  return a === undefined ? [] : [a]
+}
+
+// '@gip/repos' value encoding
+const collection0_enc = getEncoding('@gip/repos/hyperdb#0')
+
+// '@gip/repos' reconstruction function
+function collection0_reconstruct(schemaVersion, keyBuf, valueBuf) {
+  const key = collection0_key.decode(keyBuf)
+  setVersion(schemaVersion)
+  const state = { start: 0, end: valueBuf.byteLength, buffer: valueBuf }
+  const type = c.uint.decode(state)
+  if (type !== 0) throw new Error('Unknown collection type: ' + type)
+  collection0.decodedVersion = c.uint.decode(state)
+  const record = collection0_enc.decode(state)
+  record.name = key[0]
+  return record
+}
+// '@gip/repos' key reconstruction function
+function collection0_reconstruct_key(keyBuf) {
+  const key = collection0_key.decode(keyBuf)
+  return {
+    name: key[0]
+  }
+}
+
+// '@gip/repos'
+const collection0 = {
+  name: '@gip/repos',
+  id: 0,
+  version: 1,
+  encodeKey(record) {
+    const key = [record.name]
+    return collection0_key.encode(key)
+  },
+  encodeKeyRange({ gt, lt, gte, lte } = {}) {
+    return collection0_key.encodeRange({
+      gt: gt ? collection0_indexify(gt) : null,
+      lt: lt ? collection0_indexify(lt) : null,
+      gte: gte ? collection0_indexify(gte) : null,
+      lte: lte ? collection0_indexify(lte) : null
+    })
+  },
+  encodeValue(schemaVersion, collectionVersion, record) {
+    setVersion(schemaVersion)
+    const state = { start: 0, end: 2, buffer: null }
+    collection0_enc.preencode(state, record)
+    state.buffer = b4a.allocUnsafe(state.end)
+    state.buffer[state.start++] = 0
+    state.buffer[state.start++] = collectionVersion
+    collection0_enc.encode(state, record)
+    return state.buffer
+  },
+  trigger: null,
+  reconstruct: collection0_reconstruct,
+  reconstructKey: collection0_reconstruct_key,
+  indexes: [],
+  decodedVersion: 0
+}
+
+// '@gip/branches' collection key
+const collection1_key = new IndexEncoder([IndexEncoder.STRING], { prefix: 1 })
+
+function collection1_indexify(record) {
+  const a = record.name
+  return a === undefined ? [] : [a]
+}
+
+// '@gip/branches' value encoding
+const collection1_enc = getEncoding('@gip/branches/hyperdb#1')
+
+// '@gip/branches' reconstruction function
+function collection1_reconstruct(schemaVersion, keyBuf, valueBuf) {
+  const key = collection1_key.decode(keyBuf)
+  setVersion(schemaVersion)
+  const state = { start: 0, end: valueBuf.byteLength, buffer: valueBuf }
+  const type = c.uint.decode(state)
+  if (type !== 0) throw new Error('Unknown collection type: ' + type)
+  collection1.decodedVersion = c.uint.decode(state)
+  const record = collection1_enc.decode(state)
+  record.name = key[0]
+  return record
+}
+// '@gip/branches' key reconstruction function
+function collection1_reconstruct_key(keyBuf) {
+  const key = collection1_key.decode(keyBuf)
+  return {
+    name: key[0]
+  }
+}
+
+// '@gip/branches'
+const collection1 = {
+  name: '@gip/branches',
+  id: 1,
+  version: 1,
+  encodeKey(record) {
+    const key = [record.name]
+    return collection1_key.encode(key)
+  },
+  encodeKeyRange({ gt, lt, gte, lte } = {}) {
+    return collection1_key.encodeRange({
+      gt: gt ? collection1_indexify(gt) : null,
+      lt: lt ? collection1_indexify(lt) : null,
+      gte: gte ? collection1_indexify(gte) : null,
+      lte: lte ? collection1_indexify(lte) : null
+    })
+  },
+  encodeValue(schemaVersion, collectionVersion, record) {
+    setVersion(schemaVersion)
+    const state = { start: 0, end: 2, buffer: null }
+    collection1_enc.preencode(state, record)
+    state.buffer = b4a.allocUnsafe(state.end)
+    state.buffer[state.start++] = 0
+    state.buffer[state.start++] = collectionVersion
+    collection1_enc.encode(state, record)
+    return state.buffer
+  },
+  trigger: null,
+  reconstruct: collection1_reconstruct,
+  reconstructKey: collection1_reconstruct_key,
+  indexes: [],
+  decodedVersion: 0
+}
+
+// '@gip/files' collection key
+const collection2_key = new IndexEncoder([IndexEncoder.STRING, IndexEncoder.STRING], { prefix: 2 })
+
+function collection2_indexify(record) {
+  const arr = []
+
+  const a0 = record.branch
+  if (a0 === undefined) return arr
+  arr.push(a0)
+
+  const a1 = record.path
+  if (a1 === undefined) return arr
+  arr.push(a1)
+
+  return arr
+}
+
+// '@gip/files' value encoding
+const collection2_enc = getEncoding('@gip/files/hyperdb#2')
+
+// '@gip/files' reconstruction function
+function collection2_reconstruct(schemaVersion, keyBuf, valueBuf) {
+  const key = collection2_key.decode(keyBuf)
+  setVersion(schemaVersion)
+  const state = { start: 0, end: valueBuf.byteLength, buffer: valueBuf }
+  const type = c.uint.decode(state)
+  if (type !== 0) throw new Error('Unknown collection type: ' + type)
+  collection2.decodedVersion = c.uint.decode(state)
+  const record = collection2_enc.decode(state)
+  record.branch = key[0]
+  record.path = key[1]
+  return record
+}
+// '@gip/files' key reconstruction function
+function collection2_reconstruct_key(keyBuf) {
+  const key = collection2_key.decode(keyBuf)
+  return {
+    branch: key[0],
+    path: key[1]
+  }
+}
+
+// '@gip/files'
+const collection2 = {
+  name: '@gip/files',
+  id: 2,
+  version: 1,
+  encodeKey(record) {
+    const key = [record.branch, record.path]
+    return collection2_key.encode(key)
+  },
+  encodeKeyRange({ gt, lt, gte, lte } = {}) {
+    return collection2_key.encodeRange({
+      gt: gt ? collection2_indexify(gt) : null,
+      lt: lt ? collection2_indexify(lt) : null,
+      gte: gte ? collection2_indexify(gte) : null,
+      lte: lte ? collection2_indexify(lte) : null
+    })
+  },
+  encodeValue(schemaVersion, collectionVersion, record) {
+    setVersion(schemaVersion)
+    const state = { start: 0, end: 2, buffer: null }
+    collection2_enc.preencode(state, record)
+    state.buffer = b4a.allocUnsafe(state.end)
+    state.buffer[state.start++] = 0
+    state.buffer[state.start++] = collectionVersion
+    collection2_enc.encode(state, record)
+    return state.buffer
+  },
+  trigger: null,
+  reconstruct: collection2_reconstruct,
+  reconstructKey: collection2_reconstruct_key,
+  indexes: [],
+  decodedVersion: 0
+}
+
+// '@gip/objects' collection key
+const collection3_key = new IndexEncoder([IndexEncoder.STRING], { prefix: 3 })
+
+function collection3_indexify(record) {
+  const a = record.oid
+  return a === undefined ? [] : [a]
+}
+
+// '@gip/objects' value encoding
+const collection3_enc = getEncoding('@gip/objects/hyperdb#3')
+
+// '@gip/objects' reconstruction function
+function collection3_reconstruct(schemaVersion, keyBuf, valueBuf) {
+  const key = collection3_key.decode(keyBuf)
+  setVersion(schemaVersion)
+  const state = { start: 0, end: valueBuf.byteLength, buffer: valueBuf }
+  const type = c.uint.decode(state)
+  if (type !== 0) throw new Error('Unknown collection type: ' + type)
+  collection3.decodedVersion = c.uint.decode(state)
+  const record = collection3_enc.decode(state)
+  record.oid = key[0]
+  return record
+}
+// '@gip/objects' key reconstruction function
+function collection3_reconstruct_key(keyBuf) {
+  const key = collection3_key.decode(keyBuf)
+  return {
+    oid: key[0]
+  }
+}
+
+// '@gip/objects'
+const collection3 = {
+  name: '@gip/objects',
+  id: 3,
+  version: 1,
+  encodeKey(record) {
+    const key = [record.oid]
+    return collection3_key.encode(key)
+  },
+  encodeKeyRange({ gt, lt, gte, lte } = {}) {
+    return collection3_key.encodeRange({
+      gt: gt ? collection3_indexify(gt) : null,
+      lt: lt ? collection3_indexify(lt) : null,
+      gte: gte ? collection3_indexify(gte) : null,
+      lte: lte ? collection3_indexify(lte) : null
+    })
+  },
+  encodeValue(schemaVersion, collectionVersion, record) {
+    setVersion(schemaVersion)
+    const state = { start: 0, end: 2, buffer: null }
+    collection3_enc.preencode(state, record)
+    state.buffer = b4a.allocUnsafe(state.end)
+    state.buffer[state.start++] = 0
+    state.buffer[state.start++] = collectionVersion
+    collection3_enc.encode(state, record)
+    return state.buffer
+  },
+  trigger: null,
+  reconstruct: collection3_reconstruct,
+  reconstructKey: collection3_reconstruct_key,
+  indexes: [],
+  decodedVersion: 0
+}
+
+// '@gip/files-by-branch' collection key
+const index4_key = new IndexEncoder(
+  [IndexEncoder.STRING, IndexEncoder.STRING, IndexEncoder.STRING],
+  { prefix: 4 }
+)
+
+function index4_indexify(record) {
+  const arr = []
+
+  const a0 = record.branch
+  if (a0 === undefined) return arr
+  arr.push(a0)
+
+  const a1 = record.branch
+  if (a1 === undefined) return arr
+  arr.push(a1)
+
+  const a2 = record.path
+  if (a2 === undefined) return arr
+  arr.push(a2)
+
+  return arr
+}
+
+// '@gip/files-by-branch'
+const index4 = {
+  name: '@gip/files-by-branch',
+  version: 1,
+  id: 4,
+  encodeKey(record) {
+    return index4_key.encode(index4_indexify(record))
+  },
+  encodeKeyRange({ gt, lt, gte, lte } = {}) {
+    return index4_key.encodeRange({
+      gt: gt ? index4_indexify(gt) : null,
+      lt: lt ? index4_indexify(lt) : null,
+      gte: gte ? index4_indexify(gte) : null,
+      lte: lte ? index4_indexify(lte) : null
+    })
+  },
+  encodeValue: (record) => index4.collection.encodeKey(record),
+  encodeIndexKeys(record, context) {
+    return [index4_key.encode([record.branch, record.branch, record.path])]
+  },
+  reconstruct: (keyBuf, valueBuf) => valueBuf,
+  offset: collection2.indexes.length,
+  collection: collection2
+}
+collection2.indexes.push(index4)
+
+const collections = [collection0, collection1, collection2, collection3]
+
+const indexes = [index4]
+
+module.exports = { versions, collections, indexes, resolveCollection, resolveIndex }
+
+function resolveCollection(name) {
+  switch (name) {
+    case '@gip/repos':
+      return collection0
+    case '@gip/branches':
+      return collection1
+    case '@gip/files':
+      return collection2
+    case '@gip/objects':
+      return collection3
+    default:
+      return null
+  }
+}
+
+function resolveIndex(name) {
+  switch (name) {
+    case '@gip/files-by-branch':
+      return index4
+    default:
+      return null
+  }
+}