@contractspec/example.analytics-dashboard 3.9.9 → 3.9.10

package/dist/browser/query-engine/index.js

@@ -1,491 +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/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);
-      }
-    }
-  }
-}
-
-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
-};
+class m{reader;defaultLimit;constructor(r,e={}){this.reader=r,this.defaultLimit=e.defaultLimit??100}async execute(r,e){let t=Date.now(),n=this.validateQuery(r);if(!n.valid)return{data:[],columns:[],rowCount:0,executionTimeMs:Date.now()-t,cached:!1,error:n.errors.join(", ")};if(!this.reader.queryHogQL)return{data:[],columns:[],rowCount:0,executionTimeMs:Date.now()-t,cached:!1,error:"Analytics reader does not support HogQL queries."};try{let u=await this.executeHogQL(r,e);return{data:u.data,columns:u.columns,rowCount:u.rowCount,executionTimeMs:Date.now()-t,cached:!1}}catch(u){return{data:[],columns:[],rowCount:0,executionTimeMs:Date.now()-t,cached:!1,error:u instanceof Error?u.message:"Unknown error"}}}validateQuery(r){let e=[];if(r.type==="SQL"&&!r.sql)e.push("SQL query is missing.");if(r.type==="AGGREGATION"&&!r.aggregation)e.push("Aggregation definition is missing.");if(r.type==="METRIC"&&!r.metricIds?.length)e.push("Metric IDs are missing.");if(r.type==="CUSTOM"&&!r.custom?.handler)e.push("Custom handler is missing.");return{valid:e.length===0,errors:e}}async executeHogQL(r,e){if(!this.reader.queryHogQL)throw Error("Analytics reader does not support HogQL queries.");if(r.type==="SQL"){let t=await this.reader.queryHogQL({query:r.sql??"",values:e.parameters??{}});return y(t)}if(r.type==="AGGREGATION"&&r.aggregation){let{query:t,values:n}=E(r.aggregation,e),u=await this.reader.queryHogQL({query:t,values:n});return y(u)}if(r.type==="METRIC"&&r.metricIds){let{query:t,values:n}=A(r.metricIds,e),u=await this.reader.queryHogQL({query:t,values:n});return y(u)}throw Error("Unsupported query type for PostHog datasource.")}}function Q(r,e){return new m(r,e)}function A(r,e){let t=p(e),n={dateFrom:t?.from.toISOString(),dateTo:t?.to.toISOString()},u=r.map((c,o)=>{return n[`metric${o}`]=c,`event = {metric${o}}`}),s=[u.length?`(${u.join(" or ")})`:"",t?"timestamp >= {dateFrom} and timestamp < {dateTo}":""].filter(Boolean).join(" and ");return{query:["select","  event as metric,","  count() as total","from events",s?`where ${s}`:"","group by metric"].filter(Boolean).join(`
+`),values:n}}function E(r,e){let t=r.measures.map((a)=>({...a,expression:b(a.field,a.aggregation)})),n=r.dimensions.map((a)=>({...a,expression:D(a.field,a.type,a.granularity)})),u=[...n.map((a)=>`${a.expression} as ${a.name}`),...t.map((a)=>`${a.expression} as ${a.name}`)],s={},c=R(r,e,s),o=r.limit??100,l=r.orderBy?.length?`order by ${r.orderBy.map((a)=>`${a.field} ${a.direction}`).join(", ")}`:"";return{query:["select",`  ${u.join(`,
+  `)}`,`from ${r.source}`,c.length?`where ${c.join(" and ")}`:"",n.length?`group by ${n.map((a)=>a.name).join(", ")}`:"",l,`limit ${o}`].filter(Boolean).join(`
+`),values:s}}function b(r,e){switch(e){case"COUNT":return r==="*"?"count()":`count(${r})`;case"COUNT_DISTINCT":return`countDistinct(${r})`;case"SUM":return`sum(${r})`;case"AVG":return`avg(${r})`;case"MIN":return`min(${r})`;case"MAX":return`max(${r})`;default:return`count(${r})`}}function D(r,e,t){if(e==="TIME")switch(t){case"HOUR":return`toStartOfHour(${r})`;case"WEEK":return`toStartOfWeek(${r})`;case"MONTH":return`toStartOfMonth(${r})`;case"YEAR":return`toStartOfYear(${r})`;case"DAY":default:return`toStartOfDay(${r})`}return r}function R(r,e,t){let n=[],u=p(e);if(u)t.dateFrom=u.from.toISOString(),t.dateTo=u.to.toISOString(),n.push("timestamp >= {dateFrom} and timestamp < {dateTo}");return r.filters?.forEach((s,c)=>{let o=`filter${c}`;switch(s.operator){case"eq":t[o]=s.value,n.push(`${s.field} = {${o}}`);break;case"neq":t[o]=s.value,n.push(`${s.field} != {${o}}`);break;case"gt":t[o]=s.value,n.push(`${s.field} > {${o}}`);break;case"gte":t[o]=s.value,n.push(`${s.field} >= {${o}}`);break;case"lt":t[o]=s.value,n.push(`${s.field} < {${o}}`);break;case"lte":t[o]=s.value,n.push(`${s.field} <= {${o}}`);break;case"contains":t[o]=s.value,n.push(`${s.field} LIKE '%' || {${o}} || '%'`);break;case"between":{if(Array.isArray(s.value)&&s.value.length>=2)t[`${o}Start`]=s.value[0],t[`${o}End`]=s.value[1],n.push(`${s.field} BETWEEN {${o}Start} AND {${o}End}`);break}case"in":case"nin":if(Array.isArray(s.value)){let l=[];if(s.value.forEach((a,w)=>{let $=`${o}_${w}`;t[$]=a,l.push(`{${$}}`)}),l.length)n.push(`${s.field} ${s.operator==="in"?"IN":"NOT IN"} (${l.join(", ")})`)}break;default:break}}),n}function p(r){let e=r.dateRange;if(!e)return null;return{from:e.start,to:e.end}}function y(r){if(!Array.isArray(r.results)||!Array.isArray(r.columns))return{data:[],columns:[],rowCount:0};let e=r.columns.map((n)=>({name:n,type:"STRING"})),t=r.results.map((n)=>{if(!Array.isArray(n))return{};let u={};return r.columns?.forEach((s,c)=>{u[s]=n[c]}),u});return{data:t,columns:e,rowCount:t.length}}class h{cache=new Map;async get(r){let e=this.cache.get(r);if(!e)return null;if(e.expiresAt<new Date)return this.cache.delete(r),null;return{...e.result,cached:!0,cachedAt:e.expiresAt}}async set(r,e,t){let n=new Date(Date.now()+t*1000);this.cache.set(r,{result:e,expiresAt:n})}async invalidate(r){let e=new RegExp(r);for(let t of this.cache.keys())if(e.test(t))this.cache.delete(t)}}class g{cache;constructor(r){this.cache=r??new h}async execute(r,e){let t=Date.now(),n=this.validateQuery(r);if(!n.valid)return{data:[],columns:[],rowCount:0,executionTimeMs:Date.now()-t,cached:!1,error:n.errors.join(", ")};let u=this.buildCacheKey(r,e),s=await this.cache.get(u);if(s)return s;let c;switch(r.type){case"AGGREGATION":if(!r.aggregation)throw Error("Aggregation definition is missing");c=await this.executeAggregation(r.aggregation,e);break;case"METRIC":if(!r.metricIds)throw Error("Metric IDs are missing");c=await this.executeMetric(r.metricIds,e);break;case"SQL":if(!r.sql)throw Error("SQL query is missing");c=await this.executeSql(r.sql,e);break;default:c={data:[],columns:[],rowCount:0,executionTimeMs:Date.now()-t,cached:!1,error:`Unknown query type: ${r.type}`}}return c.executionTimeMs=Date.now()-t,c.cached=!1,await this.cache.set(u,c,300),c}validateQuery(r){let e=[];if(!r.type)e.push("Query type is required");switch(r.type){case"SQL":if(!r.sql)e.push("SQL query is required for SQL type");break;case"METRIC":if(!r.metricIds||r.metricIds.length===0)e.push("Metric IDs are required for METRIC type");break;case"AGGREGATION":if(!r.aggregation)e.push("Aggregation definition is required for AGGREGATION type");else{if(!r.aggregation.source)e.push("Aggregation source is required");if(!r.aggregation.measures||r.aggregation.measures.length===0)e.push("At least one measure is required")}break}return{valid:e.length===0,errors:e}}buildCacheKey(r,e){return JSON.stringify({definition:r,params:e})}async executeAggregation(r,e){let t=[...r.dimensions.map((u)=>({name:u.name,type:u.type==="NUMBER"?"NUMBER":u.type==="TIME"?"DATE":"STRING",label:u.name})),...r.measures.map((u)=>({name:u.name,type:"NUMBER",label:u.name,format:u.format}))],n=this.generateMockData(r,e);return{data:n,columns:t,rowCount:n.length,executionTimeMs:0,cached:!1}}async executeMetric(r,e){let t=r.map((n)=>({metricId:n,value:Math.random()*1000,change:(Math.random()-0.5)*20}));return{data:t,columns:[{name:"metricId",type:"STRING"},{name:"value",type:"NUMBER"},{name:"change",type:"NUMBER"}],rowCount:t.length,executionTimeMs:0,cached:!1}}async executeSql(r,e){return{data:[],columns:[],rowCount:0,executionTimeMs:0,cached:!1,error:"SQL execution not implemented in demo"}}generateMockData(r,e){let t=[],n=10,u=r.dimensions.find((s)=>s.type==="TIME");for(let s=0;s<10;s++){let c={};for(let o of r.dimensions)if(o.type==="TIME"){let l=new Date(e.dateRange?.start??new Date);l.setDate(l.getDate()+s),c[o.name]=l.toISOString().split("T")[0]}else c[o.name]=`${o.name}_${s%5}`;for(let o of r.measures){let l=u?100+s*10:Math.random()*1000,a=(Math.random()-0.5)*20;c[o.name]=Math.round((l+a)*100)/100}t.push(c)}return t}}function v(r){return new g(r)}export{v as createQueryEngine,Q as createPosthogQueryEngine,m as PosthogQueryEngine,h as InMemoryQueryCache,g as BasicQueryEngine};

package/dist/browser/seeders/index.js

@@ -1,20 +1,2 @@
-// src/seeders/index.ts
-async function seedAnalyticsDashboard(params) {
-  const { projectId, db } = params;
-  const existing = await db.query(`SELECT COUNT(*) as count FROM analytics_dashboard WHERE "projectId" = $1`, [projectId]);
-  if (existing.rows[0]?.count > 0)
-    return;
-  await db.execute(`INSERT INTO analytics_dashboard (id, "projectId", "organizationId", name, slug, description, status)
-     VALUES ($1, $2, $3, $4, $5, $6, $7)`, [
-    "dash_1",
-    projectId,
-    "org_demo",
-    "Sales Overview",
-    "sales-overview",
-    "Sales performance dashboard",
-    "PUBLISHED"
-  ]);
-}
-export {
-  seedAnalyticsDashboard
-};
+async function o(e){let{projectId:a,db:t}=e;if((await t.query('SELECT COUNT(*) as count FROM analytics_dashboard WHERE "projectId" = $1',[a])).rows[0]?.count>0)return;await t.execute(`INSERT INTO analytics_dashboard (id, "projectId", "organizationId", name, slug, description, status)
+     VALUES ($1, $2, $3, $4, $5, $6, $7)`,["dash_1",a,"org_demo","Sales Overview","sales-overview","Sales performance dashboard","PUBLISHED"])}export{o as seedAnalyticsDashboard};