measurr 0.1.0

package/dist/index-e6k30sfp.js

@@ -0,0 +1,218 @@
+// src/expr.ts
+class Expr2 {
+  node;
+  sqlType;
+  valueType;
+  constructor(node) {
+    this.node = node;
+  }
+  isNull() {
+    return new Expr2({ kind: "isNull", item: this.node, negated: false });
+  }
+  isNotNull() {
+    return new Expr2({ kind: "isNull", item: this.node, negated: true });
+  }
+  add(other) {
+    return arithmetic("+", this, other);
+  }
+  sub(other) {
+    return arithmetic("-", this, other);
+  }
+  mul(other) {
+    return arithmetic("*", this, other);
+  }
+  div(other) {
+    return arithmetic("/", this, other);
+  }
+}
+function arithmetic(op, left, right) {
+  return new Expr2({
+    kind: "arithmetic",
+    op,
+    left: left.node,
+    right: toNode(right)
+  });
+}
+
+class Table2 {
+  ref;
+  row;
+  constructor(ref) {
+    this.ref = ref;
+  }
+  col(key) {
+    return new Expr2({
+      kind: "column",
+      table: this.ref,
+      column: key
+    });
+  }
+  leftJoin(other, on) {
+    return this.join("left", other, on);
+  }
+  innerJoin(other, on) {
+    return this.join("inner", other, on);
+  }
+  join(type, other, on) {
+    const ref = {
+      name: other.ref.name,
+      alias: other.ref.alias,
+      join: undefined
+    };
+    const joined = new Table2(ref);
+    ref.join = { type, parent: this.ref, on: on(joined).node };
+    return joined;
+  }
+}
+function table2(name, alias) {
+  return new Table2({ name, alias, join: undefined });
+}
+function toNode(value) {
+  if (value instanceof Expr2)
+    return value.node;
+  return { kind: "param", value };
+}
+function literal2(value) {
+  return new Expr2({ kind: "param", value });
+}
+function compare(op, left, right) {
+  return new Expr2({
+    kind: "compare",
+    op,
+    left: left.node,
+    right: toNode(right)
+  });
+}
+function eq2(left, right) {
+  return compare("=", left, right);
+}
+function ne2(left, right) {
+  return compare("<>", left, right);
+}
+function gt2(left, right) {
+  return compare(">", left, right);
+}
+function gte2(left, right) {
+  return compare(">=", left, right);
+}
+function lt2(left, right) {
+  return compare("<", left, right);
+}
+function lte2(left, right) {
+  return compare("<=", left, right);
+}
+function and2(...items) {
+  return new Expr2({
+    kind: "logical",
+    op: "and",
+    items: items.map((i) => i.node)
+  });
+}
+function or2(...items) {
+  return new Expr2({
+    kind: "logical",
+    op: "or",
+    items: items.map((i) => i.node)
+  });
+}
+function not2(item) {
+  if (item.node.kind === "exists") {
+    return new Expr2({ ...item.node, negated: !item.node.negated });
+  }
+  return new Expr2({ kind: "not", item: item.node });
+}
+function isNull2(item) {
+  return item.isNull();
+}
+function isNotNull2(item) {
+  return item.isNotNull();
+}
+function caseWhen2(branches, otherwise) {
+  if (branches.length === 0) {
+    throw new Error("caseWhen needs at least one branch");
+  }
+  return new Expr2({
+    kind: "case",
+    branches: branches.map(([when, then]) => ({
+      when: when.node,
+      result: toNode(then)
+    })),
+    otherwise: otherwise === undefined ? null : toNode(otherwise)
+  });
+}
+function exists2(from, where) {
+  return new Expr2({
+    kind: "exists",
+    table: from.ref,
+    where: where.node,
+    negated: false
+  });
+}
+function coalesce2(first, ...rest) {
+  return new Expr2({
+    kind: "coalesce",
+    items: [first.node, ...rest.map((item) => toNode(item))]
+  });
+}
+function inList2(item, values) {
+  return new Expr2({
+    kind: "in",
+    item: item.node,
+    values: values.map((value) => toNode(value)),
+    negated: false
+  });
+}
+function toText2(item) {
+  return new Expr2({ kind: "toText", item: item.node });
+}
+function minutesAgo2(minutes) {
+  return new Expr2({ kind: "minutesAgo", minutes });
+}
+function rootOf(ref) {
+  let current = ref;
+  while (current.join)
+    current = current.join.parent;
+  return current;
+}
+function directChildren(node) {
+  switch (node.kind) {
+    case "compare":
+    case "arithmetic":
+      return [node.left, node.right];
+    case "logical":
+    case "coalesce":
+      return node.items;
+    case "not":
+    case "isNull":
+    case "lower":
+    case "toText":
+    case "timeBucket":
+    case "timePart":
+      return [node.item];
+    case "in":
+      return [node.item, ...node.values];
+    case "case":
+      return [
+        ...node.branches.flatMap((branch) => [branch.when, branch.result]),
+        ...node.otherwise ? [node.otherwise] : []
+      ];
+    case "aggregate":
+      return [
+        ...node.arg ? [node.arg] : [],
+        ...node.where ? [node.where] : []
+      ];
+    case "exists":
+      return [node.where];
+    case "column":
+    case "param":
+    case "minutesAgo":
+      return [];
+  }
+}
+function walk(node, visit) {
+  visit(node);
+  for (const child of directChildren(node))
+    walk(child, visit);
+}
+
+export { Expr2, Table2, table2, literal2, eq2, ne2, gt2, gte2, lt2, lte2, and2, or2, not2, isNull2, isNotNull2, caseWhen2, exists2, coalesce2, inList2, toText2, minutesAgo2, rootOf, directChildren, walk };