breadfruit 2.2.1 → 3.1.0

package/README.md

@@ -1,49 +1,258 @@
 # breadfruit
 
-[![NPM](https://nodei.co/npm/breadfruit.png?compact=true)](https://nodei.co/npm/breadfruit/)
+[![npm version](https://img.shields.io/npm/v/breadfruit.svg)](https://www.npmjs.com/package/breadfruit)
+[![CI](https://github.com/iceddev/breadfruit/actions/workflows/ci.yml/badge.svg)](https://github.com/iceddev/breadfruit/actions/workflows/ci.yml)
+[![codecov](https://codecov.io/gh/iceddev/breadfruit/branch/main/graph/badge.svg)](https://codecov.io/gh/iceddev/breadfruit)
+[![node](https://img.shields.io/node/v/breadfruit.svg)](https://nodejs.org)
+[![npm downloads](https://img.shields.io/npm/dm/breadfruit.svg)](https://www.npmjs.com/package/breadfruit)
+[![license](https://img.shields.io/npm/l/breadfruit.svg)](https://github.com/iceddev/breadfruit/blob/main/LICENSE)
 
-Not really bread. Not really fruit. Just like this package.  Some simple helpers on top of knex.
+Not really bread. Not really fruit. Just like this package. Simple CRUD helpers on top of [knex](https://knexjs.org/).
 
 ![breadfruit](happy_breadfruit.png)
 
-## create an instance of breadfruit
+## Install
+
+```sh
+npm install breadfruit
+```
+
+Requires Node.js `>=22`.
+
+## Usage
+
+Breadfruit is an ES module with a default export.
+
+```js
+import breadfruit from 'breadfruit';
 
-```javascript
 const config = {
-  client: 'postgresql',
+  client: 'pg',
   connection: 'postgres://postgres@localhost:5432/someDatabase',
-  pool: { min: 1, max: 7 }
+  pool: { min: 1, max: 7 },
 };
 
-const bread = require('breadfruit')(config);
+const { browse, read, edit, add, del, raw } = breadfruit(config);
 ```
 
-## Browse, Read, Edit, Add, Delete, Raw
+## API
+
+### `browse(table, fields, filter, options?)`
 
-```javascript
-const {browse, read, edit, add, del, raw} = require('breadfruit')(config);
+Returns an array of rows.
 
-//get an array of users, by table, columns, and a filter
-const users = await browse('users', ['username', 'user_id'], {active: true});
+```js
+const users = await browse('users', ['username', 'user_id'], { active: true });
+```
 
+Supported `options`:
+- `limit` (default `1000`)
+- `offset` (default `0`)
+- `orderBy` — column name or array of column names
+- `sortOrder` — `'ASC'` / `'DESC'` (default `'ASC'`), or an array matching `orderBy`
+- `dateField` (default `'created_at'`)
+- `search_start_date` / `search_end_date` — adds a `whereBetween` on `dateField`
+- `dbApi` — override the internal knex instance (useful for transactions)
 
-//get a single user by table, columns, and a filter
-const user = await read('users', ['username', 'first_name'], {user_id: 1337});
+### `read(table, fields, filter, options?)`
 
+Returns a single row.
 
-//edit a user by table, returned columns, updated values, and a filter
-const updatedUser = await edit('users', ['username', 'first_name'], {first_name: 'Howard'}, {user_id: 1337});
+```js
+const user = await read('users', ['username', 'first_name'], { user_id: 1337 });
+```
+
+### `add(table, returnFields, data, options?)`
+
+Inserts and returns the new row.
+
+```js
+const newUser = await add('users', ['user_id'], {
+  first_name: 'Howard',
+  username: 'howitzer',
+});
+```
+
+### `edit(table, returnFields, data, filter, options?)`
+
+Updates matching rows and returns the first updated row.
+
+```js
+const updated = await edit(
+  'users',
+  ['username', 'first_name'],
+  { first_name: 'Howard' },
+  { user_id: 1337 },
+);
+```
 
+### `del(table, filter, options?)`
 
-//add a new user by table, returned columns, and user data
-const newUser = await add('users', ['user_id'], {first_name: 'Howard', username: 'howitzer'});
+Deletes matching rows and returns the count.
 
+```js
+const count = await del('users', { user_id: 1337 });
+```
 
-//delete a user by table and a filter
-const deleteCount = await del('users', {user_id: 1337});
+### `raw(sql, options?)`
 
+Runs a raw SQL statement and returns rows.
 
-//perform a raw query
+```js
 const rows = await raw('select * from users');
+```
+
+### `count(table, filter, options?)`
 
+Returns the count of matching rows as a number.
+
+```js
+const activeUsers = await count('users', { active: true });
 ```
+
+### `upsert(table, returnFields, data, conflictColumns, options?)`
+
+Inserts a row, or updates on conflict. `conflictColumns` can be a string or array.
+
+```js
+const row = await upsert(
+  'users',
+  '*',
+  { email: 'luis@example.com', name: 'Luis' },
+  'email',
+);
+```
+
+### `transaction(callback)`
+
+Wraps `knex.transaction()`. Pass the `trx` object as `dbApi` in your method calls.
+
+```js
+await transaction(async (trx) => {
+  await add('users', ['id'], { name: 'a' }, { dbApi: trx });
+  await add('users', ['id'], { name: 'b' }, { dbApi: trx });
+});
+```
+
+## Advanced
+
+### Passing an existing Knex instance
+
+Instead of a config object, you can pass a Knex instance. Useful when you already have a Knex connection in your app and want breadfruit to use it rather than open a second pool.
+
+```js
+import knex from './db.js';
+import breadfruit from 'breadfruit';
+
+const bf = breadfruit(knex);
+```
+
+### Composite filters
+
+Filter values accept operators beyond simple equality.
+
+| Shape | SQL |
+|---|---|
+| `{ col: value }` | `col = value` |
+| `{ col: [a, b, c] }` | `col IN (a, b, c)` |
+| `{ col: null }` | `col IS NULL` |
+| `{ col: { eq: x } }` | `col = x` |
+| `{ col: { ne: x } }` | `col != x` |
+| `{ col: { gt: x } }` | `col > x` |
+| `{ col: { gte: x } }` | `col >= x` |
+| `{ col: { lt: x } }` | `col < x` |
+| `{ col: { lte: x } }` | `col <= x` |
+| `{ col: { like: 'x%' } }` | `col LIKE 'x%'` |
+| `{ col: { ilike: 'x%' } }` | `col ILIKE 'x%'` |
+| `{ col: { in: [a, b] } }` | `col IN (a, b)` |
+| `{ col: { notIn: [a, b] } }` | `col NOT IN (a, b)` |
+| `{ col: { between: [a, b] } }` | `col BETWEEN a AND b` |
+| `{ col: { notBetween: [a, b] } }` | `col NOT BETWEEN a AND b` |
+| `{ col: { null: true } }` | `col IS NULL` |
+| `{ col: { null: false } }` | `col IS NOT NULL` |
+
+Multiple operators on the same column AND together:
+
+```js
+await browse('events', '*', {
+  count: { gt: 1, lte: 100 },
+  created_at: { gte: '2026-01-01' },
+});
+```
+
+### `forTable(tableName, options?)` — table-bound helpers
+
+Returns an object with the same BREAD methods but bound to a specific table, with optional **soft delete** and **view-for-reads** behavior.
+
+```js
+const users = bf.forTable('users', {
+  softDelete: true,
+  viewName: 'users_v',
+});
+
+await users.browse('*', { active: true });   // reads from users_v
+await users.del({ id: 42 });                  // soft-deletes in users
+await users.restore({ id: 42 });              // un-soft-deletes
+const total = await users.count({});          // respects soft delete
+```
+
+#### Soft delete
+
+Three options for the `softDelete` config:
+
+```js
+// 1. Boolean shorthand — uses is_deleted column, true/false
+softDelete: true
+
+// 2. Full config
+softDelete: {
+  column: 'is_deleted',
+  value: true,           // set on delete
+  undeletedValue: false, // the "active" value for filtering
+}
+
+// 3. Timestamp style — deleted_at IS NULL means active
+softDelete: {
+  column: 'deleted_at',
+  value: 'NOW',          // special string -> knex.fn.now()
+  undeletedValue: null,
+}
+```
+
+The `value` field accepts:
+- a literal (`true`, `false`, `Date`, etc.)
+- the string `'NOW'` — becomes `knex.fn.now()` so the DB generates the timestamp
+- a Knex raw expression like `knex.fn.now()` or `knex.raw('...')`
+- a function — called at delete time (runs in JS, not DB)
+
+#### Reads from a view, writes to the table
+
+Pass `viewName` to read from a view while writing to the underlying table. Great for denormalized read paths.
+
+```js
+bf.forTable('users', { viewName: 'user_groups_v' });
+```
+
+#### `withDeleted`
+
+Bypass the soft-delete filter for admin or audit views:
+
+```js
+const allUsers = await users.browse('*', {}, { withDeleted: true });
+const count = await users.count({}, { withDeleted: true });
+```
+
+### Transactions with `forTable`
+
+Pass `dbApi: trx` through just like the top-level API:
+
+```js
+await bf.transaction(async (trx) => {
+  await users.add('*', { email: 'a@b.c' }, { dbApi: trx });
+  await users.edit('*', { active: true }, { email: 'a@b.c' }, { dbApi: trx });
+});
+```
+
+## License
+
+ISC

package/index.js

@@ -1,89 +1,248 @@
-const knexConstructor = require('knex');
-
-function connect(settings) {
-  const knex = knexConstructor(settings);
-  const defaultOptions = {
-    dateField: 'created_at',
-    dbApi: knex,
-    limit: 1000,
-    offset: 0,
-    sortOrder: 'ASC',
-  };
-
-  return {
-    browse(table, fields, filter, options = {}) {
-      const dbApi = options.dbApi || defaultOptions.dbApi || knex;
-      const limit = options.limit || defaultOptions.limit;
-      const offset = options.offset || defaultOptions.offset;
-      const dateField = options.dateField || defaultOptions.dateField;
-      const sortOrder = options.sortOrder || defaultOptions.sortOrder;
-
-      let query = dbApi(table)
-        .where(filter)
-        .select(fields)
-        .limit(limit)
-        .offset(offset);
-
-      if (options.search_start_date && options.search_end_date) {
-        query = query
-          .whereBetween(dateField, [options.search_start_date, options.search_end_date]);
-      }
+import knexConstructor from 'knex';
 
-      if (options.orderBy) {
-        if(Array.isArray(options.orderBy)) {
-          options.orderBy.forEach((orderBy, index) => {
-            if(Array.isArray(sortOrder)) {
-              return query = query.orderBy(orderBy, sortOrder[index]);
-            }
-            query = query.orderBy(orderBy, sortOrder);
-          });
+const defaults = {
+  dateField: 'created_at',
+  limit: 1000,
+  offset: 0,
+  sortOrder: 'ASC',
+};
+
+const OPERATORS = {
+  eq: '=',
+  ne: '!=',
+  gt: '>',
+  gte: '>=',
+  lt: '<',
+  lte: '<=',
+  like: 'like',
+  ilike: 'ilike',
+};
+
+// Apply a filter object to a Knex query. Supports:
+//   { col: value }                        -> WHERE col = value
+//   { col: [a, b, c] }                    -> WHERE col IN (...)
+//   { col: null }                         -> WHERE col IS NULL
+//   { col: { gt: x, lte: y } }            -> WHERE col > x AND col <= y
+//   { col: { in: [a, b] } }               -> WHERE col IN (...)
+//   { col: { notIn: [a, b] } }            -> WHERE col NOT IN (...)
+//   { col: { between: [a, b] } }          -> WHERE col BETWEEN a AND b
+function applyFilter(query, filter) {
+  if (!filter) return query;
+  for (const [key, value] of Object.entries(filter)) {
+    if (value === undefined) continue;
+    if (value === null) {
+      query = query.whereNull(key);
+    } else if (Array.isArray(value)) {
+      query = query.whereIn(key, value);
+    } else if (typeof value === 'object' && !(value instanceof Date) && !value.toSQL) {
+      for (const [op, operand] of Object.entries(value)) {
+        if (operand === undefined) continue;
+        if (op === 'in') query = query.whereIn(key, operand);
+        else if (op === 'notIn') query = query.whereNotIn(key, operand);
+        else if (op === 'between') query = query.whereBetween(key, operand);
+        else if (op === 'notBetween') query = query.whereNotBetween(key, operand);
+        else if (op === 'null') {
+          query = operand ? query.whereNull(key) : query.whereNotNull(key);
+        } else if (OPERATORS[op]) {
+          query = query.where(key, OPERATORS[op], operand);
         } else {
-          query = query.orderBy(options.orderBy, sortOrder);
+          throw new Error(`Unknown filter operator: ${op}`);
         }
       }
+    } else {
+      query = query.where(key, value);
+    }
+  }
+  return query;
+}
 
-      return query;
-    },
-    read(table, fields, filter, options = {}) {
-      const dbApi = options.dbApi || knex;
-      return dbApi(table)
-        .where(filter)
-        .select(fields)
-        .then(([row]) => {
-          return row;
-        });
-    },
-    add(table, fields, data, options = {}) {
-      const dbApi = options.dbApi || knex;
-      return dbApi(table)
-        .returning(fields)
-        .insert(data)
-        .then(([row]) => {
-          return row;
-        });
-    },
-    edit(table, fields, data, filter, options = {}) {
-      const dbApi = options.dbApi || knex;
-      return dbApi(table)
-        .where(filter)
-        .returning(fields)
-        .update(data)
-        .then(([row]) => {
-          return row;
+// Resolve a soft-delete config to { column, value, undeletedValue }.
+// Accepts:
+//   true                                  -> { column: 'is_deleted', value: true, undeletedValue: false }
+//   { column, value, undeletedValue }     -> used as-is
+//   value can be:
+//     - a literal (true, false, Date, etc.)
+//     - the string 'NOW' -> knex.fn.now()
+//     - a Knex raw expression (e.g. knex.fn.now())
+//     - a function -> called at delete time
+function resolveSoftDelete(config, knex) {
+  if (!config) return null;
+  if (config === true) {
+    return { column: 'is_deleted', value: true, undeletedValue: false };
+  }
+  if (typeof config !== 'object') {
+    throw new Error('softDelete must be true or an object');
+  }
+  const column = config.column || 'is_deleted';
+  const undeletedValue = 'undeletedValue' in config ? config.undeletedValue : false;
+  let value = 'value' in config ? config.value : true;
+  if (value === 'NOW') value = knex.fn.now();
+  return { column, value, undeletedValue };
+}
+
+function resolveValue(value) {
+  return typeof value === 'function' ? value() : value;
+}
+
+export default function connect(settings) {
+  // Allow passing an existing knex instance or a config
+  const knex = typeof settings === 'function' ? settings : knexConstructor(settings);
+
+  function browse(table, fields, filter, options = {}) {
+    const dbApi = options.dbApi || knex;
+    const limit = options.limit ?? defaults.limit;
+    const offset = options.offset ?? defaults.offset;
+    const dateField = options.dateField || defaults.dateField;
+    const sortOrder = options.sortOrder || defaults.sortOrder;
+
+    let query = dbApi(table).select(fields).limit(limit).offset(offset);
+
+    query = applyFilter(query, filter);
+
+    if (options.search_start_date && options.search_end_date) {
+      query = query.whereBetween(dateField, [
+        options.search_start_date,
+        options.search_end_date,
+      ]);
+    }
+
+    if (options.orderBy) {
+      if (Array.isArray(options.orderBy)) {
+        options.orderBy.forEach((orderBy, index) => {
+          const order = Array.isArray(sortOrder) ? sortOrder[index] : sortOrder;
+          query = query.orderBy(orderBy, order);
         });
-    },
-    del(table, filter, options = {}) {
-      const dbApi = options.dbApi || knex;
-      return dbApi(table)
-        .where(filter)
-        .del();
-    },
-    raw(sql, options = {}) {
-      const dbApi = options.dbApi || knex;
-      return dbApi.raw(sql, options)
-        .then(res => res.rows || res);
+      } else {
+        query = query.orderBy(options.orderBy, sortOrder);
+      }
     }
-  };
-}
 
-module.exports = connect;
+    return query;
+  }
+
+  async function read(table, fields, filter, options = {}) {
+    const dbApi = options.dbApi || knex;
+    let query = dbApi(table).select(fields);
+    query = applyFilter(query, filter);
+    const row = await query.first();
+    return row || null;
+  }
+
+  async function add(table, fields, data, options = {}) {
+    const dbApi = options.dbApi || knex;
+    const [row] = await dbApi(table).returning(fields).insert(data);
+    return row;
+  }
+
+  async function edit(table, fields, data, filter, options = {}) {
+    const dbApi = options.dbApi || knex;
+    let query = dbApi(table).returning(fields).update(data);
+    query = applyFilter(query, filter);
+    const [row] = await query;
+    return row;
+  }
+
+  function del(table, filter, options = {}) {
+    const dbApi = options.dbApi || knex;
+    let query = dbApi(table).del();
+    query = applyFilter(query, filter);
+    return query;
+  }
+
+  async function count(table, filter, options = {}) {
+    const dbApi = options.dbApi || knex;
+    let query = dbApi(table).count('* as total');
+    query = applyFilter(query, filter);
+    const [row] = await query;
+    return Number(row.total);
+  }
+
+  async function upsert(table, fields, data, conflictColumns, options = {}) {
+    const dbApi = options.dbApi || knex;
+    const cols = Array.isArray(conflictColumns) ? conflictColumns : [conflictColumns];
+    const [row] = await dbApi(table)
+      .insert(data)
+      .onConflict(cols)
+      .merge()
+      .returning(fields);
+    return row;
+  }
+
+  async function raw(sql, options = {}) {
+    const dbApi = options.dbApi || knex;
+    const res = await dbApi.raw(sql, options);
+    return res.rows || res;
+  }
+
+  function transaction(callback) {
+    return knex.transaction(callback);
+  }
+
+  // Table-bound API with optional softDelete and viewName support.
+  // Returns an object with the same BREAD methods but bound to a specific table,
+  // with soft-delete filtering baked into browse/read/del, and optional
+  // separate readTable (view) for reads vs writes.
+  function forTable(tableName, tableOptions = {}) {
+    const softDelete = resolveSoftDelete(tableOptions.softDelete, knex);
+    const readTable = tableOptions.viewName || tableName;
+    const writeTable = tableName;
+
+    function addSoftDeleteFilter(filter = {}, options = {}) {
+      if (!softDelete) return filter;
+      if (options.withDeleted) return filter;
+      // Don't override if caller explicitly set the column
+      if (filter[softDelete.column] !== undefined) return filter;
+      return { ...filter, [softDelete.column]: softDelete.undeletedValue };
+    }
+
+    return {
+      browse(fields, filter, options = {}) {
+        return browse(readTable, fields, addSoftDeleteFilter(filter, options), options);
+      },
+      read(fields, filter, options = {}) {
+        return read(readTable, fields, addSoftDeleteFilter(filter, options), options);
+      },
+      add(fields, data, options = {}) {
+        return add(writeTable, fields, data, options);
+      },
+      edit(fields, data, filter, options = {}) {
+        return edit(writeTable, fields, data, addSoftDeleteFilter(filter, options), options);
+      },
+      del(filter, options = {}) {
+        if (softDelete) {
+          const dbApi = options.dbApi || knex;
+          let query = dbApi(writeTable).update({
+            [softDelete.column]: resolveValue(softDelete.value),
+          });
+          query = applyFilter(query, addSoftDeleteFilter(filter, options));
+          return query;
+        }
+        return del(writeTable, filter, options);
+      },
+      restore(filter, options = {}) {
+        if (!softDelete) {
+          throw new Error('restore() requires softDelete to be configured');
+        }
+        const dbApi = options.dbApi || knex;
+        let query = dbApi(writeTable).update({
+          [softDelete.column]: softDelete.undeletedValue,
+        });
+        // When restoring, look only at deleted rows
+        const restoreFilter = { ...filter, [softDelete.column]: { ne: softDelete.undeletedValue } };
+        query = applyFilter(query, restoreFilter);
+        return query;
+      },
+      count(filter, options = {}) {
+        return count(readTable, addSoftDeleteFilter(filter, options), options);
+      },
+      upsert(fields, data, conflictColumns, options = {}) {
+        return upsert(writeTable, fields, data, conflictColumns, options);
+      },
+      softDelete,
+      tableName: writeTable,
+      readTable,
+    };
+  }
+
+  return { browse, read, add, edit, del, raw, count, upsert, transaction, forTable, knex };
+}

package/package.json

@@ -1,10 +1,28 @@
 {
   "name": "breadfruit",
-  "version": "2.2.1",
-  "description": "Boilerplate sql query system for Node.js using Knex",
-  "main": "index.js",
+  "version": "3.1.0",
+  "description": "Boilerplate SQL query helpers for Node.js using Knex",
+  "type": "module",
+  "main": "./index.js",
+  "exports": {
+    ".": {
+      "import": "./index.js",
+      "default": "./index.js"
+    }
+  },
+  "files": [
+    "index.js",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=22"
+  },
   "scripts": {
-    "test": "nyc --reporter=lcov --reporter=text-summary mocha"
+    "lint": "eslint .",
+    "lint:fix": "eslint . --fix",
+    "test": "node --test",
+    "test:coverage": "c8 --reporter=text --reporter=lcov node --test",
+    "prepublishOnly": "npm run lint && npm test"
   },
   "author": "Alyson Zepeda",
   "license": "ISC",
@@ -14,14 +32,26 @@
   "homepage": "https://github.com/iceddev/breadfruit#readme",
   "repository": {
     "type": "git",
-    "url": "git+ssh://git@github.com/iceddev/breadfruit.git"
+    "url": "git+https://github.com/iceddev/breadfruit.git"
   },
+  "keywords": [
+    "knex",
+    "sql",
+    "crud",
+    "postgres",
+    "mysql",
+    "database"
+  ],
   "dependencies": {
-    "knex": "^0.21.5"
+    "knex": "^3.2.0"
   },
   "devDependencies": {
-    "chai": "^4.2.0",
-    "mocha": "^8.1.3",
-    "nyc": "^15.1.0"
+    "@eslint/js": "^10.0.1",
+    "c8": "^11.0.0",
+    "eslint": "^10.2.0",
+    "globals": "^17.5.0"
+  },
+  "publishConfig": {
+    "access": "public"
   }
 }

package/.coveralls.yml

@@ -1,2 +0,0 @@
-service_name: travis-pro
-repo_token: 

package/.travis.yml

@@ -1,4 +0,0 @@
-language: node_js
-node_js:
-  - '6'
-after_success: 'npm run coveralls'

package/test/index.js

@@ -1,95 +0,0 @@
-'use strict';
-
-var chai = require('chai');
-
-
-var expect = chai.expect;
-chai.should();
-
-var breadfruit = require('../');
-
-describe('breadfruit', function(){
-
-  it('be awesome', function(done){
-    done();
-  });
-
-  it('should create an instance of the api', function(done) {
-    const api = breadfruit({client: 'pg'});
-    api.should.be.an('object');
-    done();
-  });
-
-  it('should fail to browse without a real connection', function(done) {
-    const api = breadfruit({client: 'pg'});
-    api.browse('tableName', [], {})
-      .catch((error) => {
-        done();
-      });
-  });
-
-  it('should fail to browse without a real connection', function(done) {
-    const api = breadfruit({client: 'pg'});
-    api.browse('tableName', [], {}, {orderBy: 'someColumn'})
-      .catch((error) => {
-        done();
-      });
-  });
-
-  it('should fail to browse without a real connection', function(done) {
-    const api = breadfruit({client: 'pg'});
-    api.browse('tableName', [], {}, {orderBy: ['someColumn', 'otherColumn']})
-      .catch((error) => {
-        done();
-      });
-  });
-
-  it('should fail to browse without a real connection', function(done) {
-    const api = breadfruit({client: 'pg'});
-    api.browse('tableName', [], {}, {orderBy: ['someColumn', 'otherColumn'], sortOrder: ['asc', 'desc']})
-      .catch((error) => {
-        done();
-      });
-  });
-
-  it('should fail to read without a real connection', function(done) {
-    const api = breadfruit({client: 'pg'});
-    api.read('tableName', [], {})
-      .catch((error) => {
-        done();
-      });
-  });
-
-  it('should fail to add without a real connection', function(done) {
-    const api = breadfruit({client: 'pg'});
-    api.add('tableName', [], {})
-      .catch((error) => {
-        done();
-      });
-  });
-
-  it('should fail to edit without a real connection', function(done) {
-    const api = breadfruit({client: 'pg'});
-    api.edit('tableName', [], {})
-      .catch((error) => {
-        done();
-      });
-  });
-
-  it('should fail to delete without a real connection', function(done) {
-    const api = breadfruit({client: 'pg'});
-    api.del('tableName', [], {})
-      .catch((error) => {
-        done();
-      });
-  });
-
-  it('should fail to do raw query without a real connection', function(done) {
-    const api = breadfruit({client: 'pg'});
-    api.raw('select NOW()', {})
-      .catch((error) => {
-        done();
-      });
-  });
-
-});