@cuboapp/database 1.0.6 → 1.0.7

package/package.json

@@ -1,17 +1,27 @@
 {
   "name": "@cuboapp/database",
-  "version": "1.0.6",
+  "version": "1.0.7",
   "description": "Database methods",
   "main": "src/index.ts",
-  "repository": "git@cuboapp.gitlab.yandexcloud.net:cubo/database.git",
+  "files": [
+    "src"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git@cuboapp.gitlab.yandexcloud.net:cubo/database.git"
+  },
   "author": "CuboSoft",
   "license": "MIT",
   "type": "module",
   "publishConfig": {
     "access": "public"
   },
+  "scripts": {
+    "clean": "rm -rf dist",
+    "build": "npm run clean && tsc -p tsconfig.build.json"
+  },
   "dependencies": {
-    "sequelize": "^6.37.7"
+    "sequelize": "^6.37.8"
   },
   "devDependencies": {
     "@types/node": "^24.0.0",

package/src/db/index.ts

@@ -1,14 +1,14 @@
 import { Options, QueryTypes, Sequelize, Transaction } from 'sequelize'
 
 import { DatabaseOptions } from './types'
-import { dbPrepareInsertQueryString, dbPrepareUpdateQueryString } from './utils'
+import { dbPrepareBatchInsertQueryString, dbPrepareInsertQueryString, dbPrepareUpdateQueryString } from './utils'
 
 export * from 'sequelize'
 export * from './types'
 export * from './utils'
 
 export class Database {
-  public connection: Sequelize
+  public connection!: Sequelize
 
   constructor(
     private connectOptions: Options,
@@ -90,7 +90,7 @@ export class Database {
             return []
           }
 
-          let pk = []
+          let pk: string[] = []
 
           switch (this.connectOptions.dialect) {
             case 'postgres':
@@ -101,7 +101,7 @@ export class Database {
               break
           }
 
-          return pkType === 'number' ? pk.map((r) => +r) : pk
+          return (pkType === 'number' ? pk.map((r) => +r) : pk) as T[]
         })
     }
 
@@ -160,5 +160,187 @@ export class Database {
           return result as unknown as T[]
       }
     }
+
+    return []
+  }
+
+  /**
+   * Inserts many rows in a single statement. The column set is the union of keys
+   * across all rows; columns absent from a given row are written as `null`.
+   *
+   * For postgres every primary key is returned (via `RETURNING`). MySQL only
+   * surfaces the first auto-increment id of the batch, so the returned array
+   * holds that single id.
+   */
+  public async createMany<T extends number | string = number>(
+    table: string,
+    arInsert: any[],
+    opts?: { log?: boolean; transaction?: Transaction; pk_key?: string; pk_type?: 'string' | 'number' }
+  ): Promise<T[]> {
+    if (!Array.isArray(arInsert) || arInsert.length === 0) {
+      throw 'QUERY: db createMany insert array is empty'
+    }
+
+    const rows = arInsert.filter((row) => row && Object.keys(row).length > 0)
+
+    if (rows.length === 0) {
+      throw 'QUERY: db createMany insert array is empty'
+    }
+
+    const { keys, values, replacements } = dbPrepareBatchInsertQueryString(rows)
+
+    const pkKey = opts?.pk_key ?? 'id'
+    const pkType = opts?.pk_type ?? 'number'
+
+    let sql = ''
+
+    switch (this.connectOptions.dialect) {
+      case 'postgres':
+        if (!!pkKey) {
+          sql = `insert into ${table} (${keys}) values ${values} returning ${pkKey}`
+        } else {
+          sql = `insert into ${table} (${keys}) values ${values}`
+        }
+        break
+      case 'mysql':
+        sql = `insert into ${table} (${keys}) values ${values}`
+        break
+      default:
+        throw 'QUERY: db createMany unsupported dialect'
+    }
+
+    if (opts?.log) {
+      console.warn(`CREATE MANY QUERY: ${sql} [${JSON.stringify(replacements)}]`)
+    }
+
+    return this.connection
+      .query(sql, {
+        type: QueryTypes.INSERT,
+        replacements,
+        transaction: opts?.transaction
+      })
+      .then((res: any) => {
+        if (!pkKey) {
+          return []
+        }
+
+        let pk: string[] = []
+
+        switch (this.connectOptions.dialect) {
+          case 'postgres':
+            pk = (res?.[0] || []).map((r: any) => r[pkKey]) as string[]
+            break
+          case 'mysql':
+            pk = (res?.[0] != null ? [res[0]] : []) as string[]
+            break
+        }
+
+        return (pkType === 'number' ? pk.map((r) => +r) : pk) as T[]
+      })
+  }
+
+  /**
+   * Applies a set of updates atomically. Each item carries its own `where` clause,
+   * its `where` replacements and the columns to set, so different rows can receive
+   * different values. When no transaction is supplied a managed one is created so
+   * the whole batch commits or rolls back together. Returns the flattened primary
+   * keys of every affected row.
+   */
+  public async updateMany<T = number | string>(
+    table: string,
+    arUpdate: Array<{ where: string; replacements?: Record<string, any>; values: Record<string, any> }>,
+    opts?: { log?: boolean; transaction?: Transaction; pk_key?: string; pk_type?: 'string' | 'number' }
+  ): Promise<T[]> {
+    if (!Array.isArray(arUpdate) || arUpdate.length === 0) {
+      throw 'QUERY: db updateMany update array is empty'
+    }
+
+    const run = async (transaction: Transaction): Promise<T[]> => {
+      const ids: T[] = []
+
+      for (const item of arUpdate) {
+        if (!item?.values || Object.keys(item.values).length === 0) {
+          continue
+        }
+
+        const res = await this.update<T>(table, item.where, item.replacements ?? {}, item.values, {
+          ...opts,
+          transaction
+        })
+
+        if (res?.length) {
+          ids.push(...res)
+        }
+      }
+
+      return ids
+    }
+
+    if (opts?.transaction) {
+      return run(opts.transaction)
+    }
+
+    return this.connection.transaction((transaction) => run(transaction))
+  }
+
+  /**
+   * Deletes many rows in a single statement, matched by a list of primary keys
+   * (`where <pk_key> in (...)`). For postgres the keys actually removed are
+   * returned (via `RETURNING`); MySQL has no `RETURNING`, so it resolves to an
+   * empty array.
+   */
+  public async deleteMany<T extends number | string = number>(
+    table: string,
+    ids: Array<number | string>,
+    opts?: { log?: boolean; transaction?: Transaction; pk_key?: string; pk_type?: 'string' | 'number' }
+  ): Promise<T[]> {
+    if (!Array.isArray(ids) || ids.length === 0) {
+      throw 'QUERY: db deleteMany id array is empty'
+    }
+
+    const pkKey = opts?.pk_key ?? 'id'
+    const pkType = opts?.pk_type ?? 'number'
+
+    const replacements: Record<string, any> = {}
+
+    const placeholders = ids.map((id, index) => {
+      const name = `${pkKey}_${index}`
+      replacements[name] = id
+      return `:${name}`
+    })
+
+    let sql = ''
+    let queryType: QueryTypes
+
+    switch (this.connectOptions.dialect) {
+      case 'postgres':
+        sql = `delete from ${table} where ${pkKey} in (${placeholders.join(', ')}) returning ${pkKey}`
+        queryType = QueryTypes.SELECT
+        break
+      case 'mysql':
+        sql = `delete from ${table} where ${pkKey} in (${placeholders.join(', ')})`
+        queryType = QueryTypes.DELETE
+        break
+      default:
+        throw 'QUERY: db deleteMany unsupported dialect'
+    }
+
+    if (opts?.log) {
+      console.warn(`DELETE MANY QUERY: ${sql} [${JSON.stringify(replacements)}]`)
+    }
+
+    const result: any = await this.connection.query(sql, {
+      type: queryType,
+      replacements,
+      transaction: opts?.transaction
+    })
+
+    if (this.connectOptions.dialect !== 'postgres') {
+      return []
+    }
+
+    const pk = (result || []).map((r: any) => r[pkKey]) as string[]
+
+    return (pkType === 'number' ? pk.map((r) => +r) : pk) as T[]
   }
 }

package/src/db/utils.ts

@@ -3,36 +3,49 @@ import { literal, Options, QueryTypes, Sequelize, Transaction } from 'sequelize'
 import { Database } from '.'
 import { DatabaseOptions } from './types'
 
+/**
+ * Normalizes a JS value into something safe to pass to Sequelize as a replacement:
+ * empty strings / NaN / nullish objects collapse to `null`, Buffers become raw
+ * literals, and plain arrays/objects are JSON-stringified. Shared by every
+ * insert/update query builder so the coercion rules stay in one place.
+ */
+export function dbNormalizeValue(value: any) {
+  if (typeof value === 'string') {
+    return value ? value : null
+  }
+
+  if (typeof value === 'number') {
+    return !isNaN(value) ? value : null
+  }
+
+  if (typeof value === 'boolean') {
+    return value
+  }
+
+  if (Array.isArray(value) || typeof value === 'object') {
+    if (Buffer.isBuffer(value)) {
+      return literal(value.toString('utf-8'))
+    }
+
+    if (['Literal', 'Date'].includes(value?.constructor?.name)) {
+      return value
+    }
+
+    return value ? JSON.stringify(value) : null
+  }
+
+  return null
+}
+
 export function dbPrepareUpdateQueryString(obj: Record<string, any>, prefix = '') {
   const keys: string[] = []
   const replacements: Record<string, any> = {}
 
   for (const key in obj) {
-    const value = obj[key]
-
-    keys.push(`${key + (prefix ? '_' + prefix : '')} = :${key + (prefix ? '_' + prefix : '')}`)
-
-    let val = null
-
-    if (typeof value === 'string') {
-      val = !!value ? value : null
-    } else if (typeof value === 'number') {
-      val = !isNaN(value) ? value : null
-    } else if (typeof value === 'boolean') {
-      val = value
-    } else if (Array.isArray(value) || typeof value === 'object') {
-      if (Buffer.isBuffer(value)) {
-        val = literal(value.toString('utf-8'))
-      } else {
-        if (['Literal', 'Date'].includes(value?.constructor?.name)) {
-          val = value
-        } else {
-          val = value ? JSON.stringify(value) : null
-        }
-      }
-    }
+    const name = key + (prefix ? '_' + prefix : '')
 
-    replacements[key + (prefix ? '_' + prefix : '')] = val
+    keys.push(`${name} = :${name}`)
+    replacements[name] = dbNormalizeValue(obj[key])
   }
 
   return { query: keys.join(', '), replacements }
@@ -43,38 +56,48 @@ export function dbPrepareInsertQueryString(obj: Record<string, any>, prefix = ''
   const replacements: Record<string, any> = {}
 
   for (const key in obj) {
-    const value = obj[key]
-
-    values.push(`:${key + (prefix ? '_' + prefix : '')}`)
-
-    let val = null
-
-    // console.log(key, typeof value, value, value?.constructor?.name, value?.name)
-
-    if (typeof value === 'string') {
-      val = !!value ? value : null
-    } else if (typeof value === 'number') {
-      val = !isNaN(value) ? value : null
-    } else if (typeof value === 'boolean') {
-      val = value
-    } else if (Array.isArray(value) || typeof value === 'object') {
-      if (Buffer.isBuffer(value)) {
-        val = literal(value.toString('utf-8'))
-      } else {
-        if (['Literal', 'Date'].includes(value?.constructor?.name)) {
-          val = value
-        } else {
-          val = value ? JSON.stringify(value) : null
-        }
-      }
-    }
+    const name = key + (prefix ? '_' + prefix : '')
 
-    replacements[key + (prefix ? '_' + prefix : '')] = val
+    values.push(`:${name}`)
+    replacements[name] = dbNormalizeValue(obj[key])
   }
 
   return { keys: Object.keys(obj).join(', '), values: values.join(','), replacements }
 }
 
+/**
+ * Builds the column list and a multi-row `VALUES (...), (...)` clause for a batch
+ * insert. The column set is the union of keys across every row (first-seen order);
+ * columns missing from a given row are inserted as `null`. Each placeholder is
+ * suffixed with the row index (e.g. `:name_0`, `:name_1`) so replacements never
+ * collide.
+ */
+export function dbPrepareBatchInsertQueryString(rows: Record<string, any>[]) {
+  const columns: string[] = []
+
+  for (const row of rows) {
+    for (const key in row) {
+      if (!columns.includes(key)) {
+        columns.push(key)
+      }
+    }
+  }
+
+  const replacements: Record<string, any> = {}
+
+  const values = rows.map((row, index) => {
+    const placeholders = columns.map((column) => {
+      const name = `${column}_${index}`
+      replacements[name] = dbNormalizeValue(row[column])
+      return `:${name}`
+    })
+
+    return `(${placeholders.join(', ')})`
+  })
+
+  return { keys: columns.join(', '), values: values.join(', '), replacements }
+}
+
 export async function dbCreate<T = number>(
   db: Sequelize,
   table: string,

package/.prettierrc

@@ -1,8 +0,0 @@
-{
-  "trailingComma": "none",
-  "tabWidth": 2,
-  "semi": false,
-  "singleQuote": true,
-  "eslintIntegration": true,
-  "printWidth": 140
-}

package/tsconfig.build.json

@@ -1,4 +0,0 @@
-{
-  "extends": "./tsconfig.json",
-  "exclude": ["node_modules", "test", "dist", "**/*spec.ts"]
-}

package/tsconfig.json

@@ -1,21 +0,0 @@
-{
-  "compilerOptions": {
-    "module": "commonjs",
-    "declaration": true,
-    "removeComments": true,
-    "emitDecoratorMetadata": true,
-    "experimentalDecorators": true,
-    "allowSyntheticDefaultImports": true,
-    "target": "ES2021",
-    "sourceMap": true,
-    "outDir": "./dist",
-    "baseUrl": "./",
-    "incremental": true,
-    "skipLibCheck": true,
-    "paths": {
-      "@/*": ["src/*"]
-    }
-  },
-  "include": ["src/**/*"],
-  "exclude": ["node_modules", "dist"]
-}