@malloydata/db-mysql 0.0.196-dev241007230836

package/dist/index.d.ts

@@ -0,0 +1 @@
+export { MySQLConnection, MySQLExecutor } from './mysql_connection';

package/dist/index.js

@@ -0,0 +1,13 @@
+"use strict";
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ *  LICENSE file in the root directory of this source tree.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MySQLExecutor = exports.MySQLConnection = void 0;
+var mysql_connection_1 = require("./mysql_connection");
+Object.defineProperty(exports, "MySQLConnection", { enumerable: true, get: function () { return mysql_connection_1.MySQLConnection; } });
+Object.defineProperty(exports, "MySQLExecutor", { enumerable: true, get: function () { return mysql_connection_1.MySQLExecutor; } });
+//# sourceMappingURL=index.js.map

package/dist/mysql_connection.d.ts

@@ -0,0 +1,40 @@
+import { Connection, MalloyQueryData, PersistSQLResults, PooledConnection, QueryRunStats, RunSQLOptions, StreamingConnection, QueryOptionsReader, SQLSourceDef, TableSourceDef } from '@malloydata/malloy';
+import { BaseConnection } from '@malloydata/malloy/connection';
+import * as MYSQL from 'mysql2/promise';
+export interface MySQLConfiguration {
+    host?: string;
+    port?: number;
+    database?: string;
+    user?: string;
+    password?: string;
+}
+export declare class MySQLExecutor {
+    static getConnectionOptionsFromEnv(): MySQLConfiguration;
+}
+export declare class MySQLConnection extends BaseConnection implements Connection, PersistSQLResults {
+    private readonly dialect;
+    private connection?;
+    config: MySQLConfiguration;
+    queryOptions: QueryOptionsReader | undefined;
+    name: string;
+    get dialectName(): string;
+    constructor(name: string, config: MySQLConfiguration, queryOptions?: QueryOptionsReader);
+    getClient(): Promise<MYSQL.Connection>;
+    manifestTemporaryTable(sqlCommand: string): Promise<string>;
+    test(): Promise<void>;
+    runSQL(sql: string, _options?: RunSQLOptions): Promise<MalloyQueryData>;
+    isPool(): this is PooledConnection;
+    canPersist(): this is PersistSQLResults;
+    canStream(): this is StreamingConnection;
+    close(): Promise<void>;
+    estimateQueryCost(_sqlCommand: string): Promise<QueryRunStats>;
+    fetchTableSchema(tableName: string, tablePath: string): Promise<TableSourceDef>;
+    fetchSelectSchema(sqlRef: SQLSourceDef): Promise<SQLSourceDef>;
+    private schemaFromResult;
+    runRawSQL(sql: string, _options?: RunSQLOptions): Promise<MalloyQueryData>;
+    static removeNulls(jsonObj: any): any;
+    static removeNullsObject(jsonObj: Record<string, any>): Record<string, any>;
+    static removeNullsArray(jsonArray: any[]): any[];
+    static checkIsMalloyMetadata(jsonObj: any): any;
+    private fillStructDefFromTypeMap;
+}

package/dist/mysql_connection.js

@@ -0,0 +1,239 @@
+"use strict";
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ *  LICENSE file in the root directory of this source tree.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MySQLConnection = exports.MySQLExecutor = void 0;
+const malloy_1 = require("@malloydata/malloy");
+const connection_1 = require("@malloydata/malloy/connection");
+const crypto_1 = require("crypto");
+const MYSQL = __importStar(require("mysql2/promise"));
+class MySQLExecutor {
+    static getConnectionOptionsFromEnv() {
+        const user = process.env['MYSQL_USER'];
+        if (user) {
+            const host = process.env['MYSQL_HOST'];
+            const port = Number(process.env['MYSQL_PORT']);
+            const password = process.env['MYSQL_PASSWORD'];
+            const database = process.env['MYSQL_DATABASE'];
+            return {
+                host,
+                port,
+                user,
+                password,
+                database,
+            };
+        }
+        return {};
+    }
+}
+exports.MySQLExecutor = MySQLExecutor;
+class MySQLConnection extends connection_1.BaseConnection {
+    get dialectName() {
+        return this.dialect.name;
+    }
+    constructor(name, config, queryOptions) {
+        super();
+        this.dialect = new malloy_1.MySQLDialect();
+        this.config = config;
+        this.queryOptions = queryOptions;
+        this.name = name;
+        // TODO: handle when connection fails.
+    }
+    async getClient() {
+        var _a;
+        if (!this.connection) {
+            this.connection = await MYSQL.createConnection({
+                host: this.config.host,
+                port: (_a = this.config.port) !== null && _a !== void 0 ? _a : 3306,
+                user: this.config.user,
+                password: this.config.password,
+                database: this.config.database,
+                multipleStatements: true,
+                decimalNumbers: true,
+            });
+            this.connection.query(
+            // LTNOTE: Need to make the group_concat_max_len configurable.
+            "set @@session.time_zone = 'UTC';" +
+                // LTNOTE: for nesting this is the max buffer size.  Currently set to 10M, have to figure out perf implications.
+                'SET SESSION group_concat_max_len = 10000000;' +
+                // Need this to make NULL LAST in order by (ISNULL(exp) can't appear in an ORDER BY without it)
+                "SET SESSION sql_mode=(SELECT REPLACE(@@sql_mode,'ONLY_FULL_GROUP_BY',''));");
+        }
+        return this.connection;
+    }
+    async manifestTemporaryTable(sqlCommand) {
+        const hash = (0, crypto_1.createHash)('md5').update(sqlCommand).digest('hex');
+        const tableName = `tt${hash}`;
+        const cmd = `CREATE TEMPORARY TABLE IF NOT EXISTS ${tableName} AS (${sqlCommand});`;
+        // console.log(cmd);
+        await this.runRawSQL(cmd);
+        return tableName;
+    }
+    async test() {
+        await this.runRawSQL('SELECT 1');
+    }
+    runSQL(sql, _options) {
+        // TODO: what are options here?
+        return this.runRawSQL(sql);
+    }
+    isPool() {
+        return false;
+    }
+    canPersist() {
+        return true;
+    }
+    canStream() {
+        // TODO: implement;
+        throw new Error('Method not implemented.2');
+    }
+    async close() {
+        if (this.connection) {
+            this.connection.end();
+        }
+        return undefined;
+    }
+    estimateQueryCost(_sqlCommand) {
+        // TODO: implement;
+        throw new Error('Method not implemented.3');
+    }
+    // get name(): string {
+    //   return connectionFactory.connectionName;
+    // }
+    // TODO: make sure this is exercised.
+    async fetchTableSchema(tableName, tablePath) {
+        const structDef = {
+            type: 'table',
+            name: tableName,
+            tablePath,
+            dialect: this.dialectName,
+            connection: this.name,
+            fields: [],
+        };
+        const quotedTablePath = tablePath.match(/[:*/]/)
+            ? `\`${tablePath}\``
+            : tablePath;
+        const infoQuery = `DESCRIBE ${quotedTablePath}`;
+        const result = await this.runRawSQL(infoQuery);
+        await this.schemaFromResult(result, structDef);
+        return structDef;
+    }
+    async fetchSelectSchema(sqlRef) {
+        const structDef = {
+            ...sqlRef,
+            name: sqlRef.name,
+        };
+        const tempTableName = `tmp${(0, crypto_1.randomUUID)()}`.replace(/-/g, '');
+        const client = await this.getClient();
+        await client.query(`CREATE TEMPORARY TABLE ${tempTableName} AS (${sqlRef.selectStr});`);
+        const [results, _fields] = await client.query(`DESCRIBE ${tempTableName};`);
+        // console.log(results); // results contains rows returned by server
+        // console.log(fields); // fields contains extra meta data about results, if available
+        const rows = results;
+        this.schemaFromResult({ rows, totalRows: rows.length }, structDef);
+        return structDef;
+    }
+    async schemaFromResult(result, structDef) {
+        const typeMap = {};
+        for (const row of result.rows) {
+            typeMap[row['Field']] = row['Type'];
+        }
+        this.fillStructDefFromTypeMap(structDef, typeMap);
+    }
+    async runRawSQL(sql, _options) {
+        // TODO: what are options here?
+        const client = await this.getClient();
+        try {
+            const [results, _fields] = await client.query(sql);
+            // console.log(results); // results contains rows returned by server
+            // console.log(fields); // fields contains extra meta data about results, if available
+            const rows = results;
+            return { rows, totalRows: rows.length };
+        }
+        catch (e) {
+            throw new Error('BADNESS');
+        }
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    static removeNulls(jsonObj) {
+        if (Array.isArray(jsonObj)) {
+            return MySQLConnection.removeNullsArray(jsonObj);
+        }
+        return MySQLConnection.removeNullsObject(jsonObj);
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    static removeNullsObject(jsonObj) {
+        for (const key in jsonObj) {
+            if (Array.isArray(jsonObj[key])) {
+                jsonObj[key] = MySQLConnection.removeNullsArray(jsonObj[key]);
+            }
+            else if (typeof jsonObj === 'object') {
+                jsonObj[key] = MySQLConnection.removeNullsObject(jsonObj[key]);
+            }
+        }
+        return jsonObj;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    static removeNullsArray(jsonArray) {
+        const metadata = jsonArray
+            .filter(MySQLConnection.checkIsMalloyMetadata)
+            .shift();
+        if (!metadata) {
+            return jsonArray;
+        }
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const filteredArray = jsonArray
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            .filter(
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        (element) => element !== null && !MySQLConnection.checkIsMalloyMetadata(element))
+            .map(MySQLConnection.removeNulls);
+        if (metadata['limit']) {
+            return filteredArray.slice(0, metadata['limit']);
+        }
+        return filteredArray;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    static checkIsMalloyMetadata(jsonObj) {
+        return (jsonObj !== null &&
+            typeof jsonObj === 'object' &&
+            jsonObj['_is_malloy_metadata']);
+    }
+    fillStructDefFromTypeMap(structDef, typeMap) {
+        for (const fieldName in typeMap) {
+            let mySqlType = typeMap[fieldName].toLocaleLowerCase();
+            mySqlType = mySqlType.trim().split('(')[0];
+            const malloyType = this.dialect.sqlTypeToMalloyType(mySqlType);
+            // no arrays or records exist in mysql
+            structDef.fields.push({ ...malloyType, name: fieldName });
+        }
+    }
+}
+exports.MySQLConnection = MySQLConnection;
+//# sourceMappingURL=mysql_connection.js.map

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "@malloydata/db-mysql",
+  "version": "0.0.196-dev241007230836",
+  "license": "MIT",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "engines": {
+    "node": ">=18"
+  },
+  "homepage": "https://github.com/malloydata/malloy#readme",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/malloydata/malloy"
+  },
+  "scripts": {
+    "lint": "eslint '**/*.ts{,x}'",
+    "lint-fix": "eslint '**/*.ts{,x}' --fix",
+    "test": "jest --config=../../jest.config.js",
+    "build": "tsc --build",
+    "clean": "tsc --build --clean",
+    "malloyc": "ts-node ../../scripts/malloy-to-json",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {
+    "@malloydata/malloy": "^0.0.196-dev241007230836",
+    "@types/node": "^22.7.4",
+    "fastestsmallesttextencoderdecoder": "^1.0.22",
+    "luxon": "^3.5.0",
+    "mysql2": "^3.11.3"
+  }
+}