neopg 2.2.7 → 2.2.9

package/lib/ModelChain.js

@@ -418,10 +418,17 @@ class ModelChain {
     }
   }
 
-  async update(data) {
+  /**
+   * 
+   * @param {object} data 
+   * @param {boolean} one_result - auto return result[0] if only one item, default true
+   * @returns 
+   */
+  async update(data, one_result=true) {
     this._ensureActive()
     try {
-      if (!data || Object.keys(data).length === 0) throw new Error('[NeoPG] Update data cannot be empty')
+      if (!data || Object.keys(data).length === 0)
+        throw new Error('[NeoPG] Update data cannot be empty')
 
         if (!this._isRaw) {
         this._prepareDataForUpdate(data)
@@ -436,7 +443,7 @@ class ModelChain {
       const result = await this.sql`UPDATE ${fullTable} SET ${this.sql(data)} ${whereFragment} ${retFragment}`
 
       if (this._returning && this._returning.length > 0) {
-          if (result.length === 1) return result[0]
+          if (result.length === 1 && one_result) return result[0]
           return result
       }
       return result

package/lib/SchemaSync.js

@@ -102,9 +102,9 @@ class SchemaSync {
     for (const c of cols) inf[c.column_name] = c;
 
     await this.syncColumn(sql, def, inf, curTableName, debug, force, dropNotExistCol);
+    await this.autoRemoveIndex(sql, def, schema, tableName, debug);
     await this.syncIndex(sql, def, schema, curTableName, debug);
     await this.syncUnique(sql, def, schema, curTableName, debug);
-    await this.autoRemoveIndex(sql, def, schema, tableName, debug);
     await this.syncReferences(sql, def, schema, curTableName, schemaOid, debug, ctx, options);
 
     if (debug) console.log(` - 表结构同步完成 (${tableName}) - `);
@@ -290,6 +290,33 @@ class SchemaSync {
     const indices = def.index || [];
     if (!Array.isArray(indices)) return;
 
+    let gen_real_index = indname => {
+      let real_indexname
+      if (Array.isArray(indname)) {
+        real_indexname = indname.sort((a,b) => a.localeCompare(b)).join('_');
+      } else if (typeof indname === 'string') {
+        if (indname.indexOf(',') >= 0) {
+          real_indexname = indname.split(',').map(s=>s.trim()).filter(s=>s)
+                                .sort((a,b)=>a.localeCompare(b))
+                                .join('_');
+        } else {
+          real_indexname = indname.trim();
+        }
+      }
+
+      return real_indexname;
+    }
+
+    let unique_indexs = (def.unique || []).map(a => gen_real_index(a));
+
+    let check_in_unique = (indname) => {
+      for (let a of unique_indexs) {
+        if (a === gen_real_index(indname)) return true;
+      }
+
+      return false;
+    }
+
     for (const indname of indices) {
         const removeIndex = def.removeIndex || [];
         if (removeIndex.includes(indname)) continue;
@@ -299,7 +326,21 @@ class SchemaSync {
             continue;
         }
 
-        let idxCols = Array.isArray(indname) ? indname : indname.split(',').map(s=>s.trim()).filter(s=>s);
+        if (!Array.isArray(indname) && typeof indname !== 'string') {
+          debug && console.error(`Index ${indname} 不是字符串或数组，跳过。`);
+          continue;
+        }
+
+        if (check_in_unique(indname)) {
+          debug && console.error(`Index ${indname} 是唯一索引，不会创建index索引，跳过。`);
+          continue;
+        }
+
+        let idxCols = Array.isArray(indname)
+                     ? indname.sort((a,b) => a.localeCompare(b))
+                      : indname.split(',').map(s=>s.trim()).filter(s=>s)
+                              .sort((a,b) => a.localeCompare(b));
+
         const idxNamePart = idxCols.join('_');
         const targetIdxName = `${def.tableName}_${idxNamePart}_idx`;
 
@@ -339,7 +380,14 @@ class SchemaSync {
       for (const indname of uniques) {
           if (!this._checkColumnsExist(indname, def)) continue;
 
-          let idxCols = Array.isArray(indname) ? indname : indname.split(',').map(s=>s.trim()).filter(s=>s);
+          if (!Array.isArray(indname) && typeof indname !== 'string') {
+            debug && console.error(`Index ${indname} 不是字符串或数组，跳过。`);
+            continue;
+          }
+
+          let idxCols = Array.isArray(indname)
+                          ? indname.sort((a,b)=>a.localeCompare(b))
+                          : indname.split(',').map(s=>s.trim()).filter(s=>s).sort((a,b)=>a.localeCompare(b));
 
           // 监测是否等于主键
           if (pkSet.size > 0 && idxCols.length === pkSet.size) {
@@ -368,7 +416,7 @@ class SchemaSync {
 
   static async autoRemoveIndex(sql, def, schema, tableName, debug) {
       const allIdx = await sql`
-        SELECT indexname FROM pg_indexes 
+        SELECT * FROM pg_indexes 
         WHERE tablename = ${tableName} 
         AND schemaname = ${schema} 
         AND indexname != ${tableName + '_pkey'}
@@ -377,22 +425,51 @@ class SchemaSync {
       if (allIdx.length === 0) return;
 
       const currentIdxNames = allIdx.map(i => i.indexname);
+      let indexTable = Object.create(null);
+      for (let a of allIdx) {
+        indexTable[a.indexname] = a;
+      }
       
       const indices = def.index || [];
       const uniques = def.unique || [];
-      
-      const keepSet = new Set();
-      const makeName = (n) => `${tableName}_${Array.isArray(n) ? n.map(x=>x.trim()).join('_') : n.split(',').map(x=>x.trim()).filter(x=>x).join('_')}_idx`;
 
-      indices.forEach(n => keepSet.add(makeName(n)));
-      uniques.forEach(n => keepSet.add(makeName(n)));
+      const makeName = (n) => `${tableName}_${Array.isArray(n) 
+                        ? n.map(x=>x.trim()).sort((a,b) => a.localeCompare(b)).join('_')
+                        : n.split(',').map(x=>x.trim()).filter(x=>x).sort((a,b) => a.localeCompare(b)).join('_')}_idx`;
+
+      let allIndex = Object.create(null);
+      for (let k of indices) {
+        allIndex[makeName(k)] = k;
+      }
+
+      let allUnique = Object.create(null);
+      for (let k of uniques) {
+        allUnique[makeName(k)] = k;
+      }
 
       for (const idxName of currentIdxNames) {
-          if (!keepSet.has(idxName)) {
+          if (!allIndex[idxName] && !allUnique[idxName]) {
               if (debug) console.log('Auto removing index:', idxName);
               await sql.unsafe(`DROP INDEX ${schema}.${idxName}`);
           }
       }
+
+      for (let k in allIndex) {
+        if (!indexTable[k]) continue;
+
+        if (indexTable[k].indexdef.toLowerCase().indexOf('create index') !== 0) {
+          debug && console.log('Auto remove index with inconsistent type:', k);
+          await sql.unsafe(`DROP INDEX ${schema}.${k};`);
+        }
+      }
+
+      for (let k in allUnique) {
+        if (!indexTable[k]) continue;
+        if (indexTable[k].indexdef.toLowerCase().indexOf('create unique') !== 0) {
+          debug && console.log('Auto remove index with inconsistent type:', k);
+          await sql.unsafe(`DROP INDEX ${schema}.${k};`);
+        }
+      }
   }
 
   // --- 外键同步 ---

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "neopg",
-  "version": "2.2.7",
+  "version": "2.2.9",
   "description": "orm for postgres",
   "keywords": [
     "neopg",

package/postgres/connection.js

@@ -51,6 +51,7 @@ const errorFields = {
 
 function Connection(options, queues = {}, { onopen = noop, onend = noop, onclose = noop } = {}) {
   const {
+    sslnegotiation,
     ssl,
     max,
     user,
@@ -77,6 +78,7 @@ function Connection(options, queues = {}, { onopen = noop, onend = noop, onclose
 
   let socket = null
     , cancelMessage
+    , errorResponse = null
     , result = new Result()
     , incoming = Buffer.alloc(0)
     , needsTypes = options.fetch_types
@@ -84,7 +86,7 @@ function Connection(options, queues = {}, { onopen = noop, onend = noop, onclose
     , statements = {}
     , statementId = Math.random().toString(36).slice(2)
     , statementCount = 1
-    , closedDate = 0
+    , closedTime = 0
     , remaining = 0
     , hostIndex = 0
     , retries = 0
@@ -155,6 +157,9 @@ function Connection(options, queues = {}, { onopen = noop, onend = noop, onclose
     if (terminated)
       return queryError(q, Errors.connection('CONNECTION_DESTROYED', options))
 
+    if (stream)
+      return queryError(q, Errors.generic('COPY_IN_PROGRESS', 'You cannot execute queries during copy'))
+
     if (q.cancelled)
       return
 
@@ -259,25 +264,29 @@ function Connection(options, queues = {}, { onopen = noop, onend = noop, onclose
   }
 
   async function secure() {
-    write(SSLRequest)
-    const canSSL = await new Promise(r => socket.once('data', x => r(x[0] === 83))) // S
+    if (sslnegotiation !== 'direct') {
+      write(SSLRequest)
+      const canSSL = await new Promise(r => socket.once('data', x => r(x[0] === 83))) // S
 
-    if (!canSSL && ssl === 'prefer')
-      return connected()
+      if (!canSSL && ssl === 'prefer')
+        return connected()
+    }
 
-    socket.removeAllListeners()
-    socket = tls.connect({
+    const options = {
       socket,
-      servername: net.isIP(socket.host) ? undefined : socket.host,
-      ...(ssl === 'require' || ssl === 'allow' || ssl === 'prefer'
-        ? { rejectUnauthorized: false }
-        : ssl === 'verify-full'
-          ? {}
-          : typeof ssl === 'object'
-            ? ssl
-            : {}
-      )
-    })
+      servername: net.isIP(socket.host) ? undefined : socket.host
+    }
+
+    if (sslnegotiation === 'direct')
+      options.ALPNProtocols = ['postgresql']
+
+    if (ssl === 'require' || ssl === 'allow' || ssl === 'prefer')
+      options.rejectUnauthorized = false
+    else if (typeof ssl === 'object')
+      Object.assign(options, ssl)
+
+    socket.removeAllListeners()
+    socket = tls.connect(options)
     socket.on('secureConnect', connected)
     socket.on('error', error)
     socket.on('close', closed)
@@ -350,7 +359,7 @@ function Connection(options, queues = {}, { onopen = noop, onend = noop, onclose
   }
 
   function reconnect() {
-    setTimeout(connect, closedDate ? Math.max(0, closedDate + delay - performance.now()) : 0)
+    setTimeout(connect, closedTime ? Math.max(0, closedTime + delay - performance.now()) : 0)
   }
 
   function connected() {
@@ -442,7 +451,7 @@ function Connection(options, queues = {}, { onopen = noop, onend = noop, onclose
       return reconnect()
 
     !hadError && (query || sent.length) && error(Errors.connection('CONNECTION_CLOSED', options, socket))
-    closedDate = performance.now()
+    closedTime = performance.now()
     hadError && options.shared.retries++
     delay = (typeof backoff === 'function' ? backoff(options.shared.retries) : backoff) * 1000
     onclose(connection, Errors.connection('CONNECTION_CLOSED', options, socket))
@@ -524,8 +533,21 @@ function Connection(options, queues = {}, { onopen = noop, onend = noop, onclose
   }
 
   function ReadyForQuery(x) {
-    query && query.options.simple && query.resolve(results || result)
-    query = results = null
+    if (query) {
+      if (errorResponse) {
+        query.retried
+          ? errored(query.retried)
+          : query.prepared && retryRoutines.has(errorResponse.routine)
+            ? retry(query, errorResponse)
+            : errored(errorResponse)
+      } else {
+        query.resolve(results || result)
+      }
+    } else if (errorResponse) {
+      errored(errorResponse)
+    }
+
+    query = results = errorResponse = null
     result = new Result()
     connectTimer.cancel()
 
@@ -590,8 +612,6 @@ function Connection(options, queues = {}, { onopen = noop, onend = noop, onclose
       result.count && query.cursorFn(result)
       write(Sync)
     }
-
-    query.resolve(result)
   }
 
   function ParseComplete() {
@@ -790,13 +810,12 @@ function Connection(options, queues = {}, { onopen = noop, onend = noop, onclose
   }
 
   function ErrorResponse(x) {
-    query && (query.cursorFn || query.describeFirst) && write(Sync)
-    const error = Errors.postgres(parseError(x))
-    query && query.retried
-      ? errored(query.retried)
-      : query && query.prepared && retryRoutines.has(error.routine)
-        ? retry(query, error)
-        : errored(error)
+    if (query) {
+      (query.cursorFn || query.describeFirst) && write(Sync)
+      errorResponse = Errors.postgres(parseError(x))
+    } else {
+      errored(Errors.postgres(parseError(x)))
+    }
   }
 
   function retry(q, error) {
@@ -849,6 +868,7 @@ function Connection(options, queues = {}, { onopen = noop, onend = noop, onclose
       final(callback) {
         socket.write(b().c().end())
         final = callback
+        stream = null
       }
     })
     query.resolve(stream)

package/postgres/index.js

@@ -446,8 +446,9 @@ function parseOptions(a, b) {
 
   const ints = ['idle_timeout', 'connect_timeout', 'max_lifetime', 'max_pipeline', 'backoff', 'keep_alive']
   const defaults = {
-    max             : 10,
+    max             : globalThis.Cloudflare ? 3 : 10,
     ssl             : false,
+    sslnegotiation  : null,
     idle_timeout    : null,
     connect_timeout : 30,
     max_lifetime    : max_lifetime,

package/test/test-db.js

@@ -135,6 +135,10 @@ const User = {
     role: {
       type: dataTypes.STRING(16),
       default: 'user'
+    },
+    number: {
+      type: dataTypes.INT,
+      default: 1
     }
   },
 
@@ -286,6 +290,16 @@ db.add(User)
     let result = await tx.model('User').where(tx.sql`level > 10`).returning('*').update(data)
     console.log('test update returning *', result)
 
+    console.log('test for update sql fragment')
+    let upd_result = await tx.model('User')
+                        .where('1=1')
+                        .returning(['id', 'username', 'number'])
+                        .update({
+                          number: tx.sql`number + ${(Math.random() * 20) | 0}`
+                        }, false);
+    
+    console.log(upd_result.count, upd_result.columns, upd_result)
+
     let sex = 3
     console.log(
       'test condition or',