measurr 0.4.0 → 0.6.0

package/dist/index-pgccd363.js

@@ -0,0 +1,303 @@
+import {
+  rootOf,
+  directChildren
+} from "./index-e6k30sfp.js";
+import {
+  DEFAULT_PERIOD
+} from "./index-115syy01.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 };

package/dist/index-xf6qpmgy.js

@@ -0,0 +1,46 @@
+import {
+  AnalyticsError2
+} from "./index-z5xv3ffk.js";
+
+// src/handler.ts
+async function queryBatch2(analytics, queries, ctx) {
+  const results = {};
+  const errors = {};
+  for await (const chunk of streamBatch2(analytics, queries, ctx)) {
+    if ("error" in chunk)
+      errors[chunk.key] = chunk.error;
+    else
+      results[chunk.key] = chunk.result;
+  }
+  return { results, errors };
+}
+async function* streamBatch2(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 toHttpError2(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 { queryBatch2, streamBatch2, toHttpError2 };