@contractspec/example.analytics-dashboard 1.56.1 → 1.58.0

package/dist/query-engine/index.js

@@ -1,189 +1,492 @@
-//#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":
-				if (!definition.aggregation) throw new Error("Aggregation definition is missing");
-				result = await this.executeAggregation(definition.aggregation, params);
-				break;
-			case "METRIC":
-				if (!definition.metricIds) throw new Error("Metric IDs are missing");
-				result = await this.executeMetric(definition.metricIds, params);
-				break;
-			case "SQL":
-				if (!definition.sql) throw new Error("SQL query is missing");
-				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);
+// @bun
+// src/datasource/posthog-datasource.ts
+class PosthogQueryEngine {
+  reader;
+  defaultLimit;
+  constructor(reader, options = {}) {
+    this.reader = reader;
+    this.defaultLimit = options.defaultLimit ?? 100;
+  }
+  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(", ")
+      };
+    }
+    if (!this.reader.queryHogQL) {
+      return {
+        data: [],
+        columns: [],
+        rowCount: 0,
+        executionTimeMs: Date.now() - startTime,
+        cached: false,
+        error: "Analytics reader does not support HogQL queries."
+      };
+    }
+    try {
+      const result = await this.executeHogQL(definition, params);
+      return {
+        data: result.data,
+        columns: result.columns,
+        rowCount: result.rowCount,
+        executionTimeMs: Date.now() - startTime,
+        cached: false
+      };
+    } catch (error) {
+      return {
+        data: [],
+        columns: [],
+        rowCount: 0,
+        executionTimeMs: Date.now() - startTime,
+        cached: false,
+        error: error instanceof Error ? error.message : "Unknown error"
+      };
+    }
+  }
+  validateQuery(definition) {
+    const errors = [];
+    if (definition.type === "SQL" && !definition.sql) {
+      errors.push("SQL query is missing.");
+    }
+    if (definition.type === "AGGREGATION" && !definition.aggregation) {
+      errors.push("Aggregation definition is missing.");
+    }
+    if (definition.type === "METRIC" && !definition.metricIds?.length) {
+      errors.push("Metric IDs are missing.");
+    }
+    if (definition.type === "CUSTOM" && !definition.custom?.handler) {
+      errors.push("Custom handler is missing.");
+    }
+    return { valid: errors.length === 0, errors };
+  }
+  async executeHogQL(definition, params) {
+    if (!this.reader.queryHogQL) {
+      throw new Error("Analytics reader does not support HogQL queries.");
+    }
+    if (definition.type === "SQL") {
+      const result = await this.reader.queryHogQL({
+        query: definition.sql ?? "",
+        values: params.parameters ?? {}
+      });
+      return mapHogqlResult(result);
+    }
+    if (definition.type === "AGGREGATION" && definition.aggregation) {
+      const { query, values } = buildAggregationQuery(definition.aggregation, params);
+      const result = await this.reader.queryHogQL({ query, values });
+      return mapHogqlResult(result);
+    }
+    if (definition.type === "METRIC" && definition.metricIds) {
+      const { query, values } = buildMetricQuery(definition.metricIds, params);
+      const result = await this.reader.queryHogQL({ query, values });
+      return mapHogqlResult(result);
+    }
+    throw new Error("Unsupported query type for PostHog datasource.");
+  }
+}
+function createPosthogQueryEngine(reader, options) {
+  return new PosthogQueryEngine(reader, options);
+}
+function buildMetricQuery(metricIds, params) {
+  const range = resolveDateRange(params);
+  const values = {
+    dateFrom: range?.from.toISOString(),
+    dateTo: range?.to.toISOString()
+  };
+  const metricClauses = metricIds.map((metricId, index) => {
+    values[`metric${index}`] = metricId;
+    return `event = {metric${index}}`;
+  });
+  const whereClauses = [
+    metricClauses.length ? `(${metricClauses.join(" or ")})` : "",
+    range ? "timestamp >= {dateFrom} and timestamp < {dateTo}" : ""
+  ].filter(Boolean).join(" and ");
+  return {
+    query: [
+      "select",
+      "  event as metric,",
+      "  count() as total",
+      "from events",
+      whereClauses ? `where ${whereClauses}` : "",
+      "group by metric"
+    ].filter(Boolean).join(`
+`),
+    values
+  };
+}
+function buildAggregationQuery(aggregation, params) {
+  const measures = aggregation.measures.map((measure) => ({
+    ...measure,
+    expression: buildMeasureExpression(measure.field, measure.aggregation)
+  }));
+  const dimensions = aggregation.dimensions.map((dimension) => ({
+    ...dimension,
+    expression: buildDimensionExpression(dimension.field, dimension.type, dimension.granularity)
+  }));
+  const selections = [
+    ...dimensions.map((dimension) => `${dimension.expression} as ${dimension.name}`),
+    ...measures.map((measure) => `${measure.expression} as ${measure.name}`)
+  ];
+  const values = {};
+  const filters = buildFilterClauses(aggregation, params, values);
+  const limit = aggregation.limit ?? 100;
+  const orderBy = aggregation.orderBy?.length ? `order by ${aggregation.orderBy.map((order) => `${order.field} ${order.direction}`).join(", ")}` : "";
+  return {
+    query: [
+      "select",
+      `  ${selections.join(`,
+  `)}`,
+      `from ${aggregation.source}`,
+      filters.length ? `where ${filters.join(" and ")}` : "",
+      dimensions.length ? `group by ${dimensions.map((d) => d.name).join(", ")}` : "",
+      orderBy,
+      `limit ${limit}`
+    ].filter(Boolean).join(`
+`),
+    values
+  };
+}
+function buildMeasureExpression(field, aggregation) {
+  switch (aggregation) {
+    case "COUNT":
+      return field === "*" ? "count()" : `count(${field})`;
+    case "COUNT_DISTINCT":
+      return `countDistinct(${field})`;
+    case "SUM":
+      return `sum(${field})`;
+    case "AVG":
+      return `avg(${field})`;
+    case "MIN":
+      return `min(${field})`;
+    case "MAX":
+      return `max(${field})`;
+    default:
+      return `count(${field})`;
+  }
+}
+function buildDimensionExpression(field, type, granularity) {
+  if (type === "TIME") {
+    switch (granularity) {
+      case "HOUR":
+        return `toStartOfHour(${field})`;
+      case "WEEK":
+        return `toStartOfWeek(${field})`;
+      case "MONTH":
+        return `toStartOfMonth(${field})`;
+      case "YEAR":
+        return `toStartOfYear(${field})`;
+      case "DAY":
+      default:
+        return `toStartOfDay(${field})`;
+    }
+  }
+  return field;
+}
+function buildFilterClauses(aggregation, params, values) {
+  const clauses = [];
+  const range = resolveDateRange(params);
+  if (range) {
+    values.dateFrom = range.from.toISOString();
+    values.dateTo = range.to.toISOString();
+    clauses.push(`timestamp >= {dateFrom} and timestamp < {dateTo}`);
+  }
+  aggregation.filters?.forEach((filter, index) => {
+    const key = `filter${index}`;
+    switch (filter.operator) {
+      case "eq":
+        values[key] = filter.value;
+        clauses.push(`${filter.field} = {${key}}`);
+        break;
+      case "neq":
+        values[key] = filter.value;
+        clauses.push(`${filter.field} != {${key}}`);
+        break;
+      case "gt":
+        values[key] = filter.value;
+        clauses.push(`${filter.field} > {${key}}`);
+        break;
+      case "gte":
+        values[key] = filter.value;
+        clauses.push(`${filter.field} >= {${key}}`);
+        break;
+      case "lt":
+        values[key] = filter.value;
+        clauses.push(`${filter.field} < {${key}}`);
+        break;
+      case "lte":
+        values[key] = filter.value;
+        clauses.push(`${filter.field} <= {${key}}`);
+        break;
+      case "contains":
+        values[key] = filter.value;
+        clauses.push(`${filter.field} LIKE '%' || {${key}} || '%'`);
+        break;
+      case "between": {
+        if (Array.isArray(filter.value) && filter.value.length >= 2) {
+          values[`${key}Start`] = filter.value[0];
+          values[`${key}End`] = filter.value[1];
+          clauses.push(`${filter.field} BETWEEN {${key}Start} AND {${key}End}`);
+        }
+        break;
+      }
+      case "in":
+      case "nin":
+        if (Array.isArray(filter.value)) {
+          const placeholders = [];
+          filter.value.forEach((value, valueIndex) => {
+            const valueKey = `${key}_${valueIndex}`;
+            values[valueKey] = value;
+            placeholders.push(`{${valueKey}}`);
+          });
+          if (placeholders.length) {
+            clauses.push(`${filter.field} ${filter.operator === "in" ? "IN" : "NOT IN"} (${placeholders.join(", ")})`);
+          }
+        }
+        break;
+      default:
+        break;
+    }
+  });
+  return clauses;
+}
+function resolveDateRange(params) {
+  const range = params.dateRange;
+  if (!range)
+    return null;
+  return { from: range.start, to: range.end };
+}
+function mapHogqlResult(result) {
+  if (!Array.isArray(result.results) || !Array.isArray(result.columns)) {
+    return { data: [], columns: [], rowCount: 0 };
+  }
+  const columns = result.columns.map((name) => ({
+    name,
+    type: "STRING"
+  }));
+  const data = result.results.map((row) => {
+    if (!Array.isArray(row))
+      return {};
+    const record = {};
+    result.columns?.forEach((column, index) => {
+      record[column] = row[index];
+    });
+    return record;
+  });
+  return {
+    data,
+    columns,
+    rowCount: data.length
+  };
+}
+
+// src/query-engine/index.ts
+class InMemoryQueryCache {
+  cache = new Map;
+  async get(key) {
+    const entry = this.cache.get(key);
+    if (!entry)
+      return null;
+    if (entry.expiresAt < 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 * 1000);
+    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);
+      }
+    }
+  }
 }
 
-//#endregion
-export { BasicQueryEngine, InMemoryQueryCache, createQueryEngine };
-//# sourceMappingURL=index.js.map
+class BasicQueryEngine {
+  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":
+        if (!definition.aggregation) {
+          throw new Error("Aggregation definition is missing");
+        }
+        result = await this.executeAggregation(definition.aggregation, params);
+        break;
+      case "METRIC":
+        if (!definition.metricIds) {
+          throw new Error("Metric IDs are missing");
+        }
+        result = await this.executeMetric(definition.metricIds, params);
+        break;
+      case "SQL":
+        if (!definition.sql) {
+          throw new Error("SQL query is missing");
+        }
+        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() * 1000,
+      change: (Math.random() - 0.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 ?? 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() * 1000;
+        const noise = (Math.random() - 0.5) * 20;
+        row[measure.name] = Math.round((baseValue + noise) * 100) / 100;
+      }
+      data.push(row);
+    }
+    return data;
+  }
+}
+function createQueryEngine(cache) {
+  return new BasicQueryEngine(cache);
+}
+export {
+  createQueryEngine,
+  createPosthogQueryEngine,
+  PosthogQueryEngine,
+  InMemoryQueryCache,
+  BasicQueryEngine
+};