export function makeKnex({ host, user, password, database }) {
  const knex = makeKnexConnection({
    client: 'pg',
    connection: {
      database,
      host,
      password: 'postgres',
      user,
    },
  })

  // @TODO: Figure out how to make this work with async await or Promises.
  // @TODO: See why migrations bugs out in tests.
  if (process.env.NODE_ENV !== 'test') {
    knex.migrate
      .rollback()
      .then(() => knex.migrate.latest())
      .then(() =>
        knex.seed
          .run()
          .then(() => knex)
          // tslint:disable-next-line:no-console
          .catch(e => console.error(e) && process.exit(1))
      )
  }

  return knex
}

    beforeAll(async () => {
        knex = Knex(DEFAULT_DB_CONFIG);
        await knex.migrate.latest();
        await knex.seed.run();

        const dbConfig = new DbConfig(DEFAULT_DB_CONFIG);
        container = new Container();

        container.bind<DbConfig>('DefaultDbConfig').toConstantValue(dbConfig);

        // container...
        container.bind<ICounterRepository>(TYPES.ICounterRepository).to(CounterRepository);

    });

async function copyRunDbFixerScript(dbFileNamePath: string, backupDbPath: string): Promise<void> {
  await promisify(fs.copyFile)(dbFileNamePath, backupDbPath);
  // need to do this because cli runs migrations in .ts and augur-app runs migrations in .js
  const db: Knex = Knex({
    client: "sqlite3",
    connection: {
      filename: backupDbPath,
    },
    acquireConnectionTimeout: 5 * 60 * 1000,
    useNullAsDefault: true,
  });
  await db.raw("update knex_migrations set name = substr(name,1, length(name)-2) || 'js';");
  await db.destroy();
}

  private config(): void {
    // Sets the global header `Server` as a middleware. We
    // are intentionally receiving and ignoring the `req`
    // parameter, indicated by the underscore.
    this.app.use((_, res, next): void => {
      res.set("Server", "TypeScript-rest");

      next();
    });

    // Initiatlize connection to the database and connect
    // the knex query builder to our objection models.
    const knex = Knex(Knexfile);
    Model.knex(knex);
  }

    knex(tableName?: string | Knex.Raw | Knex.QueryBuilder | undefined) {
        if (!knexInstance) {
            knexInstance = Knex({
                client: 'mysql',
                connection: {
                    host: DB_HOST,
                    user: DB_USER,
                    password: DB_PASS,
                    database: WORDPRESS_DB_NAME
                }
            })
        }

        return knexInstance(tableName)
    }

test('should add a new record on #save()', async function (t) {
  // startup...
  const knex = Knex({ client: 'sqlite3', connection: { filename: ':memory:' } });

  Model.knex(knex);
  Models.One.app = 'myBlog';

  const m = new Migration({ tables: [] }, { tables: [Models.One.toJSON()] });
  Migration.run(knex, await m.up());

  const one = new Models.One({ myBoolean: 1, myDate: Date.now(), myDateTime: Date.now() });
  await one.save();
  const found = await Models.One.query().where('id', 1);

  // teardown...
  await knex.destroy();
  t.same(one, found[0]);
})

  static resetDatabase(done) {
    let connection = knex({
      client    : 'mysql',
      connection: {
        user    : 'root',
        host    : '127.0.0.1',
        database: 'wetland_test',
      },
    });

    connection.raw('drop database wetland_test').then(function () {
      return connection.raw('create database wetland_test').then(() => {
        connection.destroy().then(() => {
          done();
        });
      });
    });
  }

export function knex() {
    if (!knexInstance) {
        knexInstance = Knex({
            client: 'mysql',
            connection: {
                host: DB_HOST,
                user: DB_USER,
                password: DB_PASS,
                database: DB_NAME,
                typeCast: (field: any, next: any) => {
                    if (field.type == 'TINY' && field.length == 1) {
                        return (field.string() == '1'); // 1 = true, 0 = false
                    } 
                    return next();
                }
            }
        })    
    }

    return knexInstance
}

    constructor(dataBaseInfo: IConnection) {
        // PostgreSQL, MySQL, and SQLite3.
        
        
        // XXX::: Dont know about port
        let knex = Knex({
            client: dataBaseInfo.driver,
            connection: {
                host: dataBaseInfo.host,
                user: dataBaseInfo.username,
                password: dataBaseInfo.password,
                database: dataBaseInfo.database,
                charset: 'utf8'
            }
        });

        knex['_config'] = dataBaseInfo;
        // XXX::: todo for mongo
        // XXX::: todo for elastic
        
        this._connection = Bookshelf(knex);
    }

import config from './index';
import * as knexFactory from 'knex';
import Knex from 'knex';

const env = process.env['NODE_ENV'] || 'development',
  MIGRATIONS_TABLE = 'migrations',
  { DB_CONNECTION, PG_POOL_MIN, PG_POOL_MAX, PG_SEARCH_PATH } = config[env];


export const dbConfig = {
  client: 'pg',
  connection: DB_CONNECTION,
  pool: {
    min: PG_POOL_MIN,
    max: PG_POOL_MAX
  },
  searchPath: PG_SEARCH_PATH,
  migrations: {
    directory: './migrations',
    tableName: MIGRATIONS_TABLE
  },
  seeds: {
    directory: './seeds',
  }
};

const db: Knex = knexFactory(dbConfig);

export default db;

export async function initDb(knexConfig: knex.Config): Promise<any> {
  return await knex(knexConfig)
}

export async function setupDb(): Promise<any> {
  const config = await get('knex')
  const db = knex(config)
  await db.migrate.latest()
}

ďťż

import * as knexLib from "knex";
import {dbConfig} from "../../config"

export var knex = knexLib(dbConfig);
    

import * as GeoJSON from 'geojson';
import * as Knex from 'knex';
import * as KPG from 'knex-postgis';

const knex: Knex = Knex({ dialect: 'pg' });
const st: KPG.KnexPostgis = KPG(knex);

const point: GeoJSON.Point = {
  type: 'Point',
  coordinates: [23.773206, 61.506005],
  crs: {
    type: 'name',
    properties: {
      name: 'EPSG:4326'
    }
  }
};

const wktPoint = 'POINT(23.773206 61.506005)';

knex('geometries')
  .select(st.area('wkb_geometry').as('area'))
  .then(console.log);

// Can't be done because of Knex typings
// knex('geometries')
//   .select('name')
//   .where(st.area('wkb_geometry'), '>', 0.1)

knex('geometries')
  .select(st.asText('wkb_geometry'))

const configInit = (knexConfig) => {
  knex = Knex(knexConfig);
  Model.knex(knex);
  return Promise.resolve(Model);
};

import * as knex from 'knex';

import { Model } from 'objection';

const config = require('../../../../../db/config');

Model.knex(knex(config[process.env.NODE_ENV || 'development']));

import * as libKnex from 'knex';
import * as pg from 'pg';
import { extend, _raw } from 'pg-extra';
import { isNil } from 'ramda';
import { db } from '../config';

const postgres = extend(pg);

export const pool = new postgres.extra.Pool(db);
export const knex = libKnex({ client: 'pg' });

/**
 * Run a Knex query for a single result through the pool
 * @param {object} query - A Knex query object
 */
export const getOneRaw = query => pool.one(_raw`${query}`);

/**
 * Run a Knex query for multiple results through the pool
 * @param {object} query - A Knex query object
 */
export const getManyRaw = query => pool.many(_raw`${query}`);

/**
 * On a null query response throw an error to the response handler otherwise return
 * @param {string} error - Error message to throw with
 * @param {any} data - Response from query
 */
export const result = (error: string, data: any): never | any => {
    if (isNil(data)) {
        throw new Error(error);

import registerApi from './api';
import * as bodyParser from 'body-parser';
import * as express from 'express';
import * as Knex from 'knex';
import * as morgan from 'morgan';
import { Model } from 'objection';

const knexConfig = require('../knexfile');
// Initialize knex.
export const knex = Knex(knexConfig.development);

// Create or migrate:
knex.migrate.latest();

// Bind all Models to a knex instance. If you only have one database in
// your server this is all you have to do. For multi database systems, see
// the Model.bindKnex method.
Model.knex(knex);

// Unfortunately the express-promise-router types are borked. Just require():
const router = require('express-promise-router')();
const app = express()
  .use(bodyParser.json())
  .use(morgan('dev'))
  .use(router)
  .set('json spaces', 2);

// Register our REST API.
registerApi(router);

// Error handling. The `ValidationError` instances thrown by objection.js have a `statusCode`

import * as bookshelf from "bookshelf";
import * as knex from "knex";
import * as pg from "pg";

pg.defaults.ssl = true;

// Fix for parsing of numeric fields
pg.types.setTypeParser(1700, "text", parseFloat);

import knexfile = require("./knexfile");

const dbConfig = knexfile[process.env.NODE_ENV];

export = bookshelf(knex(dbConfig));

/// <reference path='knex.d.ts' />

/// <reference path='../lodash/lodash-3.10.d.ts' />

import * as Knex from 'knex';
import * as _ from 'lodash';

// Initializing the Library
var knex = Knex({
  client: 'sqlite3',
  connection: {
    filename: "./mydb.sqlite"
  }
});

var knex = Knex({
  debug: true,
  client: 'mysql',
  connection: {
    socketPath     : '/path/to/socket.sock',
    user     : 'your_database_user',
    password : 'your_database_password',
    database : 'myapp_test'
  }
});

// Mariasql configuration
var knex = Knex({
  debug: true,
  client: 'mariasql',
  connection: {