Remove onconnect

porsager · porsager · commit 933e39780644 · 2019-12-09T21:13:50.000+01:00
diff --git a/lib/connection.js b/lib/connection.js
@@ -21,14 +21,15 @@ export default function Connection(options = {}) {
   let timer
   let id = 1
   let ended
+  let ready = false
 
   const queries = Queue()
       , statements = new Map()
-      , connection = { send, end, destroy, ready: false, active: false }
+      , connection = { send, end, destroy }
 
   const socket = postgresSocket(options, {
+    ready: () => socket.write(frontend.connect(options)),
     data,
-    ready,
     error,
     close
   })
@@ -60,13 +61,13 @@ export default function Connection(options = {}) {
   function resolve(x) {
     backend.query.resolve(x)
     backend.query = null
-    timeout && connection.active && queries.length === 0 && idle()
+    timeout && queries.length === 0 && idle()
   }
 
   function reject(err) {
     backend.query ? backend.query.reject(err) : error(err)
     backend.query = null
-    timeout && connection.active && queries.length === 0 && idle()
+    timeout && queries.length === 0 && idle()
   }
 
   function end() {
@@ -96,19 +97,21 @@ export default function Connection(options = {}) {
     query.result = []
     query.result.count = null
     timeout && clearTimeout(timer)
-    !connection.ready || backend.query
-      ? queries.push(query)
-      : (backend.query = query)
 
     const buffer = query.simple
       ? simple(str, query)
       : statements.has(sig)
         ? prepared(statements.get(sig), args, query)
         : prepare(sig, str, args, query)
 
-    connection.ready
-      ? socket.write(buffer)
-      : (messages.push(buffer), socket.connect())
+    if (ready && !backend.query) {
+      backend.query = query
+      socket.write(buffer)
+    } else {
+      queries.push(query)
+      messages.push(buffer)
+      !ready && socket.connect()
+    }
   }
 
   function simple(str, query) {
@@ -135,18 +138,17 @@ export default function Connection(options = {}) {
   }
 
   function onready() {
-    if (!backend.query)
-      backend.query = queries.shift()
-
     if (!backend.query && queries.length === 0 && ended)
       return ended()
 
-    if (!connection.ready) {
+    if (!ready) {
       messages.forEach(socket.write)
       messages = []
-      connection.ready = true
-      connection.onconnect && connection.onconnect()
+      ready = true
     }
+
+    if (!backend.query)
+      backend.query = queries.shift()
   }
 
   function data(x) {
@@ -164,14 +166,10 @@ export default function Connection(options = {}) {
     }
   }
 
-  function ready() {
-    socket.write(frontend.connect(options))
-  }
-
   function close() {
     error(errors.connection('CLOSED', options))
     statements.clear()
-    connection.ready = connection.active = false
+    ready = false
   }
 
   function unknown() {
diff --git a/lib/index.js b/lib/index.js
@@ -184,10 +184,7 @@ export default function Postgres(url, options) {
   function getConnection(reserve) {
     const connection = --max >= 0 ? createConnection(options) : connections.shift()
     !options.fifo && !reserve && connection && connections.push(connection)
-    connection && (connection.active = !(options.onconnect && !connection.ready))
-    return options.onconnect && !connection.ready
-      ? instance(options.onconnect, connection)
-      : connection
+    return connection
   }
 
   function createConnection(options) {
@@ -198,34 +195,6 @@ export default function Postgres(url, options) {
     return connection
   }
 
-  function instance(fn, connection) {
-    let queries = 0
-      , container
-
-    addTypes(scoped, connection)
-    connection.onconnect = onconnect
-
-    function scoped(xs, ...args) {
-      queries++
-      const promise = query({}, connection, xs, args)
-      promise.then(finished, finished)
-      return promise
-    }
-
-    function onconnect() {
-      container = fetchArrayTypes().then(() => fn(scoped))
-      queries === 0 && finished(queries++)
-    }
-
-    function finished() {
-      --queries === 0 && Promise.resolve(container).then(() => {
-        connections.push(connection)
-        connection.active = true
-        next()
-      })
-    }
-  }
-
   function array(value) {
     return {
       type: inferType(value) || 25,
@@ -495,10 +464,9 @@ function parseOptions(uri = {}, options) {
     types       : o.types || {},
     ssl         : o.ssl || url.ssl || false,
     timeout     : o.timeout,
-    onconnect   : o.onconnect,
     onnotice    : o.onnotice,
     onparameter : o.onparameter,
-    none        : crypto.randomBytes(18).toString('base64'),
+    nonce       : crypto.randomBytes(18).toString('base64'),
     transform   : { ...o.transform },
     connection  : { application_name: 'postgres.js', ...o.connection },
     ...mergeUserTypes(o.types)
diff --git a/tests/index.js b/tests/index.js
@@ -355,36 +355,8 @@ t('responds with server parameters (application_name)', async() =>
   })`select 1`.catch(reject))]
 )
 
-t('onconnect', async() => {
-  const sql = postgres({
-    ...options,
-    onconnect: () => 'connected'
-  })
-
-  return [1, (await sql`select 1 as x`)[0].x]
-})
-
-t('onconnect runs first', async() => {
-  const results = []
-  const sql = postgres({
-    ...options,
-    onconnect: sql => sql`select 1`.then(() => results.push('onconnect'))
-  })
-
-  const x = await sql`select 1 as x`
-  results.push(x)
-
-  return ['onconnect', results[0]]
-})
-
 t('has server parameters', async() => {
-  return ['postgres.js', await new Promise((resolve, reject) => {
-    const sql = postgres({
-      ...options,
-      onconnect: () => resolve(sql.parameters.application_name)
-    })
-    sql`select 1`.catch(reject)
-  })]
+  return ['postgres.js', (await sql`select 1`.then(() => sql.parameters.application_name))]
 })
 
 t('big query body', async() => {
@@ -498,3 +470,14 @@ t('dynamic select args', async () => {
   await sql`insert into test (a, b) values (42, 'yay')`
   return ['yay', (await sql`select ${ sql('a', 'b') } from test`)[0].b]
 }, () => sql`drop table test`)
+
+ot('connection parameters', async() => {
+  const sql = postgres({
+    ...options,
+    connection: {
+      'some.var': 'yay'
+    }
+  })
+
+  return ['yay', (await sql`select current_setting('some.var') as x`)[0].x]
+})
