@hypequery/cli 0.0.7 → 0.0.9

package/dist/generators/clickhouse.js

@@ -0,0 +1,229 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { getClickHouseClient } from '../utils/clickhouse-client.js';
+var DEFAULT_WARNING = 'Warning: No tables match the filter criteria. Check your include/exclude options.';
+var capitalizeFirstLetter = function (value) { return value.charAt(0).toUpperCase() + value.slice(1); };
+var clickhouseToTsType = function (type) {
+    if (type.startsWith('Array(')) {
+        var innerType = type.slice(6, -1);
+        return "Array<".concat(clickhouseToTsType(innerType), ">");
+    }
+    if (type.startsWith('Nullable(')) {
+        var innerType = type.slice(9, -1);
+        return "".concat(clickhouseToTsType(innerType), " | null");
+    }
+    if (type.startsWith('Map(')) {
+        var mapContent = type.slice(4, -1);
+        var commaIndex = mapContent.lastIndexOf(',');
+        if (commaIndex !== -1) {
+            var keyType = mapContent.substring(0, commaIndex).trim();
+            var valueType = mapContent.substring(commaIndex + 1).trim();
+            var keyTsType = 'string';
+            if (keyType === 'LowCardinality(String)') {
+                keyTsType = 'string';
+            }
+            else if (keyType.includes('Int') || keyType.includes('UInt')) {
+                keyTsType = 'number';
+            }
+            var valueTsType = 'unknown';
+            if (valueType.startsWith('Array(')) {
+                var innerType = valueType.slice(6, -1);
+                valueTsType = "Array<".concat(clickhouseToTsType(innerType), ">");
+            }
+            else if (valueType.startsWith('Nullable(')) {
+                var innerType = valueType.slice(9, -1);
+                valueTsType = "".concat(clickhouseToTsType(innerType), " | null");
+            }
+            else {
+                valueTsType = clickhouseToTsType(valueType);
+            }
+            return "Record<".concat(keyTsType, ", ").concat(valueTsType, ">");
+        }
+        return 'Record<string, unknown>';
+    }
+    switch (type.toLowerCase()) {
+        case 'string':
+        case 'fixedstring':
+            return 'string';
+        case 'int8':
+        case 'int16':
+        case 'int32':
+        case 'uint8':
+        case 'int64':
+        case 'uint16':
+        case 'uint32':
+        case 'uint64':
+            return 'number';
+        case 'uint128':
+        case 'uint256':
+        case 'int128':
+        case 'int256':
+            return 'string';
+        case 'float32':
+        case 'float64':
+        case 'decimal':
+            return 'number';
+        case 'datetime':
+        case 'datetime64':
+        case 'date':
+        case 'date32':
+            return 'string';
+        case 'bool':
+        case 'boolean':
+            return 'boolean';
+        default:
+            return 'string';
+    }
+};
+function fetchTables(includeTables, excludeTables) {
+    return __awaiter(this, void 0, void 0, function () {
+        var client, tablesQuery, tables;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    client = getClickHouseClient();
+                    return [4 /*yield*/, client.query({
+                            query: 'SHOW TABLES',
+                            format: 'JSONEachRow',
+                        })];
+                case 1:
+                    tablesQuery = _a.sent();
+                    return [4 /*yield*/, tablesQuery.json()];
+                case 2:
+                    tables = (_a.sent());
+                    if (includeTables === null || includeTables === void 0 ? void 0 : includeTables.length) {
+                        tables = tables.filter(function (table) { return includeTables.includes(table.name); });
+                    }
+                    if (excludeTables === null || excludeTables === void 0 ? void 0 : excludeTables.length) {
+                        tables = tables.filter(function (table) { return !excludeTables.includes(table.name); });
+                    }
+                    return [2 /*return*/, tables];
+            }
+        });
+    });
+}
+function fetchColumns(table) {
+    return __awaiter(this, void 0, void 0, function () {
+        var client, columnsQuery;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    client = getClickHouseClient();
+                    return [4 /*yield*/, client.query({
+                            query: "DESCRIBE TABLE ".concat(table),
+                            format: 'JSONEachRow',
+                        })];
+                case 1:
+                    columnsQuery = _a.sent();
+                    return [4 /*yield*/, columnsQuery.json()];
+                case 2: return [2 /*return*/, (_a.sent())];
+            }
+        });
+    });
+}
+export function generateClickHouseTypes(options) {
+    return __awaiter(this, void 0, void 0, function () {
+        var outputPath, includeTables, excludeTables, tables, typeDefinitions, _i, tables_1, table, columns, _a, columns_1, column, clickHouseType, _b, tables_2, table, columns, _c, columns_2, column, tsType, outputDir;
+        return __generator(this, function (_d) {
+            switch (_d.label) {
+                case 0:
+                    outputPath = options.outputPath, includeTables = options.includeTables, excludeTables = options.excludeTables;
+                    return [4 /*yield*/, fetchTables(includeTables, excludeTables)];
+                case 1:
+                    tables = _d.sent();
+                    if (tables.length === 0) {
+                        console.warn(DEFAULT_WARNING);
+                    }
+                    typeDefinitions = "// Generated by hypequery\n" +
+                        "// This file defines TypeScript types based on your ClickHouse database schema\n\n" +
+                        "export interface IntrospectedSchema {";
+                    _i = 0, tables_1 = tables;
+                    _d.label = 2;
+                case 2:
+                    if (!(_i < tables_1.length)) return [3 /*break*/, 5];
+                    table = tables_1[_i];
+                    return [4 /*yield*/, fetchColumns(table.name)];
+                case 3:
+                    columns = _d.sent();
+                    typeDefinitions += "\n  ".concat(table.name, ": {");
+                    for (_a = 0, columns_1 = columns; _a < columns_1.length; _a++) {
+                        column = columns_1[_a];
+                        clickHouseType = column.type.replace(/'/g, "\\'");
+                        typeDefinitions += "\n    '".concat(column.name, "': '").concat(clickHouseType, "';");
+                    }
+                    typeDefinitions += '\n  };';
+                    _d.label = 4;
+                case 4:
+                    _i++;
+                    return [3 /*break*/, 2];
+                case 5:
+                    typeDefinitions += '\n}\n';
+                    typeDefinitions += "\n// Type-safe record types for each table\n";
+                    _b = 0, tables_2 = tables;
+                    _d.label = 6;
+                case 6:
+                    if (!(_b < tables_2.length)) return [3 /*break*/, 9];
+                    table = tables_2[_b];
+                    return [4 /*yield*/, fetchColumns(table.name)];
+                case 7:
+                    columns = _d.sent();
+                    typeDefinitions += "export interface ".concat(capitalizeFirstLetter(table.name), "Record {");
+                    for (_c = 0, columns_2 = columns; _c < columns_2.length; _c++) {
+                        column = columns_2[_c];
+                        tsType = clickhouseToTsType(column.type).replace(/'/g, '');
+                        typeDefinitions += "\n  '".concat(column.name, "': ").concat(tsType, ";");
+                    }
+                    typeDefinitions += '\n}\n\n';
+                    _d.label = 8;
+                case 8:
+                    _b++;
+                    return [3 /*break*/, 6];
+                case 9:
+                    outputDir = path.dirname(path.resolve(outputPath));
+                    return [4 /*yield*/, fs.mkdir(outputDir, { recursive: true })];
+                case 10:
+                    _d.sent();
+                    return [4 /*yield*/, fs.writeFile(path.resolve(outputPath), typeDefinitions)];
+                case 11:
+                    _d.sent();
+                    return [2 /*return*/];
+            }
+        });
+    });
+}

package/dist/generators/index.d.ts

@@ -0,0 +1,7 @@
+import type { DatabaseType } from '../utils/detect-database.js';
+import { type ClickHouseGeneratorOptions } from './clickhouse.js';
+export type TypeGeneratorOptions = ClickHouseGeneratorOptions;
+type GeneratorFn = (options: TypeGeneratorOptions) => Promise<void>;
+export declare function getTypeGenerator(dbType: DatabaseType): GeneratorFn;
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/generators/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/generators/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAChE,OAAO,EAA2B,KAAK,0BAA0B,EAAE,MAAM,iBAAiB,CAAC;AAE3F,MAAM,MAAM,oBAAoB,GAAG,0BAA0B,CAAC;AAE9D,KAAK,WAAW,GAAG,CAAC,OAAO,EAAE,oBAAoB,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;AAMpE,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,YAAY,GAAG,WAAW,CAYlE"}

package/dist/generators/index.js

@@ -0,0 +1,13 @@
+import { generateClickHouseTypes } from './clickhouse.js';
+var generators = {
+    clickhouse: generateClickHouseTypes,
+};
+export function getTypeGenerator(dbType) {
+    var generator = generators[dbType];
+    if (!generator) {
+        throw new Error(dbType === 'unknown'
+            ? 'Unable to detect database type. Re-run `hypequery init --database <type>` or pass `--database` explicitly.'
+            : "Type generation for ".concat(dbType, " is not supported yet."));
+    }
+    return generator;
+}

package/dist/templates/client.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Generate client.ts file for ClickHouse
+ */
+export declare function generateClientTemplate(): string;
+//# sourceMappingURL=client.d.ts.map

package/dist/templates/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../src/templates/client.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,wBAAgB,sBAAsB,IAAI,MAAM,CAW/C"}

package/dist/templates/client.js

@@ -0,0 +1,6 @@
+/**
+ * Generate client.ts file for ClickHouse
+ */
+export function generateClientTemplate() {
+    return "import { createQueryBuilder } from '@hypequery/clickhouse';\nimport type { IntrospectedSchema } from './schema';\n\nexport const db = createQueryBuilder<IntrospectedSchema>({\n  host: process.env.CLICKHOUSE_HOST!,\n  database: process.env.CLICKHOUSE_DATABASE!,\n  username: process.env.CLICKHOUSE_USERNAME!,\n  password: process.env.CLICKHOUSE_PASSWORD,\n});\n";
+}

package/dist/templates/env.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Generate .env file content for ClickHouse
+ */
+export declare function generateEnvTemplate(config: {
+    host: string;
+    database: string;
+    username: string;
+    password: string;
+}): string;
+/**
+ * Append to existing .env file
+ */
+export declare function appendToEnv(existingContent: string, newContent: string): string;
+//# sourceMappingURL=env.d.ts.map

package/dist/templates/env.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"env.d.ts","sourceRoot":"","sources":["../../src/templates/env.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE;IAC1C,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;CAClB,GAAG,MAAM,CAoBT;AAED;;GAEG;AACH,wBAAgB,WAAW,CAAC,eAAe,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,MAAM,CA4B/E"}

package/dist/templates/env.js

@@ -0,0 +1,37 @@
+/**
+ * Generate .env file content for ClickHouse
+ */
+export function generateEnvTemplate(config) {
+    var isPlaceholder = config.host.includes('YOUR_');
+    if (isPlaceholder) {
+        return "# Hypequery Configuration\n# Replace these placeholder values with your actual ClickHouse credentials\n\nCLICKHOUSE_HOST=".concat(config.host, "\nCLICKHOUSE_DATABASE=").concat(config.database, "\nCLICKHOUSE_USERNAME=").concat(config.username, "\nCLICKHOUSE_PASSWORD=").concat(config.password, "\n");
+    }
+    return "# Hypequery Configuration\nCLICKHOUSE_HOST=".concat(config.host, "\nCLICKHOUSE_DATABASE=").concat(config.database, "\nCLICKHOUSE_USERNAME=").concat(config.username, "\nCLICKHOUSE_PASSWORD=").concat(config.password, "\n");
+}
+/**
+ * Append to existing .env file
+ */
+export function appendToEnv(existingContent, newContent) {
+    // Check if hypequery section already exists
+    if (existingContent.includes('# Hypequery Configuration')) {
+        // Replace existing section
+        var lines = existingContent.split('\n');
+        var startIndex = lines.findIndex(function (l) { return l.includes('# Hypequery Configuration'); });
+        if (startIndex !== -1) {
+            // Find the end of the hypequery section
+            var endIndex = startIndex + 1;
+            while (endIndex < lines.length &&
+                (lines[endIndex].startsWith('CLICKHOUSE_') || lines[endIndex].trim() === '')) {
+                endIndex++;
+            }
+            // Replace the section
+            lines.splice(startIndex, endIndex - startIndex, newContent.trim());
+            return lines.join('\n');
+        }
+    }
+    // Append to end
+    if (!existingContent.endsWith('\n')) {
+        existingContent += '\n';
+    }
+    return existingContent + '\n' + newContent;
+}

package/dist/templates/gitignore.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Content to append to .gitignore
+ */
+export declare const GITIGNORE_CONTENT = "\n# Hypequery\n.env\n";
+/**
+ * Check if .gitignore already has hypequery entries
+ */
+export declare function hasHypequeryEntries(content: string): boolean;
+/**
+ * Append hypequery entries to .gitignore
+ */
+export declare function appendToGitignore(existingContent: string): string;
+//# sourceMappingURL=gitignore.d.ts.map

package/dist/templates/gitignore.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gitignore.d.ts","sourceRoot":"","sources":["../../src/templates/gitignore.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,eAAO,MAAM,iBAAiB,0BAG7B,CAAC;AAEF;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAE5D;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,eAAe,EAAE,MAAM,GAAG,MAAM,CAUjE"}

package/dist/templates/gitignore.js

@@ -0,0 +1,22 @@
+/**
+ * Content to append to .gitignore
+ */
+export var GITIGNORE_CONTENT = "\n# Hypequery\n.env\n";
+/**
+ * Check if .gitignore already has hypequery entries
+ */
+export function hasHypequeryEntries(content) {
+    return content.includes('# Hypequery') || content.includes('.env');
+}
+/**
+ * Append hypequery entries to .gitignore
+ */
+export function appendToGitignore(existingContent) {
+    if (hasHypequeryEntries(existingContent)) {
+        return existingContent;
+    }
+    if (!existingContent.endsWith('\n')) {
+        existingContent += '\n';
+    }
+    return existingContent + GITIGNORE_CONTENT;
+}

package/dist/templates/queries.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Generate queries.ts file
+ */
+export declare function generateQueriesTemplate(options: {
+    hasExample: boolean;
+    tableName?: string;
+}): string;
+//# sourceMappingURL=queries.d.ts.map

package/dist/templates/queries.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"queries.d.ts","sourceRoot":"","sources":["../../src/templates/queries.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,wBAAgB,uBAAuB,CAAC,OAAO,EAAE;IAC/C,UAAU,EAAE,OAAO,CAAC;IACpB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB,GAAG,MAAM,CA6DT"}

package/dist/templates/queries.js

@@ -0,0 +1,27 @@
+/**
+ * Generate queries.ts file
+ */
+export function generateQueriesTemplate(options) {
+    var hasExample = options.hasExample, tableName = options.tableName;
+    var metricKey = hasExample && tableName ? "".concat(camelCase(tableName), "Query") : 'exampleMetric';
+    var typeAlias = "".concat(pascalCase(metricKey), "Result");
+    var template = "import { initServe } from '@hypequery/serve';\nimport type { InferApiType } from '@hypequery/serve';\nimport { z } from 'zod';\nimport { db } from './client';\n\nconst serve = initServe({\n  context: () => ({ db }),\n});\nconst { query } = serve;\n\nexport const api = serve.define({\n  queries: serve.queries({";
+    if (hasExample && tableName) {
+        template += "\n    ".concat(camelCase(tableName), "Query: query\n      .describe('Example query using the ").concat(tableName, " table')\n      .query(async ({ ctx }) =>\n        ctx.db\n          .table('").concat(tableName, "')\n          .select('*')\n          .limit(10)\n          .execute()\n      ),");
+    }
+    else {
+        template += "\n    exampleMetric: query\n      .describe('Example metric that returns a simple value')\n      .output(z.object({ ok: z.boolean() }))\n      .query(async () => ({ ok: true })),";
+    }
+    template += "\n  }),\n});\n\nexport type ApiDefinition = InferApiType<typeof api>;\n\n/**\n * Inline usage example:\n *\n * const result = await api.execute('".concat(metricKey, "');\n * console.log(result);\n *\n * // import type { InferQueryResult } from '@hypequery/serve';\n * type ").concat(typeAlias, " = InferQueryResult<typeof api, '").concat(metricKey, "'>;\n *\n * // Register HTTP route:\n * api.route('/metrics/").concat(metricKey, "', api.queries.").concat(metricKey, ");\n *\n * Dev server:\n * npx hypequery dev\n */\n");
+    return template;
+}
+/**
+ * Convert table name to camelCase
+ */
+function camelCase(str) {
+    return str.replace(/_([a-z])/g, function (_, letter) { return letter.toUpperCase(); });
+}
+function pascalCase(str) {
+    var camel = camelCase(str);
+    return camel.charAt(0).toUpperCase() + camel.slice(1);
+}

package/dist/test-utils.d.ts

@@ -0,0 +1,86 @@
+import type { Mock } from 'vitest';
+/**
+ * Mock prompts module for testing
+ */
+export declare function createMockPrompts(): {
+    promptDatabaseType: Mock<(...args: any[]) => any>;
+    promptClickHouseConnection: Mock<(...args: any[]) => any>;
+    promptOutputDirectory: Mock<(...args: any[]) => any>;
+    promptGenerateExample: Mock<(...args: any[]) => any>;
+    promptTableSelection: Mock<(...args: any[]) => any>;
+    confirmOverwrite: Mock<(...args: any[]) => any>;
+    promptRetry: Mock<(...args: any[]) => any>;
+    promptContinueWithoutDb: Mock<(...args: any[]) => any>;
+};
+/**
+ * Mock database detection utilities
+ */
+export declare function createMockDatabaseUtils(): {
+    validateConnection: Mock<(...args: any[]) => any>;
+    getTableCount: Mock<(...args: any[]) => any>;
+    getTables: Mock<(...args: any[]) => any>;
+};
+/**
+ * Mock file system utilities
+ */
+export declare function createMockFileUtils(): {
+    hasEnvFile: Mock<(...args: any[]) => any>;
+    hasGitignore: Mock<(...args: any[]) => any>;
+    findQueriesFile: Mock<(...args: any[]) => any>;
+    findSchemaFile: Mock<(...args: any[]) => any>;
+};
+/**
+ * Mock logger to capture output
+ */
+export declare function createMockLogger(): {
+    success: Mock<(...args: any[]) => any>;
+    error: Mock<(...args: any[]) => any>;
+    warn: Mock<(...args: any[]) => any>;
+    info: Mock<(...args: any[]) => any>;
+    reload: Mock<(...args: any[]) => any>;
+    header: Mock<(...args: any[]) => any>;
+    newline: Mock<(...args: any[]) => any>;
+    indent: Mock<(...args: any[]) => any>;
+    box: Mock<(...args: any[]) => any>;
+    table: Mock<(...args: any[]) => any>;
+    raw: Mock<(...args: any[]) => any>;
+};
+/**
+ * Mock ora spinner
+ */
+export declare function createMockSpinner(): Mock<() => {
+    start: Mock<(...args: any[]) => any>;
+    succeed: Mock<(...args: any[]) => any>;
+    fail: Mock<(...args: any[]) => any>;
+    stop: Mock<(...args: any[]) => any>;
+}>;
+/**
+ * Mock fs/promises for file operations
+ */
+export declare function createMockFs(): {
+    mkdir: Mock<(...args: any[]) => any>;
+    writeFile: Mock<(...args: any[]) => any>;
+    readFile: Mock<(...args: any[]) => any>;
+    access: Mock<(...args: any[]) => any>;
+};
+/**
+ * Capture console output
+ */
+export declare function captureConsole(): {
+    logs: string[];
+    errors: string[];
+    restore: () => void;
+};
+/**
+ * Mock process.exit to prevent tests from exiting
+ * Throws a special error to stop execution
+ */
+export declare class ProcessExitError extends Error {
+    code: number;
+    constructor(code: number);
+}
+export declare function mockProcessExit(): {
+    exitMock: Mock<(...args: any[]) => any>;
+    restore: () => void;
+};
+//# sourceMappingURL=test-utils.d.ts.map

package/dist/test-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"test-utils.d.ts","sourceRoot":"","sources":["../src/test-utils.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAEnC;;GAEG;AACH,wBAAgB,iBAAiB;;;;;;;;;EAWhC;AAED;;GAEG;AACH,wBAAgB,uBAAuB;;;;EAMtC;AAED;;GAEG;AACH,wBAAgB,mBAAmB;;;;;EAOlC;AAED;;GAEG;AACH,wBAAgB,gBAAgB;;;;;;;;;;;;EAc/B;AAED;;GAEG;AACH,wBAAgB,iBAAiB;;;;;GAQhC;AAED;;GAEG;AACH,wBAAgB,YAAY;;;;;EAO3B;AAED;;GAEG;AACH,wBAAgB,cAAc;;;;EAuB7B;AAED;;;GAGG;AACH,qBAAa,gBAAiB,SAAQ,KAAK;IACtB,IAAI,EAAE,MAAM;gBAAZ,IAAI,EAAE,MAAM;CAIhC;AAED,wBAAgB,eAAe;;;EAe9B"}

package/dist/test-utils.js

@@ -0,0 +1,153 @@
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+import { vi } from 'vitest';
+/**
+ * Mock prompts module for testing
+ */
+export function createMockPrompts() {
+    return {
+        promptDatabaseType: vi.fn(),
+        promptClickHouseConnection: vi.fn(),
+        promptOutputDirectory: vi.fn(),
+        promptGenerateExample: vi.fn(),
+        promptTableSelection: vi.fn(),
+        confirmOverwrite: vi.fn(),
+        promptRetry: vi.fn(),
+        promptContinueWithoutDb: vi.fn(),
+    };
+}
+/**
+ * Mock database detection utilities
+ */
+export function createMockDatabaseUtils() {
+    return {
+        validateConnection: vi.fn(),
+        getTableCount: vi.fn(),
+        getTables: vi.fn(),
+    };
+}
+/**
+ * Mock file system utilities
+ */
+export function createMockFileUtils() {
+    return {
+        hasEnvFile: vi.fn(),
+        hasGitignore: vi.fn(),
+        findQueriesFile: vi.fn(),
+        findSchemaFile: vi.fn(),
+    };
+}
+/**
+ * Mock logger to capture output
+ */
+export function createMockLogger() {
+    return {
+        success: vi.fn(),
+        error: vi.fn(),
+        warn: vi.fn(),
+        info: vi.fn(),
+        reload: vi.fn(),
+        header: vi.fn(),
+        newline: vi.fn(),
+        indent: vi.fn(),
+        box: vi.fn(),
+        table: vi.fn(),
+        raw: vi.fn(),
+    };
+}
+/**
+ * Mock ora spinner
+ */
+export function createMockSpinner() {
+    var spinner = {
+        start: vi.fn().mockReturnThis(),
+        succeed: vi.fn().mockReturnThis(),
+        fail: vi.fn().mockReturnThis(),
+        stop: vi.fn().mockReturnThis(),
+    };
+    return vi.fn(function () { return spinner; });
+}
+/**
+ * Mock fs/promises for file operations
+ */
+export function createMockFs() {
+    return {
+        mkdir: vi.fn().mockResolvedValue(undefined),
+        writeFile: vi.fn().mockResolvedValue(undefined),
+        readFile: vi.fn().mockResolvedValue(''),
+        access: vi.fn().mockResolvedValue(undefined),
+    };
+}
+/**
+ * Capture console output
+ */
+export function captureConsole() {
+    var logs = [];
+    var errors = [];
+    var originalLog = console.log;
+    var originalError = console.error;
+    console.log = vi.fn(function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        logs.push(args.join(' '));
+    });
+    console.error = vi.fn(function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        errors.push(args.join(' '));
+    });
+    return {
+        logs: logs,
+        errors: errors,
+        restore: function () {
+            console.log = originalLog;
+            console.error = originalError;
+        },
+    };
+}
+/**
+ * Mock process.exit to prevent tests from exiting
+ * Throws a special error to stop execution
+ */
+var ProcessExitError = /** @class */ (function (_super) {
+    __extends(ProcessExitError, _super);
+    function ProcessExitError(code) {
+        var _this = _super.call(this, "process.exit called with code ".concat(code)) || this;
+        _this.code = code;
+        _this.name = 'ProcessExitError';
+        return _this;
+    }
+    return ProcessExitError;
+}(Error));
+export { ProcessExitError };
+export function mockProcessExit() {
+    var originalExit = process.exit;
+    var exitMock = vi.fn(function (code) {
+        throw new ProcessExitError(code !== null && code !== void 0 ? code : 0);
+    });
+    // @ts-ignore
+    process.exit = exitMock;
+    return {
+        exitMock: exitMock,
+        restore: function () {
+            process.exit = originalExit;
+        },
+    };
+}

package/dist/utils/clickhouse-client.d.ts

@@ -0,0 +1,11 @@
+import { type ClickHouseClient } from '@clickhouse/client';
+export interface ClickHouseEnvConfig {
+    url: string;
+    username: string;
+    password: string;
+    database: string;
+}
+export declare function getClickHouseConfigFromEnv(): ClickHouseEnvConfig | null;
+export declare function getClickHouseClient(): ClickHouseClient;
+export declare function resetClickHouseClientForTesting(): Promise<void>;
+//# sourceMappingURL=clickhouse-client.d.ts.map