@naturalcycles/mysql-lib 3.7.1 → 3.9.1

package/dist/schema/mysql.schema.util.js

@@ -1,78 +1,102 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.mapNameFromMySQL = exports.mapNameToMySQL = exports.mysqlTableStatsToCommonSchemaField = exports.commonSchemaToMySQLDDL = void 0;
-const db_lib_1 = require("@naturalcycles/db-lib");
-const js_lib_1 = require("@naturalcycles/js-lib");
+exports.mapNameFromMySQL = exports.mapNameToMySQL = exports.mysqlTableStatsToJsonSchemaField = exports.jsonSchemaToMySQLDDL = void 0;
 const mysql = require("mysql");
 /**
  * It currently skips nullability and declares everything as "DEFAULT NULL".
  */
-function commonSchemaToMySQLDDL(schema, opt = {}) {
+function jsonSchemaToMySQLDDL(table, schema, opt = {}) {
     const { engine = 'InnoDB' } = opt;
-    const { table, fields } = schema;
     const lines = [`CREATE TABLE ${mysql.escapeId(table)} (`];
-    const innerLines = fields.map(f => commonSchemaFieldToDDL(f));
+    const innerLines = Object.entries(schema.properties).map(([k, s]) => {
+        if (k === 'id') {
+            return `id VARCHAR(255) NOT NULL`;
+        }
+        let type;
+        if (s.type === 'string') {
+            // can specify isoDate later
+            type = 'LONGTEXT';
+        }
+        else if (s.type === 'integer') {
+            type = 'INT(11)';
+        }
+        else if (s.type === 'number') {
+            if (['unixTimestamp', 'int32'].includes(s.format)) {
+                type = 'INT(11)';
+            }
+            else {
+                type = 'FLOAT(11)';
+            }
+        }
+        else if (s.type === 'boolean') {
+            type = 'TINYINT(1)';
+        }
+        else if (s.instanceof === 'Buffer') {
+            type = 'LONGBLOB';
+        }
+        else if (s.type === 'null') {
+            type = 'VARCHAR(255)';
+        }
+        else if (s.type === 'array') {
+            type = 'LONGTEXT'; // to be JSON.stringified?
+        }
+        else if (s.type === 'object') {
+            type = 'LONGTEXT'; // to be JSON.stringified?
+        }
+        else {
+            // default
+            type = 'LONGTEXT';
+        }
+        const tokens = [mysql.escapeId(mapNameToMySQL(k)), type, `DEFAULT NULL`];
+        return tokens.join(' ');
+    });
     innerLines.push(`PRIMARY KEY (id)`);
     lines.push(innerLines.join(',\n'));
     lines.push(`) ENGINE=${engine}`);
     return lines.join('\n');
 }
-exports.commonSchemaToMySQLDDL = commonSchemaToMySQLDDL;
-const typeToMySQLType = {
-    [db_lib_1.DATA_TYPE.STRING]: `LONGTEXT`,
-    [db_lib_1.DATA_TYPE.LOCAL_DATE]: `VARCHAR(255)`,
-    [db_lib_1.DATA_TYPE.INT]: `INT(11)`,
-    [db_lib_1.DATA_TYPE.TIMESTAMP]: `INT(11)`,
-    [db_lib_1.DATA_TYPE.FLOAT]: `FLOAT(11)`,
-    [db_lib_1.DATA_TYPE.BOOLEAN]: `TINYINT(1)`,
-    [db_lib_1.DATA_TYPE.BINARY]: `LONGBLOB`,
-    [db_lib_1.DATA_TYPE.ARRAY]: `LONGTEXT`,
-    [db_lib_1.DATA_TYPE.OBJECT]: `LONGTEXT`,
-    [db_lib_1.DATA_TYPE.NULL]: `VARCHAR(255)`,
-    [db_lib_1.DATA_TYPE.UNKNOWN]: `LONGTEXT`,
-};
-function commonSchemaFieldToDDL(f) {
-    if (f.name === 'id') {
-        return `id VARCHAR(255) NOT NULL`;
-    }
-    const tokens = [
-        mysql.escapeId(mapNameToMySQL(f.name)),
-        typeToMySQLType[f.type] || typeToMySQLType[db_lib_1.DATA_TYPE.UNKNOWN],
-        `DEFAULT NULL`,
-    ];
-    return tokens.join(' ');
-}
-function mysqlTableStatsToCommonSchemaField(s) {
-    const name = mapNameFromMySQL(s.Field);
-    const notNull = (s.Null || '').toUpperCase() !== 'YES';
-    let type = db_lib_1.DATA_TYPE.UNKNOWN;
-    const t = (s.Type || '').toLowerCase();
-    if (t) {
+exports.jsonSchemaToMySQLDDL = jsonSchemaToMySQLDDL;
+function mysqlTableStatsToJsonSchemaField(table, stats, logger) {
+    const s = {
+        $id: `${table}.schema.json`,
+        type: 'object',
+        properties: {},
+        required: [],
+        additionalProperties: true,
+    };
+    stats.forEach(stat => {
+        const name = stat.Field;
+        const t = stat.Type.toLowerCase();
+        const notNull = stat.Null?.toUpperCase() !== 'YES';
+        if (notNull) {
+            s.required.push(name);
+        }
         if (t.includes('text') || t.includes('char')) {
-            type = db_lib_1.DATA_TYPE.STRING;
+            s.properties[name] = { type: 'string' };
         }
         else if (t.includes('lob')) {
-            type = db_lib_1.DATA_TYPE.BINARY;
+            s.properties[name] = { instanceof: 'Buffer' };
         }
         else if (t.startsWith('tinyint') || t.includes('(1)')) {
-            type = db_lib_1.DATA_TYPE.BOOLEAN;
+            s.properties[name] = { type: 'boolean' };
         }
         else if (t.startsWith('int(')) {
-            type = db_lib_1.DATA_TYPE.INT;
+            s.properties[name] = { type: 'integer' };
         }
         else if (t.startsWith('float')) {
-            type = db_lib_1.DATA_TYPE.FLOAT;
+            s.properties[name] = { type: 'number' };
+        }
+        else {
+            logger.log(s);
+            throw new Error(`Unknown mysql field type ${name} ${stat.Type}`);
         }
-    }
-    return js_lib_1._filterFalsyValues({
-        name,
-        type,
-        notNull,
     });
+    return s;
 }
-exports.mysqlTableStatsToCommonSchemaField = mysqlTableStatsToCommonSchemaField;
+exports.mysqlTableStatsToJsonSchemaField = mysqlTableStatsToJsonSchemaField;
 /**
  * Because MySQL doesn't support `.` in field names and escapes them as tableName + fieldName.
+ *
  * @param name
  */
 function mapNameToMySQL(name) {
@@ -83,4 +107,3 @@ function mapNameFromMySQL(name) {
     return name.replace(/_dot_/g, '.');
 }
 exports.mapNameFromMySQL = mapNameFromMySQL;
-//# sourceMappingURL=mysql.schema.util.js.map

package/package.json

@@ -1,21 +1,20 @@
 {
   "name": "@naturalcycles/mysql-lib",
-  "scripts": {},
-  "peerDependencies": {
-    "@naturalcycles/db-lib": ">=7.0.0"
+  "scripts": {
+    "prepare": "husky install"
   },
   "dependencies": {
-    "@naturalcycles/db-lib": "^7.0.1",
-    "@naturalcycles/js-lib": "^13.1.5",
-    "@naturalcycles/nodejs-lib": "^10.5.0",
-    "@types/mysql": "^2.15.6",
+    "@naturalcycles/db-lib": "^8.16.2",
+    "@naturalcycles/js-lib": "^14.47.0",
+    "@naturalcycles/nodejs-lib": "^12.37.0",
+    "@types/mysql": "^2.15.19",
     "mysql": "^2.17.1"
   },
   "devDependencies": {
-    "@naturalcycles/dev-lib": "^10.3.0",
-    "@types/node": "^14.0.9",
-    "dotenv": "^8.0.0",
-    "jest": "^26.0.1"
+    "@naturalcycles/dev-lib": "^12.7.5",
+    "@types/node": "^16.10.2",
+    "dotenv": "^10.0.0",
+    "jest": "^27.2.4"
   },
   "files": [
     "dist",
@@ -35,9 +34,9 @@
     "url": "https://github.com/NaturalCycles/mysql-lib"
   },
   "engines": {
-    "node": ">=12.13.1"
+    "node": ">=14.15.0"
   },
-  "version": "3.7.1",
+  "version": "3.9.1",
   "description": "MySQL client implementing CommonDB interface",
   "keywords": [
     "mysql",

package/src/index.ts

@@ -1,12 +1,7 @@
 import { getDBAdapter } from './dbAdapter'
 import { MysqlDB, MysqlDBCfg, MysqlDBOptions, MysqlDBSaveOptions } from './mysql.db'
-import { commonSchemaToMySQLDDL } from './schema/mysql.schema.util'
+import { jsonSchemaToMySQLDDL } from './schema/mysql.schema.util'
 
-export {
-  MysqlDB,
-  MysqlDBCfg,
-  MysqlDBOptions,
-  MysqlDBSaveOptions,
-  commonSchemaToMySQLDDL,
-  getDBAdapter,
-}
+export type { MysqlDBCfg, MysqlDBOptions, MysqlDBSaveOptions }
+
+export { MysqlDB, jsonSchemaToMySQLDDL, getDBAdapter }

package/src/mysql.db.ts

@@ -1,32 +1,41 @@
+import { Transform } from 'stream'
+import { promisify } from 'util'
 import {
   BaseCommonDB,
-  BaseDBEntity,
   CommonDB,
   CommonDBCreateOptions,
   CommonDBOptions,
   CommonDBSaveOptions,
-  CommonSchema,
   DBQuery,
-  ObjectWithId,
   RunQueryResult,
 } from '@naturalcycles/db-lib'
-import { _filterUndefinedValues, _mapKeys, _mapValues, _Memo } from '@naturalcycles/js-lib'
-import { Debug, ReadableTyped } from '@naturalcycles/nodejs-lib'
+import {
+  _filterNullishValues,
+  _mapKeys,
+  _mapValues,
+  _Memo,
+  AnyObjectWithId,
+  CommonLogger,
+  commonLoggerPrefix,
+  JsonSchemaObject,
+  JsonSchemaRootObject,
+  ObjectWithId,
+} from '@naturalcycles/js-lib'
+import { ReadableTyped } from '@naturalcycles/nodejs-lib'
 import { white } from '@naturalcycles/nodejs-lib/dist/colors'
 import { Connection, Pool, PoolConfig, PoolConnection, QueryOptions, TypeCast } from 'mysql'
 import * as mysql from 'mysql'
-import { Transform } from 'stream'
-import { promisify } from 'util'
 import { dbQueryToSQLDelete, dbQueryToSQLSelect, insertSQL } from './query.util'
 import {
-  commonSchemaToMySQLDDL,
+  jsonSchemaToMySQLDDL,
   mapNameFromMySQL,
   MySQLTableStats,
-  mysqlTableStatsToCommonSchemaField,
+  mysqlTableStatsToJsonSchemaField,
 } from './schema/mysql.schema.util'
 
 export interface MysqlDBOptions extends CommonDBOptions {}
-export interface MysqlDBSaveOptions extends CommonDBSaveOptions {}
+export interface MysqlDBSaveOptions<ROW extends ObjectWithId = AnyObjectWithId>
+  extends CommonDBSaveOptions<ROW> {}
 
 /**
  * @default false / undefined
@@ -41,9 +50,12 @@ export interface MysqlDBCfg extends PoolConfig {
    * If true - will emit logs of connection events.
    */
   debugConnections?: boolean
-}
 
-const log = Debug('nc:mysql-lib')
+  /**
+   * Default to `console`
+   */
+  logger?: CommonLogger
+}
 
 const BOOLEAN_TYPES = new Set(['TINY', 'TINYINT', 'INT'])
 const BOOLEAN_BIT_TYPES = new Set(['BIT'])
@@ -79,12 +91,13 @@ export class MysqlDB extends BaseCommonDB implements CommonDB {
       // password: MYSQL_PW,
       // database: MYSQL_DB,
       ...cfg,
+      logger: commonLoggerPrefix(cfg.logger || console, '[mysql]'),
     }
   }
 
-  cfg!: MysqlDBCfg
+  cfg: MysqlDBCfg & { logger: CommonLogger }
 
-  async ping(): Promise<void> {
+  override async ping(): Promise<void> {
     const con = await this.getConnection()
     con.release()
   }
@@ -92,29 +105,29 @@ export class MysqlDB extends BaseCommonDB implements CommonDB {
   @_Memo()
   pool(): Pool {
     const pool = mysql.createPool(this.cfg)
-    const { host, database } = this.cfg
-    log(`connected to ${white(host + '/' + database)}`)
+    const { host, database, logger } = this.cfg
+    logger.log(`connected to ${white(host + '/' + database)}`)
 
     if (this.cfg.debugConnections) {
       pool.on('acquire', con => {
-        log(`acquire(${con.threadId})`)
+        logger.log(`acquire(${con.threadId})`)
       })
 
       pool.on('connection', con => {
-        log(`connection(${con.threadId})`)
+        logger.log(`connection(${con.threadId})`)
       })
 
       pool.on('enqueue', () => {
-        log(`enqueue`)
+        logger.log(`enqueue`)
       })
 
       pool.on('release', con => {
-        log(`release(${con.threadId})`)
+        logger.log(`release(${con.threadId})`)
       })
     }
 
     pool.on('error', err => {
-      log.error(`error`, err)
+      logger.error(err)
     })
 
     return pool
@@ -122,7 +135,9 @@ export class MysqlDB extends BaseCommonDB implements CommonDB {
 
   async close(): Promise<void> {
     const pool = this.pool()
+    // eslint-disable-next-line @typescript-eslint/await-thenable
     await promisify(pool.end.bind(pool))
+    this.cfg.logger.log('closed')
   }
 
   /**
@@ -130,7 +145,7 @@ export class MysqlDB extends BaseCommonDB implements CommonDB {
    */
   async getConnection(): Promise<PoolConnection> {
     const pool = this.pool()
-    return promisify(pool.getConnection.bind(pool))()
+    return await promisify(pool.getConnection.bind(pool))()
   }
 
   /**
@@ -143,23 +158,23 @@ export class MysqlDB extends BaseCommonDB implements CommonDB {
     const { threadId } = con
 
     if (this.cfg.debugConnections) {
-      log(`createSingleConnection(${threadId})`)
+      this.cfg.logger.log(`createSingleConnection(${threadId})`)
 
-      con.on('connect', () => log(`createSingleConnection(${threadId}).connect`))
-      con.on('drain', () => log(`createSingleConnection(${threadId}).drain`))
-      con.on('enqueue', () => log(`createSingleConnection(${threadId}).enqueue`))
-      con.on('end', () => log(`createSingleConnection(${threadId}).end`))
+      con.on('connect', () => this.cfg.logger.log(`createSingleConnection(${threadId}).connect`))
+      con.on('drain', () => this.cfg.logger.log(`createSingleConnection(${threadId}).drain`))
+      con.on('enqueue', () => this.cfg.logger.log(`createSingleConnection(${threadId}).enqueue`))
+      con.on('end', () => this.cfg.logger.log(`createSingleConnection(${threadId}).end`))
     }
 
     con.on('error', err => {
-      log.error(`createSingleConnection(${threadId}).error`, err)
+      this.cfg.logger.error(`createSingleConnection(${threadId}).error`, err)
     })
 
     return con
   }
 
   // GET
-  async getByIds<ROW extends ObjectWithId>(
+  override async getByIds<ROW extends ObjectWithId>(
     table: string,
     ids: string[],
     opt: MysqlDBOptions = {},
@@ -167,27 +182,25 @@ export class MysqlDB extends BaseCommonDB implements CommonDB {
     if (!ids.length) return []
     const q = new DBQuery<ROW>(table).filterEq('id', ids)
     const { rows } = await this.runQuery(q, opt)
-    return rows.map(r => _mapKeys(r, (_v, k) => mapNameFromMySQL(k)) as any)
+    return rows.map(r => _mapKeys(r, k => mapNameFromMySQL(k)) as any)
   }
 
   // QUERY
-  async runQuery<ROW extends ObjectWithId, OUT = ROW>(
+  override async runQuery<ROW extends ObjectWithId, OUT = ROW>(
     q: DBQuery<ROW>,
-    opt: MysqlDBOptions = {},
+    _opt: MysqlDBOptions = {},
   ): Promise<RunQueryResult<OUT>> {
     const sql = dbQueryToSQLSelect(q)
     const rows = await this.runSQL<ROW[]>({ sql })
     return {
-      rows: rows.map(
-        r => _mapKeys(_filterUndefinedValues(r, true), (_v, k) => mapNameFromMySQL(k)) as any,
-      ),
+      rows: rows.map(r => _mapKeys(_filterNullishValues(r, true), k => mapNameFromMySQL(k)) as any),
     }
   }
 
   async runSQL<RESULT>(q: QueryOptions): Promise<RESULT> {
-    if (this.cfg.logSQL) log(q.sql, q.values)
+    if (this.cfg.logSQL) this.cfg.logger.log(q.sql, q.values)
 
-    return new Promise(async (resolve, reject) => {
+    return await new Promise<RESULT>((resolve, reject) => {
       this.pool().query(q, (err, res) => {
         if (err) return reject(err)
         resolve(res)
@@ -195,21 +208,21 @@ export class MysqlDB extends BaseCommonDB implements CommonDB {
     })
   }
 
-  async runQueryCount<ROW extends ObjectWithId>(
+  override async runQueryCount<ROW extends ObjectWithId>(
     q: DBQuery<ROW>,
-    opt?: CommonDBOptions,
+    _opt?: CommonDBOptions,
   ): Promise<number> {
-    const { rows } = await this.runQuery(q.select(['count(*) as _count']))
+    const { rows } = await this.runQuery(q.select(['count(*) as _count' as any]))
     return (rows[0] as any)._count
   }
 
-  streamQuery<ROW extends ObjectWithId, OUT = ROW>(
+  override streamQuery<ROW extends ObjectWithId, OUT = ROW>(
     q: DBQuery<ROW>,
-    opt: MysqlDBOptions = {},
+    _opt: MysqlDBOptions = {},
   ): ReadableTyped<OUT> {
     const sql = dbQueryToSQLSelect(q)
 
-    if (this.cfg.logSQL) log(`stream: ${sql}`)
+    if (this.cfg.logSQL) this.cfg.logger.log(`stream: ${sql}`)
 
     // return this.streamSQL(sql, opt)
     return this.pool()
@@ -219,17 +232,17 @@ export class MysqlDB extends BaseCommonDB implements CommonDB {
         new Transform({
           objectMode: true,
           transform(row, _encoding, cb) {
-            cb(null, _filterUndefinedValues(row, true))
+            cb(null, _filterNullishValues(row, true))
           },
         }),
       )
   }
 
   // SAVE
-  async saveBatch<ROW extends BaseDBEntity>(
+  override async saveBatch<ROW extends ObjectWithId>(
     table: string,
     _rows: ROW[],
-    opt?: MysqlDBSaveOptions,
+    _opt?: MysqlDBSaveOptions<ROW>,
   ): Promise<void> {
     if (!_rows.length) return
 
@@ -241,7 +254,7 @@ export class MysqlDB extends BaseCommonDB implements CommonDB {
     )
 
     // inserts are split into multiple sentenses to respect the max_packet_size (1Mb usually)
-    const sqls = insertSQL(table, rows)
+    const sqls = insertSQL(table, rows, 'INSERT', this.cfg.logger)
 
     for await (const sql of sqls) {
       await this.runSQL({ sql })
@@ -252,16 +265,16 @@ export class MysqlDB extends BaseCommonDB implements CommonDB {
   /**
    * Limitation: always returns [], regardless of which rows are actually deleted
    */
-  async deleteByIds(table: string, ids: string[], opt?: MysqlDBOptions): Promise<number> {
+  override async deleteByIds(table: string, ids: string[], _opt?: MysqlDBOptions): Promise<number> {
     if (!ids.length) return 0
     const sql = dbQueryToSQLDelete(new DBQuery(table).filterEq('id', ids))
     const res = await this.runSQL<any>({ sql })
     return res.affectedRows
   }
 
-  async deleteByQuery<ROW extends ObjectWithId>(
+  override async deleteByQuery<ROW extends ObjectWithId>(
     q: DBQuery<ROW>,
-    opt?: CommonDBOptions,
+    _opt?: CommonDBOptions,
   ): Promise<number> {
     const sql = dbQueryToSQLDelete(q)
     const res = await this.runSQL<any>({ sql })
@@ -278,27 +291,30 @@ export class MysqlDB extends BaseCommonDB implements CommonDB {
   /**
    * dropIfExists=true needed as a safety check
    */
-  async createTable(schema: CommonSchema, opt: CommonDBCreateOptions = {}): Promise<void> {
-    if (opt.dropIfExists) await this.dropTable(schema.table)
+  override async createTable<ROW extends ObjectWithId>(
+    table: string,
+    schema: JsonSchemaObject<ROW>,
+    opt: CommonDBCreateOptions = {},
+  ): Promise<void> {
+    if (opt.dropIfExists) await this.dropTable(table)
 
-    const sql = commonSchemaToMySQLDDL(schema)
+    const sql = jsonSchemaToMySQLDDL(table, schema)
     await this.runSQL({ sql })
   }
 
-  async getTables(): Promise<string[]> {
-    return (await this.runSQL<object[]>({ sql: `show tables` }))
+  override async getTables(): Promise<string[]> {
+    return (await this.runSQL<Record<any, any>[]>({ sql: `show tables` }))
       .map(r => Object.values(r)[0])
       .filter(Boolean)
   }
 
-  async getTableSchema<ROW extends ObjectWithId>(table: string): Promise<CommonSchema<ROW>> {
-    const statsArray = await this.runSQL<MySQLTableStats[]>({
+  override async getTableSchema<ROW extends ObjectWithId>(
+    table: string,
+  ): Promise<JsonSchemaRootObject<ROW>> {
+    const stats = await this.runSQL<MySQLTableStats[]>({
       sql: `describe ${mysql.escapeId(table)}`,
     })
 
-    return {
-      table,
-      fields: statsArray.map(stats => mysqlTableStatsToCommonSchemaField(stats)),
-    }
+    return mysqlTableStatsToJsonSchemaField<ROW>(table, stats, this.cfg.logger)
   }
 }

package/src/query.util.ts

@@ -1,5 +1,6 @@
 import { DBQuery } from '@naturalcycles/db-lib'
-import { _hb } from '@naturalcycles/js-lib'
+import { DBQueryFilterOperator } from '@naturalcycles/db-lib/src/query/dbQuery'
+import { _hb, CommonLogger } from '@naturalcycles/js-lib'
 import { white, yellow } from '@naturalcycles/nodejs-lib/dist/colors'
 import { QueryOptions } from 'mysql'
 import * as mysql from 'mysql'
@@ -8,7 +9,7 @@ import { mapNameToMySQL } from './schema/mysql.schema.util'
 const MAX_PACKET_SIZE = 1024 * 1024 // 1Mb
 const MAX_ROW_SIZE = 800 * 1024 // 1Mb - margin
 
-export function dbQueryToSQLSelect(q: DBQuery): string {
+export function dbQueryToSQLSelect(q: DBQuery<any>): string {
   const tokens = selectTokens(q)
 
   // filters
@@ -23,7 +24,7 @@ export function dbQueryToSQLSelect(q: DBQuery): string {
   return tokens.join(' ')
 }
 
-export function dbQueryToSQLDelete(q: DBQuery): string {
+export function dbQueryToSQLDelete(q: DBQuery<any>): string {
   const tokens = [`DELETE FROM`, mysql.escapeId(q.table)]
 
   // filters
@@ -40,12 +41,14 @@ export function dbQueryToSQLDelete(q: DBQuery): string {
  */
 export function insertSQL(
   table: string,
-  records: object[],
+  records: Record<any, any>[],
   verb: 'INSERT' | 'REPLACE' = 'INSERT',
+  logger: CommonLogger = console,
 ): string[] {
   // INSERT INTO table_name (column1, column2, column3, ...)
   // VALUES (value1, value2, value3, ...);
 
+  // eslint-disable-next-line unicorn/no-array-reduce
   const fieldSet = records.reduce((set: Set<string>, rec) => {
     Object.keys(rec).forEach(field => set.add(field))
     return set
@@ -88,7 +91,7 @@ export function insertSQL(
     sqls.push(sql) // last one
   }
 
-  console.log(
+  logger.log(
     `${white(table)} large sql query (${yellow(_hb(full.length))}) was split into ${yellow(
       sqls.length,
     )} chunks`,
@@ -99,7 +102,7 @@ export function insertSQL(
   // todo: handle "upsert" later
 }
 
-export function insertSQLSingle(table: string, record: object): string {
+export function insertSQLSingle(table: string, record: Record<any, any>): string {
   // INSERT INTO table_name (column1, column2, column3, ...)
   // VALUES (value1, value2, value3, ...);
 
@@ -122,14 +125,14 @@ export function insertSQLSingle(table: string, record: object): string {
   return tokens.join(' ')
 }
 
-export function insertSQLSetSingle(table: string, record: object): QueryOptions {
+export function insertSQLSetSingle(table: string, record: Record<any, any>): QueryOptions {
   return {
     sql: `INSERT INTO ${mysql.escapeId(table)} SET ?`,
     values: [record],
   }
 }
 
-export function dbQueryToSQLUpdate(q: DBQuery, record: object): string {
+export function dbQueryToSQLUpdate(q: DBQuery<any>, record: Record<any, any>): string {
   // var sql = mysql.format('UPDATE posts SET modified = ? WHERE id = ?', [CURRENT_TIMESTAMP, 42]);
   const tokens = [
     `UPDATE`,
@@ -148,14 +151,14 @@ function selectTokens(q: DBQuery): string[] {
   let fields = ['*']
 
   if (q._selectedFieldNames) {
-    fields = q._selectedFieldNames.length ? q._selectedFieldNames : ['id']
+    fields = q._selectedFieldNames.length ? (q._selectedFieldNames as string[]) : ['id']
   }
 
   // We don't do `escapeId` cause it'll ruin e.g SELECT `count *` FROM ...
   return [`SELECT`, fields.map(f => mapNameToMySQL(f)).join(', '), `FROM`, mysql.escapeId(q.table)]
 }
 
-function offsetLimitTokens(q: DBQuery): string[] {
+function offsetLimitTokens(q: DBQuery<any>): string[] {
   const tokens: string[] = []
 
   if (q._limitValue) {
@@ -178,6 +181,10 @@ function orderTokens(q: DBQuery): string[] {
   ]
 }
 
+const OP_MAP: Partial<Record<DBQueryFilterOperator, string>> = {
+  '==': '=',
+}
+
 function whereTokens(q: DBQuery): string[] {
   if (!q._filters.length) return []
 
@@ -189,17 +196,21 @@ function whereTokens(q: DBQuery): string[] {
           // special treatment
 
           return [
-            mysql.escapeId(mapNameToMySQL(f.name)),
-            f.op === '=' ? 'IS NULL' : 'IS NOT NULL',
+            mysql.escapeId(mapNameToMySQL(f.name as string)),
+            f.op === '==' ? 'IS NULL' : 'IS NOT NULL',
           ].join(' ')
         }
 
         if (Array.isArray(f.val)) {
           // special case for arrays
-          return `${mysql.escapeId(mapNameToMySQL(f.name))} IN (${mysql.escape(f.val)})`
+          return `${mysql.escapeId(mapNameToMySQL(f.name as string))} IN (${mysql.escape(f.val)})`
         }
 
-        return [mysql.escapeId(mapNameToMySQL(f.name)), f.op, mysql.escape(f.val)].join(' ')
+        return [
+          mysql.escapeId(mapNameToMySQL(f.name as string)),
+          OP_MAP[f.op] || f.op,
+          mysql.escape(f.val),
+        ].join(' ')
       })
       .join(' AND '),
   ]