@protobase/query 0.28.1 → 0.28.2

package/dist/group-totals.d.ts

@@ -16,6 +16,7 @@ export type GroupTotal = {
   count: number;
   sum?: number | null;
   average?: number | null;
+  maximum?: number | null;
 };
 /**
  * Rows per value of `field` under the whole filter, largest first: by the measure when there is one, else by count.

package/dist/measure.d.ts

@@ -1,8 +1,8 @@
 import { ResourceModel } from "@protobase/schema";
 //#region src/measure.d.ts
-/** What a group adds up besides its count: the sum or the average of a numeric field over its rows. */
+/** What a group adds up besides its count: the sum, the average or the maximum of a numeric field over its rows. */
 export type Measure = {
-  kind: 'sum' | 'average';
+  kind: 'sum' | 'average' | 'maximum';
   field: string;
 };
 //#endregion

package/dist/measure.js

@@ -7,13 +7,18 @@ const numericTypes = [
 	"bigint",
 	"decimal"
 ];
+const aggregates = {
+	sum: "sum",
+	average: "avg",
+	maximum: "max"
+};
 /** The SQL aggregate of a measure; select it `::text`, so a decimal keeps its digits until it is read. */
 const measureSql = (model, measure) => {
 	const field = findField(model, measure.field);
 	if (!numericTypes.includes(field.type)) throw new QueryError("unsupported_field_type", `A ${measure.kind} needs a numeric field, "${measure.field}" is ${field.type}`);
 	if (field.sensitive) throw new QueryError("unsupported_field_type", `"${measure.field}" is sensitive, so it cannot be added up`);
 	const column = columnRef(field);
-	return measure.kind === "sum" ? sql`sum(${column})` : sql`avg(${column})`;
+	return sql`${sql.raw(aggregates[measure.kind])}(${column})`;
 };
 /** A measure's value: `null` when no row of the group has a value to add up. */
 const measureValue = (raw) => raw === null || raw === void 0 ? null : Number(raw);

package/dist/series-buckets.d.ts

@@ -2,6 +2,9 @@ import { sql } from "kysely";
 import { ResourceModel } from "@protobase/schema";
 //#region src/series-buckets.d.ts
 declare const approxMs: {
+  minute: number;
+  '5_minutes': number;
+  '15_minutes': number;
   hour: number;
   day: number;
   week: number;

package/dist/series-buckets.js

@@ -5,12 +5,19 @@ import { sql } from "kysely";
 //#region src/series-buckets.ts
 const maxBuckets = 1e4;
 const approxMs = {
+	minute: 6e4,
+	"5_minutes": 3e5,
+	"15_minutes": 9e5,
 	hour: 36e5,
 	day: 864e5,
 	week: 6048e5,
 	month: 26298e5,
 	year: 315576e5
 };
+const minuteStrides = {
+	"5_minutes": "5 minutes",
+	"15_minutes": "15 minutes"
+};
 const checkTimeZone = (timeZone) => {
 	try {
 		new Intl.DateTimeFormat("en", { timeZone });
@@ -35,8 +42,9 @@ const seriesBuckets = (model, field, options) => {
 	if (!(spanMs > 0)) throw new QueryError("invalid_option", "range.to must be after range.from");
 	if (spanMs / approxMs[options.granularity] > maxBuckets) throw new QueryError("invalid_option", `Range spans more than ${maxBuckets} buckets`);
 	const col = columnRef(target);
-	const unit = sql.lit(options.granularity);
-	const step = sql`${sql.lit(`1 ${options.granularity}`)}::interval`;
+	const stride = minuteStrides[options.granularity];
+	const step = sql`${sql.lit(stride ?? `1 ${options.granularity}`)}::interval`;
+	const truncate = (value) => stride ? sql`date_bin(${step}, ${value}, timestamp '2000-01-01')` : sql`date_trunc(${sql.lit(options.granularity)}, ${value})`;
 	const isDate = target.type === "date";
 	const bound = sql.raw(isDate ? "date" : "timestamptz");
 	const local = (value) => isDate ? sql`${value}::timestamp` : sql`(${value}::timestamptz at time zone ${timeZone}::text)`;
@@ -45,11 +53,11 @@ const seriesBuckets = (model, field, options) => {
 		col,
 		from,
 		to,
-		unit,
+		truncate,
 		step,
 		bound,
 		local,
-		laterBucket: sql`date_trunc(${unit}, ${local(to)} - interval '1 microsecond')`,
+		laterBucket: truncate(sql`${local(to)} - interval '1 microsecond'`),
 		isDate
 	};
 };

package/dist/series.d.ts

@@ -15,9 +15,10 @@ export type SeriesPoint = {
   count: number;
   sum?: number | null;
   average?: number | null;
+  maximum?: number | null;
 };
 /**
- * Row counts per calendar bucket, in `timeZone`, with empty buckets present. `to` is exclusive.
+ * Row counts per calendar bucket (or of 1, 5 or 15 minutes), in `timeZone`, with empty buckets present. `to` is exclusive.
  * Buckets are returned as local ISO strings without offset. `date` fields ignore the time zone;
  * `timestamp` columns without a zone are read in the session time zone. With a measure, a bucket without a row to add
  * up has `null` for it.

package/dist/series.js

@@ -6,24 +6,24 @@ import { seriesBuckets } from "./series-buckets.js";
 import { sql } from "kysely";
 //#region src/series.ts
 /**
-* Row counts per calendar bucket, in `timeZone`, with empty buckets present. `to` is exclusive.
+* Row counts per calendar bucket (or of 1, 5 or 15 minutes), in `timeZone`, with empty buckets present. `to` is exclusive.
 * Buckets are returned as local ISO strings without offset. `date` fields ignore the time zone;
 * `timestamp` columns without a zone are read in the session time zone. With a measure, a bucket without a row to add
 * up has `null` for it.
 */
 const series = async (db, model, field, options) => {
-	const { col, from, to, unit, step, bound, local, laterBucket, isDate } = seriesBuckets(model, field, options);
+	const { col, from, to, truncate, step, bound, local, laterBucket, isDate } = seriesBuckets(model, field, options);
 	const { measure } = options;
 	const amount = measure ? measureSql(model, measure) : void 0;
 	await assertFilterRequirements(db, options.filter, options.scope);
 	const counts = baseQuery(db, model, options.filter, options.scope).where(sql`${col} >= ${from}::${bound} and ${col} < ${to}::${bound}`).select([
-		sql`date_trunc(${unit}, ${isDate ? sql`${col}::timestamp` : local(col)})`.as("bucket"),
+		truncate(isDate ? sql`${col}::timestamp` : local(col)).as("bucket"),
 		sql`count(*)::text`.as("n"),
 		...amount ? [sql`${amount}::text`.as("m")] : []
 	]).groupBy(sql`1`);
 	return (await sql`
     with b as (
-      select generate_series(date_trunc(${unit}, ${local(from)}), ${laterBucket}, ${step}) as bucket
+      select generate_series(${truncate(local(from))}, ${laterBucket}, ${step}) as bucket
     ), c as (${counts})
     select to_char(b.bucket, 'YYYY-MM-DD"T"HH24:MI:SS') as bucket, coalesce(c.n, '0') as n${amount ? sql`, c.m` : sql``}
     from b left join c on c.bucket = b.bucket

package/dist/split-series.d.ts

@@ -12,6 +12,7 @@ export type SplitPoint = {
   count: number;
   sum?: number | null;
   average?: number | null;
+  maximum?: number | null;
 };
 /**
  * The rows of each calendar bucket of `field` (as `series` buckets it) split by the values of another field.

package/dist/split-series.js

@@ -21,7 +21,7 @@ const unsplittable = [
 * where a value has rows. What the other values hold is the bucket's total from `series` minus its points.
 */
 const splitSeries = async (db, model, field, split, options) => {
-	const { col, from, to, unit, bound, local, isDate } = seriesBuckets(model, field, options);
+	const { col, from, to, truncate, bound, local, isDate } = seriesBuckets(model, field, options);
 	const splitField = requireField(model, split, "filterable");
 	if (unsplittable.includes(splitField.type)) throw new QueryError("unsupported_field_type", `Cannot split by "${split}", which is ${splitField.type}`);
 	if (splitField.sensitive) throw new QueryError("unsupported_field_type", `"${split}" is sensitive, so it cannot be split by`);
@@ -32,7 +32,7 @@ const splitSeries = async (db, model, field, split, options) => {
 	const amount = measure ? measureSql(model, measure) : void 0;
 	await assertFilterRequirements(db, options.filter, options.scope);
 	const splitCol = columnRef(splitField);
-	const bucketSql = sql`to_char(date_trunc(${unit}, ${isDate ? sql`${col}::timestamp` : local(col)}), 'YYYY-MM-DD"T"HH24:MI:SS')`;
+	const bucketSql = sql`to_char(${truncate(isDate ? sql`${col}::timestamp` : local(col))}, 'YYYY-MM-DD"T"HH24:MI:SS')`;
 	const parts = baseQuery(db, model, options.filter, options.scope).where(sql`${col} >= ${from}::${bound} and ${col} < ${to}::${bound}`).select([
 		bucketSql.as("bucket"),
 		sql`${splitCol}`.as("split"),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@protobase/query",
-  "version": "0.28.1",
+  "version": "0.28.2",
   "description": "Kysely list, filter, count and aggregate queries over Protobase resources.",
   "license": "Apache-2.0",
   "repository": {
@@ -29,7 +29,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@protobase/schema": "0.28.1",
+    "@protobase/schema": "0.28.2",
     "kysely": "^0.29.6"
   }
 }