measurr 0.1.0

package/dist/testing.js

@@ -0,0 +1,191 @@
+import {
+  MAX_MEASURES,
+  createAnalytics2,
+  measure2,
+  dimension2
+} from "./index-m0czpsyv.js";
+
+// src/testing.ts
+var COUNT = "__contractCount";
+var dayKey = (time) => `__contractDay_${time}`;
+async function checkDatasetContract(options) {
+  const { dataset } = options;
+  const timezone = options.timezone ?? "Pacific/Auckland";
+  const period = options.period ?? { last: { days: 365 } };
+  const emptyTenant = options.emptyTenant ?? (typeof options.tenant === "number" ? -1 : "__contract_empty_tenant__");
+  const probe = {
+    ...dataset,
+    measures: {
+      ...dataset.measures,
+      [COUNT]: measure2.count({ label: "Rows" })
+    },
+    dimensions: {
+      ...dataset.dimensions,
+      ...Object.fromEntries(Object.keys(dataset.time).map((time) => [
+        dayKey(time),
+        dimension2.timeBucket(time, "day")
+      ]))
+    }
+  };
+  const analytics = createAnalytics2({
+    datasets: [probe],
+    sources: { main: options.source },
+    tenant: (ctx) => ctx.tenant,
+    timezone: () => timezone,
+    ...options.now && { now: options.now }
+  });
+  const run = async (query, tenant = options.tenant) => {
+    const input = { dataset: dataset.key, period, limit: 100, ...query };
+    return await analytics.query(input, {
+      tenant
+    });
+  };
+  const checks = [];
+  const check = async (name, body) => {
+    try {
+      const problem = await body();
+      checks.push({ name, ok: problem === undefined, message: problem });
+    } catch (error) {
+      checks.push({
+        name,
+        ok: false,
+        message: error instanceof Error ? error.message : String(error)
+      });
+    }
+  };
+  const total = (await run({ measures: [COUNT] })).totals[COUNT] ?? 0;
+  if (total === 0) {
+    checks.push({
+      name: "seeded rows",
+      ok: false,
+      message: `Tenant ${options.tenant} has no rows in the period; the checks below prove little`
+    });
+  }
+  for (const key of Object.keys(dataset.measures)) {
+    await check(`measure ${key}`, async () => {
+      const value = (await run({ measures: [key] })).totals[key];
+      if (value !== null && typeof value !== "number")
+        return `returned ${String(value)}`;
+      if (typeof value === "number" && Number.isNaN(value))
+        return "returned NaN";
+      return;
+    });
+  }
+  const dimensions = Object.entries(dataset.dimensions);
+  for (const [key, entry] of dimensions) {
+    if (entry.groupable) {
+      await check(`group by ${key}`, async () => {
+        const result = await run({ measures: [COUNT], groupBy: [key] });
+        if (entry.kind === "manyToMany" || result.truncated)
+          return;
+        const sum = result.rows.reduce((acc, row) => acc + Number(row[COUNT] ?? 0), 0);
+        return sum === total ? undefined : `groups add up to ${sum}, the total is ${total}`;
+      });
+    }
+    if (entry.filterable) {
+      await check(`filter ${key} by emptiness`, async () => {
+        const empty = await run({
+          measures: [COUNT],
+          filters: [{ dimension: key, op: "isEmpty" }]
+        });
+        const notEmpty = await run({
+          measures: [COUNT],
+          filters: [{ dimension: key, op: "isNotEmpty" }]
+        });
+        const sum = (empty.totals[COUNT] ?? 0) + (notEmpty.totals[COUNT] ?? 0);
+        return sum === total ? undefined : `isEmpty + isNotEmpty is ${sum}, the total is ${total}`;
+      });
+    }
+    if (entry.filterable && entry.groupable && entry.category === "open") {
+      await check(`filter ${key} by label`, async () => {
+        const grouped = await run({ measures: [COUNT], groupBy: [key] });
+        const first = grouped.rows.find((row) => {
+          const value = row[key];
+          return typeof value === "object" && value !== null && value.key !== null;
+        });
+        const value = first?.[key];
+        if (!first || typeof value !== "object" || value === null)
+          return;
+        const filtered = await run({
+          measures: [COUNT],
+          filters: [{ dimension: key, op: "in", values: [value.label] }]
+        });
+        const expected = Number(first[COUNT]);
+        const actual = filtered.totals[COUNT];
+        return actual === expected ? undefined : `filtering by the label "${value.label}" counts ${actual}, its group counts ${expected}`;
+      });
+    }
+    if (entry.filterable && entry.category === "closed") {
+      await check(`filter ${key} by value`, async () => {
+        const [first] = Object.keys(entry.kind === "enum" || entry.kind === "computed" ? entry.values : {});
+        if (first === undefined)
+          return "lists no values";
+        await run({
+          measures: [COUNT],
+          filters: [{ dimension: key, op: "in", values: [first] }]
+        });
+        return;
+      });
+    }
+  }
+  await check("tenant isolation", async () => {
+    const measures = Object.keys(probe.measures);
+    const leaked = [];
+    for (let start = 0;start < measures.length; start += MAX_MEASURES) {
+      const batch = measures.slice(start, start + MAX_MEASURES);
+      const other = await run({ measures: batch }, emptyTenant);
+      leaked.push(...Object.entries(other.totals).filter(([, value]) => value !== 0 && value !== null));
+    }
+    if (leaked.length > 0) {
+      return `an empty tenant sees ${leaked.map(([key, value]) => `${key}=${value}`).join(", ")}`;
+    }
+    for (const [key, entry] of dimensions) {
+      if (!entry.groupable)
+        continue;
+      const grouped = await run({ measures: [COUNT], groupBy: [key] }, emptyTenant);
+      if (grouped.rows.length > 0)
+        return `an empty tenant sees ${grouped.rows.length} ${key} groups`;
+    }
+    return;
+  });
+  for (const time of Object.keys(dataset.time)) {
+    await check(`day buckets of ${time} in ${timezone}`, async () => {
+      const days = await run({
+        measures: [COUNT],
+        groupBy: [dayKey(time)],
+        time,
+        sort: { by: COUNT, direction: "desc" }
+      });
+      for (const row of days.rows.slice(0, 5)) {
+        const bucket = row[dayKey(time)];
+        if (typeof bucket !== "object" || bucket === null || typeof bucket.key !== "string")
+          continue;
+        const day = await run({
+          measures: [COUNT],
+          time,
+          period: { from: bucket.key, to: bucket.key }
+        });
+        if (day.totals[COUNT] !== row[COUNT]) {
+          return `the ${bucket.key} bucket counts ${row[COUNT]}, the period ${bucket.key} counts ${day.totals[COUNT]}`;
+        }
+      }
+      return;
+    });
+  }
+  return { ok: checks.every((entry) => entry.ok), checks };
+}
+async function assertDatasetContract(options) {
+  const report = await checkDatasetContract(options);
+  const failed = report.checks.filter((entry) => !entry.ok);
+  if (failed.length > 0) {
+    const lines = failed.map((entry) => `- ${entry.name}: ${entry.message}`);
+    throw new Error(`Dataset ${options.dataset.key} breaks the contract:
+${lines.join(`
+`)}`);
+  }
+  return report;
+}
+export {
+  assertDatasetContract,
+  checkDatasetContract
+};

package/package.json

@@ -0,0 +1,84 @@
+{
+	"name": "measurr",
+	"version": "0.1.0",
+	"description": "A small typed semantic layer: datasets of measures and dimensions compiled to one SQL statement per dialect.",
+	"type": "module",
+	"module": "./dist/index.js",
+	"main": "./dist/index.js",
+	"types": "./dist/index.d.ts",
+	"license": "MIT",
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/HansKristoffer/measurr.git"
+	},
+	"homepage": "https://github.com/HansKristoffer/measurr#readme",
+	"bugs": {
+		"url": "https://github.com/HansKristoffer/measurr/issues"
+	},
+	"author": "Kristoffer Hansen",
+	"keywords": [
+		"typescript",
+		"semantic-layer",
+		"analytics",
+		"sql",
+		"postgres",
+		"zod",
+		"llm-tools"
+	],
+	"files": [
+		"src/**/*.ts",
+		"dist",
+		"!src/**/*.test.ts",
+		"!src/fixtures"
+	],
+	"sideEffects": false,
+	"exports": {
+		".": {
+			"types": "./dist/index.d.ts",
+			"bun": "./src/index.ts",
+			"import": "./dist/index.js",
+			"default": "./dist/index.js"
+		},
+		"./postgres": {
+			"types": "./dist/dialects/postgres.d.ts",
+			"bun": "./src/dialects/postgres.ts",
+			"import": "./dist/dialects/postgres.js",
+			"default": "./dist/dialects/postgres.js"
+		},
+		"./testing": {
+			"types": "./dist/testing.d.ts",
+			"bun": "./src/testing.ts",
+			"import": "./dist/testing.js",
+			"default": "./dist/testing.js"
+		}
+	},
+	"scripts": {
+		"build": "rm -rf dist && bun run build:js && bun run build:types",
+		"build:js": "bun build ./src/index.ts ./src/dialects/postgres.ts ./src/testing.ts --root ./src --outdir ./dist --target node --packages external --splitting",
+		"build:types": "tsgo -p tsconfig.build.json",
+		"prepublishOnly": "bun run build",
+		"test": "bun test",
+		"lint": "bun run typecheck && biome check",
+		"lint:write": "bun run typecheck && biome check --write",
+		"typecheck": "tsgo --noEmit",
+		"prepare": "husky",
+		"verify:package": "node scripts/verify-package.mjs"
+	},
+	"devDependencies": {
+		"@biomejs/biome": "^2.5.15",
+		"@types/bun": "latest",
+		"@typescript/native-preview": "^7.0.0-dev.20260306.1",
+		"husky": "^9.1.7",
+		"zod": "^4.3.6"
+	},
+	"peerDependencies": {
+		"typescript": ">=6.0.0",
+		"zod": "^4.0.0"
+	},
+	"peerDependenciesMeta": {
+		"typescript": {
+			"optional": true
+		}
+	},
+	"packageManager": "bun@1.4.2"
+}