@naturalcycles/mysql-lib 3.7.1 → 3.9.1

package/dist/dbAdapter.js

@@ -7,4 +7,3 @@ function getDBAdapter(cfgStr = '{}') {
     return new mysql_db_1.MysqlDB(cfg);
 }
 exports.getDBAdapter = getDBAdapter;
-//# sourceMappingURL=dbAdapter.js.map

package/dist/index.d.ts

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

package/dist/index.js

@@ -1,10 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getDBAdapter = exports.commonSchemaToMySQLDDL = exports.MysqlDB = void 0;
+exports.getDBAdapter = exports.jsonSchemaToMySQLDDL = exports.MysqlDB = void 0;
 const dbAdapter_1 = require("./dbAdapter");
 Object.defineProperty(exports, "getDBAdapter", { enumerable: true, get: function () { return dbAdapter_1.getDBAdapter; } });
 const mysql_db_1 = require("./mysql.db");
 Object.defineProperty(exports, "MysqlDB", { enumerable: true, get: function () { return mysql_db_1.MysqlDB; } });
 const mysql_schema_util_1 = require("./schema/mysql.schema.util");
-Object.defineProperty(exports, "commonSchemaToMySQLDDL", { enumerable: true, get: function () { return mysql_schema_util_1.commonSchemaToMySQLDDL; } });
-//# sourceMappingURL=index.js.map
+Object.defineProperty(exports, "jsonSchemaToMySQLDDL", { enumerable: true, get: function () { return mysql_schema_util_1.jsonSchemaToMySQLDDL; } });

package/dist/mysql.db.d.ts

@@ -1,9 +1,10 @@
-import { BaseCommonDB, BaseDBEntity, CommonDB, CommonDBCreateOptions, CommonDBOptions, CommonDBSaveOptions, CommonSchema, DBQuery, ObjectWithId, RunQueryResult } from '@naturalcycles/db-lib';
+import { BaseCommonDB, CommonDB, CommonDBCreateOptions, CommonDBOptions, CommonDBSaveOptions, DBQuery, RunQueryResult } from '@naturalcycles/db-lib';
+import { AnyObjectWithId, CommonLogger, JsonSchemaObject, JsonSchemaRootObject, ObjectWithId } from '@naturalcycles/js-lib';
 import { ReadableTyped } from '@naturalcycles/nodejs-lib';
 import { Connection, Pool, PoolConfig, PoolConnection, QueryOptions } from 'mysql';
 export interface MysqlDBOptions extends CommonDBOptions {
 }
-export interface MysqlDBSaveOptions extends CommonDBSaveOptions {
+export interface MysqlDBSaveOptions<ROW extends ObjectWithId = AnyObjectWithId> extends CommonDBSaveOptions<ROW> {
 }
 /**
  * @default false / undefined
@@ -17,10 +18,16 @@ export interface MysqlDBCfg extends PoolConfig {
      * If true - will emit logs of connection events.
      */
     debugConnections?: boolean;
+    /**
+     * Default to `console`
+     */
+    logger?: CommonLogger;
 }
 export declare class MysqlDB extends BaseCommonDB implements CommonDB {
     constructor(cfg?: MysqlDBCfg);
-    cfg: MysqlDBCfg;
+    cfg: MysqlDBCfg & {
+        logger: CommonLogger;
+    };
     ping(): Promise<void>;
     pool(): Pool;
     close(): Promise<void>;
@@ -34,16 +41,16 @@ export declare class MysqlDB extends BaseCommonDB implements CommonDB {
      */
     createSingleConnection(): Promise<Connection>;
     getByIds<ROW extends ObjectWithId>(table: string, ids: string[], opt?: MysqlDBOptions): Promise<ROW[]>;
-    runQuery<ROW extends ObjectWithId, OUT = ROW>(q: DBQuery<ROW>, opt?: MysqlDBOptions): Promise<RunQueryResult<OUT>>;
+    runQuery<ROW extends ObjectWithId, OUT = ROW>(q: DBQuery<ROW>, _opt?: MysqlDBOptions): Promise<RunQueryResult<OUT>>;
     runSQL<RESULT>(q: QueryOptions): Promise<RESULT>;
-    runQueryCount<ROW extends ObjectWithId>(q: DBQuery<ROW>, opt?: CommonDBOptions): Promise<number>;
-    streamQuery<ROW extends ObjectWithId, OUT = ROW>(q: DBQuery<ROW>, opt?: MysqlDBOptions): ReadableTyped<OUT>;
-    saveBatch<ROW extends BaseDBEntity>(table: string, _rows: ROW[], opt?: MysqlDBSaveOptions): Promise<void>;
+    runQueryCount<ROW extends ObjectWithId>(q: DBQuery<ROW>, _opt?: CommonDBOptions): Promise<number>;
+    streamQuery<ROW extends ObjectWithId, OUT = ROW>(q: DBQuery<ROW>, _opt?: MysqlDBOptions): ReadableTyped<OUT>;
+    saveBatch<ROW extends ObjectWithId>(table: string, _rows: ROW[], _opt?: MysqlDBSaveOptions<ROW>): Promise<void>;
     /**
      * Limitation: always returns [], regardless of which rows are actually deleted
      */
-    deleteByIds(table: string, ids: string[], opt?: MysqlDBOptions): Promise<number>;
-    deleteByQuery<ROW extends ObjectWithId>(q: DBQuery<ROW>, opt?: CommonDBOptions): Promise<number>;
+    deleteByIds(table: string, ids: string[], _opt?: MysqlDBOptions): Promise<number>;
+    deleteByQuery<ROW extends ObjectWithId>(q: DBQuery<ROW>, _opt?: CommonDBOptions): Promise<number>;
     /**
      * Use with caution!
      */
@@ -51,7 +58,7 @@ export declare class MysqlDB extends BaseCommonDB implements CommonDB {
     /**
      * dropIfExists=true needed as a safety check
      */
-    createTable(schema: CommonSchema, opt?: CommonDBCreateOptions): Promise<void>;
+    createTable<ROW extends ObjectWithId>(table: string, schema: JsonSchemaObject<ROW>, opt?: CommonDBCreateOptions): Promise<void>;
     getTables(): Promise<string[]>;
-    getTableSchema<ROW extends ObjectWithId>(table: string): Promise<CommonSchema<ROW>>;
+    getTableSchema<ROW extends ObjectWithId>(table: string): Promise<JsonSchemaRootObject<ROW>>;
 }

package/dist/mysql.db.js

@@ -2,16 +2,14 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MysqlDB = void 0;
 const tslib_1 = require("tslib");
+const stream_1 = require("stream");
+const util_1 = require("util");
 const db_lib_1 = require("@naturalcycles/db-lib");
 const js_lib_1 = require("@naturalcycles/js-lib");
-const nodejs_lib_1 = require("@naturalcycles/nodejs-lib");
 const colors_1 = require("@naturalcycles/nodejs-lib/dist/colors");
 const mysql = require("mysql");
-const stream_1 = require("stream");
-const util_1 = require("util");
 const query_util_1 = require("./query.util");
 const mysql_schema_util_1 = require("./schema/mysql.schema.util");
-const log = nodejs_lib_1.Debug('nc:mysql-lib');
 const BOOLEAN_TYPES = new Set(['TINY', 'TINYINT', 'INT']);
 const BOOLEAN_BIT_TYPES = new Set(['BIT']);
 const typeCast = (field, next) => {
@@ -33,188 +31,184 @@ const typeCast = (field, next) => {
     }
     return next();
 };
-let MysqlDB = /** @class */ (() => {
-    class MysqlDB extends db_lib_1.BaseCommonDB {
-        constructor(cfg = {}) {
-            super();
-            this.cfg = {
-                typeCast,
-                // charset: 'utf8mb4', // for emoji support
-                // host: 'localhost',
-                // user: MYSQL_USER,
-                // password: MYSQL_PW,
-                // database: MYSQL_DB,
-                ...cfg,
-            };
-        }
-        async ping() {
-            const con = await this.getConnection();
-            con.release();
-        }
-        pool() {
-            const pool = mysql.createPool(this.cfg);
-            const { host, database } = this.cfg;
-            log(`connected to ${colors_1.white(host + '/' + database)}`);
-            if (this.cfg.debugConnections) {
-                pool.on('acquire', con => {
-                    log(`acquire(${con.threadId})`);
-                });
-                pool.on('connection', con => {
-                    log(`connection(${con.threadId})`);
-                });
-                pool.on('enqueue', () => {
-                    log(`enqueue`);
-                });
-                pool.on('release', con => {
-                    log(`release(${con.threadId})`);
-                });
-            }
-            pool.on('error', err => {
-                log.error(`error`, err);
+class MysqlDB extends db_lib_1.BaseCommonDB {
+    constructor(cfg = {}) {
+        super();
+        this.cfg = {
+            typeCast,
+            // charset: 'utf8mb4', // for emoji support
+            // host: 'localhost',
+            // user: MYSQL_USER,
+            // password: MYSQL_PW,
+            // database: MYSQL_DB,
+            ...cfg,
+            logger: (0, js_lib_1.commonLoggerPrefix)(cfg.logger || console, '[mysql]'),
+        };
+    }
+    async ping() {
+        const con = await this.getConnection();
+        con.release();
+    }
+    pool() {
+        const pool = mysql.createPool(this.cfg);
+        const { host, database, logger } = this.cfg;
+        logger.log(`connected to ${(0, colors_1.white)(host + '/' + database)}`);
+        if (this.cfg.debugConnections) {
+            pool.on('acquire', con => {
+                logger.log(`acquire(${con.threadId})`);
             });
-            return pool;
-        }
-        async close() {
-            const pool = this.pool();
-            await util_1.promisify(pool.end.bind(pool));
-        }
-        /**
-         * Be careful to always call `con.release()` when you get connection with this method.
-         */
-        async getConnection() {
-            const pool = this.pool();
-            return util_1.promisify(pool.getConnection.bind(pool))();
-        }
-        /**
-         * Manually create a single (not pool) connection.
-         * Be careful to manage this connection yourself (open, release, etc).
-         */
-        async createSingleConnection() {
-            const con = mysql.createConnection(this.cfg);
-            await util_1.promisify(con.connect.bind(con))();
-            const { threadId } = con;
-            if (this.cfg.debugConnections) {
-                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('error', err => {
-                log.error(`createSingleConnection(${threadId}).error`, err);
+            pool.on('connection', con => {
+                logger.log(`connection(${con.threadId})`);
             });
-            return con;
-        }
-        // GET
-        async getByIds(table, ids, opt = {}) {
-            if (!ids.length)
-                return [];
-            const q = new db_lib_1.DBQuery(table).filterEq('id', ids);
-            const { rows } = await this.runQuery(q, opt);
-            return rows.map(r => js_lib_1._mapKeys(r, (_v, k) => mysql_schema_util_1.mapNameFromMySQL(k)));
-        }
-        // QUERY
-        async runQuery(q, opt = {}) {
-            const sql = query_util_1.dbQueryToSQLSelect(q);
-            const rows = await this.runSQL({ sql });
-            return {
-                rows: rows.map(r => js_lib_1._mapKeys(js_lib_1._filterUndefinedValues(r, true), (_v, k) => mysql_schema_util_1.mapNameFromMySQL(k))),
-            };
-        }
-        async runSQL(q) {
-            if (this.cfg.logSQL)
-                log(q.sql, q.values);
-            return new Promise(async (resolve, reject) => {
-                this.pool().query(q, (err, res) => {
-                    if (err)
-                        return reject(err);
-                    resolve(res);
-                });
+            pool.on('enqueue', () => {
+                logger.log(`enqueue`);
+            });
+            pool.on('release', con => {
+                logger.log(`release(${con.threadId})`);
             });
         }
-        async runQueryCount(q, opt) {
-            const { rows } = await this.runQuery(q.select(['count(*) as _count']));
-            return rows[0]._count;
-        }
-        streamQuery(q, opt = {}) {
-            const sql = query_util_1.dbQueryToSQLSelect(q);
-            if (this.cfg.logSQL)
-                log(`stream: ${sql}`);
-            // return this.streamSQL(sql, opt)
-            return this.pool()
-                .query(sql)
-                .stream()
-                .pipe(new stream_1.Transform({
-                objectMode: true,
-                transform(row, _encoding, cb) {
-                    cb(null, js_lib_1._filterUndefinedValues(row, true));
-                },
-            }));
-        }
-        // SAVE
-        async saveBatch(table, _rows, opt) {
-            if (!_rows.length)
-                return;
-            // Stringify object values
-            const rows = _rows.map(row => js_lib_1._mapValues(row, v => {
-                return v && typeof v === 'object' && !Buffer.isBuffer(v) ? JSON.stringify(v) : v;
-            }));
-            // inserts are split into multiple sentenses to respect the max_packet_size (1Mb usually)
-            const sqls = query_util_1.insertSQL(table, rows);
-            for await (const sql of sqls) {
-                await this.runSQL({ sql });
-            }
-        }
-        // DELETE
-        /**
-         * Limitation: always returns [], regardless of which rows are actually deleted
-         */
-        async deleteByIds(table, ids, opt) {
-            if (!ids.length)
-                return 0;
-            const sql = query_util_1.dbQueryToSQLDelete(new db_lib_1.DBQuery(table).filterEq('id', ids));
-            const res = await this.runSQL({ sql });
-            return res.affectedRows;
-        }
-        async deleteByQuery(q, opt) {
-            const sql = query_util_1.dbQueryToSQLDelete(q);
-            const res = await this.runSQL({ sql });
-            return res.affectedRows;
-        }
-        /**
-         * Use with caution!
-         */
-        async dropTable(table) {
-            await this.runSQL({ sql: `DROP TABLE IF EXISTS ${table}` });
-        }
-        /**
-         * dropIfExists=true needed as a safety check
-         */
-        async createTable(schema, opt = {}) {
-            if (opt.dropIfExists)
-                await this.dropTable(schema.table);
-            const sql = mysql_schema_util_1.commonSchemaToMySQLDDL(schema);
-            await this.runSQL({ sql });
-        }
-        async getTables() {
-            return (await this.runSQL({ sql: `show tables` }))
-                .map(r => Object.values(r)[0])
-                .filter(Boolean);
-        }
-        async getTableSchema(table) {
-            const statsArray = await this.runSQL({
-                sql: `describe ${mysql.escapeId(table)}`,
+        pool.on('error', err => {
+            logger.error(err);
+        });
+        return pool;
+    }
+    async close() {
+        const pool = this.pool();
+        // eslint-disable-next-line @typescript-eslint/await-thenable
+        await (0, util_1.promisify)(pool.end.bind(pool));
+        this.cfg.logger.log('closed');
+    }
+    /**
+     * Be careful to always call `con.release()` when you get connection with this method.
+     */
+    async getConnection() {
+        const pool = this.pool();
+        return await (0, util_1.promisify)(pool.getConnection.bind(pool))();
+    }
+    /**
+     * Manually create a single (not pool) connection.
+     * Be careful to manage this connection yourself (open, release, etc).
+     */
+    async createSingleConnection() {
+        const con = mysql.createConnection(this.cfg);
+        await (0, util_1.promisify)(con.connect.bind(con))();
+        const { threadId } = con;
+        if (this.cfg.debugConnections) {
+            this.cfg.logger.log(`createSingleConnection(${threadId})`);
+            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 => {
+            this.cfg.logger.error(`createSingleConnection(${threadId}).error`, err);
+        });
+        return con;
+    }
+    // GET
+    async getByIds(table, ids, opt = {}) {
+        if (!ids.length)
+            return [];
+        const q = new db_lib_1.DBQuery(table).filterEq('id', ids);
+        const { rows } = await this.runQuery(q, opt);
+        return rows.map(r => (0, js_lib_1._mapKeys)(r, k => (0, mysql_schema_util_1.mapNameFromMySQL)(k)));
+    }
+    // QUERY
+    async runQuery(q, _opt = {}) {
+        const sql = (0, query_util_1.dbQueryToSQLSelect)(q);
+        const rows = await this.runSQL({ sql });
+        return {
+            rows: rows.map(r => (0, js_lib_1._mapKeys)((0, js_lib_1._filterNullishValues)(r, true), k => (0, mysql_schema_util_1.mapNameFromMySQL)(k))),
+        };
+    }
+    async runSQL(q) {
+        if (this.cfg.logSQL)
+            this.cfg.logger.log(q.sql, q.values);
+        return await new Promise((resolve, reject) => {
+            this.pool().query(q, (err, res) => {
+                if (err)
+                    return reject(err);
+                resolve(res);
             });
-            return {
-                table,
-                fields: statsArray.map(stats => mysql_schema_util_1.mysqlTableStatsToCommonSchemaField(stats)),
-            };
+        });
+    }
+    async runQueryCount(q, _opt) {
+        const { rows } = await this.runQuery(q.select(['count(*) as _count']));
+        return rows[0]._count;
+    }
+    streamQuery(q, _opt = {}) {
+        const sql = (0, query_util_1.dbQueryToSQLSelect)(q);
+        if (this.cfg.logSQL)
+            this.cfg.logger.log(`stream: ${sql}`);
+        // return this.streamSQL(sql, opt)
+        return this.pool()
+            .query(sql)
+            .stream()
+            .pipe(new stream_1.Transform({
+            objectMode: true,
+            transform(row, _encoding, cb) {
+                cb(null, (0, js_lib_1._filterNullishValues)(row, true));
+            },
+        }));
+    }
+    // SAVE
+    async saveBatch(table, _rows, _opt) {
+        if (!_rows.length)
+            return;
+        // Stringify object values
+        const rows = _rows.map(row => (0, js_lib_1._mapValues)(row, v => {
+            return v && typeof v === 'object' && !Buffer.isBuffer(v) ? JSON.stringify(v) : v;
+        }));
+        // inserts are split into multiple sentenses to respect the max_packet_size (1Mb usually)
+        const sqls = (0, query_util_1.insertSQL)(table, rows, 'INSERT', this.cfg.logger);
+        for await (const sql of sqls) {
+            await this.runSQL({ sql });
         }
     }
-    tslib_1.__decorate([
-        js_lib_1._Memo()
-    ], MysqlDB.prototype, "pool", null);
-    return MysqlDB;
-})();
+    // DELETE
+    /**
+     * Limitation: always returns [], regardless of which rows are actually deleted
+     */
+    async deleteByIds(table, ids, _opt) {
+        if (!ids.length)
+            return 0;
+        const sql = (0, query_util_1.dbQueryToSQLDelete)(new db_lib_1.DBQuery(table).filterEq('id', ids));
+        const res = await this.runSQL({ sql });
+        return res.affectedRows;
+    }
+    async deleteByQuery(q, _opt) {
+        const sql = (0, query_util_1.dbQueryToSQLDelete)(q);
+        const res = await this.runSQL({ sql });
+        return res.affectedRows;
+    }
+    /**
+     * Use with caution!
+     */
+    async dropTable(table) {
+        await this.runSQL({ sql: `DROP TABLE IF EXISTS ${table}` });
+    }
+    /**
+     * dropIfExists=true needed as a safety check
+     */
+    async createTable(table, schema, opt = {}) {
+        if (opt.dropIfExists)
+            await this.dropTable(table);
+        const sql = (0, mysql_schema_util_1.jsonSchemaToMySQLDDL)(table, schema);
+        await this.runSQL({ sql });
+    }
+    async getTables() {
+        return (await this.runSQL({ sql: `show tables` }))
+            .map(r => Object.values(r)[0])
+            .filter(Boolean);
+    }
+    async getTableSchema(table) {
+        const stats = await this.runSQL({
+            sql: `describe ${mysql.escapeId(table)}`,
+        });
+        return (0, mysql_schema_util_1.mysqlTableStatsToJsonSchemaField)(table, stats, this.cfg.logger);
+    }
+}
+(0, tslib_1.__decorate)([
+    (0, js_lib_1._Memo)()
+], MysqlDB.prototype, "pool", null);
 exports.MysqlDB = MysqlDB;
-//# sourceMappingURL=mysql.db.js.map

package/dist/query.util.d.ts

@@ -1,11 +1,12 @@
 import { DBQuery } from '@naturalcycles/db-lib';
+import { CommonLogger } from '@naturalcycles/js-lib';
 import { QueryOptions } from 'mysql';
-export declare function dbQueryToSQLSelect(q: DBQuery): string;
-export declare function dbQueryToSQLDelete(q: DBQuery): string;
+export declare function dbQueryToSQLSelect(q: DBQuery<any>): string;
+export declare function dbQueryToSQLDelete(q: DBQuery<any>): string;
 /**
  * Returns array of sql statements to respect the max sql size.
  */
-export declare function insertSQL(table: string, records: object[], verb?: 'INSERT' | 'REPLACE'): string[];
-export declare function insertSQLSingle(table: string, record: object): string;
-export declare function insertSQLSetSingle(table: string, record: object): QueryOptions;
-export declare function dbQueryToSQLUpdate(q: DBQuery, record: object): string;
+export declare function insertSQL(table: string, records: Record<any, any>[], verb?: 'INSERT' | 'REPLACE', logger?: CommonLogger): string[];
+export declare function insertSQLSingle(table: string, record: Record<any, any>): string;
+export declare function insertSQLSetSingle(table: string, record: Record<any, any>): QueryOptions;
+export declare function dbQueryToSQLUpdate(q: DBQuery<any>, record: Record<any, any>): string;

package/dist/query.util.js

@@ -30,9 +30,10 @@ exports.dbQueryToSQLDelete = dbQueryToSQLDelete;
 /**
  * Returns array of sql statements to respect the max sql size.
  */
-function insertSQL(table, records, verb = 'INSERT') {
+function insertSQL(table, records, verb = 'INSERT', logger = console) {
     // INSERT INTO table_name (column1, column2, column3, ...)
     // VALUES (value1, value2, value3, ...);
+    // eslint-disable-next-line unicorn/no-array-reduce
     const fieldSet = records.reduce((set, rec) => {
         Object.keys(rec).forEach(field => set.add(field));
         return set;
@@ -42,7 +43,7 @@ function insertSQL(table, records, verb = 'INSERT') {
         verb,
         `INTO`,
         mysql.escapeId(table),
-        `(` + [...fields].map(f => mysql.escapeId(mysql_schema_util_1.mapNameToMySQL(f))).join(',') + `)`,
+        `(` + [...fields].map(f => mysql.escapeId((0, mysql_schema_util_1.mapNameToMySQL)(f))).join(',') + `)`,
         `VALUES\n`,
     ].join(' ');
     const valueRows = records.map(rec => {
@@ -70,7 +71,7 @@ function insertSQL(table, records, verb = 'INSERT') {
     if (sql) {
         sqls.push(sql); // last one
     }
-    console.log(`${colors_1.white(table)} large sql query (${colors_1.yellow(js_lib_1._hb(full.length))}) was split into ${colors_1.yellow(sqls.length)} chunks`);
+    logger.log(`${(0, colors_1.white)(table)} large sql query (${(0, colors_1.yellow)((0, js_lib_1._hb)(full.length))}) was split into ${(0, colors_1.yellow)(sqls.length)} chunks`);
     return sqls;
     // todo: handle "upsert" later
 }
@@ -83,7 +84,7 @@ function insertSQLSingle(table, record) {
         mysql.escapeId(table),
         `(` +
             Object.keys(record)
-                .map(f => mysql.escapeId(mysql_schema_util_1.mapNameToMySQL(f)))
+                .map(f => mysql.escapeId((0, mysql_schema_util_1.mapNameToMySQL)(f)))
                 .join(',') +
             `)`,
         `\nVALUES`,
@@ -110,7 +111,7 @@ function dbQueryToSQLUpdate(q, record) {
         mysql.escapeId(q.table),
         `SET`,
         Object.keys(record)
-            .map(f => mysql.escapeId(mysql_schema_util_1.mapNameToMySQL(f)) + ' = ?')
+            .map(f => mysql.escapeId((0, mysql_schema_util_1.mapNameToMySQL)(f)) + ' = ?')
             .join(', '),
         ...whereTokens(q),
     ];
@@ -123,7 +124,7 @@ function selectTokens(q) {
         fields = q._selectedFieldNames.length ? q._selectedFieldNames : ['id'];
     }
     // We don't do `escapeId` cause it'll ruin e.g SELECT `count *` FROM ...
-    return [`SELECT`, fields.map(f => mysql_schema_util_1.mapNameToMySQL(f)).join(', '), `FROM`, mysql.escapeId(q.table)];
+    return [`SELECT`, fields.map(f => (0, mysql_schema_util_1.mapNameToMySQL)(f)).join(', '), `FROM`, mysql.escapeId(q.table)];
 }
 function offsetLimitTokens(q) {
     const tokens = [];
@@ -144,6 +145,9 @@ function orderTokens(q) {
         q._orders.map(o => `\`${o.name}\` ${o.descending ? 'DESC' : 'ASC'}`).join(', '),
     ];
 }
+const OP_MAP = {
+    '==': '=',
+};
 function whereTokens(q) {
     if (!q._filters.length)
         return [];
@@ -154,17 +158,20 @@ function whereTokens(q) {
             if (f.val === null || f.val === undefined) {
                 // special treatment
                 return [
-                    mysql.escapeId(mysql_schema_util_1.mapNameToMySQL(f.name)),
-                    f.op === '=' ? 'IS NULL' : 'IS NOT NULL',
+                    mysql.escapeId((0, mysql_schema_util_1.mapNameToMySQL)(f.name)),
+                    f.op === '==' ? 'IS NULL' : 'IS NOT NULL',
                 ].join(' ');
             }
             if (Array.isArray(f.val)) {
                 // special case for arrays
-                return `${mysql.escapeId(mysql_schema_util_1.mapNameToMySQL(f.name))} IN (${mysql.escape(f.val)})`;
+                return `${mysql.escapeId((0, mysql_schema_util_1.mapNameToMySQL)(f.name))} IN (${mysql.escape(f.val)})`;
             }
-            return [mysql.escapeId(mysql_schema_util_1.mapNameToMySQL(f.name)), f.op, mysql.escape(f.val)].join(' ');
+            return [
+                mysql.escapeId((0, mysql_schema_util_1.mapNameToMySQL)(f.name)),
+                OP_MAP[f.op] || f.op,
+                mysql.escape(f.val),
+            ].join(' ');
         })
             .join(' AND '),
     ];
 }
-//# sourceMappingURL=query.util.js.map

package/dist/schema/mysql.schema.util.d.ts

@@ -1,4 +1,4 @@
-import { CommonSchema, CommonSchemaField } from '@naturalcycles/db-lib';
+import { CommonLogger, JsonSchemaObject, JsonSchemaRootObject } from '@naturalcycles/js-lib';
 export interface MySQLTableStats {
     Field: string;
     Type: string;
@@ -13,10 +13,11 @@ export interface MySQLSchemaOptions {
 /**
  * It currently skips nullability and declares everything as "DEFAULT NULL".
  */
-export declare function commonSchemaToMySQLDDL(schema: CommonSchema, opt?: MySQLSchemaOptions): string;
-export declare function mysqlTableStatsToCommonSchemaField(s: MySQLTableStats): CommonSchemaField;
+export declare function jsonSchemaToMySQLDDL(table: string, schema: JsonSchemaObject<any>, opt?: MySQLSchemaOptions): string;
+export declare function mysqlTableStatsToJsonSchemaField<T = any>(table: string, stats: MySQLTableStats[], logger: CommonLogger): JsonSchemaRootObject<T>;
 /**
  * Because MySQL doesn't support `.` in field names and escapes them as tableName + fieldName.
+ *
  * @param name
  */
 export declare function mapNameToMySQL(name: string): string;