@hypequery/clickhouse 1.6.2 → 2.0.1

package/dist/migrations/sql/render.js

@@ -1,347 +0,0 @@
-import { createMigrationPlan, isMigrationPlan } from '../plan/index.js';
-/**
- * Renders a snapshot diff into reviewable migration artifacts.
- *
- * The renderer produces forward SQL, best-effort reverse SQL, and metadata. It
- * also sequences dependent materialized views around table mutations so stored
- * view SELECT definitions are dropped and recreated with the target snapshot.
- */
-export function renderMigrationArtifacts(input, options) {
-    const plan = isMigrationPlan(input) ? input : createMigrationPlan(input);
-    assertNoPlanBlockers(plan);
-    const upStatements = [];
-    const downStatements = [];
-    const consumedViewNames = new Set();
-    const renderedOperations = [];
-    let containsManualSteps = false;
-    for (const plannedOperation of normalizeOperationsForRendering(plan.operations)) {
-        const { operation } = plannedOperation;
-        if (isMaterializedViewOperation(operation) && consumedViewNames.has(getOperationViewName(operation))) {
-            continue;
-        }
-        renderedOperations.push({
-            kind: operation.kind,
-            classification: plannedOperation.classification,
-        });
-        upStatements.push(...renderOperationUp(operation, { plan, cluster: options.cluster }, consumedViewNames));
-        const renderedDown = renderOperationDown(operation, {
-            previousSnapshot: plan.previousSnapshot,
-            nextSnapshot: plan.nextSnapshot,
-            cluster: options.cluster,
-        }, consumedViewNames);
-        downStatements.unshift(...renderedDown.statements);
-        containsManualSteps = containsManualSteps || renderedDown.manual;
-    }
-    return {
-        upSql: joinStatements(upStatements),
-        downSql: joinStatements(downStatements),
-        meta: {
-            name: options.name,
-            timestamp: options.timestamp,
-            operations: renderedOperations,
-            sourceSnapshotHash: plan.sourceSnapshotHash,
-            targetSnapshotHash: plan.targetSnapshotHash,
-            custom: false,
-            unsafe: plan.diagnostics.some(diagnostic => diagnostic.level === 'warning') ||
-                plan.blockers.length > 0 ||
-                containsManualSteps,
-            containsManualSteps,
-        },
-        plan,
-    };
-}
-function renderOperationUp(operation, context, consumedViewNames) {
-    switch (operation.kind) {
-        case 'CreateTable':
-            return [renderCreateTable(operation.table, context.cluster)];
-        case 'DropTable':
-            return [renderDropTable(operation.tableName, context.cluster)];
-        case 'AddColumn':
-            return [renderAlterTableAddColumn(operation.tableName, operation.column, context.cluster)];
-        case 'DropColumn':
-            return [renderAlterTableDropColumn(operation.tableName, operation.columnName, context.cluster)];
-        case 'ModifyColumnDefault':
-        case 'ModifyColumnType': {
-            const nextColumn = requireColumn(context.plan.nextSnapshot, operation.tableName, operation.columnName);
-            return [renderAlterTableModifyColumn(operation.tableName, nextColumn, context.cluster)];
-        }
-        case 'CreateMaterializedView':
-            return [renderCreateMaterializedView({ view: operation.view, cluster: context.cluster })];
-        case 'DropMaterializedView':
-            return [renderDropMaterializedView(operation.viewName, context.cluster)];
-        case 'RecreateMaterializedView':
-            return [
-                renderDropMaterializedView(operation.previousView.name, context.cluster),
-                renderCreateMaterializedView({ view: operation.nextView, cluster: context.cluster }),
-            ];
-        case 'AlterTableWithDependentViews':
-            return renderAlterTableWithDependentViewsUp(operation, context, consumedViewNames);
-        default: {
-            const exhaustiveCheck = operation;
-            return exhaustiveCheck;
-        }
-    }
-}
-function renderOperationDown(operation, lookup, consumedViewNames) {
-    switch (operation.kind) {
-        case 'CreateTable':
-            return { statements: [renderDropTable(operation.table.name, lookup.cluster)], manual: false };
-        case 'DropTable':
-            return { statements: [manualDownComment(`recreate dropped table "${operation.tableName}" manually`)], manual: true };
-        case 'AddColumn':
-            return {
-                statements: [renderAlterTableDropColumn(operation.tableName, operation.column.name, lookup.cluster)],
-                manual: false,
-            };
-        case 'DropColumn':
-            return {
-                statements: [manualDownComment(`recreate dropped column "${operation.tableName}.${operation.columnName}" manually`)],
-                manual: true,
-            };
-        case 'ModifyColumnDefault': {
-            const previousColumn = requireColumn(lookup.previousSnapshot, operation.tableName, operation.columnName);
-            return {
-                statements: [renderAlterTableModifyColumn(operation.tableName, previousColumn, lookup.cluster)],
-                manual: false,
-            };
-        }
-        case 'ModifyColumnType':
-            return {
-                statements: [manualDownComment(`revert type change for "${operation.tableName}.${operation.columnName}" manually`)],
-                manual: true,
-            };
-        case 'CreateMaterializedView':
-            return { statements: [renderDropMaterializedView(operation.view.name, lookup.cluster)], manual: false };
-        case 'DropMaterializedView': {
-            const previousView = requireMaterializedView(lookup.previousSnapshot, operation.viewName);
-            return {
-                statements: [renderCreateMaterializedView({ view: previousView, cluster: lookup.cluster })],
-                manual: false,
-            };
-        }
-        case 'RecreateMaterializedView':
-            return {
-                statements: [
-                    renderDropMaterializedView(operation.nextView.name, lookup.cluster),
-                    renderCreateMaterializedView({ view: operation.previousView, cluster: lookup.cluster }),
-                ],
-                manual: false,
-            };
-        case 'AlterTableWithDependentViews':
-            return renderAlterTableWithDependentViewsDown(operation, lookup, consumedViewNames);
-        default: {
-            const exhaustiveCheck = operation;
-            return exhaustiveCheck;
-        }
-    }
-}
-function renderAlterTableWithDependentViewsUp(operation, context, consumedViewNames) {
-    const statements = [];
-    for (const viewName of operation.dependentViewNames) {
-        statements.push(renderDropMaterializedView(viewName, context.cluster));
-        consumedViewNames.add(viewName);
-    }
-    for (const nestedOperation of normalizeTableMutationOperations(operation.operations)) {
-        statements.push(...renderOperationUp(nestedOperation, context, consumedViewNames));
-    }
-    for (const viewName of operation.dependentViewNames) {
-        statements.push(renderCreateMaterializedView({
-            view: requireMaterializedView(context.plan.nextSnapshot, viewName),
-            cluster: context.cluster,
-        }));
-    }
-    return statements;
-}
-function renderAlterTableWithDependentViewsDown(operation, lookup, consumedViewNames) {
-    const statements = [];
-    let manual = false;
-    for (const viewName of operation.dependentViewNames) {
-        statements.push(renderDropMaterializedView(viewName, lookup.cluster));
-        consumedViewNames.add(viewName);
-    }
-    for (const nestedOperation of [...normalizeTableMutationOperations(operation.operations)].reverse()) {
-        const rendered = renderOperationDown(nestedOperation, lookup, consumedViewNames);
-        statements.push(...rendered.statements);
-        manual = manual || rendered.manual;
-    }
-    for (const viewName of operation.dependentViewNames) {
-        statements.push(renderCreateMaterializedView({
-            view: requireMaterializedView(lookup.previousSnapshot, viewName),
-            cluster: lookup.cluster,
-        }));
-    }
-    return { statements, manual };
-}
-function renderCreateTable(table, cluster) {
-    const columns = table.columns
-        .map(column => `  ${quoteIdentifier(column.name)} ${column.type}${renderColumnDefault(column)}`)
-        .join(',\n');
-    const settings = Object.keys(table.settings).length > 0
-        ? `\nSETTINGS ${Object.entries(table.settings).map(([key, value]) => `${key} = ${value}`).join(', ')}`
-        : '';
-    return [
-        `CREATE TABLE ${quoteIdentifier(table.name)}${renderClusterClause(cluster)} (`,
-        columns,
-        `) ENGINE = ${renderTableEngine(table)}${settings};`,
-    ].join('\n');
-}
-function renderDropTable(tableName, cluster) {
-    return `DROP TABLE ${quoteIdentifier(tableName)}${renderClusterClause(cluster)};`;
-}
-function renderAlterTableAddColumn(tableName, column, cluster) {
-    return `ALTER TABLE ${quoteIdentifier(tableName)}${renderClusterClause(cluster)} ADD COLUMN ` +
-        `${quoteIdentifier(column.name)} ${column.type}${renderColumnDefault(column)};`;
-}
-function renderAlterTableDropColumn(tableName, columnName, cluster) {
-    return `ALTER TABLE ${quoteIdentifier(tableName)}${renderClusterClause(cluster)} DROP COLUMN ${quoteIdentifier(columnName)};`;
-}
-function renderAlterTableModifyColumn(tableName, column, cluster) {
-    return `ALTER TABLE ${quoteIdentifier(tableName)}${renderClusterClause(cluster)} MODIFY COLUMN ` +
-        `${quoteIdentifier(column.name)} ${column.type}${renderColumnDefault(column)};`;
-}
-function renderCreateMaterializedView(context) {
-    const toClause = context.view.to ? `\nTO ${quoteIdentifier(context.view.to)}` : '';
-    return [
-        `CREATE MATERIALIZED VIEW ${quoteIdentifier(context.view.name)}${renderClusterClause(context.cluster)}${toClause} AS`,
-        context.view.select,
-        ';',
-    ].join('\n');
-}
-function renderDropMaterializedView(viewName, cluster) {
-    return `DROP TABLE ${quoteIdentifier(viewName)}${renderClusterClause(cluster)};`;
-}
-function renderTableEngine(table) {
-    const parts = [table.engine.type, `ORDER BY (${table.engine.orderBy.join(', ')})`];
-    if (table.engine.partitionBy) {
-        parts.push(`PARTITION BY ${table.engine.partitionBy}`);
-    }
-    if (table.engine.primaryKey.length > 0) {
-        parts.push(`PRIMARY KEY (${table.engine.primaryKey.join(', ')})`);
-    }
-    if (table.engine.sampleBy) {
-        parts.push(`SAMPLE BY ${table.engine.sampleBy}`);
-    }
-    return parts.join('\n');
-}
-function renderColumnDefault(column) {
-    return column.default !== undefined ? ` DEFAULT ${renderDefaultValue(column.default)}` : '';
-}
-function renderClusterClause(cluster) {
-    return cluster ? ` ON CLUSTER ${quoteIdentifier(cluster)}` : '';
-}
-function quoteIdentifier(identifier) {
-    if (identifier.trim() === '') {
-        throw new Error('Invalid ClickHouse identifier: identifiers must not be empty.');
-    }
-    return `\`${identifier.replace(/`/g, '``')}\``;
-}
-function requireColumn(snapshot, tableName, columnName) {
-    const table = snapshot.tables.find(candidate => candidate.name === tableName);
-    if (!table) {
-        throw new Error(`Table "${tableName}" not found in snapshot.`);
-    }
-    const column = table.columns.find(candidate => candidate.name === columnName);
-    if (!column) {
-        throw new Error(`Column "${tableName}.${columnName}" not found in snapshot.`);
-    }
-    return column;
-}
-function requireMaterializedView(snapshot, viewName) {
-    const view = snapshot.materializedViews.find(candidate => candidate.name === viewName);
-    if (!view) {
-        throw new Error(`Materialized view "${viewName}" not found in snapshot.`);
-    }
-    return view;
-}
-function isMaterializedViewOperation(operation) {
-    return operation.kind === 'DropMaterializedView' ||
-        operation.kind === 'CreateMaterializedView' ||
-        operation.kind === 'RecreateMaterializedView';
-}
-function getOperationViewName(operation) {
-    switch (operation.kind) {
-        case 'DropMaterializedView':
-            return operation.viewName;
-        case 'CreateMaterializedView':
-            return operation.view.name;
-        case 'RecreateMaterializedView':
-            return operation.nextView.name;
-        default: {
-            const exhaustiveCheck = operation;
-            return exhaustiveCheck;
-        }
-    }
-}
-function manualDownComment(message) {
-    return `-- MANUAL STEP REQUIRED: ${message}`;
-}
-function joinStatements(statements) {
-    return statements.join('\n\n').trim();
-}
-function renderDefaultValue(defaultValue) {
-    if (defaultValue.kind === 'sql') {
-        return defaultValue.value;
-    }
-    if (defaultValue.value === null) {
-        return 'NULL';
-    }
-    if (typeof defaultValue.value === 'number') {
-        return String(defaultValue.value);
-    }
-    if (typeof defaultValue.value === 'boolean') {
-        return defaultValue.value ? 'true' : 'false';
-    }
-    return `'${escapeStringLiteral(defaultValue.value)}'`;
-}
-function escapeStringLiteral(value) {
-    return value
-        .replace(/\\/g, '\\\\')
-        .replace(/\0/g, '\\0')
-        .replace(/\x08/g, '\\b')
-        .replace(/\f/g, '\\f')
-        .replace(/\n/g, '\\n')
-        .replace(/\r/g, '\\r')
-        .replace(/\t/g, '\\t')
-        .replace(/\v/g, '\\v')
-        .replace(/'/g, "\\'");
-}
-function normalizeOperationsForRendering(operations) {
-    return operations.map(plannedOperation => {
-        if (plannedOperation.operation.kind !== 'AlterTableWithDependentViews') {
-            return plannedOperation;
-        }
-        return {
-            ...plannedOperation,
-            operation: {
-                ...plannedOperation.operation,
-                operations: normalizeTableMutationOperations(plannedOperation.operation.operations),
-            },
-        };
-    }).filter(plannedOperation => {
-        if (plannedOperation.operation.kind !== 'ModifyColumnDefault') {
-            return true;
-        }
-        const operation = plannedOperation.operation;
-        return !operations.some(candidate => candidate.operation.kind === 'ModifyColumnType' &&
-            candidate.operation.tableName === operation.tableName &&
-            candidate.operation.columnName === operation.columnName);
-    });
-}
-function normalizeTableMutationOperations(operations) {
-    return operations.filter(operation => {
-        if (operation.kind !== 'ModifyColumnDefault') {
-            return true;
-        }
-        return !operations.some(candidate => candidate.kind === 'ModifyColumnType' &&
-            candidate.tableName === operation.tableName &&
-            candidate.columnName === operation.columnName);
-    });
-}
-function assertNoPlanBlockers(plan) {
-    if (plan.blockers.length === 0) {
-        return;
-    }
-    throw new Error('Cannot render migration with unsupported changes:\n' +
-        plan.blockers.map(blocker => `- ${blocker.message}`).join('\n') +
-        '\n\nUse a custom SQL migration for this change, or split the schema evolution into supported steps.');
-}

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

@@ -1,53 +0,0 @@
-import type { MigrationOperation, SnapshotDiffResult } from '../diff/types.js';
-import type { MigrationOperationClassification, MigrationPlan, MigrationPlanInput } from '../plan/types.js';
-import type { Snapshot, SnapshotMaterializedView } from '../snapshot/types.js';
-export interface MigrationMeta {
-    name: string;
-    timestamp: string;
-    operations: Array<{
-        kind: MigrationOperation['kind'];
-        classification: MigrationOperationClassification;
-    }>;
-    sourceSnapshotHash: string;
-    targetSnapshotHash: string;
-    custom: boolean;
-    unsafe: boolean;
-    containsManualSteps: boolean;
-}
-export interface RenderMigrationArtifactsOptions {
-    name: string;
-    timestamp: string;
-    cluster?: string;
-}
-export interface RenderMigrationArtifactsResult {
-    upSql: string;
-    downSql: string;
-    meta: MigrationMeta;
-    plan: MigrationPlan;
-}
-export interface RenderSqlContext {
-    plan: MigrationPlan;
-    cluster?: string;
-}
-export interface MaterializedViewRenderContext {
-    view: SnapshotMaterializedView;
-    cluster?: string;
-}
-export interface WriteMigrationArtifactsOptions {
-    outDir: string;
-    migrationName: string;
-    artifacts: RenderMigrationArtifactsResult;
-}
-export interface WriteMigrationArtifactsResult {
-    migrationDir: string;
-    upPath: string;
-    downPath: string;
-    metaPath: string;
-    planPath: string;
-}
-export interface SnapshotLookup {
-    previousSnapshot: Snapshot;
-    nextSnapshot: Snapshot;
-}
-export type RenderMigrationArtifactsInput = MigrationPlanInput | SnapshotDiffResult;
-//# sourceMappingURL=types.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/migrations/sql/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,kBAAkB,EAAE,MAAM,kBAAkB,CAAC;AAC/E,OAAO,KAAK,EACV,gCAAgC,EAChC,aAAa,EACb,kBAAkB,EACnB,MAAM,kBAAkB,CAAC;AAC1B,OAAO,KAAK,EAAE,QAAQ,EAAE,wBAAwB,EAAE,MAAM,sBAAsB,CAAC;AAE/E,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,KAAK,CAAC;QAChB,IAAI,EAAE,kBAAkB,CAAC,MAAM,CAAC,CAAC;QACjC,cAAc,EAAE,gCAAgC,CAAC;KAClD,CAAC,CAAC;IACH,kBAAkB,EAAE,MAAM,CAAC;IAC3B,kBAAkB,EAAE,MAAM,CAAC;IAC3B,MAAM,EAAE,OAAO,CAAC;IAChB,MAAM,EAAE,OAAO,CAAC;IAChB,mBAAmB,EAAE,OAAO,CAAC;CAC9B;AAED,MAAM,WAAW,+BAA+B;IAC9C,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,8BAA8B;IAC7C,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,aAAa,CAAC;IACpB,IAAI,EAAE,aAAa,CAAC;CACrB;AAED,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,aAAa,CAAC;IACpB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,6BAA6B;IAC5C,IAAI,EAAE,wBAAwB,CAAC;IAC/B,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,8BAA8B;IAC7C,MAAM,EAAE,MAAM,CAAC;IACf,aAAa,EAAE,MAAM,CAAC;IACtB,SAAS,EAAE,8BAA8B,CAAC;CAC3C;AAED,MAAM,WAAW,6BAA6B;IAC5C,YAAY,EAAE,MAAM,CAAC;IACrB,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,cAAc;IAC7B,gBAAgB,EAAE,QAAQ,CAAC;IAC3B,YAAY,EAAE,QAAQ,CAAC;CACxB;AAED,MAAM,MAAM,6BAA6B,GAAG,kBAAkB,GAAG,kBAAkB,CAAC"}

package/dist/migrations/sql/types.js

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

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

@@ -1,10 +0,0 @@
-import type { WriteMigrationArtifactsOptions, WriteMigrationArtifactsResult } from './types.js';
-/**
- * Writes rendered migration artifacts to a migration directory.
- *
- * The migration name must be a single safe path segment. The writer creates
- * `up.sql`, `down.sql`, `meta.json`, and `plan.json` files under
- * `outDir/migrationName`.
- */
-export declare function writeMigrationArtifacts(options: WriteMigrationArtifactsOptions): Promise<WriteMigrationArtifactsResult>;
-//# sourceMappingURL=write.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"write.d.ts","sourceRoot":"","sources":["../../../src/migrations/sql/write.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,8BAA8B,EAC9B,6BAA6B,EAC9B,MAAM,YAAY,CAAC;AAEpB;;;;;;GAMG;AACH,wBAAsB,uBAAuB,CAC3C,OAAO,EAAE,8BAA8B,GACtC,OAAO,CAAC,6BAA6B,CAAC,CAuBxC"}

package/dist/migrations/sql/write.js

@@ -1,35 +0,0 @@
-import { mkdir, writeFile } from 'node:fs/promises';
-import path from 'node:path';
-/**
- * Writes rendered migration artifacts to a migration directory.
- *
- * The migration name must be a single safe path segment. The writer creates
- * `up.sql`, `down.sql`, `meta.json`, and `plan.json` files under
- * `outDir/migrationName`.
- */
-export async function writeMigrationArtifacts(options) {
-    assertValidMigrationName(options.migrationName);
-    const migrationDir = path.join(options.outDir, options.migrationName);
-    await mkdir(migrationDir, { recursive: true });
-    const upPath = path.join(migrationDir, 'up.sql');
-    const downPath = path.join(migrationDir, 'down.sql');
-    const metaPath = path.join(migrationDir, 'meta.json');
-    const planPath = path.join(migrationDir, 'plan.json');
-    await writeFile(upPath, `${options.artifacts.upSql}\n`, 'utf8');
-    await writeFile(downPath, `${options.artifacts.downSql}\n`, 'utf8');
-    await writeFile(metaPath, `${JSON.stringify(options.artifacts.meta, null, 2)}\n`, 'utf8');
-    await writeFile(planPath, `${JSON.stringify(options.artifacts.plan, null, 2)}\n`, 'utf8');
-    return {
-        migrationDir,
-        upPath,
-        downPath,
-        metaPath,
-        planPath,
-    };
-}
-function assertValidMigrationName(migrationName) {
-    if (!/^[A-Za-z0-9][A-Za-z0-9_-]*$/.test(migrationName)) {
-        throw new Error(`Invalid migration name "${migrationName}". ` +
-            'Migration names must be a single path segment containing only letters, numbers, underscores, and hyphens.');
-    }
-}