npm - @bonnard/cli - Versions diffs - 0.1.1 → 0.1.2 - Mend

@bonnard/cli 0.1.1 → 0.1.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (3) hide show

package/dist/bin/bon.mjs +504 -0
package/dist/bin/validate-Bd1D39Bj.mjs +65 -0
package/package.json +6 -2

package/dist/bin/bon.mjs CHANGED Viewed

@@ -3,6 +3,10 @@ import { program } from "commander";
 import fs from "node:fs";
 import path from "node:path";
 import pc from "picocolors";
+import http from "node:http";
+import crypto from "node:crypto";
+import os from "node:os";
+import { encode } from "@toon-format/toon";
 //#region src/commands/init.ts
 const BON_YAML_TEMPLATE = (projectName) => `project:
@@ -31,10 +35,510 @@ async function initCommand() {
 	console.log(`  ${pc.dim(".gitignore")}      git ignore rules`);
 }
+//#endregion
+//#region src/lib/credentials.ts
+const CREDENTIALS_DIR = path.join(os.homedir(), ".config", "bon");
+const CREDENTIALS_FILE = path.join(CREDENTIALS_DIR, "credentials.json");
+function saveCredentials(credentials) {
+	fs.mkdirSync(CREDENTIALS_DIR, {
+		recursive: true,
+		mode: 448
+	});
+	fs.writeFileSync(CREDENTIALS_FILE, JSON.stringify(credentials, null, 2), { mode: 384 });
+}
+function loadCredentials() {
+	try {
+		const raw = fs.readFileSync(CREDENTIALS_FILE, "utf-8");
+		const parsed = JSON.parse(raw);
+		if (parsed.token && parsed.email) return parsed;
+		return null;
+	} catch {
+		return null;
+	}
+}
+function clearCredentials() {
+	try {
+		fs.unlinkSync(CREDENTIALS_FILE);
+	} catch {}
+}
+//#endregion
+//#region src/commands/login.ts
+const APP_URL$1 = process.env.BON_APP_URL || "http://localhost:3000";
+const TIMEOUT_MS = 120 * 1e3;
+async function loginCommand() {
+	const state = crypto.randomUUID();
+	const { port, close } = await startCallbackServer(state);
+	const url = `${APP_URL$1}/auth/device?state=${state}&port=${port}`;
+	console.log(pc.dim(`Opening browser to ${url}`));
+	const open = (await import("open")).default;
+	await open(url);
+	console.log("Waiting for authentication...");
+	const timeout = setTimeout(() => {
+		close();
+		console.log(pc.red("Login timed out. Please try again."));
+		process.exit(1);
+	}, TIMEOUT_MS);
+	const result = await waitForCallback;
+	clearTimeout(timeout);
+	close();
+	saveCredentials({
+		token: result.token,
+		email: result.email
+	});
+	console.log(pc.green(`Logged in as ${result.email}`));
+}
+let resolveCallback;
+const waitForCallback = new Promise((resolve, reject) => {
+	resolveCallback = resolve;
+});
+function startCallbackServer(expectedState) {
+	return new Promise((resolve, reject) => {
+		const server = http.createServer((req, res) => {
+			const url = new URL(req.url, `http://localhost`);
+			if (url.pathname !== "/callback") {
+				res.writeHead(404);
+				res.end("Not found");
+				return;
+			}
+			const token = url.searchParams.get("token");
+			const email = url.searchParams.get("email");
+			if (url.searchParams.get("state") !== expectedState) {
+				res.writeHead(400);
+				res.end("Invalid state parameter");
+				return;
+			}
+			if (!token || !email) {
+				res.writeHead(400);
+				res.end("Missing token or email");
+				return;
+			}
+			res.writeHead(200, { "Content-Type": "text/html" });
+			res.end(`<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="utf-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1" />
+  <title>Bonnard CLI</title>
+  <style>
+    * { margin: 0; padding: 0; box-sizing: border-box; }
+    body {
+      font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, Helvetica, Arial, sans-serif;
+      background: #0a0a0a;
+      color: #fafafa;
+      display: flex;
+      align-items: center;
+      justify-content: center;
+      min-height: 100vh;
+    }
+    .card {
+      text-align: center;
+      padding: 3rem;
+      max-width: 400px;
+    }
+    .check {
+      width: 48px;
+      height: 48px;
+      border-radius: 50%;
+      background: #22c55e;
+      display: inline-flex;
+      align-items: center;
+      justify-content: center;
+      margin-bottom: 1.5rem;
+    }
+    .check svg { width: 24px; height: 24px; }
+    h1 {
+      font-size: 1.25rem;
+      font-weight: 600;
+      margin-bottom: 0.5rem;
+    }
+    p {
+      color: #a1a1aa;
+      font-size: 0.875rem;
+      line-height: 1.5;
+    }
+  </style>
+</head>
+<body>
+  <div class="card">
+    <div class="check">
+      <svg fill="none" stroke="white" stroke-width="3" viewBox="0 0 24 24">
+        <path stroke-linecap="round" stroke-linejoin="round" d="M5 13l4 4L19 7" />
+      </svg>
+    </div>
+    <h1>Authentication successful</h1>
+    <p>You can close this tab and return to your terminal.</p>
+  </div>
+</body>
+</html>`);
+			resolveCallback({
+				token,
+				email
+			});
+		});
+		server.on("error", reject);
+		server.listen(0, "127.0.0.1", () => {
+			const addr = server.address();
+			if (!addr || typeof addr === "string") {
+				reject(/* @__PURE__ */ new Error("Failed to start callback server"));
+				return;
+			}
+			resolve({
+				port: addr.port,
+				close: () => server.close()
+			});
+		});
+	});
+}
+//#endregion
+//#region src/commands/logout.ts
+async function logoutCommand() {
+	clearCredentials();
+	console.log(pc.green("Logged out"));
+}
+//#endregion
+//#region src/lib/api.ts
+const APP_URL = process.env.BON_APP_URL || "http://localhost:3000";
+function getToken() {
+	const creds = loadCredentials();
+	if (!creds) {
+		console.error(pc.red("Not logged in. Run `bon login` first."));
+		process.exit(1);
+	}
+	return creds.token;
+}
+async function request(method, path, body) {
+	const token = getToken();
+	const url = `${APP_URL}${path}`;
+	const res = await fetch(url, {
+		method,
+		headers: {
+			Authorization: `Bearer ${token}`,
+			"Content-Type": "application/json"
+		},
+		body: body ? JSON.stringify(body) : void 0
+	});
+	const data = await res.json();
+	if (!res.ok) {
+		const message = data.error || res.statusText;
+		throw new Error(message);
+	}
+	return data;
+}
+function get(path) {
+	return request("GET", path);
+}
+function post(path, body) {
+	return request("POST", path, body);
+}
+function del(path) {
+	return request("DELETE", path);
+}
+//#endregion
+//#region src/commands/datasource/add.ts
+async function prompts() {
+	return import("@inquirer/prompts");
+}
+const WAREHOUSE_TYPES = [
+	{
+		value: "snowflake",
+		label: "Snowflake",
+		configFields: [
+			{
+				name: "account",
+				message: "Account identifier (e.g. xy12345.us-east-1)",
+				required: true
+			},
+			{
+				name: "database",
+				message: "Database name",
+				required: true
+			},
+			{
+				name: "schema",
+				message: "Schema name",
+				required: true
+			},
+			{
+				name: "warehouse",
+				message: "Warehouse name",
+				required: true
+			},
+			{
+				name: "role",
+				message: "Role (optional)"
+			}
+		],
+		credentialFields: [{
+			name: "username",
+			message: "Username"
+		}, {
+			name: "password",
+			message: "Password",
+			secret: true
+		}]
+	},
+	{
+		value: "postgres",
+		label: "Postgres",
+		configFields: [
+			{
+				name: "host",
+				message: "Host",
+				required: true
+			},
+			{
+				name: "port",
+				message: "Port (default: 5432)"
+			},
+			{
+				name: "database",
+				message: "Database name",
+				required: true
+			},
+			{
+				name: "schema",
+				message: "Schema (default: public)"
+			}
+		],
+		credentialFields: [{
+			name: "username",
+			message: "Username"
+		}, {
+			name: "password",
+			message: "Password",
+			secret: true
+		}]
+	},
+	{
+		value: "bigquery",
+		label: "BigQuery",
+		configFields: [
+			{
+				name: "project_id",
+				message: "GCP Project ID",
+				required: true
+			},
+			{
+				name: "dataset",
+				message: "Dataset name",
+				required: true
+			},
+			{
+				name: "location",
+				message: "Location (e.g. US, EU)"
+			}
+		],
+		credentialFields: [{
+			name: "service_account_json",
+			message: "Service account JSON (paste or path)"
+		}]
+	},
+	{
+		value: "databricks",
+		label: "Databricks",
+		configFields: [
+			{
+				name: "hostname",
+				message: "Server hostname",
+				required: true
+			},
+			{
+				name: "http_path",
+				message: "HTTP path",
+				required: true
+			},
+			{
+				name: "catalog",
+				message: "Catalog name"
+			}
+		],
+		credentialFields: [{
+			name: "token",
+			message: "Personal access token",
+			secret: true
+		}]
+	}
+];
+async function datasourceAddCommand() {
+	const { input, select, password } = await prompts();
+	let name;
+	while (true) {
+		name = await input({ message: "Name for this data source:" });
+		const { dataSources } = await get("/api/datasources");
+		if (dataSources.some((ds) => ds.name === name)) {
+			console.log(pc.red(`A data source named "${name}" already exists. Choose a different name.`));
+			continue;
+		}
+		break;
+	}
+	const warehouseType = await select({
+		message: "Warehouse type:",
+		choices: WAREHOUSE_TYPES.map((w) => ({
+			name: w.label,
+			value: w.value
+		}))
+	});
+	const wt = WAREHOUSE_TYPES.find((w) => w.value === warehouseType);
+	const config = {};
+	for (const field of wt.configFields) {
+		const value = await input({
+			message: field.message,
+			required: field.required
+		});
+		if (value) config[field.name] = value;
+	}
+	const credentials = {};
+	for (const field of wt.credentialFields) {
+		const value = field.secret ? await password({ message: field.message }) : await input({ message: field.message });
+		if (value) credentials[field.name] = value;
+	}
+	try {
+		const result = await post("/api/datasources", {
+			name,
+			warehouse_type: warehouseType,
+			config,
+			credentials
+		});
+		console.log(pc.green(`Data source "${result.dataSource.name}" created (${result.dataSource.id})`));
+	} catch (err) {
+		console.error(pc.red(`Failed to create data source: ${err.message}`));
+		process.exit(1);
+	}
+}
+//#endregion
+//#region src/commands/datasource/list.ts
+async function datasourceListCommand() {
+	try {
+		const result = await get("/api/datasources");
+		if (result.dataSources.length === 0) {
+			console.log(pc.dim("No data sources found. Run `bon datasource add` to create one."));
+			return;
+		}
+		console.log(pc.bold("Data Sources\n"));
+		for (const ds of result.dataSources) {
+			const statusColor = ds.status === "active" ? pc.green : ds.status === "error" ? pc.red : pc.yellow;
+			console.log(`  ${pc.bold(ds.name)}`);
+			console.log(`    ID:        ${pc.dim(ds.id)}`);
+			console.log(`    Type:      ${ds.warehouse_type}`);
+			console.log(`    Status:    ${statusColor(ds.status)}`);
+			console.log(`    Created:   ${new Date(ds.created_at).toLocaleDateString()}`);
+			console.log();
+		}
+	} catch (err) {
+		console.error(pc.red(`Failed to list data sources: ${err.message}`));
+		process.exit(1);
+	}
+}
+//#endregion
+//#region src/commands/datasource/test.ts
+async function datasourceTestCommand(name) {
+	try {
+		const result = await post("/api/datasources/test", { name });
+		if (result.success) {
+			console.log(pc.green(result.message));
+			if (result.details) {
+				if (result.details.warehouse) console.log(pc.dim(`  Warehouse: ${result.details.warehouse}`));
+				if (result.details.account) console.log(pc.dim(`  Account:   ${result.details.account}`));
+				if (result.details.latencyMs != null) console.log(pc.dim(`  Latency:   ${result.details.latencyMs}ms`));
+			}
+		} else console.log(pc.red(result.message));
+	} catch (err) {
+		console.error(pc.red(`Failed to test data source: ${err.message}`));
+		process.exit(1);
+	}
+}
+//#endregion
+//#region src/commands/datasource/remove.ts
+async function datasourceRemoveCommand(name) {
+	try {
+		await del(`/api/datasources/${encodeURIComponent(name)}`);
+		console.log(pc.green(`Data source "${name}" removed.`));
+	} catch (err) {
+		console.error(pc.red(`Failed to remove data source: ${err.message}`));
+		process.exit(1);
+	}
+}
+//#endregion
+//#region src/commands/query.ts
+async function queryCommand(datasourceName, sql, options) {
+	const limit = options.limit ? parseInt(options.limit, 10) : 1e3;
+	const format = options.format ?? "toon";
+	try {
+		const result = await post("/api/datasources/query", {
+			name: datasourceName,
+			sql,
+			options: {
+				schema: options.schema,
+				database: options.database,
+				limit
+			}
+		});
+		if (result.error) {
+			console.error(pc.red(result.error));
+			process.exit(1);
+		}
+		if (result.rowCount === 0) {
+			console.log("No rows returned.");
+			return;
+		}
+		if (format === "json") console.log(JSON.stringify(result, null, 2));
+		else {
+			const toon = encode({ results: result.rows });
+			console.log(toon);
+		}
+		if (result.truncated) console.log(pc.dim(`(truncated to ${result.rowCount} rows)`));
+	} catch (err) {
+		console.error(pc.red(`Query failed: ${err.message}`));
+		process.exit(1);
+	}
+}
+//#endregion
+//#region src/commands/validate.ts
+async function validateCommand() {
+	const cwd = process.cwd();
+	if (!fs.existsSync(path.join(cwd, "bon.yaml"))) {
+		console.log(pc.red("No bon.yaml found. Are you in a Bonnard project?"));
+		process.exit(1);
+	}
+	const { validate } = await import("./validate-Bd1D39Bj.mjs");
+	const result = await validate(cwd);
+	if (result.cubes.length === 0 && result.views.length === 0 && result.valid) {
+		console.log(pc.yellow("No model or view files found in models/ or views/."));
+		return;
+	}
+	if (!result.valid) {
+		console.log(pc.red("Validation failed:\n"));
+		for (const err of result.errors) console.log(pc.red(`  • ${err}`));
+		process.exit(1);
+	}
+	console.log(pc.green("Validation passed."));
+	console.log();
+	if (result.cubes.length > 0) console.log(`  ${pc.dim("Cubes")}  (${result.cubes.length}): ${result.cubes.join(", ")}`);
+	if (result.views.length > 0) console.log(`  ${pc.dim("Views")}  (${result.views.length}): ${result.views.join(", ")}`);
+}
 //#endregion
 //#region src/bin/bon.ts
 program.name("bon").description("Bonnard semantic layer CLI").version("0.1.0");
 program.command("init").description("Create a new Bonnard project in the current directory").action(initCommand);
+program.command("login").description("Authenticate with Bonnard via your browser").action(loginCommand);
+program.command("logout").description("Remove stored credentials").action(logoutCommand);
+const datasource = program.command("datasource").description("Manage warehouse data source connections");
+datasource.command("add").description("Add a new data source connection").action(datasourceAddCommand);
+datasource.command("list").description("List configured data sources").action(datasourceListCommand);
+datasource.command("test").description("Test data source connectivity").argument("<name>", "Data source name").action(datasourceTestCommand);
+datasource.command("remove").description("Remove a data source").argument("<name>", "Data source name").action(datasourceRemoveCommand);
+program.command("query").description("Run a SQL query against a warehouse").argument("<datasource-name>", "Data source name").argument("<sql>", "SQL query to execute").option("--schema <schema>", "Override schema").option("--database <database>", "Override database").option("--limit <limit>", "Max rows to return", "1000").option("--format <format>", "Output format: toon or json", "toon").action(queryCommand);
+program.command("validate").description("Validate Cube model and view YAML files").action(validateCommand);
 program.parse();
 //#endregion

package/dist/bin/validate-Bd1D39Bj.mjs ADDED Viewed

@@ -0,0 +1,65 @@
+import fs from "node:fs";
+import path from "node:path";
+import { compile } from "@cubejs-backend/schema-compiler";
+//#region src/lib/validate.ts
+function collectYamlFiles(dir, rootDir) {
+	if (!fs.existsSync(dir)) return [];
+	const results = [];
+	function walk(current) {
+		for (const entry of fs.readdirSync(current, { withFileTypes: true })) {
+			const fullPath = path.join(current, entry.name);
+			if (entry.isDirectory()) walk(fullPath);
+			else if (entry.name.endsWith(".yaml") || entry.name.endsWith(".yml")) results.push({
+				fileName: path.relative(rootDir, fullPath),
+				content: fs.readFileSync(fullPath, "utf-8")
+			});
+		}
+	}
+	walk(dir);
+	return results;
+}
+function createModelRepository(projectPath) {
+	const modelsDir = path.join(projectPath, "models");
+	const viewsDir = path.join(projectPath, "views");
+	return {
+		localPath: () => projectPath,
+		dataSchemaFiles: () => {
+			const files = [...collectYamlFiles(modelsDir, projectPath), ...collectYamlFiles(viewsDir, projectPath)];
+			return Promise.resolve(files);
+		}
+	};
+}
+async function validate(projectPath) {
+	const repo = createModelRepository(projectPath);
+	if ((await repo.dataSchemaFiles()).length === 0) return {
+		valid: true,
+		errors: [],
+		cubes: [],
+		views: []
+	};
+	try {
+		const { cubeEvaluator } = await compile(repo, {});
+		const cubes = [];
+		const views = [];
+		for (const cube of cubeEvaluator.cubeNames()) if (cubeEvaluator.cubeFromPath(cube).isView) views.push(cube);
+		else cubes.push(cube);
+		return {
+			valid: true,
+			errors: [],
+			cubes,
+			views
+		};
+	} catch (err) {
+		const raw = err.messages ?? err.message ?? String(err);
+		return {
+			valid: false,
+			errors: Array.isArray(raw) ? raw : [raw],
+			cubes: [],
+			views: []
+		};
+	}
+}
+//#endregion
+export { validate };

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "@bonnard/cli",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "type": "module",
   "bin": {
     "bon": "./dist/bin/bon.mjs"
@@ -14,11 +14,15 @@
     "test": "vitest run"
   },
   "dependencies": {
+    "@inquirer/prompts": "^7.0.0",
+    "@toon-format/toon": "^2.1.0",
     "commander": "^12.0.0",
+    "open": "^11.0.0",
+    "@cubejs-backend/schema-compiler": "^1.6.7",
+    "@cubejs-backend/shared": "^1.6.7",
     "picocolors": "^1.0.0"
   },
   "devDependencies": {
-    "@bonnard/core": "workspace:*",
     "tsdown": "^0.20.1",
     "vitest": "^2.0.0"
   },