@lssm/example.analytics-dashboard 0.0.0-canary-20251216033905 → 0.0.0-canary-20251216062412

package/dist/query-engine/index.js

@@ -1 +1,185 @@
-var e=class{cache=new Map;async get(e){let t=this.cache.get(e);return t?t.expiresAt<new Date?(this.cache.delete(e),null):{...t.result,cached:!0,cachedAt:t.expiresAt}:null}async set(e,t,n){let r=new Date(Date.now()+n*1e3);this.cache.set(e,{result:t,expiresAt:r})}async invalidate(e){let t=new RegExp(e);for(let e of this.cache.keys())t.test(e)&&this.cache.delete(e)}},t=class{cache;constructor(t){this.cache=t??new e}async execute(e,t){let n=Date.now(),r=this.validateQuery(e);if(!r.valid)return{data:[],columns:[],rowCount:0,executionTimeMs:Date.now()-n,cached:!1,error:r.errors.join(`, `)};let i=this.buildCacheKey(e,t),a=await this.cache.get(i);if(a)return a;let o;switch(e.type){case`AGGREGATION`:o=await this.executeAggregation(e.aggregation,t);break;case`METRIC`:o=await this.executeMetric(e.metricIds,t);break;case`SQL`:o=await this.executeSql(e.sql,t);break;default:o={data:[],columns:[],rowCount:0,executionTimeMs:Date.now()-n,cached:!1,error:`Unknown query type: ${e.type}`}}return o.executionTimeMs=Date.now()-n,o.cached=!1,await this.cache.set(i,o,300),o}validateQuery(e){let t=[];switch(e.type||t.push(`Query type is required`),e.type){case`SQL`:e.sql||t.push(`SQL query is required for SQL type`);break;case`METRIC`:(!e.metricIds||e.metricIds.length===0)&&t.push(`Metric IDs are required for METRIC type`);break;case`AGGREGATION`:e.aggregation?(e.aggregation.source||t.push(`Aggregation source is required`),(!e.aggregation.measures||e.aggregation.measures.length===0)&&t.push(`At least one measure is required`)):t.push(`Aggregation definition is required for AGGREGATION type`);break}return{valid:t.length===0,errors:t}}buildCacheKey(e,t){return JSON.stringify({definition:e,params:t})}async executeAggregation(e,t){let n=[...e.dimensions.map(e=>({name:e.name,type:e.type===`NUMBER`?`NUMBER`:e.type===`TIME`?`DATE`:`STRING`,label:e.name})),...e.measures.map(e=>({name:e.name,type:`NUMBER`,label:e.name,format:e.format}))],r=this.generateMockData(e,t);return{data:r,columns:n,rowCount:r.length,executionTimeMs:0,cached:!1}}async executeMetric(e,t){let n=e.map(e=>({metricId:e,value:Math.random()*1e3,change:(Math.random()-.5)*20}));return{data:n,columns:[{name:`metricId`,type:`STRING`},{name:`value`,type:`NUMBER`},{name:`change`,type:`NUMBER`}],rowCount:n.length,executionTimeMs:0,cached:!1}}async executeSql(e,t){return{data:[],columns:[],rowCount:0,executionTimeMs:0,cached:!1,error:`SQL execution not implemented in demo`}}generateMockData(e,t){let n=[],r=e.dimensions.find(e=>e.type===`TIME`);for(let i=0;i<10;i++){let a={};for(let n of e.dimensions)if(n.type===`TIME`){let e=new Date(t.dateRange?.start??new Date);e.setDate(e.getDate()+i),a[n.name]=e.toISOString().split(`T`)[0]}else a[n.name]=`${n.name}_${i%5}`;for(let t of e.measures){let e=r?100+i*10:Math.random()*1e3,n=(Math.random()-.5)*20;a[t.name]=Math.round((e+n)*100)/100}n.push(a)}return n}};function n(e){return new t(e)}export{t as BasicQueryEngine,e as InMemoryQueryCache,n as createQueryEngine};
+//#region src/query-engine/index.ts
+var InMemoryQueryCache = class {
+	cache = /* @__PURE__ */ new Map();
+	async get(key) {
+		const entry = this.cache.get(key);
+		if (!entry) return null;
+		if (entry.expiresAt < /* @__PURE__ */ new Date()) {
+			this.cache.delete(key);
+			return null;
+		}
+		return {
+			...entry.result,
+			cached: true,
+			cachedAt: entry.expiresAt
+		};
+	}
+	async set(key, result, ttlSeconds) {
+		const expiresAt = new Date(Date.now() + ttlSeconds * 1e3);
+		this.cache.set(key, {
+			result,
+			expiresAt
+		});
+	}
+	async invalidate(pattern) {
+		const regex = new RegExp(pattern);
+		for (const key of this.cache.keys()) if (regex.test(key)) this.cache.delete(key);
+	}
+};
+var BasicQueryEngine = class {
+	cache;
+	constructor(cache) {
+		this.cache = cache ?? new InMemoryQueryCache();
+	}
+	async execute(definition, params) {
+		const startTime = Date.now();
+		const validation = this.validateQuery(definition);
+		if (!validation.valid) return {
+			data: [],
+			columns: [],
+			rowCount: 0,
+			executionTimeMs: Date.now() - startTime,
+			cached: false,
+			error: validation.errors.join(", ")
+		};
+		const cacheKey = this.buildCacheKey(definition, params);
+		const cachedResult = await this.cache.get(cacheKey);
+		if (cachedResult) return cachedResult;
+		let result;
+		switch (definition.type) {
+			case "AGGREGATION":
+				result = await this.executeAggregation(definition.aggregation, params);
+				break;
+			case "METRIC":
+				result = await this.executeMetric(definition.metricIds, params);
+				break;
+			case "SQL":
+				result = await this.executeSql(definition.sql, params);
+				break;
+			default: result = {
+				data: [],
+				columns: [],
+				rowCount: 0,
+				executionTimeMs: Date.now() - startTime,
+				cached: false,
+				error: `Unknown query type: ${definition.type}`
+			};
+		}
+		result.executionTimeMs = Date.now() - startTime;
+		result.cached = false;
+		await this.cache.set(cacheKey, result, 300);
+		return result;
+	}
+	validateQuery(definition) {
+		const errors = [];
+		if (!definition.type) errors.push("Query type is required");
+		switch (definition.type) {
+			case "SQL":
+				if (!definition.sql) errors.push("SQL query is required for SQL type");
+				break;
+			case "METRIC":
+				if (!definition.metricIds || definition.metricIds.length === 0) errors.push("Metric IDs are required for METRIC type");
+				break;
+			case "AGGREGATION":
+				if (!definition.aggregation) errors.push("Aggregation definition is required for AGGREGATION type");
+				else {
+					if (!definition.aggregation.source) errors.push("Aggregation source is required");
+					if (!definition.aggregation.measures || definition.aggregation.measures.length === 0) errors.push("At least one measure is required");
+				}
+				break;
+		}
+		return {
+			valid: errors.length === 0,
+			errors
+		};
+	}
+	buildCacheKey(definition, params) {
+		return JSON.stringify({
+			definition,
+			params
+		});
+	}
+	async executeAggregation(aggregation, params) {
+		const columns = [...aggregation.dimensions.map((d) => ({
+			name: d.name,
+			type: d.type === "NUMBER" ? "NUMBER" : d.type === "TIME" ? "DATE" : "STRING",
+			label: d.name
+		})), ...aggregation.measures.map((m) => ({
+			name: m.name,
+			type: "NUMBER",
+			label: m.name,
+			format: m.format
+		}))];
+		const data = this.generateMockData(aggregation, params);
+		return {
+			data,
+			columns,
+			rowCount: data.length,
+			executionTimeMs: 0,
+			cached: false
+		};
+	}
+	async executeMetric(metricIds, _params) {
+		const data = metricIds.map((id) => ({
+			metricId: id,
+			value: Math.random() * 1e3,
+			change: (Math.random() - .5) * 20
+		}));
+		return {
+			data,
+			columns: [
+				{
+					name: "metricId",
+					type: "STRING"
+				},
+				{
+					name: "value",
+					type: "NUMBER"
+				},
+				{
+					name: "change",
+					type: "NUMBER"
+				}
+			],
+			rowCount: data.length,
+			executionTimeMs: 0,
+			cached: false
+		};
+	}
+	async executeSql(_sql, _params) {
+		return {
+			data: [],
+			columns: [],
+			rowCount: 0,
+			executionTimeMs: 0,
+			cached: false,
+			error: "SQL execution not implemented in demo"
+		};
+	}
+	generateMockData(aggregation, params) {
+		const data = [];
+		const rowCount = 10;
+		const timeDimension = aggregation.dimensions.find((d) => d.type === "TIME");
+		for (let i = 0; i < rowCount; i++) {
+			const row = {};
+			for (const dim of aggregation.dimensions) if (dim.type === "TIME") {
+				const date = new Date(params.dateRange?.start ?? /* @__PURE__ */ new Date());
+				date.setDate(date.getDate() + i);
+				row[dim.name] = date.toISOString().split("T")[0];
+			} else row[dim.name] = `${dim.name}_${i % 5}`;
+			for (const measure of aggregation.measures) {
+				const baseValue = timeDimension ? 100 + i * 10 : Math.random() * 1e3;
+				const noise = (Math.random() - .5) * 20;
+				row[measure.name] = Math.round((baseValue + noise) * 100) / 100;
+			}
+			data.push(row);
+		}
+		return data;
+	}
+};
+function createQueryEngine(cache) {
+	return new BasicQueryEngine(cache);
+}
+
+//#endregion
+export { BasicQueryEngine, InMemoryQueryCache, createQueryEngine };