@clisma/core 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export { MigrationRunner, runMigrations } from "./migrations/runner.js";
+export type { MigrationCommand, MigrationRunnerOptions, } from "./migrations/types.js";
+export { findConfigFile, parseConfig } from "@clisma/config";
+export type { ClismaConfig, EnvConfig, MigrationConfig, VariableConfig, } from "@clisma/config";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAC;AACxE,YAAY,EACV,gBAAgB,EAChB,sBAAsB,GACvB,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EAAE,cAAc,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAC7D,YAAY,EACV,YAAY,EACZ,SAAS,EACT,eAAe,EACf,cAAc,GACf,MAAM,gBAAgB,CAAC"}

package/dist/index.js

@@ -0,0 +1,2 @@
+export { MigrationRunner, runMigrations } from "./migrations/runner.js";
+export { findConfigFile, parseConfig } from "@clisma/config";

package/dist/migrations/repository.d.ts

@@ -0,0 +1,19 @@
+import type { ClickHouseClient } from "@clickhouse/client";
+import type { MigrationContext, MigrationRecord, PendingMigrationsResult } from "./types.js";
+type MigrationRepositoryOptions = {
+    client: ClickHouseClient;
+    migrationsDir: string;
+    tableName: string;
+    replicationPath?: string;
+};
+export declare class MigrationRepository {
+    #private;
+    constructor(options: MigrationRepositoryOptions);
+    getContext(): MigrationContext;
+    initialize(clusterName?: string): Promise<string | null>;
+    ensureMigrationsTable(): Promise<void>;
+    getAppliedMigrations(): Promise<Map<string, MigrationRecord>>;
+    getPendingMigrations(applied: Map<string, MigrationRecord>): Promise<PendingMigrationsResult>;
+}
+export {};
+//# sourceMappingURL=repository.d.ts.map

package/dist/migrations/repository.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"repository.d.ts","sourceRoot":"","sources":["../../src/migrations/repository.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAC3D,OAAO,KAAK,EACV,gBAAgB,EAChB,eAAe,EAEf,uBAAuB,EACxB,MAAM,YAAY,CAAC;AAGpB,KAAK,0BAA0B,GAAG;IAChC,MAAM,EAAE,gBAAgB,CAAC;IACzB,aAAa,EAAE,MAAM,CAAC;IACtB,SAAS,EAAE,MAAM,CAAC;IAClB,eAAe,CAAC,EAAE,MAAM,CAAC;CAC1B,CAAC;AAEF,qBAAa,mBAAmB;;gBAOlB,OAAO,EAAE,0BAA0B;IAO/C,UAAU,IAAI,gBAAgB;IAQxB,UAAU,CAAC,WAAW,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC;IA8DxD,qBAAqB,IAAI,OAAO,CAAC,IAAI,CAAC;IA4BtC,oBAAoB,IAAI,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,eAAe,CAAC,CAAC;IAgB7D,oBAAoB,CACxB,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE,eAAe,CAAC,GACpC,OAAO,CAAC,uBAAuB,CAAC;CA8DpC"}

package/dist/migrations/repository.js

@@ -0,0 +1,142 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import kleur from "kleur";
+import { calculateChecksum } from "./sql.js";
+export class MigrationRepository {
+    #client;
+    #ctx = null;
+    #migrationsDir;
+    #tableName;
+    #replicationPath;
+    constructor(options) {
+        this.#client = options.client;
+        this.#migrationsDir = options.migrationsDir;
+        this.#tableName = options.tableName;
+        this.#replicationPath = options.replicationPath;
+    }
+    getContext() {
+        if (!this.#ctx) {
+            throw new Error("Migration repository not initialized");
+        }
+        return this.#ctx;
+    }
+    async initialize(clusterName) {
+        if (this.#ctx) {
+            return this.#ctx.cluster || null;
+        }
+        const clusters = await this.#listClusters();
+        const clusterNames = Array.from(new Set(clusters.map((cluster) => cluster.cluster)));
+        const hasNonDefaultCluster = clusterNames.some((name) => name !== "default");
+        const defaultClusterRows = clusters.filter((cluster) => cluster.cluster === "default");
+        const defaultHasReplicasOrShards = defaultClusterRows.some((row) => row.replica_num > 1 || row.shard_num > 1);
+        if (!clusterName) {
+            if (hasNonDefaultCluster || defaultHasReplicasOrShards) {
+                const available = clusterNames.length
+                    ? clusterNames.join(", ")
+                    : "none";
+                throw new Error(`Cluster detected but no cluster_name provided. ` +
+                    `Set env.cluster_name in config. Available clusters: ${available}`);
+            }
+        }
+        else if (!clusterNames.includes(clusterName)) {
+            const available = clusterNames.length ? clusterNames.join(", ") : "none";
+            throw new Error(`Cluster "${clusterName}" not found. Available clusters: ${available}`);
+        }
+        if (clusterName) {
+            const safeClusterName = clusterName.replace(/"/g, '\\"');
+            this.#ctx = {
+                is_replicated: true,
+                create_table_options: `ON CLUSTER "${safeClusterName}"`,
+                cluster: clusterName,
+            };
+            return clusterName;
+        }
+        this.#ctx = {
+            is_replicated: false,
+            create_table_options: "",
+            cluster: "",
+        };
+        return null;
+    }
+    async ensureMigrationsTable() {
+        const ctx = this.getContext();
+        const replicationPath = this.#replicationPath
+            ? this.#replicationPath
+            : `/clickhouse/tables/cluster-{cluster}/shard-{shard}/{database}/${this.#tableName}`;
+        const engine = ctx.is_replicated
+            ? `ReplicatedReplacingMergeTree('${replicationPath}', '{replica}')`
+            : "ReplacingMergeTree()";
+        const tableOptions = ctx.create_table_options || "";
+        await this.#client.command({
+            query: `
+        CREATE TABLE IF NOT EXISTS ${this.#tableName} ${tableOptions} (
+          version String,
+          name String,
+          checksum String,
+          hostname String DEFAULT '',
+          applied_by String DEFAULT '',
+          cli_version String DEFAULT '',
+          applied_at DateTime DEFAULT now()
+        ) ENGINE = ${engine}
+        ORDER BY version
+      `,
+        });
+    }
+    async getAppliedMigrations() {
+        const result = await this.#client.query({
+            query: `
+        SELECT version, name, checksum, hostname, applied_by, cli_version, applied_at
+        FROM ${this.#tableName} FINAL 
+        ORDER BY version`,
+            format: "JSONEachRow",
+        });
+        const migrations = await result.json();
+        return new Map(migrations.map((migration) => [migration.version, migration]));
+    }
+    async getPendingMigrations(applied) {
+        const files = (await fs.readdir(this.#migrationsDir))
+            .filter((file) => file.endsWith(".sql"))
+            .sort();
+        const pending = [];
+        for (const file of files) {
+            const match = file.match(/^(\d+)_(.+)\.sql$/);
+            if (!match) {
+                console.warn(kleur.yellow(`Skipping invalid filename: ${file}`));
+                continue;
+            }
+            const [, version, name] = match;
+            const filePath = path.join(this.#migrationsDir, file);
+            const content = await fs.readFile(filePath, "utf8");
+            const checksum = calculateChecksum(content);
+            const appliedMigration = applied.get(version);
+            if (!appliedMigration) {
+                pending.push({ version, name, file, content, checksum });
+                continue;
+            }
+            if (appliedMigration.checksum !== checksum) {
+                return {
+                    pending: [],
+                    error: new Error(`Migration ${version}_${name} has been modified. ` +
+                        `Expected checksum: ${appliedMigration.checksum}. ` +
+                        `Actual checksum: ${checksum}. `),
+                };
+            }
+        }
+        return { pending, error: null };
+    }
+    async #listClusters() {
+        try {
+            const result = await this.#client.query({
+                query: `
+          SELECT cluster, shard_num, replica_num 
+          FROM system.clusters
+        `,
+                format: "JSONEachRow",
+            });
+            return await result.json();
+        }
+        catch {
+            return [];
+        }
+    }
+}

package/dist/migrations/runner.d.ts

@@ -0,0 +1,10 @@
+import type { MigrationCommand, MigrationRunnerOptions } from "./types.js";
+export declare class MigrationRunner {
+    #private;
+    constructor(options: MigrationRunnerOptions);
+    run(): Promise<void>;
+    status(): Promise<void>;
+    close(): Promise<void>;
+}
+export declare const runMigrations: (options: MigrationRunnerOptions, command: MigrationCommand) => Promise<void>;
+//# sourceMappingURL=runner.d.ts.map

package/dist/migrations/runner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runner.d.ts","sourceRoot":"","sources":["../../src/migrations/runner.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,gBAAgB,EAAE,sBAAsB,EAAE,MAAM,YAAY,CAAC;AA4B3E,qBAAa,eAAe;;gBASd,OAAO,EAAE,sBAAsB;IAwDrC,GAAG,IAAI,OAAO,CAAC,IAAI,CAAC;IA+EpB,MAAM,IAAI,OAAO,CAAC,IAAI,CAAC;IA4CvB,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;CAG7B;AAED,eAAO,MAAM,aAAa,GACxB,SAAS,sBAAsB,EAC/B,SAAS,gBAAgB,KACxB,OAAO,CAAC,IAAI,CAYd,CAAC"}

package/dist/migrations/runner.js

@@ -0,0 +1,175 @@
+import { createClient } from "@clickhouse/client";
+import ora from "ora";
+import kleur from "kleur";
+import os from "node:os";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { splitStatements } from "./sql.js";
+import { renderTemplate } from "./template.js";
+import { MigrationRepository } from "./repository.js";
+const resolveAppliedBy = () => {
+    try {
+        return os.userInfo().username || process.env.USER || "";
+    }
+    catch {
+        return process.env.USER || "";
+    }
+};
+const resolveCliVersion = async () => {
+    try {
+        const currentDir = path.dirname(fileURLToPath(import.meta.url));
+        const packagePath = path.resolve(currentDir, "../../package.json");
+        const contents = await fs.readFile(packagePath, "utf8");
+        const parsed = JSON.parse(contents);
+        return parsed.version || "";
+    }
+    catch {
+        return "";
+    }
+};
+export class MigrationRunner {
+    #client;
+    #repository;
+    #tableName;
+    #clusterName;
+    #replicationPath;
+    #templateVars;
+    #initialized = false;
+    constructor(options) {
+        const url = new URL(options.connectionString);
+        if (!url.username) {
+            throw new Error("ClickHouse connection string must include username");
+        }
+        const database = url.pathname.replace("/", "");
+        if (!database) {
+            throw new Error("ClickHouse connection string must include database name");
+        }
+        this.#tableName = options.tableName || "schema_migrations";
+        this.#clusterName = options.clusterName;
+        this.#replicationPath = options.replicationPath;
+        this.#templateVars = options.templateVars || {};
+        this.#client = createClient({
+            url: `${url.protocol}//${url.host}`,
+            username: decodeURIComponent(url.username),
+            password: decodeURIComponent(url.password),
+            database,
+        });
+        this.#repository = new MigrationRepository({
+            client: this.#client,
+            migrationsDir: options.migrationsDir,
+            tableName: this.#tableName,
+            replicationPath: this.#replicationPath,
+        });
+    }
+    async #initialize() {
+        if (this.#initialized) {
+            return;
+        }
+        const spinner = ora("Detecting cluster configuration...").start();
+        const clusterName = await this.#repository.initialize(this.#clusterName);
+        if (clusterName) {
+            const message = this.#clusterName
+                ? `Using cluster from config: ${kleur.bold(clusterName)}`
+                : `Detected cluster: ${kleur.bold(clusterName)}`;
+            spinner.succeed(kleur.green(message));
+        }
+        else {
+            spinner.succeed("No cluster detected, using non-replicated mode");
+        }
+        this.#initialized = true;
+    }
+    async run() {
+        await this.#initialize();
+        await this.#repository.ensureMigrationsTable();
+        const applied = await this.#repository.getAppliedMigrations();
+        const { pending, error } = await this.#repository.getPendingMigrations(applied);
+        if (error) {
+            throw error;
+        }
+        if (pending.length === 0) {
+            console.log("✓ No pending migrations");
+            return;
+        }
+        console.log(kleur.bold(`\nFound ${kleur.yellow(pending.length)} pending migration(s):`));
+        pending.forEach((migration) => console.log(kleur.dim(`  • ${migration.version}_${migration.name}`)));
+        console.log("");
+        for (const migration of pending) {
+            const spinner = ora(`Applying ${kleur.bold(migration.version)}_${migration.name}`).start();
+            try {
+                const sql = renderTemplate(migration.content, this.#templateVars);
+                const statements = splitStatements(sql);
+                for (const statement of statements) {
+                    await this.#client.command({
+                        query: statement,
+                    });
+                }
+                const cliVersion = await resolveCliVersion();
+                await this.#client.insert({
+                    table: this.#tableName,
+                    values: [
+                        {
+                            version: migration.version,
+                            name: migration.name,
+                            checksum: migration.checksum,
+                            hostname: os.hostname(),
+                            applied_by: resolveAppliedBy(),
+                            cli_version: cliVersion,
+                        },
+                    ],
+                    format: "JSONEachRow",
+                });
+                spinner.succeed(kleur.green(`Applied ${kleur.bold(migration.version)}_${migration.name}`));
+            }
+            catch (err) {
+                spinner.fail(kleur.red(`Failed to apply ${migration.version}_${migration.name}`));
+                throw err;
+            }
+        }
+        console.log(kleur.bold(kleur.green("\n✓ All migrations applied successfully")));
+    }
+    async status() {
+        await this.#initialize();
+        await this.#repository.ensureMigrationsTable();
+        const applied = await this.#repository.getAppliedMigrations();
+        const { pending, error } = await this.#repository.getPendingMigrations(applied);
+        if (error) {
+            throw error;
+        }
+        console.log("");
+        console.log(kleur.bold("Migration Status"));
+        console.log(`${kleur.green("Applied:")} ${kleur.bold(applied.size.toString())}`);
+        console.log(`${kleur.yellow("Pending:")} ${kleur.bold(pending.length.toString())}`);
+        console.log("");
+        if (applied.size > 0) {
+            console.log(kleur.bold("Applied migrations:"));
+            Array.from(applied.values())
+                .sort((a, b) => a.version.localeCompare(b.version))
+                .forEach((migration) => console.log(kleur.dim(`  ✓ ${migration.version}_${migration.name}`) +
+                kleur.gray(` (${migration.applied_at})`)));
+            console.log("");
+        }
+        if (pending.length > 0) {
+            console.log(kleur.bold("Pending migrations:"));
+            pending.forEach((migration) => console.log(kleur.yellow(`  • ${migration.version}_${migration.name}`)));
+            console.log("");
+        }
+    }
+    async close() {
+        await this.#client.close();
+    }
+}
+export const runMigrations = async (options, command) => {
+    const runner = new MigrationRunner(options);
+    try {
+        if (command === "status") {
+            await runner.status();
+        }
+        else {
+            await runner.run();
+        }
+    }
+    finally {
+        await runner.close();
+    }
+};

package/dist/migrations/sql.d.ts

@@ -0,0 +1,3 @@
+export declare const calculateChecksum: (content: string) => string;
+export declare const splitStatements: (sql: string) => string[];
+//# sourceMappingURL=sql.d.ts.map

package/dist/migrations/sql.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sql.d.ts","sourceRoot":"","sources":["../../src/migrations/sql.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,iBAAiB,GAAI,SAAS,MAAM,KAAG,MAEnD,CAAC;AAEF,eAAO,MAAM,eAAe,GAAI,KAAK,MAAM,KAAG,MAAM,EAuFnD,CAAC"}

package/dist/migrations/sql.js

@@ -0,0 +1,74 @@
+import crypto from "node:crypto";
+export const calculateChecksum = (content) => {
+    return crypto.createHash("sha256").update(content).digest("hex");
+};
+export const splitStatements = (sql) => {
+    const statements = [];
+    let current = "";
+    let isSingleQuoted = false;
+    let isDoubleQuoted = false;
+    let isLineComment = false;
+    let isBlockComment = false;
+    for (let index = 0; index < sql.length; index += 1) {
+        const char = sql[index];
+        const next = sql[index + 1];
+        if (isLineComment) {
+            current += char;
+            if (char === "\n") {
+                isLineComment = false;
+            }
+            continue;
+        }
+        if (isBlockComment) {
+            current += char;
+            if (char === "*" && next === "/") {
+                current += next;
+                index += 1;
+                isBlockComment = false;
+            }
+            continue;
+        }
+        if (!isSingleQuoted && !isDoubleQuoted) {
+            if (char === "-" && next === "-") {
+                current += char + next;
+                index += 1;
+                isLineComment = true;
+                continue;
+            }
+            if (char === "/" && next === "*") {
+                current += char + next;
+                index += 1;
+                isBlockComment = true;
+                continue;
+            }
+        }
+        if (char === "'" && !isDoubleQuoted) {
+            const prev = sql[index - 1];
+            const isEscaped = prev === "\\" && sql[index - 2] !== "\\";
+            if (!isEscaped) {
+                isSingleQuoted = !isSingleQuoted;
+            }
+        }
+        else if (char === '"' && !isSingleQuoted) {
+            const prev = sql[index - 1];
+            const isEscaped = prev === "\\" && sql[index - 2] !== "\\";
+            if (!isEscaped) {
+                isDoubleQuoted = !isDoubleQuoted;
+            }
+        }
+        if (char === ";" && !isSingleQuoted && !isDoubleQuoted) {
+            const trimmed = current.trim();
+            if (trimmed.length > 0) {
+                statements.push(trimmed);
+            }
+            current = "";
+            continue;
+        }
+        current += char;
+    }
+    const trimmed = current.trim();
+    if (trimmed.length > 0) {
+        statements.push(trimmed);
+    }
+    return statements;
+};

package/dist/migrations/template.d.ts

@@ -0,0 +1,3 @@
+import type { MigrationRunnerOptions } from "./types.js";
+export declare const renderTemplate: (content: string, ctx?: MigrationRunnerOptions["templateVars"]) => string;
+//# sourceMappingURL=template.d.ts.map

package/dist/migrations/template.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"template.d.ts","sourceRoot":"","sources":["../../src/migrations/template.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,YAAY,CAAC;AAEzD,eAAO,MAAM,cAAc,GACzB,SAAS,MAAM,EACf,MAAK,sBAAsB,CAAC,cAAc,CAAM,KAC/C,MAIF,CAAC"}

package/dist/migrations/template.js

@@ -0,0 +1,5 @@
+import Handlebars from "handlebars";
+export const renderTemplate = (content, ctx = {}) => {
+    const template = Handlebars.compile(content);
+    return template(ctx);
+};

package/dist/migrations/types.d.ts

@@ -0,0 +1,35 @@
+export type MigrationRunnerOptions = {
+    migrationsDir: string;
+    connectionString: string;
+    clusterName?: string;
+    tableName?: string;
+    replicationPath?: string;
+    templateVars?: Record<string, unknown>;
+};
+export type MigrationCommand = "run" | "status";
+export type MigrationContext = {
+    is_replicated: boolean;
+    create_table_options: string;
+    cluster: string;
+};
+export type MigrationRecord = {
+    version: string;
+    name: string;
+    checksum: string;
+    hostname: string;
+    applied_by: string;
+    cli_version: string;
+    applied_at: string;
+};
+export type PendingMigration = {
+    version: string;
+    name: string;
+    file: string;
+    content: string;
+    checksum: string;
+};
+export type PendingMigrationsResult = {
+    pending: PendingMigration[];
+    error: Error | null;
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/migrations/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/migrations/types.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,sBAAsB,GAAG;IACnC,aAAa,EAAE,MAAM,CAAC;IACtB,gBAAgB,EAAE,MAAM,CAAC;IACzB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,YAAY,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACxC,CAAC;AAEF,MAAM,MAAM,gBAAgB,GAAG,KAAK,GAAG,QAAQ,CAAC;AAEhD,MAAM,MAAM,gBAAgB,GAAG;IAC7B,aAAa,EAAE,OAAO,CAAC;IACvB,oBAAoB,EAAE,MAAM,CAAC;IAC7B,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC;AAEF,MAAM,MAAM,eAAe,GAAG;IAC5B,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AAEF,MAAM,MAAM,gBAAgB,GAAG;IAC7B,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC;AAEF,MAAM,MAAM,uBAAuB,GAAG;IACpC,OAAO,EAAE,gBAAgB,EAAE,CAAC;IAC5B,KAAK,EAAE,KAAK,GAAG,IAAI,CAAC;CACrB,CAAC"}

package/dist/migrations/types.js

@@ -0,0 +1 @@
+export {};

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

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

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

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

package/dist/tests/sql.test.js

@@ -0,0 +1,24 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { calculateChecksum, splitStatements } from "../migrations/sql.js";
+test("splitStatements handles basic semicolons", () => {
+    const sql = "SELECT 1; SELECT 2;";
+    const statements = splitStatements(sql);
+    assert.deepEqual(statements, ["SELECT 1", "SELECT 2"]);
+});
+test("splitStatements ignores semicolons in strings and comments", () => {
+    const sql = `
+    -- comment with ;
+    SELECT 'value;still_string';
+    /* block ; comment */
+    SELECT "value;still_string";
+  `;
+    const statements = splitStatements(sql);
+    assert.equal(statements.length, 2);
+    assert.ok(statements[0].includes("SELECT 'value;still_string'"));
+    assert.ok(statements[1].includes('SELECT "value;still_string"'));
+});
+test("calculateChecksum returns stable sha256", () => {
+    const checksum = calculateChecksum("hello");
+    assert.equal(checksum, "2cf24dba5fb0a30e26e83b2ac5b9e29e1b161e5c1fa7425e73043362938b9824");
+});

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "@clisma/core",
+  "version": "0.1.0",
+  "description": "Core ClickHouse migration logic for clisma",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@clisma/config": "*",
+    "@clickhouse/client": "^1.11.2",
+    "handlebars": "^4.7.8",
+    "kleur": "^4.1.5",
+    "ora": "^9.1.0"
+  },
+  "scripts": {
+    "build": "tsc -b tsconfig.json",
+    "test": "node --import tsx --test src/tests/*.test.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"
+  }
+}