@contractspec/example.analytics-dashboard 3.9.9 → 3.9.10

package/dist/node/handlers/query.handlers.js

@@ -1,294 +1,4 @@
-// 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/handlers/query.handlers.ts
-async function executePosthogQuery(input) {
-  const engine = createPosthogQueryEngine(input.reader);
-  return engine.execute(input.definition, input.params);
-}
-export {
-  executePosthogQuery
-};
+class y{reader;defaultLimit;constructor(e,t={}){this.reader=e,this.defaultLimit=t.defaultLimit??100}async execute(e,t){let r=Date.now(),s=this.validateQuery(e);if(!s.valid)return{data:[],columns:[],rowCount:0,executionTimeMs:Date.now()-r,cached:!1,error:s.errors.join(", ")};if(!this.reader.queryHogQL)return{data:[],columns:[],rowCount:0,executionTimeMs:Date.now()-r,cached:!1,error:"Analytics reader does not support HogQL queries."};try{let a=await this.executeHogQL(e,t);return{data:a.data,columns:a.columns,rowCount:a.rowCount,executionTimeMs:Date.now()-r,cached:!1}}catch(a){return{data:[],columns:[],rowCount:0,executionTimeMs:Date.now()-r,cached:!1,error:a instanceof Error?a.message:"Unknown error"}}}validateQuery(e){let t=[];if(e.type==="SQL"&&!e.sql)t.push("SQL query is missing.");if(e.type==="AGGREGATION"&&!e.aggregation)t.push("Aggregation definition is missing.");if(e.type==="METRIC"&&!e.metricIds?.length)t.push("Metric IDs are missing.");if(e.type==="CUSTOM"&&!e.custom?.handler)t.push("Custom handler is missing.");return{valid:t.length===0,errors:t}}async executeHogQL(e,t){if(!this.reader.queryHogQL)throw Error("Analytics reader does not support HogQL queries.");if(e.type==="SQL"){let r=await this.reader.queryHogQL({query:e.sql??"",values:t.parameters??{}});return m(r)}if(e.type==="AGGREGATION"&&e.aggregation){let{query:r,values:s}=$(e.aggregation,t),a=await this.reader.queryHogQL({query:r,values:s});return m(a)}if(e.type==="METRIC"&&e.metricIds){let{query:r,values:s}=h(e.metricIds,t),a=await this.reader.queryHogQL({query:r,values:s});return m(a)}throw Error("Unsupported query type for PostHog datasource.")}}function g(e,t){return new y(e,t)}function h(e,t){let r=d(t),s={dateFrom:r?.from.toISOString(),dateTo:r?.to.toISOString()},a=e.map((i,o)=>{return s[`metric${o}`]=i,`event = {metric${o}}`}),n=[a.length?`(${a.join(" or ")})`:"",r?"timestamp >= {dateFrom} and timestamp < {dateTo}":""].filter(Boolean).join(" and ");return{query:["select","  event as metric,","  count() as total","from events",n?`where ${n}`:"","group by metric"].filter(Boolean).join(`
+`),values:s}}function $(e,t){let r=e.measures.map((u)=>({...u,expression:w(u.field,u.aggregation)})),s=e.dimensions.map((u)=>({...u,expression:Q(u.field,u.type,u.granularity)})),a=[...s.map((u)=>`${u.expression} as ${u.name}`),...r.map((u)=>`${u.expression} as ${u.name}`)],n={},i=f(e,t,n),o=e.limit??100,c=e.orderBy?.length?`order by ${e.orderBy.map((u)=>`${u.field} ${u.direction}`).join(", ")}`:"";return{query:["select",`  ${a.join(`,
+  `)}`,`from ${e.source}`,i.length?`where ${i.join(" and ")}`:"",s.length?`group by ${s.map((u)=>u.name).join(", ")}`:"",c,`limit ${o}`].filter(Boolean).join(`
+`),values:n}}function w(e,t){switch(t){case"COUNT":return e==="*"?"count()":`count(${e})`;case"COUNT_DISTINCT":return`countDistinct(${e})`;case"SUM":return`sum(${e})`;case"AVG":return`avg(${e})`;case"MIN":return`min(${e})`;case"MAX":return`max(${e})`;default:return`count(${e})`}}function Q(e,t,r){if(t==="TIME")switch(r){case"HOUR":return`toStartOfHour(${e})`;case"WEEK":return`toStartOfWeek(${e})`;case"MONTH":return`toStartOfMonth(${e})`;case"YEAR":return`toStartOfYear(${e})`;case"DAY":default:return`toStartOfDay(${e})`}return e}function f(e,t,r){let s=[],a=d(t);if(a)r.dateFrom=a.from.toISOString(),r.dateTo=a.to.toISOString(),s.push("timestamp >= {dateFrom} and timestamp < {dateTo}");return e.filters?.forEach((n,i)=>{let o=`filter${i}`;switch(n.operator){case"eq":r[o]=n.value,s.push(`${n.field} = {${o}}`);break;case"neq":r[o]=n.value,s.push(`${n.field} != {${o}}`);break;case"gt":r[o]=n.value,s.push(`${n.field} > {${o}}`);break;case"gte":r[o]=n.value,s.push(`${n.field} >= {${o}}`);break;case"lt":r[o]=n.value,s.push(`${n.field} < {${o}}`);break;case"lte":r[o]=n.value,s.push(`${n.field} <= {${o}}`);break;case"contains":r[o]=n.value,s.push(`${n.field} LIKE '%' || {${o}} || '%'`);break;case"between":{if(Array.isArray(n.value)&&n.value.length>=2)r[`${o}Start`]=n.value[0],r[`${o}End`]=n.value[1],s.push(`${n.field} BETWEEN {${o}Start} AND {${o}End}`);break}case"in":case"nin":if(Array.isArray(n.value)){let c=[];if(n.value.forEach((u,p)=>{let l=`${o}_${p}`;r[l]=u,c.push(`{${l}}`)}),c.length)s.push(`${n.field} ${n.operator==="in"?"IN":"NOT IN"} (${c.join(", ")})`)}break;default:break}}),s}function d(e){let t=e.dateRange;if(!t)return null;return{from:t.start,to:t.end}}function m(e){if(!Array.isArray(e.results)||!Array.isArray(e.columns))return{data:[],columns:[],rowCount:0};let t=e.columns.map((s)=>({name:s,type:"STRING"})),r=e.results.map((s)=>{if(!Array.isArray(s))return{};let a={};return e.columns?.forEach((n,i)=>{a[n]=s[i]}),a});return{data:r,columns:t,rowCount:r.length}}async function R(e){return g(e.reader).execute(e.definition,e.params)}export{R as executePosthogQuery};