feat: add basic error codes and update test

examples/full-s3-repo/index.js

@@ -3,7 +3,7 @@
 const IPFS = require('ipfs')
 const Repo = require('ipfs-repo')
 const S3 = require('aws-sdk').S3
-const S3Store = require('../../src')
+const S3Store = require('datastore-s3')
 const S3Lock = require('./s3-lock')
 
 // Initialize the AWS S3 instance
@@ -38,9 +38,15 @@ const repo = new Repo('/tmp/test/.ipfs', {
 
 // Create a new IPFS node with our S3 backed Repo
 let node = new IPFS({
-  repo
+  repo,
+  config: {
+    Discovery: { MDNS: { Enabled: false }, webRTCStar: { Enabled: false } },
+    Bootstrap: []
+  }
 })
 
+console.log('Start the node')
+
 // Test out the repo by sending and fetching some data
 node.on('ready', () => {
   console.log('Ready')
@@ -51,8 +57,8 @@ node.on('ready', () => {
     // Once we have the version, let's add a file to IPFS
     .then(() => {
       return node.files.add({
-        path: 'hello.txt',
-        content: Buffer.from('Hello World 101')
+        path: 'data.txt',
+        content: Buffer.from(require('crypto').randomBytes(1024 * 25))
       })
     })
     // Log out the added files metadata and cat the file from IPFS
@@ -62,8 +68,7 @@ node.on('ready', () => {
     })
     // Print out the files contents to console
     .then((data) => {
-      console.log('\nFetched file content:')
-      process.stdout.write(data)
+      console.log(`\nFetched file content containing ${data.byteLength} bytes`)
     })
     // Log out the error, if there is one
     .catch((err) => {

examples/full-s3-repo/package.json

@@ -10,9 +10,10 @@
   "author": "",
   "license": "ISC",
   "dependencies": {
-    "async": "^2.6.0",
-    "aws-sdk": "^2.220.1",
-    "ipfs": "^0.28.2",
-    "ipfs-repo": "^0.20.0"
+    "async": "^2.6.1",
+    "aws-sdk": "^2.313.0",
+    "datastore-s3": "../../",
+    "ipfs": "~0.32.3",
+    "ipfs-repo": "~0.24.0"
   }
 }

examples/full-s3-repo/s3-lock.js

@@ -85,7 +85,7 @@ class S3Lock {
    */
   locked (dir, callback) {
     this.s3.get(this.getLockfilePath(dir), (err, data) => {
-      if (err && err.message.match(/not found/)) {
+      if (err && err.code === 'ERR_NOT_FOUND') {
         return callback(null, false)
       } else if (err) {
         return callback(err)

package.json

@@ -33,20 +33,20 @@
   },
   "homepage": "https://github.com/ipfs/js-datastore-s3#readme",
   "dependencies": {
-    "async": "^2.6.0",
-    "datastore-core": "^0.4.0",
-    "interface-datastore": "^0.4.2",
-    "pull-defer": "^0.2.2",
-    "pull-stream": "^3.6.7",
-    "upath": "^1.0.5"
+    "async": "^2.6.1",
+    "datastore-core": "~0.5.0",
+    "interface-datastore": "~0.5.0",
+    "pull-defer": "~0.2.3",
+    "pull-stream": "^3.6.9",
+    "upath": "^1.1.0"
   },
   "devDependencies": {
-    "aegir": "^13.0.6",
-    "aws-sdk": "^2.219.1",
+    "aegir": "^15.2.0",
+    "aws-sdk": "^2.316.0",
     "chai": "^4.1.2",
     "dirty-chai": "^2.0.1",
-    "flow-bin": "^0.69.0",
-    "flow-typed": "^2.4.0",
+    "flow-bin": "~0.81.0",
+    "flow-typed": "^2.5.1",
     "stand-in": "^4.2.0"
   },
   "contributors": [

src/index.js

@@ -9,7 +9,10 @@ const each = require('async/each')
 const waterfall = require('async/series')
 const asyncFilter = require('interface-datastore').utils.asyncFilter
 const asyncSort = require('interface-datastore').utils.asyncSort
-const Key = require('interface-datastore').Key
+
+const IDatastore = require('interface-datastore')
+const Key = IDatastore.Key
+const Errors = IDatastore.Errors
 
 const Deferred = require('pull-defer')
 const pull = require('pull-stream')
@@ -90,13 +93,15 @@ class S3Datastore {
       Body: val
     }, (err, data) => {
       if (err && err.code === 'NoSuchBucket' && this.createIfMissing) {
-        this.opts.s3.createBucket({}, (err) => {
+        return this.opts.s3.createBucket({}, (err) => {
           if (err) return callback(err)
           setImmediate(() => this.put(key, val, callback))
         })
-      } else {
-        callback(err)
+      } else if (err) {
+        return callback(Errors.dbWriteFailedError(err))
       }
+
+      callback()
     })
   }
 
@@ -112,8 +117,7 @@ class S3Datastore {
       Key: this._getFullKey(key)
     }, (err, data) => {
       if (err && err.statusCode === 404) {
-        // TODO: Cleanup across repos https://github.com/ipfs/js-ipfs/blob/master/src/core/boot.js#L43
-        return callback(new Error('not found'))
+        return callback(Errors.notFoundError(err))
       } else if (err) {
         return callback(err)
       }
@@ -154,8 +158,11 @@ class S3Datastore {
   delete (key /* : Key */, callback /* : Callback<void> */) /* : void */ {
     this.opts.s3.deleteObject({
       Key: this._getFullKey(key)
-    }, (err, data) => {
-      callback(err)
+    }, (err) => {
+      if (err) {
+        return callback(Errors.dbDeleteFailedError(err))
+      }
+      callback()
     })
   }
 
@@ -346,7 +353,10 @@ class S3Datastore {
         return this.put(new Key('/', false), Buffer.from(''), callback)
       }
 
-      callback(err)
+      if (err) {
+        return callback(Errors.dbOpenFailedError(err))
+      }
+      callback()
     })
   }
 

test/index.spec.js

@@ -73,7 +73,7 @@ describe('S3Datastore', () => {
 
       store.put(new Key('/z/key'), Buffer.from('test data'), done)
     })
-    it('should create the bucket when missing if createIfMissing is true', (done) => {
+    it('should not create the bucket when missing if createIfMissing is false', (done) => {
       const s3 = new S3({ params: { Bucket: 'my-ipfs-bucket' } })
       const store = new S3Store('.ipfs/datastore', { s3, createIfMissing: false })
 
@@ -95,9 +95,22 @@ describe('S3Datastore', () => {
 
       store.put(new Key('/z/key'), Buffer.from('test data'), (err) => {
         expect(bucketCreated).to.equal(false)
-        expect(err).to.deep.equal({
-          code: 'NoSuchBucket'
-        })
+        expect(err).to.have.property('code', 'ERR_DB_WRITE_FAILED')
+        done()
+      })
+    })
+    it('should return a standard error when the put fails', (done) => {
+      const s3 = new S3({ params: { Bucket: 'my-ipfs-bucket' } })
+      const store = new S3Store('.ipfs/datastore', { s3 })
+
+      standin.replace(s3, 'upload', function (stand, params, callback) {
+        expect(params.Key).to.equal('.ipfs/datastore/z/key')
+        stand.restore()
+        callback(new Error('bad things happened'))
+      })
+
+      store.put(new Key('/z/key'), Buffer.from('test data'), (err) => {
+        expect(err.code).to.equal('ERR_DB_WRITE_FAILED')
         done()
       })
     })
@@ -116,6 +129,58 @@ describe('S3Datastore', () => {
 
       store.get(new Key('/z/key'), done)
     })
+    it('should return a standard not found error code if the key isnt found', (done) => {
+      const s3 = new S3({ params: { Bucket: 'my-ipfs-bucket' } })
+      const store = new S3Store('.ipfs/datastore', { s3 })
+
+      standin.replace(s3, 'getObject', function (stand, params, callback) {
+        expect(params.Key).to.equal('.ipfs/datastore/z/key')
+        stand.restore()
+        let error = new Error('not found')
+        error.statusCode = 404
+        callback(error)
+      })
+
+      store.get(new Key('/z/key'), (err) => {
+        expect(err.code).to.equal('ERR_NOT_FOUND')
+        done()
+      })
+    })
+  })
+
+  describe('delete', () => {
+    it('should return a standard delete error if deletion fails', (done) => {
+      const s3 = new S3({ params: { Bucket: 'my-ipfs-bucket' } })
+      const store = new S3Store('.ipfs/datastore', { s3 })
+
+      standin.replace(s3, 'deleteObject', function (stand, params, callback) {
+        expect(params.Key).to.equal('.ipfs/datastore/z/key')
+        stand.restore()
+        callback(new Error('bad things'))
+      })
+
+      store.delete(new Key('/z/key'), (err) => {
+        expect(err.code).to.equal('ERR_DB_DELETE_FAILED')
+        done()
+      })
+    })
+  })
+
+  describe('open', () => {
+    it('should return a standard open error if the head request fails with an unknown error', (done) => {
+      const s3 = new S3({ params: { Bucket: 'my-ipfs-bucket' } })
+      const store = new S3Store('.ipfs/datastore', { s3 })
+
+      standin.replace(s3, 'headObject', function (stand, _, callback) {
+        stand.restore()
+        callback(new Error('unknown'))
+      })
+
+      store.open((err) => {
+        expect(err.code).to.equal('ERR_DB_OPEN_FAILED')
+        done()
+      })
+    })
   })
 
   describe('interface-datastore', () => {