@bluemarble/bi 0.0.0-stage → 0.1.2

package/dist/server/index.js

@@ -0,0 +1,744 @@
+import { C as validateModel, D as parseColumnRef, E as modelEdges, O as reachFrom, S as modelMeta, T as measureHome, _ as AGGREGATIONS, b as aggregateSql, d as layoutModelWarnings, f as validateLayout, g as toModelCode, h as modelObjectCode, k as referencedTables, m as modelImports, p as canonicalJson, u as layoutFileContent, w as joinPlan, x as isAggregate } from "../layout-iPByu6V0.js";
+import { n as diffRows, t as describeDiffs } from "../compare-DloZhg1T.js";
+//#region src/server/compile.ts
+var DashboardQueryError = class extends Error {};
+const MAX_FILTER_VALUES = 1e3;
+const quote = (identifier) => `\`${identifier}\``;
+/**
+* Expressão de uma medida. `leaf` diz como sai cada agregação (`sum`, `count`, `avg`...): a coluna
+* já agregada pela tabela de origem.
+*/
+function measureSql(model, name, leaf, stack = []) {
+	if (stack.includes(name)) throw new DashboardQueryError(`Medida circular: ${[...stack, name].join(" -> ")}`);
+	const measure = model.measures[name];
+	if (!measure) throw new DashboardQueryError(`Medida desconhecida: "${name}"`);
+	if (isAggregate(measure)) return leaf(name, measure);
+	const next = [...stack, name];
+	const ref = (other) => measureSql(model, other, leaf, next);
+	if (measure.type === "ratio") return `(${ref(measure.numerator)}) / NULLIF(${ref(measure.denominator)}, 0)`;
+	return `(${measure.expression.replace(/\{([A-Za-z_][A-Za-z0-9_]*)\}/g, (_, other) => `(${ref(other)})`)})`;
+}
+/** Agregações de que as medidas pedidas dependem (razões e fórmulas abertas). */
+function leafMeasures(model, names) {
+	const leaves = /* @__PURE__ */ new Set();
+	for (const name of names) measureSql(model, name, (leaf, measure) => {
+		leaves.add(leaf);
+		return measure.sql;
+	});
+	return [...leaves];
+}
+function compileFilters(model, query) {
+	const filters = [];
+	for (const [name, values] of Object.entries(query.filters ?? {})) {
+		const dimension = model.dimensions[name];
+		if (!dimension) throw new DashboardQueryError(`Filtro em dimensão desconhecida: "${name}"`);
+		if (!Array.isArray(values) || !values.length) continue;
+		if (values.length > MAX_FILTER_VALUES) throw new DashboardQueryError(`Valores demais no filtro "${name}"`);
+		for (const value of values) if (!(dimension.type === "number" ? Number.isFinite(value) : typeof value === "string")) throw new DashboardQueryError(`Valor inválido no filtro "${name}": ${value}`);
+		filters.push({
+			dimension: name,
+			clause: `${dimension.sql} IN (${values.map(() => "?").join(", ")})`,
+			params: values
+		});
+	}
+	return filters;
+}
+/**
+* Transforma uma consulta (dimensões + medidas + filtros) em SQL parametrizado (ver `compileStar`).
+*
+* Nomes de dimensões/medidas só são aceitos se existirem no modelo; valores de filtro vão sempre
+* como parâmetro — nada vindo da request é concatenado no SQL.
+*/
+function compileQuery(model, query, options = {}) {
+	const dimensions = query.dimensions ?? [];
+	const measures = query.measures ?? [];
+	if (!dimensions.length && !measures.length) throw new DashboardQueryError("Informe ao menos uma dimensão ou medida");
+	for (const name of dimensions) if (!model.dimensions[name]) throw new DashboardQueryError(`Dimensão desconhecida: "${name}"`);
+	return compileStar(model, dimensions, measures, compileFilters(model, query), options);
+}
+const range = (count) => Array.from({ length: count }, (_, index) => index + 1).join(", ");
+/**
+* Cada tabela de origem (a das medidas pedidas) vira uma agregação no próprio
+* grão, com LEFT JOIN só nas tabelas que levam às dimensões e filtros usados:
+*
+*   SELECT <dimensões>, SUM(<medida>) FROM fPesagem
+*   LEFT JOIN dOperacao ON dOperacao.id = fPesagem.navio_operacao_id
+*   WHERE <filtros> GROUP BY <dimensões>
+*
+* Com medidas de mais de uma fato, cada uma agrega separada e o resultado é somado por dimensão
+* (`UNION ALL` + `GROUP BY`) — juntar duas fatos antes de somar multiplicaria os valores. Razões e
+* fórmulas são calculadas no fim, sobre os totais.
+*
+* Filtro numa dimensão que a fato não alcança é ignorado por ela (como no Power BI, a medida não é
+* filtrada); agrupar por uma dimensão que ela não alcança é erro.
+*/
+function compileStar(model, dimensions, measures, filters, { sampleLimit }) {
+	const { tables } = model;
+	const tableNames = Object.keys(tables);
+	const edges = modelEdges(model);
+	const tableOf = (sql) => referencedTables(sql, tableNames);
+	const dimensionTable = (name) => tableOf(model.dimensions[name].sql)[0];
+	const groups = /* @__PURE__ */ new Map();
+	const leafOf = (name) => model.measures[name];
+	for (const leaf of leafMeasures(model, measures)) {
+		const measure = model.measures[leaf];
+		if (!isAggregate(measure)) continue;
+		const home = measureHome(tableOf(measure.sql), edges);
+		if (!home) throw new DashboardQueryError(`Medida "${leaf}" sem tabela de origem`);
+		groups.set(home, [...groups.get(home) ?? [], leaf]);
+	}
+	if (!groups.size) groups.set(dimensionHome(model, dimensions, filters, edges), []);
+	const source = (name) => {
+		const sql = tables[name].sql;
+		return sampleLimit === void 0 ? `(${sql})` : `(SELECT * FROM (${sql}) t LIMIT ${Math.max(0, Math.trunc(sampleLimit))})`;
+	};
+	const aggregate = (home, leaves) => {
+		const { paths } = reachFrom(home, edges);
+		for (const name of dimensions) if (!paths.has(dimensionTable(name))) throw new DashboardQueryError(leaves.length ? `A dimensão "${name}" (${dimensionTable(name)}) não se relaciona com ${home}, de onde vêm ${leaves.join(", ")}` : `As dimensões ${dimensions.join(", ")} não se relacionam entre si`);
+		const applied = filters.filter((filter) => paths.has(dimensionTable(filter.dimension)));
+		const needed = /* @__PURE__ */ new Set([
+			...dimensions.map(dimensionTable),
+			...applied.map((filter) => dimensionTable(filter.dimension)),
+			...leaves.flatMap((leaf) => tableOf(leafOf(leaf).sql))
+		]);
+		const joins = joinPlan(home, needed, edges).map(({ table, edge }) => `${edge.inner ? "JOIN" : "LEFT JOIN"} ${source(table)} ${quote(table)}\n  ON ${quote(table)}.${quote(edge.to.column)} = ${quote(edge.from.table)}.${quote(edge.from.column)}`);
+		return {
+			home,
+			sql: [
+				`SELECT ${[...dimensions.map((name) => `${model.dimensions[name].sql} AS ${quote(name)}`), ...leaves.map((leaf) => `${aggregateSql(leafOf(leaf))} AS ${quote(leaf)}`)].join(",\n  ")}`,
+				`FROM ${source(home)} ${quote(home)}`,
+				...joins,
+				applied.length ? `WHERE ${applied.map((filter) => filter.clause).join(" AND ")}` : "",
+				dimensions.length ? `GROUP BY ${range(dimensions.length)}` : ""
+			].filter(Boolean).join("\n"),
+			params: applied.flatMap((filter) => filter.params)
+		};
+	};
+	const aggregates = [...groups].map(([home, leaves]) => aggregate(home, leaves));
+	const parts = aggregates.map(({ home, sql, params }) => ({
+		name: `fato:${home}`,
+		sql: `SELECT COUNT(*) AS n FROM (${sql}) g`,
+		params
+	}));
+	const orderBy = dimensions.length ? `\nORDER BY ${range(dimensions.length)}` : "";
+	if (aggregates.length === 1) {
+		const [only] = aggregates;
+		if (!measures.length || measures.every((name) => isAggregate(model.measures[name]))) return {
+			sql: `${only.sql}${orderBy}`,
+			params: only.params,
+			parts
+		};
+	}
+	const columns = [...dimensions, ...[...groups.values()].flat()];
+	const union = aggregates.map(({ home }, index) => {
+		const own = new Set(groups.get(home));
+		return `SELECT ${columns.map((column) => dimensions.includes(column) || own.has(column) ? quote(column) : `NULL AS ${quote(column)}`).join(", ")} FROM ${quote(`__fato${index}`)}`;
+	}).join("\n  UNION ALL ");
+	const leaf = (name) => `SUM(${quote("__u")}.${quote(name)})`;
+	const select = [...dimensions.map((name) => `${quote("__u")}.${quote(name)} AS ${quote(name)}`), ...measures.map((name) => `${measureSql(model, name, leaf)} AS ${quote(name)}`)];
+	return {
+		sql: [
+			`WITH ${aggregates.map(({ sql }, index) => `${quote(`__fato${index}`)} AS (\n${sql}\n)`).join(",\n")}`,
+			`SELECT ${select.join(",\n  ")}`,
+			`FROM (\n  ${union}\n) ${quote("__u")}`,
+			dimensions.length ? `GROUP BY ${range(dimensions.length)}${orderBy}` : ""
+		].filter(Boolean).join("\n"),
+		params: aggregates.flatMap((item) => item.params),
+		parts
+	};
+}
+/**
+* Consulta só de dimensões (ex.: opções de um filtro): parte da tabela que alcança todas as
+* dimensões pedidas e o maior número de filtros ativos — com "Mês = Janeiro", a lista de navios sai
+* da fato que liga navio e calendário, e só mostra quem tem lançamento em janeiro. Sem filtro, a
+* própria tabela da dimensão (lista tudo, mesmo sem lançamento).
+*/
+function dimensionHome(model, dimensions, filters, edges) {
+	const tableNames = Object.keys(model.tables);
+	const tableOf = (name) => referencedTables(model.dimensions[name].sql, tableNames)[0];
+	const own = tableOf(dimensions[0]);
+	const targets = dimensions.map(tableOf);
+	const filterTables = filters.map((filter) => tableOf(filter.dimension));
+	let best = null;
+	for (const table of [own, ...tableNames.filter((name) => name !== own)]) {
+		const { paths } = reachFrom(table, edges);
+		if (!targets.every((target) => paths.has(target))) continue;
+		const score = filterTables.filter((target) => paths.has(target)).length;
+		if (!best || score > best.score) best = {
+			table,
+			score
+		};
+	}
+	return best?.table ?? own;
+}
+//#endregion
+//#region src/server/defineModel.ts
+/**
+* Modelo semântico de um dashboard: o equivalente ao modelo do Power BI (tabelas, relacionamentos e
+* medidas DAX), só que versionado em código.
+*
+* - `tables`: tabelas fato (lançamentos, lado N) e dimensão (cadastros, lado 1). O SQL é a consulta
+*   de origem — tabela, view ou SELECT, sem agregar.
+* - `relationships`: N:1 (`from: 'fato.coluna'`, `to: 'dimensao.coluna'`); o filtro vai do lado 1
+*   para o lado N. Cada medida agrega no grão da própria tabela, então juntar fatos não duplica
+*   valores (o problema de "fan-out").
+* - `dimensions`: por onde se agrupa e filtra, citando `tabela.coluna` de uma tabela.
+* - `measures`: agregações (`sum`, `count`, `countDistinct`, `avg`, `min`, `max`) sobre
+*   `tabela.coluna`, razões entre medidas (`ratio`) ou fórmulas (`formula`).
+*
+* Dialeto: MySQL/MariaDB.
+*/
+const sum = (sql, meta) => ({
+	...meta,
+	type: "sum",
+	sql
+});
+const aggregate = (type) => (sql, meta) => ({
+	...meta,
+	type,
+	sql
+});
+/** `COUNT(sql)`: valores não nulos. Para contar linhas, use uma coluna que nunca é nula (a chave). */
+const count = aggregate("count");
+/** `COUNT(DISTINCT sql)`: ex. quantas operações têm lançamento (`fVeiculo.navio_operacao_id`). */
+const countDistinct = aggregate("countDistinct");
+/** `AVG(sql)`: média das linhas (no estrela, das linhas da própria tabela, não de totais). */
+const avg = aggregate("avg");
+const min = aggregate("min");
+const max = aggregate("max");
+/** `numerator / denominator`, ambos nomes de medidas do mesmo modelo (nulo quando o divisor é 0). */
+const ratio = (numerator, denominator, meta) => ({
+	...meta,
+	type: "ratio",
+	numerator,
+	denominator
+});
+/**
+* Combina medidas já agregadas: `{nome}` vira o valor da medida. Ex.:
+* `formula('COALESCE({custoMmo}, 0) + COALESCE({custoAppa}, 0)')` — o jeito de somar medidas de
+* fatos diferentes no modelo estrela.
+*/
+const formula = (expression, meta) => ({
+	...meta,
+	type: "formula",
+	expression
+});
+/** Valida o modelo na carga do módulo: erro de definição aparece no deploy, não na primeira query. */
+function defineModel(model) {
+	const errors = validateModel(model);
+	if (errors.length) throw new Error(`[${model.name}] ${errors.join("; ")}`);
+	return model;
+}
+//#endregion
+//#region src/server/modelFile.ts
+/**
+* Troca, dentro do arquivo do modelo, só o objeto passado ao `defineModel(...)` e o import do
+* `@bluemarble/bi/server`. O resto do arquivo (JSDoc do modelo, outros exports) fica como está.
+*/
+var ModelFileError = class extends Error {};
+/** Índice do `)` que fecha o `(` em `open`, pulando strings, templates e comentários. */
+function findClosingParen(source, open) {
+	let depth = 0;
+	let comments = false;
+	const stack = [];
+	for (let i = open; i < source.length; i++) {
+		const char = source[i];
+		const next = source[i + 1];
+		if (stack[stack.length - 1] === "`") {
+			if (char === "\\") i++;
+			else if (char === "`") stack.pop();
+			else if (char === "$" && next === "{") {
+				stack.push("${");
+				i++;
+			}
+			continue;
+		}
+		if (char === "'" || char === "\"") {
+			for (i++; i < source.length && source[i] !== char; i++) if (source[i] === "\\") i++;
+			continue;
+		}
+		if (char === "/" && next === "/") {
+			comments = true;
+			while (i < source.length && source[i] !== "\n") i++;
+			continue;
+		}
+		if (char === "/" && next === "*") {
+			comments = true;
+			i = source.indexOf("*/", i + 2) + 1;
+			if (i === 0) break;
+			continue;
+		}
+		if (char === "`") stack.push("`");
+		else if (char === "{") stack.push("{");
+		else if (char === "}") stack.pop();
+		else if (char === "(") depth++;
+		else if (char === ")" && --depth === 0) return {
+			close: i,
+			comments
+		};
+	}
+	throw new ModelFileError("Não encontrei o fim da chamada `defineModel(...)`");
+}
+function replaceModelInFile(source, model) {
+	const warnings = [];
+	const match = new RegExp(`export\\s+const\\s+${model.name}\\s*=\\s*defineModel(?:<[^>]*>)?\\s*\\(`).exec(source);
+	if (!match) throw new ModelFileError(`O arquivo não tem \`export const ${model.name} = defineModel(...)\``);
+	const open = match.index + match[0].length - 1;
+	const { close, comments } = findClosingParen(source, open);
+	if (comments) warnings.push("Comentários dentro do defineModel(...) serão perdidos (os de fora ficam).");
+	let content = `${source.slice(0, open + 1)}${modelObjectCode(model)}${source.slice(close)}`;
+	const importRegex = /import\s*\{([^}]*)\}\s*from\s*'@bluemarble\/bi\/server'/;
+	const current = importRegex.exec(content);
+	const helpers = /* @__PURE__ */ new Set([
+		"defineModel",
+		"formula",
+		"ratio",
+		...AGGREGATIONS
+	]);
+	const line = `import { ${[...(current?.[1] ?? "").split(",").map((name) => name.trim()).filter((name) => name && !helpers.has(name)), ...modelImports(model)].sort((a, b) => a.localeCompare(b, "en", { sensitivity: "base" })).join(", ")} } from '@bluemarble/bi/server'`;
+	content = current ? content.replace(importRegex, line) : `${line}\n${content}`;
+	const outside = source.slice(0, match.index) + source.slice(close + 1);
+	const measureHelpers = [...helpers].filter((name) => name !== "defineModel");
+	if (new RegExp(`\\b(${measureHelpers.join("|")})\\(`).test(outside)) warnings.push("O arquivo usa os helpers de medida fora do modelo; confira o import.");
+	return {
+		content,
+		warnings
+	};
+}
+//#endregion
+//#region src/server/normalize.ts
+/** Decimal do Prisma, bigint e afins viram number; datas viram ISO. */
+function normalizeValue(value) {
+	if (value === null || value === void 0) return null;
+	if (typeof value === "string" || typeof value === "number") return value;
+	if (typeof value === "bigint") return Number(value);
+	if (value instanceof Date) return value.toISOString();
+	const number = Number(value);
+	return Number.isNaN(number) ? String(value) : number;
+}
+function normalizeRow(row) {
+	const normalized = {};
+	for (const [key, value] of Object.entries(row)) normalized[key] = normalizeValue(value);
+	return normalized;
+}
+//#endregion
+//#region src/server/devtools.ts
+const fs = () => import("node:fs/promises");
+/** Mensagem do banco sem o embrulho do Prisma (`Raw query failed. Code: ... Message: ...`). */
+function dbMessage(error) {
+	const err = error;
+	const message = err?.meta?.message ?? err?.message ?? String(error);
+	return message.match(/Message: `?([\s\S]*?)`?$/)?.[1] ?? message;
+}
+const timed = async (load) => {
+	const startedAt = performance.now();
+	return {
+		result: await load(),
+		durationMs: Math.round(performance.now() - startedAt)
+	};
+};
+const SLUG = /^[A-Za-z0-9_-]{1,80}$/;
+async function handleDevtoolsRequest(context) {
+	const { request } = context;
+	if (request.describe) return describe(context);
+	if (request.schema) return {
+		rows: [],
+		devtools: { schema: await loadSchema(context.execute) }
+	};
+	if (request.columns) {
+		const { columns, errors } = await describeColumns(context);
+		return {
+			rows: [],
+			devtools: {
+				columns,
+				columnErrors: errors
+			}
+		};
+	}
+	if (request.validate) return {
+		rows: [],
+		devtools: { validation: await validateSql(context) }
+	};
+	if (request.save) return {
+		rows: [],
+		devtools: { save: await saveModel(context) }
+	};
+	if (request.saveLayout) return {
+		rows: [],
+		devtools: { save: await saveLayout(context) }
+	};
+	if (request.snapshots) return {
+		rows: [],
+		devtools: { snapshots: await listSnapshots(context) }
+	};
+	if (request.snapshot) return {
+		rows: [],
+		devtools: { snapshot: await saveSnapshot(context) }
+	};
+	if (request.explain) {
+		const { sql, params } = compileQuery(context.model, context.query);
+		return {
+			rows: [],
+			devtools: { explain: (await context.execute(`EXPLAIN ${sql}`, params)).map(context.normalize) }
+		};
+	}
+	if (request.profile) return {
+		rows: [],
+		devtools: { profile: await profile(context) }
+	};
+	return null;
+}
+function describe({ registered, options }) {
+	return {
+		rows: [],
+		meta: modelMeta(registered),
+		devtools: {
+			model: registered,
+			capabilities: {
+				saveModel: !!options.modelsDir,
+				snapshots: !!options.snapshotsDir,
+				saveLayout: !!options.layoutsDir
+			}
+		}
+	};
+}
+async function profile({ model, query, execute }) {
+	const { sql, params, parts } = compileQuery(model, query);
+	const steps = [];
+	for (const part of parts) {
+		const { result, durationMs } = await timed(() => execute(part.sql, part.params));
+		steps.push({
+			name: part.name,
+			durationMs,
+			rows: Number(result[0]?.n ?? 0)
+		});
+	}
+	const total = await timed(() => execute(sql, params));
+	steps.push({
+		name: "consulta",
+		durationMs: total.durationMs,
+		rows: total.result.length
+	});
+	return steps;
+}
+async function loadSchema(execute) {
+	const rows = await execute(`SELECT c.TABLE_NAME AS tableName, t.TABLE_TYPE AS tableType,
+            c.COLUMN_NAME AS columnName, c.DATA_TYPE AS dataType
+     FROM information_schema.COLUMNS c
+     JOIN information_schema.TABLES t
+       ON t.TABLE_SCHEMA = c.TABLE_SCHEMA AND t.TABLE_NAME = c.TABLE_NAME
+     WHERE c.TABLE_SCHEMA = DATABASE()
+     ORDER BY c.TABLE_NAME, c.ORDINAL_POSITION`, []);
+	const tables = /* @__PURE__ */ new Map();
+	for (const row of rows) {
+		const name = String(row.tableName);
+		let table = tables.get(name);
+		if (!table) {
+			table = {
+				name,
+				type: String(row.tableType).includes("VIEW") ? "view" : "table",
+				columns: []
+			};
+			tables.set(name, table);
+		}
+		table.columns.push({
+			name: String(row.columnName),
+			type: String(row.dataType)
+		});
+	}
+	return [...tables.values()];
+}
+/** Poucas chaves bastam para o banco acusar erro de SQL e para descobrir as colunas. */
+const SAMPLE_KEYS = 20;
+const emptyColumns = () => ({
+	tables: {},
+	numeric: []
+});
+/** Colunas numéricas da primeira linha (Decimal do Prisma e bigint contam). */
+function numericColumns(node, row) {
+	return Object.entries(row ?? {}).filter(([, value]) => typeof normalizeValue(value) === "number").map(([column]) => `${node}.${column}`);
+}
+/**
+* Colunas de cada tabela do modelo (uma linha de cada). `errors` traz o que o banco recusou, com as
+* chaves da validação (`table:<nome>`).
+*/
+async function loadColumns(model, execute) {
+	const columns = emptyColumns();
+	const errors = {};
+	const attempt = async (key, sql) => {
+		try {
+			return await execute(sql, []);
+		} catch (error) {
+			errors[key] = dbMessage(error);
+			return null;
+		}
+	};
+	for (const [name, table] of Object.entries(model.tables)) {
+		const rows = await attempt(`table:${name}`, `SELECT * FROM (${table.sql}) t LIMIT 1`);
+		if (!rows) continue;
+		columns.tables[name] = Object.keys(rows[0] ?? {});
+		columns.numeric.push(...numericColumns(name, rows[0]));
+	}
+	return {
+		columns,
+		errors
+	};
+}
+async function describeColumns({ model, execute }) {
+	const errors = validateModel(model);
+	if (errors.length) throw new DashboardQueryError(`Modelo inválido: ${errors.join("; ")}`);
+	return loadColumns(model, execute);
+}
+async function validateSql({ model, execute }) {
+	const validation = {
+		errors: {},
+		warnings: {},
+		columns: emptyColumns()
+	};
+	const modelErrors = validateModel(model);
+	if (modelErrors.length) {
+		validation.errors.model = modelErrors.join("; ");
+		return validation;
+	}
+	const attempt = async (key, sql) => {
+		try {
+			return await execute(sql, []);
+		} catch (error) {
+			validation.errors[key] = dbMessage(error);
+			return null;
+		}
+	};
+	const loaded = await loadColumns(model, execute);
+	validation.columns = loaded.columns;
+	Object.assign(validation.errors, loaded.errors);
+	const tableNames = Object.keys(model.tables);
+	for (const [index, relationship] of (model.relationships ?? []).entries()) {
+		const key = `relationship:${index}`;
+		const from = parseColumnRef(relationship.from);
+		const to = parseColumnRef(relationship.to);
+		if (!from || !to) continue;
+		const missing = [from, to].find((ref) => validation.columns.tables[ref.table]?.length && !validation.columns.tables[ref.table].includes(ref.column));
+		if (missing) {
+			validation.errors[key] = `a tabela "${missing.table}" não tem a coluna "${missing.column}"`;
+			continue;
+		}
+		const toSql = model.tables[to.table]?.sql;
+		if (!toSql || validation.errors[`table:${to.table}`]) continue;
+		const repeated = await attempt(key, `SELECT \`${to.column}\` AS v FROM (${toSql}) t WHERE \`${to.column}\` IS NOT NULL GROUP BY 1 HAVING COUNT(*) > 1 LIMIT 1`);
+		if (repeated?.length) validation.errors[key] = `o lado 1 (${relationship.to}) tem valor repetido: ${String(normalizeValue(repeated[0].v))}`;
+	}
+	for (const [name, dimension] of Object.entries(model.dimensions)) {
+		const table = referencedTables(dimension.sql, tableNames)[0];
+		if (validation.errors[`table:${table}`]) continue;
+		const sql = `SELECT ${dimension.sql} AS v FROM (SELECT * FROM (${model.tables[table]?.sql}) t LIMIT ${SAMPLE_KEYS}) \`${table}\` WHERE ${dimension.sql} IS NOT NULL LIMIT 1`;
+		const value = (await attempt(`dimension:${name}`, sql))?.[0]?.v;
+		if (value === void 0 || value === null) continue;
+		const isNumber = typeof value === "number" || typeof value === "bigint";
+		if (dimension.type === "number" && !isNumber && Number.isNaN(Number(value))) validation.warnings[`dimension:${name}`] = `tipo number, mas o banco devolveu "${value}"`;
+		if (dimension.type === "string" && isNumber) validation.warnings[`dimension:${name}`] = "tipo string, mas o banco devolveu número (filtros vão chegar como texto)";
+	}
+	for (const [name, measure] of Object.entries(model.measures)) {
+		if (!isAggregate(measure)) continue;
+		if (referencedTables(measure.sql, tableNames).some((table) => validation.errors[`table:${table}`])) continue;
+		const { sql, params } = compileQuery(model, {
+			model: model.name,
+			measures: [name]
+		}, { sampleLimit: SAMPLE_KEYS });
+		try {
+			await execute(sql, params);
+		} catch (error) {
+			validation.errors[`measure:${name}`] = dbMessage(error);
+		}
+	}
+	return validation;
+}
+async function saveModel({ registered, model, request, options }) {
+	if (!options.modelsDir) throw new DashboardQueryError("O endpoint não configurou `modelsDir`");
+	if (!request.model) throw new DashboardQueryError("Nada para salvar: não há rascunho");
+	if (model.name !== registered.name) throw new DashboardQueryError("O rascunho não pode trocar o nome do modelo");
+	const path = `${options.modelsDir.replace(/\/+$/, "")}/${registered.name}.ts`;
+	const { readFile, writeFile } = await fs();
+	let previous;
+	try {
+		previous = await readFile(path, "utf8");
+	} catch {
+		throw new DashboardQueryError(`Arquivo do modelo não encontrado: ${path}`);
+	}
+	try {
+		const replaced = replaceModelInFile(previous, model);
+		const { warnings } = replaced;
+		const content = options.format ? await options.format(replaced.content, path) : replaced.content;
+		const written = request.save === "write" && content !== previous;
+		if (written) await writeFile(path, content, "utf8");
+		return {
+			path,
+			previous,
+			content,
+			written,
+			warnings
+		};
+	} catch (error) {
+		if (error instanceof ModelFileError) throw new DashboardQueryError(error.message);
+		throw error;
+	}
+}
+async function saveLayout({ model, request, options }) {
+	if (!options.layoutsDir) throw new DashboardQueryError("O endpoint não configurou `layoutsDir`");
+	const { layout, mode } = request.saveLayout ?? {};
+	const errors = layout ? validateLayout(layout) : ["Nada para salvar: não há layout"];
+	if (errors.length) throw new DashboardQueryError(`Layout inválido: ${errors.join("; ")}`);
+	const valid = layout;
+	const path = `${options.layoutsDir.replace(/\/+$/, "")}/${valid.id}.json`;
+	const { readFile, writeFile } = await fs();
+	let previous;
+	try {
+		previous = await readFile(path, "utf8");
+	} catch {
+		throw new DashboardQueryError(`Arquivo do layout não encontrado: ${path}`);
+	}
+	const raw = layoutFileContent(valid);
+	const content = options.format ? await options.format(raw, path) : raw;
+	const written = mode === "write" && content !== previous;
+	if (written) await writeFile(path, content, "utf8");
+	return {
+		path,
+		previous,
+		content,
+		written,
+		warnings: layoutModelWarnings(valid, model)
+	};
+}
+const snapshotDir = (options, model) => {
+	if (!options.snapshotsDir) throw new DashboardQueryError("O endpoint não configurou `snapshotsDir`");
+	return `${options.snapshotsDir.replace(/\/+$/, "")}/${model}`;
+};
+async function saveSnapshot({ registered, query, request, options, runRows }) {
+	const { name, overwrite } = request.snapshot ?? { name: "" };
+	if (!SLUG.test(name)) throw new DashboardQueryError("Nome do snapshot: letras, números, \"-\" e \"_\" (até 80)");
+	const dir = snapshotDir(options, registered.name);
+	const path = `${dir}/${name}.json`;
+	const { mkdir, readFile, writeFile } = await fs();
+	if (!overwrite) {
+		if (await readFile(path, "utf8").then(() => true, () => false)) throw new DashboardQueryError(`Já existe um snapshot "${name}"`);
+	}
+	const snapshot = {
+		name,
+		createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+		query: {
+			model: registered.name,
+			dimensions: query.dimensions ?? [],
+			measures: query.measures ?? [],
+			filters: query.filters ?? {}
+		},
+		rows: await runRows(registered)
+	};
+	await mkdir(dir, { recursive: true });
+	await writeFile(path, `${JSON.stringify(snapshot, null, 2)}\n`, "utf8");
+	return { path };
+}
+async function listSnapshots({ registered, options }) {
+	const dir = snapshotDir(options, registered.name);
+	const { readdir, readFile } = await fs();
+	const files = await readdir(dir).catch(() => []);
+	return await Promise.all(files.filter((file) => file.endsWith(".json")).sort().map(async (file) => JSON.parse(await readFile(`${dir}/${file}`, "utf8"))));
+}
+//#endregion
+//#region src/server/runQuery.ts
+const MAX_CACHE_ENTRIES = 500;
+const cache = /* @__PURE__ */ new Map();
+function fromCache(key, ttl, load) {
+	const now = Date.now();
+	const hit = cache.get(key);
+	if (hit && hit.expiresAt > now) return {
+		execution: hit.execution,
+		cached: true
+	};
+	if (cache.size >= MAX_CACHE_ENTRIES) {
+		for (const [k, entry] of cache) if (entry.expiresAt <= now) cache.delete(k);
+		if (cache.size >= MAX_CACHE_ENTRIES) cache.delete(cache.keys().next().value);
+	}
+	const execution = load();
+	cache.set(key, {
+		expiresAt: now + ttl,
+		execution
+	});
+	execution.catch(() => cache.delete(key));
+	return {
+		execution,
+		cached: false
+	};
+}
+async function runQuery(models, query, execute, options = {}) {
+	const { debug, ...privileged } = query?.devtools ?? {};
+	const devtools = options.devtools ? query?.devtools : void 0;
+	if (!options.devtools && Object.values(privileged).some(Boolean)) throw new DashboardQueryError("Devtools desabilitado neste ambiente");
+	const registered = models[query?.model];
+	if (!registered) throw new DashboardQueryError(`Modelo desconhecido: "${query?.model}"`);
+	const draft = devtools?.model;
+	if (draft) {
+		const errors = validateModel(draft);
+		if (errors.length) throw new DashboardQueryError(`Rascunho inválido: ${errors.join("; ")}`);
+	}
+	const model = draft ?? registered;
+	if (query.meta) return {
+		rows: [],
+		meta: modelMeta(model)
+	};
+	const ttl = options.cacheTtlMs ?? 0;
+	const run = async (target) => {
+		const { sql, params } = compileQuery(target, query);
+		const load = async () => {
+			const startedAt = performance.now();
+			const rows = await execute(sql, params);
+			return {
+				durationMs: Math.round(performance.now() - startedAt),
+				rows: rows.map(normalizeRow)
+			};
+		};
+		const { execution, cached } = ttl > 0 ? fromCache(JSON.stringify([sql, params]), ttl, load) : {
+			execution: load(),
+			cached: false
+		};
+		return {
+			sql,
+			params,
+			cached,
+			...await execution
+		};
+	};
+	if (devtools) {
+		if (devtools.clearCache) cache.clear();
+		try {
+			const handled = await handleDevtoolsRequest({
+				registered,
+				model,
+				query,
+				request: devtools,
+				execute: (sql, params) => execute(sql, params),
+				normalize: normalizeRow,
+				options: typeof options.devtools === "object" ? options.devtools : {},
+				runRows: async (target) => (await run(target)).rows
+			});
+			if (handled) return handled;
+		} catch (error) {
+			if (error instanceof DashboardQueryError) throw error;
+			throw new DashboardQueryError(dbMessage(error));
+		}
+	}
+	const { rows, sql, params, durationMs, cached } = await run(model);
+	if (!devtools?.debug) return { rows };
+	return {
+		rows,
+		devtools: { debug: {
+			sql,
+			params,
+			durationMs,
+			cached,
+			draft: !!draft
+		} }
+	};
+}
+//#endregion
+export { DashboardQueryError, avg, canonicalJson, compileQuery, count, countDistinct, defineModel, describeDiffs, diffRows, formula, layoutModelWarnings, max, min, modelMeta, ratio, runQuery, sum, toModelCode, validateLayout, validateModel };
+
+//# sourceMappingURL=index.js.map