@bonnard/cli 0.2.0 → 0.2.2

package/dist/bin/validate-DEh1XQnH.mjs

@@ -0,0 +1,365 @@
+import { t as getProjectPaths } from "./bon.mjs";
+import fs from "node:fs";
+import path from "node:path";
+import YAML from "yaml";
+import { z } from "zod";
+
+//#region src/lib/schema.ts
+const identifier = z.string().regex(/^[_a-zA-Z][_a-zA-Z0-9]*$/, "must be a valid identifier (letters, numbers, underscores; cannot start with a number)");
+const refreshKeySchema = z.object({
+	every: z.string().regex(/^\d+\s+(second|minute|hour|day|week)s?$/, { message: "must be a time interval like \"1 hour\", \"30 minute\", \"1 day\"" }).optional(),
+	sql: z.string().optional()
+});
+const measureTypes = [
+	"count",
+	"count_distinct",
+	"count_distinct_approx",
+	"sum",
+	"avg",
+	"min",
+	"max",
+	"number",
+	"string",
+	"time",
+	"boolean",
+	"running_total",
+	"number_agg"
+];
+const dimensionTypes = [
+	"string",
+	"number",
+	"boolean",
+	"time",
+	"geo",
+	"switch"
+];
+const relationshipTypes = [
+	"many_to_one",
+	"one_to_many",
+	"one_to_one"
+];
+const granularities = [
+	"second",
+	"minute",
+	"hour",
+	"day",
+	"week",
+	"month",
+	"quarter",
+	"year"
+];
+const preAggTypes = [
+	"rollup",
+	"original_sql",
+	"rollup_join",
+	"rollup_lambda"
+];
+const formats = [
+	"percent",
+	"currency",
+	"number",
+	"imageUrl",
+	"link",
+	"id"
+];
+const measureSchema = z.object({
+	name: identifier,
+	type: z.enum(measureTypes),
+	sql: z.string().optional(),
+	description: z.string().optional(),
+	title: z.string().optional(),
+	format: z.enum(formats).optional(),
+	public: z.boolean().optional(),
+	filters: z.array(z.object({ sql: z.string() })).optional(),
+	rolling_window: z.object({
+		trailing: z.string().optional(),
+		leading: z.string().optional(),
+		offset: z.string().optional()
+	}).optional(),
+	drill_members: z.array(z.string()).optional(),
+	meta: z.record(z.string(), z.unknown()).optional()
+});
+const dimensionFormatSchema = z.union([z.enum(formats), z.string().startsWith("%")]);
+const dimensionSchema = z.object({
+	name: identifier,
+	type: z.enum(dimensionTypes),
+	sql: z.string().optional(),
+	primary_key: z.boolean().optional(),
+	sub_query: z.boolean().optional(),
+	propagate_filters_to_sub_query: z.boolean().optional(),
+	description: z.string().optional(),
+	title: z.string().optional(),
+	format: dimensionFormatSchema.optional(),
+	public: z.boolean().optional(),
+	meta: z.record(z.string(), z.unknown()).optional(),
+	latitude: z.object({ sql: z.string() }).optional(),
+	longitude: z.object({ sql: z.string() }).optional(),
+	case: z.object({
+		when: z.array(z.object({
+			sql: z.string(),
+			label: z.string()
+		})),
+		else: z.object({ label: z.string() }).optional()
+	}).optional()
+});
+const joinSchema = z.object({
+	name: identifier,
+	relationship: z.enum(relationshipTypes),
+	sql: z.string()
+});
+const segmentSchema = z.object({
+	name: identifier,
+	sql: z.string(),
+	description: z.string().optional(),
+	title: z.string().optional(),
+	public: z.boolean().optional()
+});
+const preAggregationSchema = z.object({
+	name: identifier,
+	type: z.enum(preAggTypes).optional(),
+	measures: z.array(z.string()).optional(),
+	dimensions: z.array(z.string()).optional(),
+	time_dimension: z.string().optional(),
+	granularity: z.enum(granularities).optional(),
+	partition_granularity: z.enum(granularities).optional(),
+	refresh_key: refreshKeySchema.optional(),
+	scheduled_refresh: z.boolean().optional()
+});
+const hierarchySchema = z.object({
+	name: identifier,
+	levels: z.array(z.string()),
+	title: z.string().optional(),
+	public: z.boolean().optional()
+});
+const cubeSchema = z.object({
+	name: identifier,
+	sql: z.string().optional(),
+	sql_table: z.string().optional(),
+	data_source: z.string().optional(),
+	extends: z.string().optional(),
+	description: z.string().optional(),
+	title: z.string().optional(),
+	public: z.boolean().optional(),
+	refresh_key: refreshKeySchema.optional(),
+	measures: z.array(measureSchema).optional(),
+	dimensions: z.array(dimensionSchema).optional(),
+	joins: z.array(joinSchema).optional(),
+	segments: z.array(segmentSchema).optional(),
+	pre_aggregations: z.array(preAggregationSchema).optional(),
+	hierarchies: z.array(hierarchySchema).optional()
+}).refine((data) => data.sql != null || data.sql_table != null || data.extends != null, { message: "sql, sql_table, or extends is required" });
+const viewIncludeItemSchema = z.union([z.string(), z.object({
+	name: z.string(),
+	alias: z.string().optional(),
+	title: z.string().optional(),
+	description: z.string().optional(),
+	format: z.string().optional(),
+	meta: z.record(z.string(), z.unknown()).optional()
+})]);
+const viewCubeRefSchema = z.object({
+	join_path: z.string(),
+	includes: z.union([z.literal("*"), z.array(viewIncludeItemSchema)]).optional(),
+	excludes: z.array(z.string()).optional(),
+	prefix: z.boolean().optional()
+});
+const folderSchema = z.lazy(() => z.object({
+	name: z.string(),
+	members: z.array(z.string()).optional(),
+	folders: z.array(folderSchema).optional()
+}));
+const viewMeasureSchema = z.object({
+	name: identifier,
+	sql: z.string(),
+	type: z.string(),
+	format: z.string().optional(),
+	description: z.string().optional(),
+	meta: z.record(z.string(), z.unknown()).optional()
+});
+const viewDimensionSchema = z.object({
+	name: identifier,
+	sql: z.string(),
+	type: z.string(),
+	description: z.string().optional(),
+	meta: z.record(z.string(), z.unknown()).optional()
+});
+const viewSegmentSchema = z.object({
+	name: identifier,
+	sql: z.string(),
+	description: z.string().optional()
+});
+const viewSchema = z.object({
+	name: identifier,
+	description: z.string().optional(),
+	title: z.string().optional(),
+	public: z.boolean().optional(),
+	cubes: z.array(viewCubeRefSchema).optional(),
+	measures: z.array(viewMeasureSchema).optional(),
+	dimensions: z.array(viewDimensionSchema).optional(),
+	segments: z.array(viewSegmentSchema).optional(),
+	folders: z.array(folderSchema).optional()
+});
+const fileSchema = z.object({
+	cubes: z.array(cubeSchema).optional(),
+	views: z.array(viewSchema).optional()
+}).refine((data) => data.cubes && data.cubes.length > 0 || data.views && data.views.length > 0, "File must contain at least one cube or view");
+function formatZodError(error, fileName, parsed) {
+	return error.issues.map((issue) => {
+		const pathParts = issue.path;
+		let entityContext = "";
+		if (pathParts.length >= 2) {
+			const collection = pathParts[0];
+			const index = pathParts[1];
+			const entity = parsed?.[collection]?.[index];
+			if (entity?.name) entityContext = ` (${entity.name})`;
+		}
+		const pathStr = pathParts.join(".");
+		const location = pathStr ? `${pathStr}${entityContext}` : "";
+		if (issue.code === "invalid_value" && "values" in issue) return `${fileName}: ${location} — invalid value, expected one of: ${issue.values.join(", ")}`;
+		return `${fileName}: ${location ? `${location} — ` : ""}${issue.message}`;
+	});
+}
+function validateFiles(files) {
+	const errors = [];
+	const cubes = [];
+	const views = [];
+	const allNames = /* @__PURE__ */ new Map();
+	for (const file of files) {
+		let parsed;
+		try {
+			parsed = YAML.parse(file.content);
+		} catch (err) {
+			errors.push(`${file.fileName}: YAML parse error — ${err.message}`);
+			continue;
+		}
+		if (!parsed || typeof parsed !== "object") {
+			errors.push(`${file.fileName}: file is empty or not a YAML object`);
+			continue;
+		}
+		const result = fileSchema.safeParse(parsed);
+		if (!result.success) {
+			errors.push(...formatZodError(result.error, file.fileName, parsed));
+			continue;
+		}
+		for (const cube of parsed.cubes ?? []) if (cube.name) {
+			const existing = allNames.get(cube.name);
+			if (existing) errors.push(`${file.fileName}: duplicate name '${cube.name}' (also defined in ${existing})`);
+			else {
+				allNames.set(cube.name, file.fileName);
+				cubes.push(cube.name);
+			}
+		}
+		for (const view of parsed.views ?? []) if (view.name) {
+			const existing = allNames.get(view.name);
+			if (existing) errors.push(`${file.fileName}: duplicate name '${view.name}' (also defined in ${existing})`);
+			else {
+				allNames.set(view.name, file.fileName);
+				views.push(view.name);
+			}
+		}
+	}
+	return {
+		errors,
+		cubes,
+		views
+	};
+}
+
+//#endregion
+//#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 checkMissingDescriptions(files) {
+	const missing = [];
+	for (const file of files) try {
+		const parsed = YAML.parse(file.content);
+		if (!parsed) continue;
+		const cubes = parsed.cubes || [];
+		for (const cube of cubes) {
+			if (!cube.name) continue;
+			if (!cube.description) missing.push({
+				parent: cube.name,
+				type: "cube",
+				name: cube.name
+			});
+			const measures = cube.measures || [];
+			for (const measure of measures) if (measure.name && !measure.description) missing.push({
+				parent: cube.name,
+				type: "measure",
+				name: measure.name
+			});
+			const dimensions = cube.dimensions || [];
+			for (const dimension of dimensions) if (dimension.name && !dimension.description) missing.push({
+				parent: cube.name,
+				type: "dimension",
+				name: dimension.name
+			});
+		}
+		const views = parsed.views || [];
+		for (const view of views) {
+			if (!view.name) continue;
+			if (!view.description) missing.push({
+				parent: view.name,
+				type: "view",
+				name: view.name
+			});
+		}
+	} catch {}
+	return missing;
+}
+function checkMissingDataSource(files) {
+	const missing = [];
+	for (const file of files) try {
+		const parsed = YAML.parse(file.content);
+		if (!parsed) continue;
+		for (const cube of parsed.cubes || []) if (cube.name && !cube.data_source) missing.push(cube.name);
+	} catch {}
+	return missing;
+}
+async function validate(projectPath) {
+	const paths = getProjectPaths(projectPath);
+	const files = [...collectYamlFiles(paths.cubes, projectPath), ...collectYamlFiles(paths.views, projectPath)];
+	if (files.length === 0) return {
+		valid: true,
+		errors: [],
+		cubes: [],
+		views: [],
+		missingDescriptions: [],
+		cubesMissingDataSource: []
+	};
+	const result = validateFiles(files);
+	if (result.errors.length > 0) return {
+		valid: false,
+		errors: result.errors,
+		cubes: [],
+		views: [],
+		missingDescriptions: [],
+		cubesMissingDataSource: []
+	};
+	const missingDescriptions = checkMissingDescriptions(files);
+	const cubesMissingDataSource = checkMissingDataSource(files);
+	return {
+		valid: true,
+		errors: [],
+		cubes: result.cubes,
+		views: result.views,
+		missingDescriptions,
+		cubesMissingDataSource
+	};
+}
+
+//#endregion
+export { validate };

package/dist/docs/topics/cubes.measures.format.md

@@ -27,6 +27,12 @@ measures:
 
 ## Supported Formats
 
+| Format | Description |
+|--------|-------------|
+| `percent` | Percentage display (0.75 → 75%) |
+| `currency` | Monetary display ($1,234.56) |
+| `number` | Plain number with standard formatting |
+
 ### percent
 
 Displays value as a percentage:
@@ -53,6 +59,19 @@ Displays value as monetary amount:
 
 Output: `$1,234.56` (formatting depends on BI tool locale)
 
+### number
+
+Standard number formatting with grouping separators:
+
+```yaml
+- name: total_slots
+  type: sum
+  sql: slot_count
+  format: number
+```
+
+Output: `1,234` instead of raw `1234`. Use this when the measure represents a count or quantity that benefits from thousand separators.
+
 ## Usage Notes
 
 ### Format vs Calculation

package/dist/docs/topics/features.cli.md

@@ -20,10 +20,9 @@ Your agent understands Bonnard's modeling language from the first prompt.
 bon init                          # Scaffold project + agent context
 bon datasource add --demo         # Add a demo warehouse instantly
 bon datasource add --from-dbt     # Import connections from dbt
-bon validate --test-connection    # Check YAML syntax + warehouse connectivity
+bon validate                      # Check YAML syntax
 bon deploy -m "description"       # Ship to production (message required)
 bon query '{"measures":["orders.count"]}'  # Test your semantic layer
-bon preview <ds> "SELECT ..."     # Run raw SQL against a warehouse
 bon deployments                   # List deployment history
 bon diff <id>                     # View changes in a deployment
 bon annotate <id> --data '{...}'  # Add context to deployment changes

package/dist/docs/topics/workflow.md

@@ -81,9 +81,8 @@ views:
 
 Check for syntax errors and test connections:
 
-```yaml
+```bash
 bon validate
-bon validate --test-connection
 ```
 
 ### 4. Deploy
@@ -147,10 +146,8 @@ bonnard/cubes/
 | `bon datasource add --demo` | Add demo dataset (no warehouse needed) |
 | `bon datasource add --from-dbt` | Import from dbt profiles |
 | `bon datasource list` | List configured sources |
-| `bon datasource test <name>` | Test connection |
-| `bon preview <ds> "SQL"` | Run raw SQL against a warehouse |
+| `bon datasource test <name>` | Test connection (requires login) |
 | `bon validate` | Check cube and view syntax |
-| `bon validate --test-connection` | Validate + test warehouse connections |
 | `bon deploy -m "message"` | Deploy to Bonnard (message required) |
 | `bon deploy --ci` | Non-interactive deploy |
 | `bon deployments` | List deployment history |

package/dist/docs/topics/workflow.validate.md

@@ -4,16 +4,12 @@
 
 ## Overview
 
-The `bon validate` command checks your YAML cubes and views for syntax errors, schema violations, and optionally tests data source connections. Run this before deploying to catch issues early.
+The `bon validate` command checks your YAML cubes and views for syntax errors and schema violations. Run this before deploying to catch issues early.
 
 ## Usage
 
 ```bash
-# Basic validation
 bon validate
-
-# Also test data source connections
-bon validate --test-connection
 ```
 
 ## What Gets Validated
@@ -36,12 +32,6 @@ bon validate --test-connection
 - Referenced members exist
 - Join relationships are valid
 
-### Connection Testing (--test-connection)
-
-- Data source credentials work
-- Database is accessible
-- Tables/schemas exist
-
 ## Example Output
 
 ### Success
@@ -73,17 +63,6 @@ bonnard/cubes/orders.yaml:15:5
 1 error found.
 ```
 
-### Connection Warnings
-
-```
-✓ Validating YAML syntax...
-✓ All cubes and views valid.
-
-⚠ Testing connections...
-  ⚠ datasource "analytics": Connection timed out
-    (This won't block deploy, but queries may fail)
-```
-
 ## Common Errors
 
 ### Missing Required Field
@@ -125,12 +104,6 @@ measures:
   type: count
 ```
 
-## Options
-
-| Option | Description |
-|--------|-------------|
-| `--test-connection` | Also test datasource connections |
-
 ## Exit Codes
 
 | Code | Meaning |
@@ -143,7 +116,7 @@ measures:
 1. **Run before every deploy** — `bon validate && bon deploy`
 2. **Add to CI/CD** — validate on pull requests
 3. **Fix errors first** — don't deploy with validation errors
-4. **Test connections periodically** — catch credential issues early
+4. **Test connections** — use `bon datasource test <name>` to check connectivity
 
 ## See Also
 

package/dist/templates/claude/skills/bonnard-get-started/SKILL.md

@@ -41,25 +41,12 @@ If the test fails, common issues:
 
 ## Phase 2: Explore the Data
 
-Use `bon preview` to understand what tables and columns are available.
-**Always run this before creating cubes** — use the results to decide which
-tables to model and what columns to expose.
+Before creating cubes, understand what tables and columns are available in your warehouse.
 
-```bash
-# List tables — use the schema from the datasource config
-# For demo data (contoso schema):
-bon preview contoso_demo "SELECT table_name FROM information_schema.tables WHERE table_schema = 'contoso'"
-
-# For user's own data (typically public schema):
-bon preview <datasource> "SELECT table_name FROM information_schema.tables WHERE table_schema = 'public'"
-
-# Snowflake:
-bon preview <datasource> "SHOW TABLES"
-
-# Then sample the key tables to see columns and data:
-bon preview contoso_demo "SELECT * FROM contoso.fact_sales" --limit 10
-bon preview contoso_demo "SELECT * FROM contoso.dim_product" --limit 10
-```
+**Options for exploring your data:**
+- Use your database IDE or CLI (e.g., `psql`, Snowflake web UI, BigQuery console) to browse tables
+- Check your dbt docs or existing documentation for table schemas
+- For the demo dataset, the tables are: `contoso.fact_sales`, `contoso.dim_product`, `contoso.dim_store`, `contoso.dim_customer`
 
 Note the table names, column names, and data types — you'll use these in Phase 3.
 
@@ -161,12 +148,6 @@ Validate also warns about:
 - **Missing descriptions** — descriptions help AI agents and analysts discover metrics
 - **Missing `data_source`** — cubes without an explicit `data_source` use the default warehouse, which can cause issues when multiple warehouses are configured
 
-Optionally test the datasource connection too:
-
-```bash
-bon validate --test-connection
-```
-
 ## Phase 6: Deploy
 
 Log in (if not already) and deploy: