@technicity/data-service-generator 0.22.2 → 0.23.0-next.0

package/dist/test/globalSetup.js

@@ -0,0 +1,436 @@
+"use strict";
+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;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = globalSetup;
+const node_path_1 = __importDefault(require("node:path"));
+const promises_1 = __importDefault(require("node:fs/promises"));
+const node_crypto_1 = __importDefault(require("node:crypto"));
+const testcontainers_1 = require("testcontainers");
+const mysql_1 = require("@testcontainers/mysql");
+const postgresql_1 = require("@testcontainers/postgresql");
+const src_1 = require("../src");
+const RuntimeMySQL_1 = require("../src/runtime/RuntimeMySQL");
+const RuntimePostgreSQL_1 = require("../src/runtime/RuntimePostgreSQL");
+const RuntimeSQLite_1 = require("../src/runtime/RuntimeSQLite");
+const MySQL_1 = require("../src/runtime/lib/MySQL");
+const PostgreSQL_1 = require("../src/runtime/lib/PostgreSQL");
+const isNotNullOrUndefined_1 = require("../src/lib/isNotNullOrUndefined");
+// Use globalSetup because of https://github.com/facebook/jest/issues/9709
+// https://github.com/facebook/jest/issues/7184
+// The globalThis hack only seems to work if there's 1 test file :/
+// When there's multiple, the stuff I put on globalThis is undefined in test.ts.
+async function globalSetup() {
+    let testItems = await Promise.all([
+        setUpMySQL57(false),
+        setUpMySQL80(false),
+        // TODO: testcontainers version update seems to have broken these
+        // process.env.CI ? null : setUpMySQL57(true),
+        // process.env.CI ? null : setUpMySQL80(true)
+        setUpPostgreSQL()
+    ]).then((xs) => xs.filter(isNotNullOrUndefined_1.isNotNullOrUndefined));
+    // TODO: seems to be broken by TableWithColumnWithDefaultEmptyString
+    // testItems.push(await setUpSQLite(testItems[1].SDK, testItems[1].sdkPath));
+    globalThis.__testItems__ = testItems;
+    // So instanceof checks work
+    globalThis.SDKNotFoundError = src_1.SDKNotFoundError;
+}
+async function setUpMySQL57(withRedisCaching) {
+    const { containers, mysql: { host, port, user, password, database }, redis } = await _setUpMySQL57(withRedisCaching);
+    console.log("MySQL 5.7", host, port, user, password, database);
+    console.log("MySQL 5.7 redis", redis);
+    const mysql = new MySQL_1.MySQL({
+        host,
+        port,
+        user,
+        password,
+        database,
+        multipleStatements: true
+    });
+    await mysql.query(await promises_1.default.readFile(node_path_1.default.join(__dirname, "mysql57/data-model.sql"), "utf-8"));
+    await mysql.query(await promises_1.default
+        .readFile(node_path_1.default.join(__dirname, "mysql57/insert.sql"), "utf-8")
+        .then((x) => processSqlString(x)));
+    await mysql.endPool();
+    const outdir = node_path_1.default.join(__dirname, "mysql57/__generated__");
+    await promises_1.default.rm(outdir, { recursive: true, force: true });
+    const dialect = "mysql";
+    await (0, src_1.generate)({
+        dialect,
+        outdir,
+        user,
+        password,
+        host,
+        port,
+        database,
+        outputSqliteSchema: true
+    });
+    const sdkPath = node_path_1.default.join(outdir, "sdk-ts");
+    const { SDK } = require(sdkPath);
+    const sdkOpts = {
+        runtime: RuntimeMySQL_1.RuntimeMySQL,
+        clientOpts: {
+            user,
+            password,
+            host,
+            port,
+            database
+            // debug: [
+            // "ComQueryPacket", "RowDataPacket"
+            // ]
+        },
+        otherOpts: withRedisCaching
+            ? {
+                redis: {
+                    host: redis.host,
+                    port: redis.port,
+                    clusterMode: false,
+                    tls: false,
+                    db: 10,
+                    socketTimeout: 50000
+                }
+            }
+            : undefined,
+        passBeforeValueToAfterCallback: true
+    };
+    const sdk = new SDK(sdkOpts);
+    const artifacts = require(node_path_1.default.join(sdkPath, "artifacts")).artifacts;
+    return {
+        displayName: `MySQL 5.7${withRedisCaching ? " (Redis Cache)" : ""}`,
+        dialect,
+        sdk,
+        SDK,
+        sdkOpts,
+        sdkPath,
+        artifacts,
+        containers
+    };
+}
+async function _setUpMySQL57(withRedisCaching) {
+    if (process.env.CI) {
+        const database = node_crypto_1.default.randomUUID();
+        const out = {
+            containers: [],
+            mysql: {
+                // See .gitlab-ci.yml
+                host: process.env.MYSQL57_HOST,
+                port: parseInt(process.env.MYSQL57_PORT),
+                user: process.env.MYSQL57_USER,
+                password: process.env.MYSQL57_PASSWORD,
+                database
+            },
+            redis: {
+                host: process.env.REDIS_HOST,
+                port: parseInt(process.env.REDIS_PORT)
+            }
+        };
+        const mysql = new MySQL_1.MySQL({ ...out.mysql, database: "mysql" });
+        await mysql.query("CREATE DATABASE ??", [database]);
+        await mysql.endPool();
+        return out;
+    }
+    // Note: there's no linux/arm64, so on M1 machines, need to run ahead of time:
+    // docker pull --platform linux/amd64 mysql:5.7.41
+    const containerMysqlP = new mysql_1.MySqlContainer("mysql:5.7.41").withReuse().start();
+    const containers = withRedisCaching
+        ? await Promise.all([
+            containerMysqlP,
+            new testcontainers_1.GenericContainer("redis:6.2.2")
+                .withReuse()
+                .withExposedPorts(6379)
+                .start()
+        ])
+        : [await containerMysqlP];
+    const [containerMySql, containerRedis] = containers;
+    return {
+        mysql: {
+            user: containerMySql.getUsername(),
+            password: containerMySql.getUserPassword(),
+            host: containerMySql.getHost(),
+            port: containerMySql.getPort(),
+            database: containerMySql.getDatabase()
+        },
+        redis: {
+            host: containerRedis?.getHost(),
+            port: containerRedis?.getMappedPort(6379)
+        },
+        containers
+    };
+}
+async function setUpMySQL80(withRedisCaching) {
+    const { containers, mysql: { host, port, user, password, database }, redis } = await _setUpMySQL80(withRedisCaching);
+    console.log("MySQL 8.0", host, port, user, password, database);
+    console.log("MySQL 8.0 redis", redis);
+    const mysql = new MySQL_1.MySQL({
+        host,
+        port,
+        user,
+        password,
+        database,
+        multipleStatements: true
+    });
+    await mysql.query(await promises_1.default.readFile(node_path_1.default.join(__dirname, "mysql57/data-model.sql"), "utf-8"));
+    await mysql.query(await promises_1.default
+        .readFile(node_path_1.default.join(__dirname, "mysql57/insert.sql"), "utf-8")
+        .then((x) => processSqlString(x)));
+    await mysql.endPool();
+    const outdir = node_path_1.default.join(__dirname, "mysql80/__generated__");
+    await promises_1.default.rm(outdir, { recursive: true, force: true });
+    const dialect = "mysql";
+    await (0, src_1.generate)({
+        dialect,
+        outdir,
+        user,
+        password,
+        host,
+        port,
+        database,
+        outputSqliteSchema: true
+    });
+    const sdkPath = node_path_1.default.join(outdir, "sdk-ts");
+    const { SDK } = require(sdkPath);
+    const sdkOpts = {
+        runtime: RuntimeMySQL_1.RuntimeMySQL,
+        clientOpts: {
+            user,
+            password,
+            host,
+            port,
+            database
+            // debug: [
+            // "ComQueryPacket", "RowDataPacket"
+            // ]
+        },
+        otherOpts: withRedisCaching
+            ? {
+                redis: {
+                    host: redis?.host,
+                    port: redis?.port,
+                    clusterMode: false,
+                    tls: false,
+                    db: 10,
+                    socketTimeout: 50000
+                }
+            }
+            : undefined,
+        passBeforeValueToAfterCallback: true
+    };
+    const sdk = new SDK(sdkOpts);
+    const artifacts = require(node_path_1.default.join(sdkPath, "artifacts")).artifacts;
+    return {
+        displayName: `MySQL 8.0${withRedisCaching ? " (Redis Cache)" : ""}`,
+        dialect,
+        sdk,
+        SDK,
+        sdkOpts,
+        sdkPath,
+        artifacts,
+        containers
+    };
+}
+async function _setUpMySQL80(withRedisCaching) {
+    if (process.env.CI) {
+        const database = node_crypto_1.default.randomUUID();
+        const out = {
+            containers: [],
+            mysql: {
+                host: process.env.MYSQL80_HOST,
+                port: parseInt(process.env.MYSQL80_PORT),
+                user: process.env.MYSQL80_USER,
+                password: process.env.MYSQL80_PASSWORD,
+                database
+            },
+            redis: {
+                host: process.env.REDIS_HOST,
+                port: parseInt(process.env.REDIS_PORT)
+            }
+        };
+        const mysql = new MySQL_1.MySQL({ ...out.mysql, database: "mysql" });
+        await mysql.query("CREATE DATABASE ??", [database]);
+        await mysql.endPool();
+        return out;
+    }
+    const containerMysqlP = new mysql_1.MySqlContainer("mysql:8.0.32")
+        .withReuse()
+        // https://github.com/mysqljs/mysql/issues/2499
+        .withCommand(["--default-authentication-plugin=mysql_native_password"])
+        .start();
+    const containers = withRedisCaching
+        ? await Promise.all([
+            containerMysqlP,
+            new testcontainers_1.GenericContainer("redis:6.2.2")
+                .withReuse()
+                .withExposedPorts(6379)
+                .start()
+        ])
+        : [await containerMysqlP];
+    const [containerMySql, containerRedis] = containers;
+    return {
+        mysql: {
+            user: containerMySql.getUsername(),
+            password: containerMySql.getUserPassword(),
+            host: containerMySql.getHost(),
+            port: containerMySql.getPort(),
+            database: containerMySql.getDatabase()
+        },
+        redis: {
+            host: containerRedis?.getHost(),
+            port: containerRedis?.getMappedPort(6379)
+        },
+        containers
+    };
+}
+async function setUpPostgreSQL() {
+    const dialect = "postgresql";
+    let container = null;
+    let host;
+    let port;
+    let user;
+    let password;
+    let database;
+    if (process.env.CI) {
+        const dbName = node_crypto_1.default.randomUUID().replace(/-/g, "_").slice(0, 20);
+        host = process.env.POSTGRES_HOST;
+        port = parseInt(process.env.POSTGRES_PORT);
+        user = process.env.POSTGRES_USER;
+        password = process.env.POSTGRES_PASSWORD;
+        database = dbName;
+        const pg = new (await Promise.resolve().then(() => __importStar(require("pg")))).Pool({
+            host,
+            port,
+            user,
+            password,
+            database: process.env.POSTGRES_DATABASE ?? "postgres"
+        });
+        await pg.query(`CREATE DATABASE "${dbName}"`);
+        await pg.end();
+    }
+    else {
+        const postgresContainer = await new postgresql_1.PostgreSqlContainer("postgres:17.7-alpine")
+            .withReuse()
+            .start();
+        container = postgresContainer;
+        host = postgresContainer.getHost();
+        port = postgresContainer.getPort();
+        user = postgresContainer.getUsername();
+        password = postgresContainer.getPassword();
+        database = postgresContainer.getDatabase();
+    }
+    console.log("PostgreSQL", host, port, user, database);
+    const pg = new PostgreSQL_1.PostgreSQL({
+        host,
+        port,
+        user,
+        password,
+        database
+    });
+    const runSql = async (sql) => {
+        const statements = sql
+            .split(/;\s*/)
+            .map((s) => s.trim())
+            .filter((s) => s.length > 0 && !s.startsWith("--"));
+        for (const st of statements) {
+            await pg.pool.query(st);
+        }
+    };
+    await runSql(await promises_1.default.readFile(node_path_1.default.join(__dirname, "postgres/data-model.sql"), "utf-8"));
+    await runSql(await promises_1.default.readFile(node_path_1.default.join(__dirname, "postgres/insert.sql"), "utf-8"));
+    await pg.endPool();
+    const outdir = node_path_1.default.join(__dirname, "postgres/__generated__");
+    await promises_1.default.rm(outdir, { recursive: true, force: true });
+    await (0, src_1.generate)({
+        dialect,
+        outdir,
+        user,
+        password,
+        host,
+        port,
+        database,
+        outputSqliteSchema: false
+    });
+    const sdkPath = node_path_1.default.join(outdir, "sdk-ts");
+    const { SDK } = require(sdkPath);
+    const artifacts = require(node_path_1.default.join(sdkPath, "artifacts")).artifacts;
+    const sdkOpts = {
+        runtime: RuntimePostgreSQL_1.RuntimePostgreSQL,
+        clientOpts: {
+            host,
+            port,
+            user,
+            password,
+            database
+        },
+        otherOpts: undefined,
+        passBeforeValueToAfterCallback: true
+    };
+    const sdk = new SDK(sdkOpts);
+    return {
+        displayName: "PostgreSQL 17.7",
+        dialect,
+        sdk,
+        SDK,
+        sdkOpts,
+        sdkPath,
+        artifacts,
+        containers: container ? [container] : []
+    };
+}
+// Reuse generated MySQL SDK, since we don't support generation with SQLite.
+async function setUpSQLite(SDK, sdkPath) {
+    const dialect = "sqlite";
+    const sdkOpts = {
+        runtime: RuntimeSQLite_1.RuntimeSQLite,
+        clientOpts: { filename: ":memory:" },
+        otherOpts: {
+            seedString: await promises_1.default
+                .readFile(node_path_1.default.join(__dirname, "mysql57/insert.sql"), "utf-8")
+                .then((x) => processSqlString(x))
+        },
+        passBeforeValueToAfterCallback: true
+    };
+    const sdk = new SDK(sdkOpts);
+    const artifacts = require(node_path_1.default.join(sdkPath, "artifacts")).artifacts;
+    return {
+        displayName: "SQLite :memory:",
+        dialect,
+        sdk,
+        SDK,
+        sdkOpts,
+        sdkPath,
+        artifacts,
+        containers: []
+    };
+}
+function processSqlString(input) {
+    return (input
+        .split("\n")
+        // Remove comments
+        .filter((x) => !x.startsWith("--"))
+        .join("\n")
+        .replace(/\\/g, "")
+        .replace(/\n/g, ""));
+}