@hypequery/cli 0.0.1

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,CAmDT"}

package/dist/templates/queries.js

@@ -0,0 +1,21 @@
+/**
+ * Generate queries.ts file
+ */
+export function generateQueriesTemplate(options) {
+    var hasExample = options.hasExample, tableName = options.tableName;
+    var template = "import { initServe } 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\n/**\n * Inline usage example:\n *\n * const result = await api.execute('".concat(hasExample && tableName ? camelCase(tableName) + 'Query' : 'exampleMetric', "');\n * console.log(result);\n *\n * Dev server:\n *\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(); });
+}

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/detect-database.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Database type detection result
+ */
+export type DatabaseType = 'clickhouse' | 'bigquery' | 'unknown';
+/**
+ * Auto-detect database type from environment or config files
+ */
+export declare function detectDatabase(): Promise<DatabaseType>;
+/**
+ * Validate database connection
+ */
+export declare function validateConnection(dbType: DatabaseType): Promise<boolean>;
+/**
+ * Get table count from database
+ */
+export declare function getTableCount(dbType: DatabaseType): Promise<number>;
+/**
+ * Get list of tables from database
+ */
+export declare function getTables(dbType: DatabaseType): Promise<string[]>;
+//# sourceMappingURL=detect-database.d.ts.map

package/dist/utils/detect-database.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"detect-database.d.ts","sourceRoot":"","sources":["../../src/utils/detect-database.ts"],"names":[],"mappings":"AAIA;;GAEG;AACH,MAAM,MAAM,YAAY,GAAG,YAAY,GAAG,UAAU,GAAG,SAAS,CAAC;AAEjE;;GAEG;AACH,wBAAsB,cAAc,IAAI,OAAO,CAAC,YAAY,CAAC,CAyC5D;AAED;;GAEG;AACH,wBAAsB,kBAAkB,CAAC,MAAM,EAAE,YAAY,GAAG,OAAO,CAAC,OAAO,CAAC,CAS/E;AAwBD;;GAEG;AACH,wBAAsB,aAAa,CAAC,MAAM,EAAE,YAAY,GAAG,OAAO,CAAC,MAAM,CAAC,CAOzE;AA4BD;;GAEG;AACH,wBAAsB,SAAS,CAAC,MAAM,EAAE,YAAY,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAOvE"}

package/dist/utils/detect-database.js

@@ -0,0 +1,266 @@
+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 { access } from 'node:fs/promises';
+import path from 'node:path';
+/**
+ * Auto-detect database type from environment or config files
+ */
+export function detectDatabase() {
+    return __awaiter(this, void 0, void 0, function () {
+        var envPath, readFile, envContent, _a;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    // Check environment variables
+                    if (process.env.CLICKHOUSE_HOST ||
+                        process.env.CLICKHOUSE_URL ||
+                        process.env.CLICKHOUSE_DATABASE) {
+                        return [2 /*return*/, 'clickhouse'];
+                    }
+                    if (process.env.BIGQUERY_PROJECT_ID || process.env.GOOGLE_APPLICATION_CREDENTIALS) {
+                        return [2 /*return*/, 'bigquery'];
+                    }
+                    _b.label = 1;
+                case 1:
+                    _b.trys.push([1, 5, , 6]);
+                    envPath = path.join(process.cwd(), '.env');
+                    return [4 /*yield*/, access(envPath)];
+                case 2:
+                    _b.sent();
+                    return [4 /*yield*/, import('node:fs/promises')];
+                case 3:
+                    readFile = (_b.sent()).readFile;
+                    return [4 /*yield*/, readFile(envPath, 'utf-8')];
+                case 4:
+                    envContent = _b.sent();
+                    if (envContent.includes('CLICKHOUSE_') ||
+                        envContent.includes('CLICKHOUSE_HOST')) {
+                        return [2 /*return*/, 'clickhouse'];
+                    }
+                    if (envContent.includes('BIGQUERY_') ||
+                        envContent.includes('GOOGLE_APPLICATION_CREDENTIALS')) {
+                        return [2 /*return*/, 'bigquery'];
+                    }
+                    return [3 /*break*/, 6];
+                case 5:
+                    _a = _b.sent();
+                    return [3 /*break*/, 6];
+                case 6: return [2 /*return*/, 'unknown'];
+            }
+        });
+    });
+}
+/**
+ * Validate database connection
+ */
+export function validateConnection(dbType) {
+    return __awaiter(this, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            switch (dbType) {
+                case 'clickhouse':
+                    return [2 /*return*/, validateClickHouse()];
+                case 'bigquery':
+                    return [2 /*return*/, validateBigQuery()];
+                default:
+                    return [2 /*return*/, false];
+            }
+            return [2 /*return*/];
+        });
+    });
+}
+function validateClickHouse() {
+    return __awaiter(this, void 0, void 0, function () {
+        var client, result, error_1;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    _a.trys.push([0, 4, , 5]);
+                    return [4 /*yield*/, getClickHouseClient()];
+                case 1:
+                    client = _a.sent();
+                    return [4 /*yield*/, client.query({
+                            query: 'SELECT 1',
+                            format: 'JSONEachRow',
+                        })];
+                case 2:
+                    result = _a.sent();
+                    return [4 /*yield*/, result.json()];
+                case 3:
+                    _a.sent();
+                    return [2 /*return*/, true];
+                case 4:
+                    error_1 = _a.sent();
+                    return [2 /*return*/, false];
+                case 5: return [2 /*return*/];
+            }
+        });
+    });
+}
+function validateBigQuery() {
+    return __awaiter(this, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            // TODO: Implement when BigQuery support is added
+            return [2 /*return*/, false];
+        });
+    });
+}
+/**
+ * Get table count from database
+ */
+export function getTableCount(dbType) {
+    return __awaiter(this, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            switch (dbType) {
+                case 'clickhouse':
+                    return [2 /*return*/, getClickHouseTableCount()];
+                default:
+                    return [2 /*return*/, 0];
+            }
+            return [2 /*return*/];
+        });
+    });
+}
+/**
+ * Generic helper to execute ClickHouse queries with consistent error handling
+ */
+function executeClickHouseQuery(query, defaultValue) {
+    return __awaiter(this, void 0, void 0, function () {
+        var client, result, _a;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    _b.trys.push([0, 4, , 5]);
+                    return [4 /*yield*/, getClickHouseClient()];
+                case 1:
+                    client = _b.sent();
+                    return [4 /*yield*/, client.query({
+                            query: query,
+                            format: 'JSONEachRow',
+                        })];
+                case 2:
+                    result = _b.sent();
+                    return [4 /*yield*/, result.json()];
+                case 3: return [2 /*return*/, (_b.sent())];
+                case 4:
+                    _a = _b.sent();
+                    return [2 /*return*/, defaultValue];
+                case 5: return [2 /*return*/];
+            }
+        });
+    });
+}
+function getClickHouseTableCount() {
+    return __awaiter(this, void 0, void 0, function () {
+        var tables;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, executeClickHouseQuery('SHOW TABLES', [])];
+                case 1:
+                    tables = _a.sent();
+                    return [2 /*return*/, Array.isArray(tables) ? tables.length : 0];
+            }
+        });
+    });
+}
+/**
+ * Get list of tables from database
+ */
+export function getTables(dbType) {
+    return __awaiter(this, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            switch (dbType) {
+                case 'clickhouse':
+                    return [2 /*return*/, getClickHouseTables()];
+                default:
+                    return [2 /*return*/, []];
+            }
+            return [2 /*return*/];
+        });
+    });
+}
+function getClickHouseTables() {
+    return __awaiter(this, void 0, void 0, function () {
+        var tables;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, executeClickHouseQuery('SHOW TABLES', [])];
+                case 1:
+                    tables = _a.sent();
+                    return [2 /*return*/, tables.map(function (t) { return t.name; })];
+            }
+        });
+    });
+}
+function getClickHouseClient() {
+    return __awaiter(this, void 0, void 0, function () {
+        var ClickHouseConnection, config;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, import('@hypequery/clickhouse')];
+                case 1:
+                    ClickHouseConnection = (_a.sent()).ClickHouseConnection;
+                    try {
+                        return [2 /*return*/, ClickHouseConnection.getClient()];
+                    }
+                    catch (error) {
+                        if (error instanceof Error && error.message.includes('ClickHouse connection not initialized')) {
+                            config = getClickHouseEnvConfig();
+                            if (!config) {
+                                throw new Error('ClickHouse connection details are missing. Set CLICKHOUSE_HOST, CLICKHOUSE_DATABASE, CLICKHOUSE_USERNAME, and CLICKHOUSE_PASSWORD.');
+                            }
+                            ClickHouseConnection.initialize(config);
+                            return [2 /*return*/, ClickHouseConnection.getClient()];
+                        }
+                        throw error;
+                    }
+                    return [2 /*return*/];
+            }
+        });
+    });
+}
+function getClickHouseEnvConfig() {
+    var host = process.env.CLICKHOUSE_HOST || process.env.CLICKHOUSE_URL;
+    if (!host) {
+        return null;
+    }
+    return {
+        host: host,
+        database: process.env.CLICKHOUSE_DATABASE || 'default',
+        username: process.env.CLICKHOUSE_USERNAME || process.env.CLICKHOUSE_USER || 'default',
+        password: process.env.CLICKHOUSE_PASSWORD || process.env.CLICKHOUSE_PASS || '',
+    };
+}

package/dist/utils/error-messages.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Display error when queries file cannot be found
+ * @param commandName - Name of the command for the usage example
+ */
+export declare function displayQueriesFileNotFoundError(commandName: string): void;
+//# sourceMappingURL=error-messages.d.ts.map

package/dist/utils/error-messages.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"error-messages.d.ts","sourceRoot":"","sources":["../../src/utils/error-messages.ts"],"names":[],"mappings":"AAEA;;;GAGG;AACH,wBAAgB,+BAA+B,CAAC,WAAW,EAAE,MAAM,GAAG,IAAI,CAazE"}

package/dist/utils/error-messages.js

@@ -0,0 +1,19 @@
+import { logger } from './logger.js';
+/**
+ * Display error when queries file cannot be found
+ * @param commandName - Name of the command for the usage example
+ */
+export function displayQueriesFileNotFoundError(commandName) {
+    logger.error('Could not find queries file');
+    logger.newline();
+    logger.info('Expected one of:');
+    logger.indent('• analytics/queries.ts');
+    logger.indent('• src/analytics/queries.ts');
+    logger.indent('• hypequery.ts');
+    logger.newline();
+    logger.info("Did you run 'hypequery init'?");
+    logger.newline();
+    logger.info('Or specify the file explicitly:');
+    logger.indent("hypequery ".concat(commandName, " ./path/to/queries.ts"));
+    logger.newline();
+}

package/dist/utils/find-files.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Find the queries file in the project
+ */
+export declare function findQueriesFile(customPath?: string): Promise<string | null>;
+/**
+ * Find the schema file (generated types)
+ */
+export declare function findSchemaFile(): Promise<string | null>;
+/**
+ * Find the client file
+ */
+export declare function findClientFile(): Promise<string | null>;
+/**
+ * Check if .env file exists
+ */
+export declare function hasEnvFile(): Promise<boolean>;
+/**
+ * Check if .gitignore exists
+ */
+export declare function hasGitignore(): Promise<boolean>;
+//# sourceMappingURL=find-files.d.ts.map

package/dist/utils/find-files.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"find-files.d.ts","sourceRoot":"","sources":["../../src/utils/find-files.ts"],"names":[],"mappings":"AA+BA;;GAEG;AACH,wBAAsB,eAAe,CAAC,UAAU,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAcjF;AAED;;GAEG;AACH,wBAAsB,cAAc,IAAI,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAO7D;AAED;;GAEG;AACH,wBAAsB,cAAc,IAAI,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAO7D;AAED;;GAEG;AACH,wBAAsB,UAAU,IAAI,OAAO,CAAC,OAAO,CAAC,CAOnD;AAED;;GAEG;AACH,wBAAsB,YAAY,IAAI,OAAO,CAAC,OAAO,CAAC,CAOrD"}