@hypequery/clickhouse 1.6.0 → 1.6.1

package/dist/migrations/diff/diff.d.ts

@@ -0,0 +1,11 @@
+import type { Snapshot } from '../snapshot/types.js';
+import type { SnapshotDiffResult } from './types.js';
+/**
+ * Computes migration operations needed to move from one snapshot to another.
+ *
+ * The diff layer is deliberately SQL-free. It emits structured operations,
+ * warnings for potentially expensive changes, and unsupported-change diagnostics
+ * that the SQL renderer refuses to render automatically.
+ */
+export declare function diffSnapshots(previousSnapshot: Snapshot, nextSnapshot: Snapshot): SnapshotDiffResult;
+//# sourceMappingURL=diff.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"diff.d.ts","sourceRoot":"","sources":["../../../src/migrations/diff/diff.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,QAAQ,EAIT,MAAM,sBAAsB,CAAC;AAC9B,OAAO,KAAK,EAQV,kBAAkB,EAGnB,MAAM,YAAY,CAAC;AAEpB;;;;;;GAMG;AACH,wBAAgB,aAAa,CAAC,gBAAgB,EAAE,QAAQ,EAAE,YAAY,EAAE,QAAQ,GAAG,kBAAkB,CAqCpG"}

package/dist/migrations/diff/diff.js

@@ -0,0 +1,240 @@
+/**
+ * Computes migration operations needed to move from one snapshot to another.
+ *
+ * The diff layer is deliberately SQL-free. It emits structured operations,
+ * warnings for potentially expensive changes, and unsupported-change diagnostics
+ * that the SQL renderer refuses to render automatically.
+ */
+export function diffSnapshots(previousSnapshot, nextSnapshot) {
+    const warnings = [];
+    const unsupportedChanges = [];
+    const previousTables = toNameMap(previousSnapshot.tables);
+    const nextTables = toNameMap(nextSnapshot.tables);
+    const previousViews = toNameMap(previousSnapshot.materializedViews);
+    const nextViews = toNameMap(nextSnapshot.materializedViews);
+    const dropMaterializedViewOperations = diffDroppedMaterializedViews(previousViews, nextViews);
+    const dropTableOperations = diffDroppedTables(previousTables, nextTables);
+    const tableOperations = diffTables(previousSnapshot, nextSnapshot, previousTables, nextTables, warnings, unsupportedChanges);
+    const createTableOperations = diffCreatedTables(previousTables, nextTables);
+    const recreateMaterializedViewOperations = diffChangedMaterializedViews(previousViews, nextViews);
+    const createMaterializedViewOperations = diffCreatedMaterializedViews(previousViews, nextViews);
+    return {
+        previousSnapshot,
+        nextSnapshot,
+        operations: [
+            ...dropMaterializedViewOperations,
+            ...dropTableOperations,
+            ...tableOperations,
+            ...createTableOperations,
+            ...recreateMaterializedViewOperations,
+            ...createMaterializedViewOperations,
+        ],
+        warnings,
+        unsupportedChanges,
+    };
+}
+function diffDroppedMaterializedViews(previousViews, nextViews) {
+    return [...previousViews.values()]
+        .filter(view => !nextViews.has(view.name))
+        .map(view => ({
+        kind: 'DropMaterializedView',
+        viewName: view.name,
+    }));
+}
+function diffDroppedTables(previousTables, nextTables) {
+    return [...previousTables.values()]
+        .filter(table => !nextTables.has(table.name))
+        .map(table => ({
+        kind: 'DropTable',
+        tableName: table.name,
+    }));
+}
+function diffCreatedTables(previousTables, nextTables) {
+    return [...nextTables.values()]
+        .filter(table => !previousTables.has(table.name))
+        .map(table => ({
+        kind: 'CreateTable',
+        table,
+    }));
+}
+function diffCreatedMaterializedViews(previousViews, nextViews) {
+    return [...nextViews.values()]
+        .filter(view => !previousViews.has(view.name))
+        .map(view => ({
+        kind: 'CreateMaterializedView',
+        view,
+    }));
+}
+function diffChangedMaterializedViews(previousViews, nextViews) {
+    const operations = [];
+    for (const previousView of previousViews.values()) {
+        const nextView = nextViews.get(previousView.name);
+        if (!nextView) {
+            continue;
+        }
+        if (!isSameMaterializedView(previousView, nextView)) {
+            operations.push({
+                kind: 'RecreateMaterializedView',
+                previousView,
+                nextView,
+            });
+        }
+    }
+    return operations;
+}
+function diffTables(previousSnapshot, nextSnapshot, previousTables, nextTables, warnings, unsupportedChanges) {
+    const operations = [];
+    for (const previousTable of previousTables.values()) {
+        const nextTable = nextTables.get(previousTable.name);
+        if (!nextTable) {
+            continue;
+        }
+        if (!isSameTableEngine(previousTable.engine, nextTable.engine)) {
+            unsupportedChanges.push({
+                kind: 'TableEngineChanged',
+                tableName: previousTable.name,
+                message: `Table engine changed for "${previousTable.name}". Engine evolution is not auto-generated yet.`,
+            });
+        }
+        if (!isSameSettings(previousTable.settings, nextTable.settings)) {
+            unsupportedChanges.push({
+                kind: 'TableSettingsChanged',
+                tableName: previousTable.name,
+                message: `Table settings changed for "${previousTable.name}". Settings diffs are not auto-generated yet.`,
+            });
+        }
+        const tableMutations = diffColumns(previousTable, nextTable, warnings, unsupportedChanges);
+        if (tableMutations.length === 0) {
+            continue;
+        }
+        const dependentViewNames = getDependentViewNames(previousSnapshot, nextSnapshot, previousTable.name);
+        if (dependentViewNames.length > 0) {
+            operations.push({
+                kind: 'AlterTableWithDependentViews',
+                tableName: previousTable.name,
+                dependentViewNames,
+                operations: tableMutations,
+            });
+            continue;
+        }
+        operations.push(...tableMutations);
+    }
+    return operations;
+}
+function diffColumns(previousTable, nextTable, warnings, unsupportedChanges) {
+    const operations = [];
+    const previousColumns = toNameMap(previousTable.columns);
+    const nextColumns = toNameMap(nextTable.columns);
+    const droppedColumns = [...previousColumns.values()].filter(column => !nextColumns.has(column.name));
+    const addedColumns = [...nextColumns.values()].filter(column => !previousColumns.has(column.name));
+    detectPossibleRenames(previousTable.name, droppedColumns, addedColumns, unsupportedChanges);
+    for (const column of droppedColumns) {
+        operations.push({
+            kind: 'DropColumn',
+            tableName: previousTable.name,
+            columnName: column.name,
+        });
+    }
+    for (const column of addedColumns) {
+        operations.push({
+            kind: 'AddColumn',
+            tableName: previousTable.name,
+            column,
+        });
+    }
+    for (const previousColumn of previousColumns.values()) {
+        const nextColumn = nextColumns.get(previousColumn.name);
+        if (!nextColumn) {
+            continue;
+        }
+        if (previousColumn.type !== nextColumn.type) {
+            operations.push({
+                kind: 'ModifyColumnType',
+                tableName: previousTable.name,
+                columnName: previousColumn.name,
+                previousType: previousColumn.type,
+                nextType: nextColumn.type,
+            });
+            warnings.push({
+                kind: 'ModifyColumnTypeRequiresConfirmation',
+                tableName: previousTable.name,
+                columnName: previousColumn.name,
+                message: `Column type changed for "${previousTable.name}.${previousColumn.name}" ` +
+                    `from "${previousColumn.type}" to "${nextColumn.type}".`,
+            });
+        }
+        if (!isSameColumnDefault(previousColumn.default, nextColumn.default)) {
+            operations.push({
+                kind: 'ModifyColumnDefault',
+                tableName: previousTable.name,
+                columnName: previousColumn.name,
+                previousDefault: previousColumn.default,
+                nextDefault: nextColumn.default,
+            });
+        }
+    }
+    return operations;
+}
+function isSameColumnDefault(left, right) {
+    if (left === right) {
+        return true;
+    }
+    if (left === undefined || right === undefined) {
+        return false;
+    }
+    return left.kind === right.kind && left.value === right.value;
+}
+function detectPossibleRenames(tableName, droppedColumns, addedColumns, unsupportedChanges) {
+    for (const droppedColumn of droppedColumns) {
+        const renameCandidate = addedColumns.find(addedColumn => addedColumn.type === droppedColumn.type &&
+            isSameColumnDefault(addedColumn.default, droppedColumn.default));
+        if (!renameCandidate) {
+            continue;
+        }
+        unsupportedChanges.push({
+            kind: 'PossibleColumnRename',
+            tableName,
+            columnName: droppedColumn.name,
+            message: `Possible column rename detected in "${tableName}": ` +
+                `"${droppedColumn.name}" -> "${renameCandidate.name}". ` +
+                `Rename inference is not supported in generated migrations.`,
+        });
+    }
+}
+function getDependentViewNames(previousSnapshot, nextSnapshot, tableName) {
+    return [...new Set([
+            ...previousSnapshot.dependencies
+                .filter(edge => edge.kind === 'table_to_materialized_view' && edge.from === tableName)
+                .map(edge => edge.to),
+            ...nextSnapshot.dependencies
+                .filter(edge => edge.kind === 'table_to_materialized_view' && edge.from === tableName)
+                .map(edge => edge.to),
+        ])].sort((left, right) => left.localeCompare(right));
+}
+function isSameTableEngine(left, right) {
+    return left.type === right.type &&
+        isSameStringArray(left.orderBy, right.orderBy) &&
+        (left.partitionBy ?? null) === (right.partitionBy ?? null) &&
+        isSameStringArray(left.primaryKey, right.primaryKey) &&
+        (left.sampleBy ?? null) === (right.sampleBy ?? null);
+}
+function isSameSettings(left, right) {
+    const leftEntries = Object.entries(left);
+    const rightEntries = Object.entries(right);
+    if (leftEntries.length !== rightEntries.length) {
+        return false;
+    }
+    return leftEntries.every(([key, value]) => right[key] === value);
+}
+function isSameMaterializedView(left, right) {
+    return left.name === right.name &&
+        left.from === right.from &&
+        (left.to ?? null) === (right.to ?? null) &&
+        left.select === right.select;
+}
+function isSameStringArray(left, right) {
+    return left.length === right.length && left.every((value, index) => value === right[index]);
+}
+function toNameMap(entries) {
+    return new Map(entries.map(entry => [entry.name, entry]));
+}

package/dist/migrations/diff/index.d.ts

@@ -0,0 +1,3 @@
+export { diffSnapshots } from './diff.js';
+export type { AddColumnOperation, AlterTableWithDependentViewsOperation, CreateMaterializedViewOperation, CreateTableOperation, DiffWarning, DropColumnOperation, DropMaterializedViewOperation, DropTableOperation, MigrationOperation, ModifyColumnDefaultOperation, ModifyColumnTypeOperation, RecreateMaterializedViewOperation, SnapshotDiffResult, TableMutationOperation, UnsupportedChange, } from './types.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/migrations/diff/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/migrations/diff/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,WAAW,CAAC;AAE1C,YAAY,EACV,kBAAkB,EAClB,qCAAqC,EACrC,+BAA+B,EAC/B,oBAAoB,EACpB,WAAW,EACX,mBAAmB,EACnB,6BAA6B,EAC7B,kBAAkB,EAClB,kBAAkB,EAClB,4BAA4B,EAC5B,yBAAyB,EACzB,iCAAiC,EACjC,kBAAkB,EAClB,sBAAsB,EACtB,iBAAiB,GAClB,MAAM,YAAY,CAAC"}

package/dist/migrations/diff/index.js

@@ -0,0 +1 @@
+export { diffSnapshots } from './diff.js';

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

@@ -0,0 +1,74 @@
+import type { Snapshot, SnapshotColumn, SnapshotColumnDefault, SnapshotMaterializedView, SnapshotTable } from '../snapshot/types.js';
+export interface CreateTableOperation {
+    kind: 'CreateTable';
+    table: SnapshotTable;
+}
+export interface DropTableOperation {
+    kind: 'DropTable';
+    tableName: string;
+}
+export interface AddColumnOperation {
+    kind: 'AddColumn';
+    tableName: string;
+    column: SnapshotColumn;
+}
+export interface DropColumnOperation {
+    kind: 'DropColumn';
+    tableName: string;
+    columnName: string;
+}
+export interface ModifyColumnDefaultOperation {
+    kind: 'ModifyColumnDefault';
+    tableName: string;
+    columnName: string;
+    previousDefault?: SnapshotColumnDefault;
+    nextDefault?: SnapshotColumnDefault;
+}
+export interface ModifyColumnTypeOperation {
+    kind: 'ModifyColumnType';
+    tableName: string;
+    columnName: string;
+    previousType: string;
+    nextType: string;
+}
+export interface CreateMaterializedViewOperation {
+    kind: 'CreateMaterializedView';
+    view: SnapshotMaterializedView;
+}
+export interface DropMaterializedViewOperation {
+    kind: 'DropMaterializedView';
+    viewName: string;
+}
+export interface RecreateMaterializedViewOperation {
+    kind: 'RecreateMaterializedView';
+    previousView: SnapshotMaterializedView;
+    nextView: SnapshotMaterializedView;
+}
+export type TableMutationOperation = AddColumnOperation | DropColumnOperation | ModifyColumnDefaultOperation | ModifyColumnTypeOperation;
+export interface AlterTableWithDependentViewsOperation {
+    kind: 'AlterTableWithDependentViews';
+    tableName: string;
+    dependentViewNames: string[];
+    operations: TableMutationOperation[];
+}
+export type MigrationOperation = AlterTableWithDependentViewsOperation | CreateMaterializedViewOperation | CreateTableOperation | DropMaterializedViewOperation | DropTableOperation | RecreateMaterializedViewOperation | TableMutationOperation;
+export interface DiffWarning {
+    kind: 'ModifyColumnTypeRequiresConfirmation';
+    tableName: string;
+    columnName: string;
+    message: string;
+}
+export interface UnsupportedChange {
+    kind: 'PossibleColumnRename' | 'TableEngineChanged' | 'TableSettingsChanged';
+    message: string;
+    tableName: string;
+    columnName?: string;
+}
+export interface SnapshotDiffResult {
+    previousSnapshot: Snapshot;
+    nextSnapshot: Snapshot;
+    operations: MigrationOperation[];
+    warnings: DiffWarning[];
+    unsupportedChanges: UnsupportedChange[];
+}
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/migrations/diff/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,QAAQ,EACR,cAAc,EACd,qBAAqB,EACrB,wBAAwB,EACxB,aAAa,EACd,MAAM,sBAAsB,CAAC;AAE9B,MAAM,WAAW,oBAAoB;IACnC,IAAI,EAAE,aAAa,CAAC;IACpB,KAAK,EAAE,aAAa,CAAC;CACtB;AAED,MAAM,WAAW,kBAAkB;IACjC,IAAI,EAAE,WAAW,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,kBAAkB;IACjC,IAAI,EAAE,WAAW,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,cAAc,CAAC;CACxB;AAED,MAAM,WAAW,mBAAmB;IAClC,IAAI,EAAE,YAAY,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,4BAA4B;IAC3C,IAAI,EAAE,qBAAqB,CAAC;IAC5B,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,eAAe,CAAC,EAAE,qBAAqB,CAAC;IACxC,WAAW,CAAC,EAAE,qBAAqB,CAAC;CACrC;AAED,MAAM,WAAW,yBAAyB;IACxC,IAAI,EAAE,kBAAkB,CAAC;IACzB,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,YAAY,EAAE,MAAM,CAAC;IACrB,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,+BAA+B;IAC9C,IAAI,EAAE,wBAAwB,CAAC;IAC/B,IAAI,EAAE,wBAAwB,CAAC;CAChC;AAED,MAAM,WAAW,6BAA6B;IAC5C,IAAI,EAAE,sBAAsB,CAAC;IAC7B,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,iCAAiC;IAChD,IAAI,EAAE,0BAA0B,CAAC;IACjC,YAAY,EAAE,wBAAwB,CAAC;IACvC,QAAQ,EAAE,wBAAwB,CAAC;CACpC;AAED,MAAM,MAAM,sBAAsB,GAC9B,kBAAkB,GAClB,mBAAmB,GACnB,4BAA4B,GAC5B,yBAAyB,CAAC;AAE9B,MAAM,WAAW,qCAAqC;IACpD,IAAI,EAAE,8BAA8B,CAAC;IACrC,SAAS,EAAE,MAAM,CAAC;IAClB,kBAAkB,EAAE,MAAM,EAAE,CAAC;IAC7B,UAAU,EAAE,sBAAsB,EAAE,CAAC;CACtC;AAED,MAAM,MAAM,kBAAkB,GAC1B,qCAAqC,GACrC,+BAA+B,GAC/B,oBAAoB,GACpB,6BAA6B,GAC7B,kBAAkB,GAClB,iCAAiC,GACjC,sBAAsB,CAAC;AAE3B,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,sCAAsC,CAAC;IAC7C,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,iBAAiB;IAChC,IAAI,EACA,sBAAsB,GACtB,oBAAoB,GACpB,sBAAsB,CAAC;IAC3B,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,kBAAkB;IACjC,gBAAgB,EAAE,QAAQ,CAAC;IAC3B,YAAY,EAAE,QAAQ,CAAC;IACvB,UAAU,EAAE,kBAAkB,EAAE,CAAC;IACjC,QAAQ,EAAE,WAAW,EAAE,CAAC;IACxB,kBAAkB,EAAE,iBAAiB,EAAE,CAAC;CACzC"}

package/dist/migrations/diff/types.js

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

package/dist/migrations/schema/column.d.ts

@@ -0,0 +1,71 @@
+import type { ClickHouseColumnBuilderLike, ClickHouseColumnDefaultValue, ClickHouseDefaultInput, ClickHouseColumnDefinition, ClickHouseColumnType } from './types.js';
+type NestedColumnTypeInput = string | ClickHouseColumnBuilder | ClickHouseColumnType;
+/**
+ * Immutable builder for ClickHouse column definitions.
+ *
+ * Each modifier returns a new builder so reusable column fragments can be shared
+ * safely without later calls mutating earlier definitions.
+ */
+export declare class ClickHouseColumnBuilder implements ClickHouseColumnBuilderLike {
+    private readonly columnType;
+    private readonly defaultExpression?;
+    constructor(columnType: ClickHouseColumnType, defaultExpression?: ClickHouseColumnDefaultValue | undefined);
+    /**
+     * Adds a column default.
+     *
+     * Primitive values are rendered as SQL literals. Use the `sql` template tag for
+     * database expressions such as `sql\`now()\``.
+     */
+    default(expression: ClickHouseDefaultInput): ClickHouseColumnBuilder;
+    /**
+     * Wraps this column type in `Nullable(...)`.
+     */
+    nullable(): ClickHouseColumnBuilder;
+    /**
+     * Wraps this column type in `LowCardinality(...)`.
+     */
+    lowCardinality(): ClickHouseColumnBuilder;
+    /**
+     * Materializes the builder into a named column definition for a table AST.
+     */
+    build(name: string): ClickHouseColumnDefinition;
+    /**
+     * Returns the underlying type AST for nested type builders.
+     */
+    toColumnType(): ClickHouseColumnType;
+}
+/**
+ * Factory helpers for common ClickHouse column types.
+ *
+ * Examples:
+ * `column.String().default('pending')`, `column.Nullable('String')`,
+ * `column.DateTime('UTC')`.
+ */
+export declare const column: {
+    Int8: () => ClickHouseColumnBuilder;
+    Int16: () => ClickHouseColumnBuilder;
+    Int32: () => ClickHouseColumnBuilder;
+    Int64: () => ClickHouseColumnBuilder;
+    Int128: () => ClickHouseColumnBuilder;
+    Int256: () => ClickHouseColumnBuilder;
+    UInt8: () => ClickHouseColumnBuilder;
+    UInt16: () => ClickHouseColumnBuilder;
+    UInt32: () => ClickHouseColumnBuilder;
+    UInt64: () => ClickHouseColumnBuilder;
+    UInt128: () => ClickHouseColumnBuilder;
+    UInt256: () => ClickHouseColumnBuilder;
+    Float32: () => ClickHouseColumnBuilder;
+    Float64: () => ClickHouseColumnBuilder;
+    Decimal: (precision: number, scale: number) => ClickHouseColumnBuilder;
+    String: () => ClickHouseColumnBuilder;
+    FixedString: (length: number) => ClickHouseColumnBuilder;
+    Date: () => ClickHouseColumnBuilder;
+    DateTime: (timezone?: string) => ClickHouseColumnBuilder;
+    DateTime64: (precision: number, timezone?: string) => ClickHouseColumnBuilder;
+    UUID: () => ClickHouseColumnBuilder;
+    JSON: () => ClickHouseColumnBuilder;
+    LowCardinality: (inner: NestedColumnTypeInput) => ClickHouseColumnBuilder;
+    Nullable: (inner: NestedColumnTypeInput) => ClickHouseColumnBuilder;
+};
+export {};
+//# sourceMappingURL=column.d.ts.map

package/dist/migrations/schema/column.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"column.d.ts","sourceRoot":"","sources":["../../../src/migrations/schema/column.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,2BAA2B,EAC3B,4BAA4B,EAC5B,sBAAsB,EACtB,0BAA0B,EAC1B,oBAAoB,EAErB,MAAM,YAAY,CAAC;AAIpB,KAAK,qBAAqB,GAAG,MAAM,GAAG,uBAAuB,GAAG,oBAAoB,CAAC;AAErF;;;;;GAKG;AACH,qBAAa,uBAAwB,YAAW,2BAA2B;IAEvE,OAAO,CAAC,QAAQ,CAAC,UAAU;IAC3B,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAAC;gBADlB,UAAU,EAAE,oBAAoB,EAChC,iBAAiB,CAAC,EAAE,4BAA4B,YAAA;IAGnE;;;;;OAKG;IACH,OAAO,CAAC,UAAU,EAAE,sBAAsB,GAAG,uBAAuB;IAIpE;;OAEG;IACH,QAAQ,IAAI,uBAAuB;IAOnC;;OAEG;IACH,cAAc,IAAI,uBAAuB;IAOzC;;OAEG;IACH,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,0BAA0B;IAQ/C;;OAEG;IACH,YAAY,IAAI,oBAAoB;CAGrC;AAED;;;;;;GAMG;AACH,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;yBAeI,MAAM,SAAS,MAAM;;0BAEpB,MAAM;;0BAEN,MAAM;4BACJ,MAAM,aAAa,MAAM;;;4BAIzB,qBAAqB;sBAK3B,qBAAqB;CAKxC,CAAC"}

package/dist/migrations/schema/column.js

@@ -0,0 +1,123 @@
+import { isSQLExpression } from '../../dataset/sql-tag.js';
+/**
+ * Immutable builder for ClickHouse column definitions.
+ *
+ * Each modifier returns a new builder so reusable column fragments can be shared
+ * safely without later calls mutating earlier definitions.
+ */
+export class ClickHouseColumnBuilder {
+    columnType;
+    defaultExpression;
+    constructor(columnType, defaultExpression) {
+        this.columnType = columnType;
+        this.defaultExpression = defaultExpression;
+    }
+    /**
+     * Adds a column default.
+     *
+     * Primitive values are rendered as SQL literals. Use the `sql` template tag for
+     * database expressions such as `sql\`now()\``.
+     */
+    default(expression) {
+        return new ClickHouseColumnBuilder(this.columnType, toDefaultValue(expression));
+    }
+    /**
+     * Wraps this column type in `Nullable(...)`.
+     */
+    nullable() {
+        return new ClickHouseColumnBuilder({ kind: 'nullable', inner: this.columnType }, this.defaultExpression);
+    }
+    /**
+     * Wraps this column type in `LowCardinality(...)`.
+     */
+    lowCardinality() {
+        return new ClickHouseColumnBuilder({ kind: 'low_cardinality', inner: this.columnType }, this.defaultExpression);
+    }
+    /**
+     * Materializes the builder into a named column definition for a table AST.
+     */
+    build(name) {
+        return {
+            name,
+            type: this.columnType,
+            ...(this.defaultExpression !== undefined ? { default: this.defaultExpression } : {}),
+        };
+    }
+    /**
+     * Returns the underlying type AST for nested type builders.
+     */
+    toColumnType() {
+        return this.columnType;
+    }
+}
+/**
+ * Factory helpers for common ClickHouse column types.
+ *
+ * Examples:
+ * `column.String().default('pending')`, `column.Nullable('String')`,
+ * `column.DateTime('UTC')`.
+ */
+export const column = {
+    Int8: () => named('Int8'),
+    Int16: () => named('Int16'),
+    Int32: () => named('Int32'),
+    Int64: () => named('Int64'),
+    Int128: () => named('Int128'),
+    Int256: () => named('Int256'),
+    UInt8: () => named('UInt8'),
+    UInt16: () => named('UInt16'),
+    UInt32: () => named('UInt32'),
+    UInt64: () => named('UInt64'),
+    UInt128: () => named('UInt128'),
+    UInt256: () => named('UInt256'),
+    Float32: () => named('Float32'),
+    Float64: () => named('Float64'),
+    Decimal: (precision, scale) => named('Decimal', precision, scale),
+    String: () => named('String'),
+    FixedString: (length) => named('FixedString', length),
+    Date: () => named('Date'),
+    DateTime: (timezone) => timezone ? named('DateTime', timezone) : named('DateTime'),
+    DateTime64: (precision, timezone) => timezone ? named('DateTime64', precision, timezone) : named('DateTime64', precision),
+    UUID: () => named('UUID'),
+    JSON: () => named('JSON'),
+    LowCardinality: (inner) => new ClickHouseColumnBuilder({
+        kind: 'low_cardinality',
+        inner: normalizeNestedColumnType(inner),
+    }),
+    Nullable: (inner) => new ClickHouseColumnBuilder({
+        kind: 'nullable',
+        inner: normalizeNestedColumnType(inner),
+    }),
+};
+function named(name, ...argumentsList) {
+    const type = {
+        kind: 'named',
+        name,
+        ...(argumentsList.length > 0 ? { arguments: argumentsList } : {}),
+    };
+    return new ClickHouseColumnBuilder(type);
+}
+function normalizeNestedColumnType(input) {
+    if (typeof input === 'string') {
+        return {
+            kind: 'named',
+            name: input,
+        };
+    }
+    if (input instanceof ClickHouseColumnBuilder) {
+        return input.toColumnType();
+    }
+    return input;
+}
+function toDefaultValue(input) {
+    if (isSQLExpression(input)) {
+        return {
+            kind: 'sql',
+            value: input,
+        };
+    }
+    return {
+        kind: 'literal',
+        value: input,
+    };
+}

package/dist/migrations/schema/define.d.ts

@@ -0,0 +1,24 @@
+import type { ClickHouseMaterializedViewDefinition, ClickHouseMaterializedViewInputDefinition, ClickHouseSchemaAst, ClickHouseSchemaDefinition, ClickHouseTableDefinition, ClickHouseTableInputDefinition } from './types.js';
+/**
+ * Creates a schema AST from the tables and materialized views declared in code.
+ *
+ * The returned AST is intentionally not SQL yet. It is serialized into a stable
+ * snapshot first, then diffed against a previous snapshot to generate migrations.
+ */
+export declare function defineSchema(definition: ClickHouseSchemaDefinition): ClickHouseSchemaAst;
+/**
+ * Defines a ClickHouse table for the migration DSL.
+ *
+ * Column builders are keyed by their final column names, which keeps the schema
+ * definition compact while preserving enough structure for snapshot diffing.
+ */
+export declare function defineTable(name: string, definition: ClickHouseTableInputDefinition): ClickHouseTableDefinition;
+/**
+ * Defines a ClickHouse materialized view and records its source-table dependency.
+ *
+ * The `from` and `to` fields may reference table definitions directly or use table
+ * names. Dependencies are used by the renderer to drop and recreate views around
+ * table mutations that could otherwise break stored SELECT definitions.
+ */
+export declare function defineMaterializedView(name: string, definition: ClickHouseMaterializedViewInputDefinition): ClickHouseMaterializedViewDefinition;
+//# sourceMappingURL=define.d.ts.map

package/dist/migrations/schema/define.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"define.d.ts","sourceRoot":"","sources":["../../../src/migrations/schema/define.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,oCAAoC,EACpC,yCAAyC,EACzC,mBAAmB,EACnB,0BAA0B,EAC1B,yBAAyB,EACzB,8BAA8B,EAC/B,MAAM,YAAY,CAAC;AAEpB;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,UAAU,EAAE,0BAA0B,GAAG,mBAAmB,CAOxF;AAED;;;;;GAKG;AACH,wBAAgB,WAAW,CACzB,IAAI,EAAE,MAAM,EACZ,UAAU,EAAE,8BAA8B,GACzC,yBAAyB,CAQ3B;AAED;;;;;;GAMG;AACH,wBAAgB,sBAAsB,CACpC,IAAI,EAAE,MAAM,EACZ,UAAU,EAAE,yCAAyC,GACpD,oCAAoC,CAUtC"}

package/dist/migrations/schema/define.js

@@ -0,0 +1,47 @@
+/**
+ * Creates a schema AST from the tables and materialized views declared in code.
+ *
+ * The returned AST is intentionally not SQL yet. It is serialized into a stable
+ * snapshot first, then diffed against a previous snapshot to generate migrations.
+ */
+export function defineSchema(definition) {
+    return {
+        tables: [...definition.tables],
+        ...(definition.materializedViews !== undefined
+            ? { materializedViews: [...definition.materializedViews] }
+            : {}),
+    };
+}
+/**
+ * Defines a ClickHouse table for the migration DSL.
+ *
+ * Column builders are keyed by their final column names, which keeps the schema
+ * definition compact while preserving enough structure for snapshot diffing.
+ */
+export function defineTable(name, definition) {
+    return {
+        kind: 'table',
+        name,
+        columns: Object.entries(definition.columns).map(([columnName, builder]) => builder.build(columnName)),
+        engine: definition.engine,
+        ...(definition.settings !== undefined ? { settings: definition.settings } : {}),
+    };
+}
+/**
+ * Defines a ClickHouse materialized view and records its source-table dependency.
+ *
+ * The `from` and `to` fields may reference table definitions directly or use table
+ * names. Dependencies are used by the renderer to drop and recreate views around
+ * table mutations that could otherwise break stored SELECT definitions.
+ */
+export function defineMaterializedView(name, definition) {
+    return {
+        kind: 'materialized_view',
+        name,
+        from: typeof definition.from === 'string' ? definition.from : definition.from.name,
+        ...(definition.to !== undefined
+            ? { to: typeof definition.to === 'string' ? definition.to : definition.to.name }
+            : {}),
+        select: definition.select,
+    };
+}

package/dist/migrations/schema/index.d.ts

@@ -0,0 +1,4 @@
+export { column, ClickHouseColumnBuilder } from './column.js';
+export { defineMaterializedView, defineSchema, defineTable } from './define.js';
+export type { ClickHouseColumnBuilderLike, ClickHouseColumnDefaultValue, ClickHouseColumnDefinition, ClickHouseColumnType, ClickHouseDefaultInput, ClickHouseLowCardinalityColumnType, ClickHouseLiteralDefaultValue, ClickHouseMaterializedViewDefinition, ClickHouseMaterializedViewInputDefinition, ClickHouseNamedColumnType, ClickHouseNullableColumnType, ClickHouseSqlDefaultValue, ClickHouseSchemaAst, ClickHouseSchemaDefinition, ClickHouseSqlExpression, ClickHouseTableDefinition, ClickHouseTableInputDefinition, ClickHouseTableEngine, } from './types.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/migrations/schema/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/migrations/schema/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,uBAAuB,EAAE,MAAM,aAAa,CAAC;AAC9D,OAAO,EAAE,sBAAsB,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAEhF,YAAY,EACV,2BAA2B,EAC3B,4BAA4B,EAC5B,0BAA0B,EAC1B,oBAAoB,EACpB,sBAAsB,EACtB,kCAAkC,EAClC,6BAA6B,EAC7B,oCAAoC,EACpC,yCAAyC,EACzC,yBAAyB,EACzB,4BAA4B,EAC5B,yBAAyB,EACzB,mBAAmB,EACnB,0BAA0B,EAC1B,uBAAuB,EACvB,yBAAyB,EACzB,8BAA8B,EAC9B,qBAAqB,GACtB,MAAM,YAAY,CAAC"}

package/dist/migrations/schema/index.js

@@ -0,0 +1,2 @@
+export { column, ClickHouseColumnBuilder } from './column.js';
+export { defineMaterializedView, defineSchema, defineTable } from './define.js';