clisma 0.1.0

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=cli.d.ts.map

package/dist/cli.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":""}

package/dist/cli.js

@@ -0,0 +1,176 @@
+import path from "node:path";
+import fs from "node:fs/promises";
+import crypto from "node:crypto";
+import { Command } from "commander";
+import { input } from "@inquirer/prompts";
+import kleur from "kleur";
+import { runMigrations, findConfigFile } from "@clisma/core";
+import { listEnvironmentsFile, parseConfigFile } from "@clisma/config";
+import { parse as parseDotenv } from "@dotenvx/dotenvx";
+const program = new Command();
+const withCommonOptions = (command) => {
+    command
+        .option("--config <path>", "Path to config file (default: clisma.hcl)")
+        .option("--env <name>", "Environment name from config file")
+        .option("--env-file <path>", "Load environment variables from file")
+        .option("--var <key=value>", "Set a variable value (can be used multiple times)", (value, previous = []) => {
+        return [...previous, value];
+    });
+};
+const parseVars = (varArgs = []) => {
+    const vars = {};
+    for (const arg of varArgs) {
+        const [key, ...valueParts] = arg.split("=");
+        if (key && valueParts.length > 0) {
+            vars[key] = valueParts.join("=");
+        }
+    }
+    return vars;
+};
+const parseEnvFile = async (filePath) => {
+    const contents = await fs.readFile(filePath, "utf8");
+    return parseDotenv(contents);
+};
+const resolveEnvName = async (configPath, envName) => {
+    if (envName) {
+        return envName;
+    }
+    const environments = await listEnvironmentsFile(configPath);
+    if (environments.length === 1) {
+        return environments[0];
+    }
+    if (environments.length === 0) {
+        throw new Error("No environments defined in config file");
+    }
+    throw new Error(`Multiple environments found (${environments.join(", ")}). ` +
+        "Specify one with --env.");
+};
+const runCommand = async (command, options) => {
+    const baseCwd = process.env.INIT_CWD || process.cwd();
+    const envOverrides = options.envFile
+        ? await parseEnvFile(path.resolve(baseCwd, options.envFile))
+        : undefined;
+    let migrationsDir;
+    let connectionString;
+    let tableName;
+    let clusterName;
+    let replicationPath;
+    let templateVars;
+    const configPath = options.config
+        ? path.resolve(baseCwd, options.config)
+        : await findConfigFile(baseCwd);
+    if (!configPath) {
+        throw new Error("Config file is required. Use --config or place clisma.hcl in the current directory.");
+    }
+    const envName = await resolveEnvName(configPath, options.env);
+    console.log(`Using config file: ${kleur.bold(configPath)}`);
+    const vars = parseVars(options.var);
+    const envConfig = await parseConfigFile(configPath, envName, vars, envOverrides);
+    connectionString = envConfig.url;
+    migrationsDir = path.resolve(path.dirname(configPath), envConfig.migrations.dir);
+    // Extract table_name, cluster_name, and replication_path from config
+    tableName = envConfig.migrations.table_name;
+    clusterName = envConfig.cluster_name;
+    replicationPath = envConfig.migrations.replication_path;
+    templateVars = {
+        ...(envConfig.migrations.vars || {}),
+        ...(envConfig.cluster_name ? { cluster_name: envConfig.cluster_name } : {}),
+    };
+    console.log(`Environment: ${kleur.bold(envName)}`);
+    console.log("");
+    await runMigrations({
+        migrationsDir,
+        connectionString,
+        tableName,
+        clusterName,
+        replicationPath,
+        templateVars,
+    }, command);
+};
+program.name("clisma").description("ClickHouse migrations CLI");
+withCommonOptions(program
+    .command("run")
+    .description("Apply migrations")
+    .action((options) => runCommand("run", options)));
+withCommonOptions(program
+    .command("status")
+    .description("Show migration status")
+    .action((options) => runCommand("status", options)));
+program
+    .command("create")
+    .description("Create a new migration file")
+    .option("--config <path>", "Path to config file (default: clisma.hcl)")
+    .option("--env <name>", "Environment name from config file")
+    .option("--env-file <path>", "Load environment variables from file")
+    .option("--name <name>", "Migration name")
+    .action(async (options) => {
+    const baseCwd = process.env.INIT_CWD || process.cwd();
+    let migrationsDir;
+    const envOverrides = options.envFile
+        ? await parseEnvFile(path.resolve(baseCwd, options.envFile))
+        : undefined;
+    const configPath = options.config
+        ? path.resolve(baseCwd, options.config)
+        : await findConfigFile(baseCwd);
+    if (!configPath) {
+        throw new Error("Config file is required. Use --config or place clisma.hcl in the current directory.");
+    }
+    const envName = await resolveEnvName(configPath, options.env);
+    const envConfig = await parseConfigFile(configPath, envName, {}, envOverrides);
+    migrationsDir = path.resolve(path.dirname(configPath), envConfig.migrations.dir);
+    // Get migration name from flag or prompt
+    let migrationName = options.name;
+    if (!migrationName) {
+        migrationName = await input({
+            message: "Enter migration name:",
+            validate: (value) => {
+                if (!value || value.trim().length === 0) {
+                    return "Migration name is required";
+                }
+                if (!/^[a-z0-9_]+$/.test(value)) {
+                    return "Migration name must contain only lowercase letters, numbers, and underscores";
+                }
+                return true;
+            },
+        });
+    }
+    // Sanitize migration name
+    const sanitizedName = migrationName
+        .trim()
+        .toLowerCase()
+        .replace(/\s+/g, "_");
+    // Generate timestamp (YYYYMMDDhhmmss)
+    const now = new Date();
+    const pad2 = (value) => String(value).padStart(2, "0");
+    const timestamp = `${now.getUTCFullYear()}${pad2(now.getUTCMonth() + 1)}${pad2(now.getUTCDate())}${pad2(now.getUTCHours())}${pad2(now.getUTCMinutes())}${pad2(now.getUTCSeconds())}`;
+    // Create migration filename
+    const filename = `${timestamp}_${sanitizedName}.sql`;
+    const filepath = path.join(migrationsDir, filename);
+    // Ensure migrations directory exists
+    await fs.mkdir(migrationsDir, { recursive: true });
+    // Create empty migration file with template comment
+    const template = `-- Migration: ${sanitizedName}
+-- Created: ${new Date().toISOString()}
+
+-- Write your migration here
+`;
+    await fs.writeFile(filepath, template, "utf8");
+    console.log(kleur.green(`Created migration: ${kleur.bold(filename)}`));
+    console.log(kleur.dim(`Location: ${filepath}`));
+    console.log("");
+});
+program
+    .command("checksum")
+    .description("Print checksum for a migration file")
+    .argument("<path>", "Path to migration file")
+    .action(async (filePath) => {
+    const baseCwd = process.env.INIT_CWD || process.cwd();
+    const absolutePath = path.resolve(baseCwd, filePath);
+    const content = await fs.readFile(absolutePath, "utf8");
+    const checksum = crypto.createHash("sha256").update(content).digest("hex");
+    console.log(`Checksum: ${kleur.bold(checksum)}`);
+});
+program.parseAsync(process.argv).catch((error) => {
+    console.error(kleur.red(error instanceof Error ? error.message : String(error)));
+    process.exit(1);
+});

package/dist/tests/integration.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=integration.test.d.ts.map

package/dist/tests/integration.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"integration.test.d.ts","sourceRoot":"","sources":["../../src/tests/integration.test.ts"],"names":[],"mappings":""}

package/dist/tests/integration.test.js

@@ -0,0 +1,80 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+const exec = promisify(execFile);
+const isDockerAvailable = async () => {
+    try {
+        await exec("docker", ["--version"]);
+        await exec("docker", ["compose", "version"]);
+        return true;
+    }
+    catch {
+        return false;
+    }
+};
+const waitForClickHouse = async (baseUrl) => {
+    const deadline = Date.now() + 30_000;
+    while (Date.now() < deadline) {
+        try {
+            const response = await fetch(`${baseUrl}/ping`);
+            if (response.ok) {
+                return;
+            }
+        }
+        catch {
+            // Ignore until ready.
+        }
+        await new Promise((resolve) => setTimeout(resolve, 500));
+    }
+    throw new Error("ClickHouse did not become ready in time");
+};
+const runCli = async (repoRoot, args) => {
+    const cliPath = path.join(repoRoot, "packages/cli/src/cli.ts");
+    await exec("node", ["--import", "tsx", cliPath, ...args], { cwd: repoRoot });
+};
+const queryClickHouse = async (baseUrl, query) => {
+    const response = await fetch(`${baseUrl}/?query=${encodeURIComponent(query)}`);
+    if (!response.ok) {
+        const text = await response.text();
+        throw new Error(`ClickHouse query failed: ${text}`);
+    }
+    return response.text();
+};
+test("cli applies migrations against ClickHouse", async (t) => {
+    if (!(await isDockerAvailable())) {
+        t.skip("Docker not available");
+        return;
+    }
+    const repoRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../../../..");
+    const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), "clisma-it-"));
+    const migrationsDir = path.join(tempDir, "migrations");
+    await fs.mkdir(migrationsDir, { recursive: true });
+    const baseUrl = "http://localhost:8123";
+    const dbName = `clisma_it_${Date.now()}`;
+    await exec("docker", ["compose", "up", "-d"], { cwd: repoRoot });
+    t.after(async () => {
+        try {
+            await exec("docker", ["compose", "down", "-v"], { cwd: repoRoot });
+        }
+        catch {
+            // Ignore cleanup failures.
+        }
+    });
+    await waitForClickHouse(baseUrl);
+    await queryClickHouse(baseUrl, `CREATE DATABASE IF NOT EXISTS ${dbName}`);
+    const configPath = path.join(tempDir, "clisma.hcl");
+    await fs.writeFile(configPath, `env "local" {\n  url = "http://default:@localhost:8123/${dbName}"\n\n  migrations {\n    dir = "migrations"\n  }\n}\n`, "utf8");
+    const migrationFile = path.join(migrationsDir, "20240101120000_create_table.sql");
+    await fs.writeFile(migrationFile, "CREATE TABLE IF NOT EXISTS test_table (id UInt64) ENGINE = MergeTree() ORDER BY id;", "utf8");
+    await runCli(repoRoot, ["run", "--config", configPath, "--env", "local"]);
+    const tableExists = await queryClickHouse(baseUrl, `EXISTS TABLE ${dbName}.test_table`);
+    assert.equal(tableExists.trim(), "1");
+    const migrationsCount = await queryClickHouse(baseUrl, `SELECT count() FROM ${dbName}.schema_migrations`);
+    assert.equal(migrationsCount.trim(), "1");
+    await queryClickHouse(baseUrl, `DROP DATABASE IF EXISTS ${dbName}`);
+});

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "clisma",
+  "version": "0.1.0",
+  "description": "ClickHouse migration CLI",
+  "author": "github.com/will-work-for-meal",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/will-work-for-meal/clisma.git"
+  },
+  "bugs": {
+    "url": "https://github.com/will-work-for-meal/clisma/issues"
+  },
+  "homepage": "https://github.com/will-work-for-meal/clisma",
+  "keywords": [
+    "cli",
+    "clickhouse",
+    "migrations",
+    "clickhouse-migrations",
+    "clickhouse-migration",
+    "clickhouse-migrate",
+    "atlas",
+    "atlasgo"
+  ],
+  "type": "module",
+  "bin": {
+    "clisma": "dist/cli.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@clisma/core": "^0.1.0",
+    "@dotenvx/dotenvx": "^1.51.4",
+    "@inquirer/prompts": "^8.2.0",
+    "commander": "^12.1.0",
+    "kleur": "^4.1.5"
+  },
+  "scripts": {
+    "build": "tsc -b tsconfig.json",
+    "dev": "node --import tsx src/cli.ts",
+    "lint": "oxlint src",
+    "lint:fix": "oxlint --fix src",
+    "format": "oxfmt --check src",
+    "format:fix": "oxfmt src"
+  },
+  "devDependencies": {
+    "oxfmt": "^0.4.0",
+    "oxlint": "^0.12.0"
+  }
+}