measurr 0.3.0 → 0.5.0

package/dist/handler.js

@@ -0,0 +1,49 @@
+import {
+  AnalyticsError2
+} from "./index-zgb1e89d.js";
+
+// src/handler.ts
+async function queryBatch(analytics, queries, ctx) {
+  const results = {};
+  const errors = {};
+  for await (const chunk of streamBatch(analytics, queries, ctx)) {
+    if ("error" in chunk)
+      errors[chunk.key] = chunk.error;
+    else
+      results[chunk.key] = chunk.result;
+  }
+  return { results, errors };
+}
+async function* streamBatch(analytics, queries, ctx) {
+  const pending = new Map(Object.entries(queries).map(([key, query]) => {
+    const settled = analytics.query(query, ctx).then((result) => ({ key, result }), (error) => ({ key, error: batchError(error) }));
+    return [key, settled];
+  }));
+  while (pending.size > 0) {
+    const chunk = await Promise.race(pending.values());
+    pending.delete(chunk.key);
+    yield chunk;
+  }
+}
+function batchError(error) {
+  return error instanceof AnalyticsError2 ? { code: error.code, message: error.message } : { code: "internal", message: "The query failed" };
+}
+function toHttpError(error) {
+  if (error.code === "forbidden") {
+    return { status: 403, code: "FORBIDDEN", message: error.message };
+  }
+  if (error.code === "missing_tenant") {
+    return { status: 401, code: "UNAUTHORIZED", message: error.message };
+  }
+  return {
+    status: 400,
+    code: "BAD_REQUEST",
+    message: error.message,
+    data: { code: error.code, details: error.details }
+  };
+}
+export {
+  queryBatch,
+  streamBatch,
+  toHttpError
+};

package/dist/index-g255jb1s.js

@@ -0,0 +1,149 @@
+// src/period.ts
+var MAX_PERIOD_DAYS = 731;
+var DEFAULT_PERIOD = {
+  last: { days: 30 }
+};
+var DAY_MS = 86400000;
+var formatterCache = new Map;
+function formatter(timezone) {
+  let cached = formatterCache.get(timezone);
+  if (!cached) {
+    cached = new Intl.DateTimeFormat("en-US", {
+      timeZone: timezone,
+      hourCycle: "h23",
+      year: "numeric",
+      month: "2-digit",
+      day: "2-digit",
+      hour: "2-digit",
+      minute: "2-digit",
+      second: "2-digit"
+    });
+    formatterCache.set(timezone, cached);
+  }
+  return cached;
+}
+function isValidTimezone(timezone) {
+  if (!/^[A-Za-z][A-Za-z0-9_+\-/]*$/.test(timezone))
+    return false;
+  try {
+    formatter(timezone);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function localParts(instant, timezone) {
+  const parts = {};
+  for (const part of formatter(timezone).formatToParts(instant)) {
+    if (part.type !== "literal")
+      parts[part.type] = Number(part.value);
+  }
+  return {
+    year: parts.year ?? 0,
+    month: parts.month ?? 1,
+    day: parts.day ?? 1,
+    hour: parts.hour ?? 0,
+    minute: parts.minute ?? 0,
+    second: parts.second ?? 0
+  };
+}
+function offsetAt(instant, timezone) {
+  const p = localParts(instant, timezone);
+  const asUtc = Date.UTC(p.year, p.month - 1, p.day, p.hour, p.minute, p.second);
+  return asUtc - (instant.getTime() - instant.getUTCMilliseconds());
+}
+function localDate(instant, timezone) {
+  const p = localParts(instant, timezone);
+  return formatDate(Date.UTC(p.year, p.month - 1, p.day));
+}
+function startOfLocalDay(date, timezone) {
+  const wallClock = parseDate(date);
+  const firstGuess = wallClock - offsetAt(new Date(wallClock), timezone);
+  const corrected = wallClock - offsetAt(new Date(firstGuess), timezone);
+  return new Date(corrected);
+}
+function parseDate(date) {
+  const [year, month, day] = date.split("-").map(Number);
+  return Date.UTC(year ?? 0, (month ?? 1) - 1, day ?? 1);
+}
+function formatDate(utcMs) {
+  return new Date(utcMs).toISOString().slice(0, 10);
+}
+function addDays(date, days) {
+  return formatDate(parseDate(date) + days * DAY_MS);
+}
+function daysBetween(from, to) {
+  return Math.round((parseDate(to) - parseDate(from)) / DAY_MS);
+}
+function isoWeekday(date) {
+  const day = new Date(parseDate(date)).getUTCDay();
+  return day === 0 ? 7 : day;
+}
+
+class PeriodError extends Error {
+  name = "PeriodError";
+}
+function resolvePeriod(input, timezone, now) {
+  const today = localDate(now, timezone);
+  const [from, to] = periodDays(input, today);
+  if (daysBetween(from, to) < 0) {
+    throw new PeriodError(`The period starts (${from}) after it ends (${to}).`);
+  }
+  return periodFromDays(from, to, timezone);
+}
+function periodDays(input, today) {
+  if ("last" in input)
+    return [addDays(today, -(input.last.days - 1)), today];
+  if ("from" in input)
+    return [input.from, input.to];
+  const monthStart = `${today.slice(0, 8)}01`;
+  const weekStart = addDays(today, -(isoWeekday(today) - 1));
+  switch (input.preset) {
+    case "today":
+      return [today, today];
+    case "yesterday":
+      return [addDays(today, -1), addDays(today, -1)];
+    case "thisWeek":
+      return [weekStart, today];
+    case "lastWeek":
+      return [addDays(weekStart, -7), addDays(weekStart, -1)];
+    case "thisMonth":
+      return [monthStart, today];
+    case "lastMonth": {
+      const lastMonthEnd = addDays(monthStart, -1);
+      return [`${lastMonthEnd.slice(0, 8)}01`, lastMonthEnd];
+    }
+    case "thisYear":
+      return [`${today.slice(0, 4)}-01-01`, today];
+  }
+}
+function periodFromDays(from, to, timezone) {
+  const days = daysBetween(from, to) + 1;
+  if (days > MAX_PERIOD_DAYS) {
+    throw new PeriodError(`A period may cover at most ${MAX_PERIOD_DAYS} days (two years); ${from} to ${to} is ${days} days.`);
+  }
+  return {
+    from,
+    to,
+    timezone,
+    start: startOfLocalDay(from, timezone),
+    end: startOfLocalDay(addDays(to, 1), timezone),
+    days
+  };
+}
+function previousPeriod(period) {
+  const to = addDays(period.from, -1);
+  const from = addDays(to, -(period.days - 1));
+  return periodFromDays(from, to, period.timezone);
+}
+function bucketStarts(from, to, unit) {
+  let start = unit === "day" ? from : unit === "week" ? addDays(from, -(isoWeekday(from) - 1)) : `${from.slice(0, 8)}01`;
+  const starts = [];
+  while (start <= to) {
+    starts.push(start);
+    start = unit === "day" ? addDays(start, 1) : unit === "week" ? addDays(start, 7) : formatDate(Date.UTC(Number(start.slice(0, 4)), Number(start.slice(5, 7)), 1));
+  }
+  return starts;
+}
+
+export { MAX_PERIOD_DAYS, DEFAULT_PERIOD, isValidTimezone, PeriodError, resolvePeriod, previousPeriod, bucketStarts };

package/dist/index-g2mjqx4f.js

@@ -0,0 +1,303 @@
+import {
+  rootOf,
+  directChildren
+} from "./index-e6k30sfp.js";
+import {
+  DEFAULT_PERIOD
+} from "./index-g255jb1s.js";
+
+// src/dataset.ts
+function aggregate(result, fn, arg, options) {
+  return {
+    kind: "aggregate",
+    result,
+    label: options.label,
+    description: options.description,
+    access: options.access,
+    node: {
+      kind: "aggregate",
+      fn,
+      arg: arg?.node ?? null,
+      where: options.where?.node ?? null
+    }
+  };
+}
+var measure2 = {
+  count(options) {
+    return aggregate("count", "count", null, options);
+  },
+  countWhere(condition, options) {
+    return aggregate("count", "count", null, { ...options, where: condition });
+  },
+  countDistinct(expr, options) {
+    return aggregate("count", "countDistinct", expr, options);
+  },
+  sum(expr, options) {
+    return aggregate("number", "sum", expr, options);
+  },
+  avg(expr, options) {
+    return aggregate("number", "avg", expr, options);
+  },
+  median(expr, options) {
+    return aggregate("number", "median", expr, options);
+  },
+  share(options) {
+    return {
+      kind: "share",
+      result: "ratio",
+      label: options.label,
+      description: options.description,
+      access: options.access,
+      numerator: options.numerator.node,
+      denominator: options.denominator?.node ?? null
+    };
+  },
+  ratio(numerator, denominator, options) {
+    return {
+      kind: "ratio",
+      result: "ratio",
+      label: options.label,
+      description: options.description,
+      access: options.access,
+      numerator,
+      denominator
+    };
+  }
+};
+function base(options) {
+  return {
+    label: options.label,
+    description: options.description,
+    access: options.access,
+    groupable: options.filterOnly !== true,
+    filterable: options.groupOnly !== true
+  };
+}
+function withAccess(_options, dimension) {
+  return dimension;
+}
+var dimension2 = {
+  enum(expr, values, options) {
+    for (const value of Object.values(values)) {
+      if (!(value in options.labels)) {
+        throw new Error(`${options.label}: the value ${value} has no label`);
+      }
+    }
+    return withAccess(options, {
+      ...base(options),
+      category: "closed",
+      kind: "enum",
+      expr: expr.node,
+      values: options.labels,
+      empty: options.empty
+    });
+  },
+  computed(options) {
+    return withAccess(options, {
+      ...base(options),
+      category: "closed",
+      kind: "computed",
+      expr: options.expr.node,
+      values: options.values,
+      empty: options.empty
+    });
+  },
+  relation(options) {
+    return withAccess(options, {
+      ...base(options),
+      category: "open",
+      kind: "relation",
+      key: options.key.node,
+      name: options.name.node,
+      empty: options.empty
+    });
+  },
+  manyToMany(options) {
+    return withAccess(options, {
+      ...base(options),
+      category: "open",
+      kind: "manyToMany",
+      table: options.through.table.ref,
+      on: options.through.on.node,
+      key: options.through.key.node,
+      name: options.through.name.node,
+      empty: options.empty,
+      note: options.note
+    });
+  },
+  number(expr, options) {
+    return withAccess(options, {
+      ...base(options),
+      category: "numeric",
+      kind: "number",
+      expr: expr.node,
+      labelFor: options.labelFor
+    });
+  },
+  timeBucket(time, unit, options) {
+    return withAccess(options, {
+      ...base({
+        ...options,
+        label: options?.label ?? unit[0]?.toUpperCase() + unit.slice(1)
+      }),
+      category: "time",
+      kind: "timeBucket",
+      time,
+      unit,
+      labelFor: options?.labelFor
+    });
+  },
+  timePart(time, part, options) {
+    return withAccess(options, {
+      ...base({
+        ...options,
+        label: options?.label ?? (part === "isodow" ? "Weekday" : "Hour")
+      }),
+      category: "numeric",
+      kind: "timePart",
+      time,
+      part,
+      labelFor: options?.labelFor
+    });
+  }
+};
+function defineDataset2(definition) {
+  const timeEntries = Object.entries(definition.time);
+  const firstTime = timeEntries[0];
+  if (!firstTime) {
+    throw new Error(`Dataset ${definition.key}: declare at least one time field`);
+  }
+  if (definition.tenantColumn === undefined) {
+    throw new Error(`Dataset ${definition.key}: declare tenantColumn, or null for a dataset without tenants`);
+  }
+  const time = Object.fromEntries(timeEntries.map(([key, field]) => [
+    key,
+    { column: field.column.node, label: field.label }
+  ]));
+  const dataset = {
+    key: definition.key,
+    label: definition.label,
+    description: definition.description,
+    from: definition.from.ref,
+    source: definition.source,
+    tenantColumn: definition.tenantColumn?.node ?? null,
+    scope: definition.scope?.node ?? null,
+    time,
+    defaultTime: definition.defaultTime ?? firstTime[0],
+    defaultPeriod: definition.defaultPeriod ?? DEFAULT_PERIOD,
+    measures: definition.measures,
+    dimensions: definition.dimensions
+  };
+  return validateDataset(dataset);
+}
+function validateDataset(dataset) {
+  const fail = (message) => {
+    throw new Error(`Dataset ${dataset.key}: ${message}`);
+  };
+  const check = (node, where, extraRoots = []) => {
+    visitScoped(node, [dataset.from, ...extraRoots], (inner, roots) => {
+      if (inner.kind === "column") {
+        const root = rootOf(inner.table);
+        if (!roots.includes(root)) {
+          fail(`${where} reads ${inner.table.name}.${inner.column}, which is not joined to ${dataset.from.name}`);
+        }
+      }
+    });
+  };
+  if (dataset.tenantColumn)
+    check(dataset.tenantColumn, "tenantColumn");
+  if (dataset.scope)
+    check(dataset.scope, "scope");
+  for (const [key, field] of Object.entries(dataset.time)) {
+    check(field.column, `time field ${key}`);
+  }
+  const measures = dataset.measures;
+  for (const [key, entry] of Object.entries(measures)) {
+    if (entry.kind === "aggregate")
+      check(entry.node, `measure ${key}`);
+    if (entry.kind === "share") {
+      check(entry.numerator, `measure ${key}`);
+      if (entry.denominator)
+        check(entry.denominator, `measure ${key}`);
+    }
+    if (entry.kind === "ratio")
+      checkRatio(measures, key, [], fail);
+  }
+  const dimensions = dataset.dimensions;
+  for (const [key, entry] of Object.entries(dimensions)) {
+    const where = `dimension ${key}`;
+    switch (entry.kind) {
+      case "enum":
+      case "number":
+        check(entry.expr, where);
+        break;
+      case "computed":
+        check(entry.expr, where);
+        for (const value of plainCaseValues(entry.expr)) {
+          if (!(value in entry.values)) {
+            fail(`${where} can produce "${value}", which is missing from its values`);
+          }
+        }
+        break;
+      case "relation":
+        check(entry.key, where);
+        check(entry.name, where);
+        break;
+      case "manyToMany":
+        if (entry.table.join) {
+          fail(`${where}: through.table must be a standalone table(), not a join`);
+        }
+        check(entry.on, where, [entry.table]);
+        check(entry.key, where, [entry.table]);
+        check(entry.name, where, [entry.table]);
+        break;
+      case "timeBucket":
+      case "timePart":
+        if (!(entry.time in dataset.time))
+          fail(`${where} names unknown time field ${entry.time}`);
+        break;
+    }
+  }
+  return dataset;
+}
+function checkRatio(measures, key, path, fail) {
+  if (path.includes(key))
+    fail(`ratio measures form a cycle: ${[...path, key].join(" -> ")}`);
+  const entry = measures[key];
+  if (!entry)
+    fail(`ratio measure ${path.at(-1)} names unknown measure ${key}`);
+  if (entry?.kind !== "ratio")
+    return;
+  checkRatio(measures, entry.numerator, [...path, key], fail);
+  checkRatio(measures, entry.denominator, [...path, key], fail);
+}
+function visitScoped(node, roots, visit, seenJoins = new Set) {
+  visit(node, roots);
+  if (node.kind === "exists") {
+    visitScoped(node.where, [...roots, node.table], visit, seenJoins);
+    return;
+  }
+  if (node.kind === "column" && node.table.join && !seenJoins.has(node.table)) {
+    seenJoins.add(node.table);
+    visitScoped(node.table.join.on, roots, visit, seenJoins);
+    return;
+  }
+  for (const child of directChildren(node)) {
+    visitScoped(child, roots, visit, seenJoins);
+  }
+}
+function plainCaseValues(node) {
+  if (node.kind === "param" && typeof node.value === "string")
+    return [node.value];
+  if (node.kind === "case") {
+    return [
+      ...node.branches.flatMap((branch) => plainCaseValues(branch.result)),
+      ...node.otherwise ? plainCaseValues(node.otherwise) : []
+    ];
+  }
+  if (node.kind === "coalesce")
+    return node.items.flatMap(plainCaseValues);
+  return [];
+}
+
+export { measure2, dimension2, defineDataset2 };