@softr/sdk 0.0.24 → 0.0.26-alpha-0

package/skills/softr-sdk/reading-records/references/field-types.md

@@ -1,70 +1,63 @@
-# Softr field types — TypeScript shapes
+# Softr field types and what their values look like
 
-When you write a TypeScript type for a record's fields, use these shapes. The field's **type** (shown in the datasource metadata or described by the user) determines the shape, not the field's name.
+The generated `softr-env.d.ts` is the authority for your own tables: it types every field of every registered datasource, choice ids included, with the field's name and constraints in a docstring. This reference is the general mapping behind it, for reading a record's values without opening that file.
 
-```ts
-// Simple scalar types
-SINGLE_LINE_TEXT: string
-LONG_TEXT: string
-EMAIL: string
-PHONE: string
-URL: string
-ADDRESS: string
-LOCATION: string
-BUTTON: string
-RECORD_ID: string
-DATETIME: string       // ISO timestamp string
-DATE: string           // ISO date string
-TIME: string
-CREATED_AT: string
-UPDATED_AT: string
-CHECKBOX: string | boolean
-AUTONUMBER: number | null
-NUMBER: number | null
-PERCENT: number | null
-CURRENCY: number | null
-PROGRESS: number | null
-DURATION: number | null
-COUNT: number | null
-RATING: string | number | null
-FORMULA: string | number
-
-// Object types — these are NOT plain strings
-SELECT: { id: string; label: string }
-LINKED_RECORD: { id: string; label: string }
+Three rules cover nullability:
 
-DATE_RANGE: { from: string; to: string }
+- Every field reads back present, `null` when it is empty. Nothing is optional.
+- A multi-entry field is an array, empty rather than `null`.
+- A `CHECKBOX` is a boolean, `false` rather than `null`.
 
+```ts
+// Strings
+SINGLE_LINE_TEXT, LONG_TEXT, ADDRESS, LOCATION, BUTTON, RECORD_ID: string
+EMAIL, PHONE, URL: string
+DATETIME: string            // ISO timestamp, or an ISO date at date precision
+CREATED_AT, UPDATED_AT: string
+TIME: string                // '09:30:00'
+CREATED_BY, UPDATED_BY: string
+
+// Numbers
+NUMBER, PERCENT, CURRENCY, PROGRESS, DURATION, COUNT, RATING, AUTONUMBER: number
+
+// Booleans
+CHECKBOX: boolean
+
+// Objects. These are NOT plain strings
+SELECT: { id: string; label: string }                 // generated with literal id and label unions
+LINKED_RECORD: { id: string; label: string | null }   // label is the linked record's primary field
+DATE_RANGE: { from: string; to: string }
+USER: { id: string; name: string; email: string; avatarUrl: string | null }
 ATTACHMENT: {
-  filename: string | null | undefined
-  id: string | null | undefined
-  type: string | null | undefined
+  id: string | null
+  filename: string | null
+  type: string | null
   url: string
+  expiresAt: string | null
+  size?: number
   thumbnails?: Array<{ size: 'small' | 'medium' | 'large'; url: string }>
 }
 
-USER: { avatarUrl: string | null; id: string; name: string; email: string }
-
-CREATED_BY: string | string[] | { avatarUrl: string | null; id: string; name: string; email: string }
-UPDATED_BY: string | string[] | { avatarUrl: string | null; id: string; name: string; email: string }
-
-// These depend on what the linked field/aggregation resolves to
-LOOKUP: unknown
-ROLLUP: unknown
+// Computed fields read as whatever they return
+FORMULA, LOOKUP, ROLLUP: the returned field's shape, resolved in softr-env.d.ts
 ```
 
+Every scalar above is `| null` on the record unless the field allows multiple entries, in which case the value is an `Array<...>` of the scalar.
+
 ## The non-obvious ones
 
-**SELECT and LINKED_RECORD** are the most commonly mistyped. They are never a plain string — always `{ id: string; label: string }`. To display the value, use `.label`. To filter or compare, use `.id`.
+**SELECT and LINKED_RECORD** are the most commonly mistyped. They are never a plain string, always an `{ id, label }` object. To display the value, use `.label`. To filter or compare, use `.id`. A generated SELECT narrows both to the field's own choices as literal unions.
 
 ```tsx
 // Correct
 <td>{record.fields.status?.label}</td>
 
-// Wrong — status is not a string
+// Wrong: status is not a string
 <td>{record.fields.status}</td>
 ```
 
-**CHECKBOX** can be either a string (`'true'` / `'false'`) or a boolean depending on the datasource. Type it as `string | boolean` and coerce when needed: `!!record.fields.active`.
+**DURATION** is seconds, whatever format the field displays in.
+
+**DATETIME at date precision** is generated as a `DATE` field and holds `'2026-03-14'`, not a timestamp.
 
-**CREATED_BY / UPDATED_BY** can be a plain id string, an array of ids, or a full user object. Narrow before using.
+**LOOKUP and FORMULA** take the shape of what they resolve to, so two lookups on one table can have entirely different types. Read the generated type rather than guessing from the field name.

package/skills/softr-sdk/reading-records/references/query-builder.md

@@ -1,30 +1,27 @@
-# `q`, the query builder
+# Filters and sorting
 
-Every filter, sort and field map passed to `ds` is built with `q`, imported from `@softr/sdk`. Filters and sorts built any other way are rejected at runtime.
-
-```ts
-import { q } from '@softr/sdk'
-```
+Every filter and sort is built inside the callback `where` or `orderBy` hands you. A filter built any other way is rejected at request time.
 
 ## Shape
 
 ```ts
-await ds.list(datasourceId, {
-  select: q.select({ alias: '<field id>', ... }),   // optional field map
-  where: <one filter, or q.and/q.or of filters>,
-  orderBy: q.asc('alias') | [q.desc('a'), q.asc('b')],
-  limit: number,                                // default 20, clamped down to 100
-  offset: number | null,
-})
+await ds
+  .list(action)
+  .where((q) => q.status.is('active'))        // one filter, or a $and/$or of filters
+  .orderBy((q) => q.title.asc)                // or an array of handles
+  .limit(20)                                  // default 20, clamped down to 100
+  .offset(null)                               // a previous result's nextOffset
 ```
 
-`where` takes exactly one value. For more than one condition, wrap them in `q.and(...)` or `q.or(...)`.
+A `where` callback returns exactly one value. For more than one condition, wrap them in `q.$and(...)` or `q.$or(...)`, or call `.where` again: repeated calls are anded.
+
+## Operators by field type
 
-## Field types and operators
+The handle for each field carries the operators its declared type supports, taken from the generated `softr-env.d.ts`. A field with no generated type gets every operator.
 
-Pick the builder that matches the field's type. The type travels with the operator and decides how the value is compared.
+### Text fields
 
-### `q.text(field)`
+`SINGLE_LINE_TEXT`, `LONG_TEXT`, `URL`, `EMAIL`, `PHONE`, `ADDRESS`, `LOCATION`, `TIME`, `BUTTON`, `RECORD_ID`.
 
 | Call | Meaning |
 | --- | --- |
@@ -35,52 +32,56 @@ Pick the builder that matches the field's type. The type travels with the operat
 | `.endsWith(value: string)` | Suffix match |
 | `.isOneOf(values: string[])` | Equal to any of |
 | `.isNoneOf(values: string[])` | Equal to none of |
-| `.hasAllOf(values: string[])` | Contains all of |
-| `.isEmpty()` | No value |
-| `.isNotEmpty()` | Has a value |
+| `.isEmpty()` / `.isNotEmpty()` | No value / has a value |
+
+### Number fields
 
-### `q.number(field)`
+`NUMBER`, `PERCENT`, `CURRENCY`, `PROGRESS`, `RATING`, `DURATION`, `COUNT`, `AUTONUMBER`.
 
 | Call | Meaning |
 | --- | --- |
-| `.is(value: number)` | Equal |
-| `.isNot(value: number)` | Not equal |
-| `.gt(value: number)` | Greater than |
-| `.gte(value: number)` | Greater than or equal |
-| `.lt(value: number)` | Less than |
-| `.lte(value: number)` | Less than or equal |
+| `.is(value: number)` / `.isNot(value: number)` | Equal / not equal |
+| `.gt(value)` / `.gte(value)` / `.lt(value)` / `.lte(value)` | Comparisons |
 | `.between(start: number, end: number)` | Inclusive range |
 | `.isEmpty()` / `.isNotEmpty()` | No value / has a value |
 
-Takes JavaScript numbers.
-
-### `q.boolean(field)`
+### Checkbox fields
 
 | Call | Meaning |
 | --- | --- |
-| `.is(value: boolean)` | Equal |
-| `.isNot(value: boolean)` | Not equal |
+| `.is(value: boolean)` / `.isNot(value: boolean)` | Equal / not equal |
 | `.isEmpty()` / `.isNotEmpty()` | No value / has a value |
 
-### `q.date(field)`
+### Date fields
+
+`DATE`, `DATETIME`, `CREATED_AT`, `UPDATED_AT`.
 
 | Call | Meaning |
 | --- | --- |
-| `.is(value: string)` | On that date |
-| `.isNot(value: string)` | Not on that date |
-| `.gt(value: string)` | After |
-| `.gte(value: string)` | On or after |
-| `.lt(value: string)` | Before |
-| `.lte(value: string)` | On or before |
-| `.between(start: string, end: string)` | Inclusive range |
-| `.isNotBetween(start: string, end: string)` | Outside the range |
+| `.is(value: string)` / `.isNot(value: string)` | On / not on that date |
+| `.gt(value)` / `.gte(value)` | After / on or after |
+| `.lt(value)` / `.lte(value)` | Before / on or before |
+| `.between(start, end)` | Inclusive range |
+| `.isNotBetween(start, end)` | Outside the range |
 | `.isEmpty()` / `.isNotEmpty()` | No value / has a value |
 
 Every value is an ISO date string, either `'2026-01-31'` or a full timestamp. A `Date` instance is not accepted. Call `.toISOString()` first.
 
-### `q.array(field)`
+### Choice fields
+
+`SELECT`, `LINKED_RECORD`, `CREATED_BY`, `UPDATED_BY`.
+
+| Call | Meaning |
+| --- | --- |
+| `.is(value)` / `.isNot(value)` | Equal / not equal |
+| `.isOneOf(values)` / `.isNoneOf(values)` | Any of / none of |
+| `.isEmpty()` / `.isNotEmpty()` | No value / has a value |
+
+Values are choice ids, never labels. A generated SELECT narrows the argument to the field's own choice ids, so a label or a typo is a type error. A LINKED_RECORD compares against the linked record's id.
+
+### Multi-value fields
 
-For multi-value fields: linked records, multi-selects, collaborators.
+Any generated type with a `[]` suffix: multi-selects, multi-entry linked records.
 
 | Call | Meaning |
 | --- | --- |
@@ -90,21 +91,30 @@ For multi-value fields: linked records, multi-selects, collaborators.
 | `.hasAllOf(values: string[])` | Contains all of |
 | `.isEmpty()` / `.isNotEmpty()` | Empty / non-empty |
 
+Values are the members' ids, as with choice fields.
+
+### User fields
+
+`USER` offers `.is`, `.isNot`, `.contains`, `.isEmpty` and `.isNotEmpty`.
+
+### Attachment and date range fields
+
+`ATTACHMENT` and `DATE_RANGE` have no single value to compare, so they offer only `.isEmpty()` and `.isNotEmpty()`.
+
 ## Combining
 
 ```ts
-q.and(...filters)   // all must match
-q.or(...filters)    // any may match
+q.$and(...filters)   // all must match
+q.$or(...filters)    // any may match
 ```
 
 Both take filters or nested groups:
 
 ```ts
-where: q.and(
-  q.text('status').is('active'),
-  q.or(
-    q.number('amount').gte(1000),
-    q.array('tags').hasAllOf(['priority']),
+.where((q) =>
+  q.$and(
+    q.status.is('active'),
+    q.$or(q.amount.gte(1000), q.title.contains('priority')),
   ),
 )
 ```
@@ -114,31 +124,17 @@ Nesting goes two levels, a group inside a group. A third level throws `Cannot ne
 ## Sorting
 
 ```ts
-orderBy: q.asc('title')
-orderBy: [q.desc('publishedAt'), q.asc('title')]
+.orderBy((q) => q.title.asc)
+.orderBy((q) => [q.publishedAt.desc, q.title.asc])
 ```
 
-Sorts are applied in array order.
-
-## Field maps
-
-```ts
-const select = q.select({ title: 'fZk3Qm9pLw2Xa1', views: 'Ru7bVx2cNq0Ed9' })
-```
-
-`q.select` maps names you choose onto Softr field ids — opaque strings copied from the table's schema. Two rules follow from that:
-
-1. The returned record carries exactly the keys in the map. A field left out is not returned, and no error is raised.
-2. `where` and `orderBy` name aliases, and every one of them must be in the map. A name that is not throws `Could not find an alias for subject "..."` at request time, and so does a `where` or `orderBy` passed with no `select` at all.
-
-So `select` must list every field the query touches, not just the ones being displayed.
+Each field carries `.asc` and `.desc` handles and nothing else. An array applies sorts in order. Repeated `.orderBy` calls append.
 
 ## Errors
 
 | Message | Cause |
 | --- | --- |
-| `Filters cannot be constructed manually. Use the 'q' helper.` | A `where` value built as a plain object |
-| `orderBy conditions cannot be constructed manually. Use the 'q' helper.` | An `orderBy` value not from `q.asc` / `q.desc` |
+| `a filter must come from the callback a read hands you` | A `where` value built as a plain object |
+| `a sort must come from the callback a read hands you` | An `orderBy` value not from the callback's `.asc` / `.desc` handles |
 | `Cannot nest filter groups more than three levels deep.` | A group nested one level too far |
-| `Could not find an alias for subject "..."` | A sort field missing from `select`, or an `orderBy` with no `select` at all |
-| `Could not find an alias for subject "undefined"` | The same thing on a filter, which does not report the field name |
+| A `TypeError` reading an operator off `undefined` | Filtering or sorting on a field the action does not declare |

package/skills/softr-sdk/routes-and-visibility/SKILL.md

@@ -12,7 +12,7 @@ description: >-
 metadata:
   type: sub-skill
   library: softr-sdk
-  library_version: 0.0.24
+  library_version: 0.0.25
 ---
 
 **Boundary.** `defineVisibility`, the error predicates and every type come from `@softr/sdk` and work anywhere; `ds` and `auth` live on `@softr/sdk/server` and run only inside a `createServerFn` handler. The app is already wired — `src/start.ts` registers `softrAuthMiddleware`, `src/routes/__root.tsx` publishes the visitor as route context — never add a second registration. Load the core `softr-sdk` skill only if you are unsure this is the right sub-skill.

package/dist/core/datasource.d.ts

@@ -1,31 +0,0 @@
-import { ChartOptions, ChartResult, CreateOptions, GetOptions, ListOptions, ListResult, MetricOptions, MetricResult, RecordFieldsFor, SoftrRecord, UpdateOptions } from "../types.js";
-
-//#region src/core/datasource.d.ts
-declare function listRecords<Id extends string, Sel extends Record<string, string> = Record<never, never>>(datasourceId: Id, options?: Omit<ListOptions, 'select'> & {
-  select?: Sel;
-}): Promise<ListResult<SoftrRecord<RecordFieldsFor<Id, Sel>>>>;
-declare function getRecord<Id extends string, Sel extends Record<string, string> = Record<never, never>>(datasourceId: Id, options: Omit<GetOptions, 'select'> & {
-  select?: Sel;
-}): Promise<SoftrRecord<RecordFieldsFor<Id, Sel>> | null>;
-declare function createRecord<Id extends string, Sel extends Record<string, string> = Record<never, never>>(datasourceId: Id, options: Omit<CreateOptions, 'select' | 'data'> & {
-  select?: Sel;
-  data: Partial<RecordFieldsFor<Id, Sel>>;
-}): Promise<SoftrRecord<RecordFieldsFor<Id, Sel>>>;
-declare function updateRecord<Id extends string, Sel extends Record<string, string> = Record<never, never>>(datasourceId: Id, options: Omit<UpdateOptions, 'select' | 'data'> & {
-  select?: Sel;
-  data: Partial<RecordFieldsFor<Id, Sel>>;
-}): Promise<SoftrRecord<RecordFieldsFor<Id, Sel>>>;
-declare function deleteRecord(datasourceId: string, id: string): Promise<void>;
-declare function getMetric(datasourceId: string, options: MetricOptions): Promise<MetricResult>;
-declare function getChart(datasourceId: string, options: ChartOptions): Promise<ChartResult>;
-declare const ds: {
-  list: typeof listRecords;
-  get: typeof getRecord;
-  create: typeof createRecord;
-  update: typeof updateRecord;
-  delete: typeof deleteRecord;
-  metric: typeof getMetric;
-  chart: typeof getChart;
-};
-//#endregion
-export { ds };

package/dist/core/datasource.js

@@ -1,226 +0,0 @@
-import { buildFilterCriteria, buildOrderBy, dealiasFilterCriteria, dealiasOrderBy } from "./query.js";
-import { panic } from "../assertions.js";
-import { readUserTimezone } from "../cookies.js";
-import { sessionConfig } from "../auth/config.js";
-import { readSessionToken } from "../auth/session.js";
-import { assertResponseOk } from "./utils.js";
-
-//#region src/core/datasource.ts
-const MAX_RECORD_COUNT = 100;
-const COUNT_CNT = "COUNT_CNT";
-const dsUrl = (datasourceId) => {
-	const datasourceApiUrl = process.env.SOFTR_DATASOURCE_API_URL;
-	if (!datasourceApiUrl) panic("SOFTR_DATASOURCE_API_URL is not set.");
-	const { applicationId } = sessionConfig();
-	return `${withoutTrailingSlash(datasourceApiUrl)}/v1/datasource/vibe/applications/${applicationId}/datasources/${datasourceId}`;
-};
-async function listRecords(datasourceId, options = {}) {
-	const { select, where, orderBy } = options;
-	const count = Math.min(options.limit ?? 20, MAX_RECORD_COUNT);
-	const offset = options.offset ?? null;
-	const filterCriteria = where ? dealiasFilterCriteria(buildFilterCriteria(where), select ?? {}) : {};
-	const sortingOption = orderBy ? dealiasOrderBy(buildOrderBy(orderBy), select ?? {}) : void 0;
-	const res = await fetch(`${dsUrl(datasourceId)}/records`, {
-		method: "POST",
-		headers: {
-			"Content-Type": "application/json",
-			"X-User-Timezone": options.timeZone ?? readUserTimezone() ?? "UTC",
-			"Authorization": `Bearer ${readSessionToken()}`
-		},
-		body: JSON.stringify({
-			options: { userLocale: "en-US" },
-			filterCriteria,
-			sortingOption,
-			pagingOption: {
-				offset,
-				count
-			}
-		})
-	});
-	await assertResponseOk(res, `Softr datasource list failed for "${datasourceId}"`);
-	const payload = await res.json();
-	const nextOffset = payload.offset < payload.total ? payload.offset : null;
-	return {
-		records: payload.items.map((item) => ({
-			id: item.id,
-			fields: select ? aliasFields(item.fields, select) : item.fields
-		})),
-		total: payload.total,
-		nextOffset
-	};
-}
-async function getRecord(datasourceId, options) {
-	if (options.id !== void 0) {
-		if (!options.id) throw new Error(`Softr datasource get: id must not be empty`);
-		const res = await fetch(`${dsUrl(datasourceId)}/records/${options.id}`, {
-			method: "POST",
-			headers: {
-				"Content-Type": "application/json",
-				"X-User-Timezone": options.timeZone ?? readUserTimezone() ?? "UTC",
-				"Authorization": `Bearer ${readSessionToken()}`
-			},
-			body: JSON.stringify({ options: { userLocale: "en-US" } })
-		});
-		await assertResponseOk(res, `Softr datasource get failed for "${datasourceId}"`);
-		const contentLength = res.headers.get("Content-Length");
-		if (contentLength && parseInt(contentLength, 10) === 0) return null;
-		const record = await res.json();
-		return {
-			id: record.id,
-			fields: options.select ? aliasFields(record.fields, options.select) : record.fields
-		};
-	}
-	return (await listRecords(datasourceId, {
-		where: options.where,
-		select: options.select,
-		limit: 1,
-		timeZone: options.timeZone
-	})).records[0] ?? null;
-}
-async function createRecord(datasourceId, options) {
-	const rawFields = options.select ? dealiasData(options.data, options.select) : options.data;
-	const res = await fetch(`${dsUrl(datasourceId)}/records/new`, {
-		method: "POST",
-		headers: {
-			"Content-Type": "application/json",
-			"Authorization": `Bearer ${readSessionToken()}`
-		},
-		body: JSON.stringify({ fields: rawFields })
-	});
-	await assertResponseOk(res, `Softr datasource create failed for "${datasourceId}"`);
-	const record = await res.json();
-	return {
-		id: record.id,
-		fields: options.select ? aliasFields(record.fields, options.select) : record.fields
-	};
-}
-async function updateRecord(datasourceId, options) {
-	if (!options.id) throw new Error(`Softr datasource update: id must not be empty`);
-	const rawFields = options.select ? dealiasData(options.data, options.select) : options.data;
-	const res = await fetch(`${dsUrl(datasourceId)}/records/${options.id}`, {
-		method: "PATCH",
-		headers: {
-			"Content-Type": "application/json",
-			"Authorization": `Bearer ${readSessionToken()}`
-		},
-		body: JSON.stringify({ fields: rawFields })
-	});
-	await assertResponseOk(res, `Softr datasource update failed for "${datasourceId}"`);
-	const record = await res.json();
-	return {
-		id: record.id,
-		fields: options.select ? aliasFields(record.fields, options.select) : record.fields
-	};
-}
-async function deleteRecord(datasourceId, id) {
-	await assertResponseOk(await fetch(`${dsUrl(datasourceId)}/records/${id}`, {
-		method: "DELETE",
-		headers: { "Authorization": `Bearer ${readSessionToken()}` }
-	}), `Softr datasource delete failed for "${datasourceId}"`);
-}
-async function getMetric(datasourceId, options) {
-	const { select, where, aggregation, field } = options;
-	if (aggregation !== "COUNT" && !field) throw new Error(`field is required for aggregation "${aggregation}"`);
-	const fieldId = field ? select?.[field] ?? field : void 0;
-	const filterCriteria = where ? dealiasFilterCriteria(buildFilterCriteria(where), select ?? {}) : {};
-	const res = await fetch(`${dsUrl(datasourceId)}/chart/data`, {
-		method: "POST",
-		headers: {
-			"Content-Type": "application/json",
-			"X-User-Timezone": options.timeZone ?? readUserTimezone() ?? "UTC",
-			"Authorization": `Bearer ${readSessionToken()}`
-		},
-		body: JSON.stringify({
-			options: { userLocale: "en-US" },
-			groupBy: [],
-			metrics: [{
-				field: fieldId,
-				aggregation
-			}],
-			filterCriteria
-		})
-	});
-	await assertResponseOk(res, `Softr datasource metric failed for "${datasourceId}"`);
-	const payload = await res.json();
-	const executionTimestamp = /* @__PURE__ */ new Date(payload.executionTimestamp * 1e3);
-	let value;
-	const responseKey = aggregation === "COUNT" && !fieldId ? COUNT_CNT : fieldId;
-	value = payload.data.find((item) => responseKey in item)?.[responseKey] ?? null;
-	return {
-		value,
-		executionTimestamp
-	};
-}
-async function getChart(datasourceId, options) {
-	const { select, where, groupBy, metrics, orderBy } = options;
-	const filterCriteria = where ? dealiasFilterCriteria(buildFilterCriteria(where), select ?? {}) : {};
-	const sortingOptions = orderBy ? dealiasOrderBy(buildOrderBy(orderBy), select ?? {}) : void 0;
-	const groupByFields = (Array.isArray(groupBy) ? groupBy : [groupBy]).map((field) => ({ field: select?.[field] ?? field }));
-	const yAxisFields = Object.values(metrics).map(({ field, aggregation }) => ({
-		field: field ? select?.[field] ?? field : void 0,
-		aggregation
-	}));
-	if (!yAxisFields.length) throw new Error("chart requires at least one metric");
-	const res = await fetch(`${dsUrl(datasourceId)}/chart/data`, {
-		method: "POST",
-		headers: {
-			"Content-Type": "application/json",
-			"X-User-Timezone": options.timeZone ?? readUserTimezone() ?? "UTC",
-			"Authorization": `Bearer ${readSessionToken()}`
-		},
-		body: JSON.stringify({
-			options: { userLocale: "en-US" },
-			filterCriteria,
-			sortingOptions,
-			groupBy: groupByFields,
-			metrics: yAxisFields
-		})
-	});
-	await assertResponseOk(res, `Softr datasource chart failed for "${datasourceId}"`);
-	const payload = await res.json();
-	const executionTimestamp = /* @__PURE__ */ new Date(payload.executionTimestamp * 1e3);
-	const aliases = {};
-	const multipleMetrics = Object.keys(metrics).length > 1;
-	for (const [alias, { field, aggregation }] of Object.entries(metrics)) if (aggregation === "COUNT") aliases[COUNT_CNT] = alias;
-	else {
-		const fieldId = field ? select?.[field] ?? field : field;
-		if (fieldId) {
-			const suffix = multipleMetrics ? `_${aggregation.toLowerCase()}` : "";
-			aliases[fieldId + suffix] = alias;
-		}
-	}
-	for (const field of Array.isArray(groupBy) ? groupBy : [groupBy]) aliases[select?.[field] ?? field] = field;
-	return {
-		data: payload.data.map((item) => {
-			const row = {};
-			for (const [rawKey, alias] of Object.entries(aliases)) if (rawKey in item) row[alias] = item[rawKey];
-			return row;
-		}),
-		executionTimestamp
-	};
-}
-function aliasFields(fields, aliases) {
-	const result = {};
-	for (const [alias, fieldId] of Object.entries(aliases)) result[alias] = fields[fieldId];
-	return result;
-}
-function dealiasData(data, select) {
-	const result = {};
-	for (const [alias, value] of Object.entries(data)) result[select[alias] ?? alias] = value;
-	return result;
-}
-const ds = {
-	list: listRecords,
-	get: getRecord,
-	create: createRecord,
-	update: updateRecord,
-	delete: deleteRecord,
-	metric: getMetric,
-	chart: getChart
-};
-function withoutTrailingSlash(url) {
-	return url.replace(/\/+$/, "");
-}
-
-//#endregion
-export { ds, dsUrl };