@softr/sdk 0.0.25 → 0.0.26

package/dist/datasource/fields.js

@@ -0,0 +1,82 @@
+import { INTERNAL_KIND } from "./filter.js";
+
+//#region src/datasource/fields.ts
+function makeFieldSet(aliases) {
+	const set = {};
+	for (const alias of aliases) set[alias] = makeChain(alias);
+	set["$and"] = (...members) => group("AND", members);
+	set["$or"] = (...members) => group("OR", members);
+	return set;
+}
+function makeSortSet(aliases) {
+	const set = {};
+	for (const alias of aliases) set[alias] = {
+		asc: {
+			sortingField: alias,
+			sortType: "ASC",
+			[INTERNAL_KIND]: "ORDER_BY"
+		},
+		desc: {
+			sortingField: alias,
+			sortType: "DESC",
+			[INTERNAL_KIND]: "ORDER_BY"
+		}
+	};
+	return set;
+}
+/** Ands a list of filters into one group, which is what an accumulated `where` needs. */
+function andAll(filters) {
+	return group("AND", filters);
+}
+function group(logicalOperator, filters) {
+	return {
+		logicalOperator,
+		filters,
+		[INTERNAL_KIND]: "LOGICAL_GROUP"
+	};
+}
+/**
+* One chain per alias, carrying every operator whatever the alias reads as. Only the types
+* narrow: a call the types reject cannot reach here, so there is nothing for a per-type
+* runtime chain to catch.
+*/
+function makeChain(subject) {
+	return {
+		is: (value) => leaf(subject, "IS", value),
+		isNot: (value) => leaf(subject, "IS_NOT", value),
+		isEmpty: () => leaf(subject, "IS_EMPTY"),
+		isNotEmpty: () => leaf(subject, "IS_NOT_EMPTY"),
+		contains: (value) => leaf(subject, "CONTAINS", value),
+		startsWith: (value) => leaf(subject, "STARTS_WITH", value),
+		endsWith: (value) => leaf(subject, "ENDS_WITH", value),
+		isOneOf: (values) => leaf(subject, "IS_ONE_OF", values),
+		isNoneOf: (values) => leaf(subject, "IS_NONE_OF", values),
+		hasAllOf: (values) => leaf(subject, "HAS_ALL_OF", values),
+		gt: (value) => leaf(subject, "GT", value),
+		gte: (value) => leaf(subject, "GTE", value),
+		lt: (value) => leaf(subject, "LT", value),
+		lte: (value) => leaf(subject, "LTE", value),
+		between: (start, end) => leaf(subject, "BETWEEN", [start, end]),
+		isNotBetween: (start, end) => leaf(subject, "IS_NOT_BETWEEN", [start, end])
+	};
+}
+function leaf(subject, operator, value) {
+	const probe = Array.isArray(value) ? value[0] : value;
+	if (typeof probe === "number") return {
+		subject,
+		operator,
+		value: Array.isArray(value) ? value.map(String) : String(value),
+		type: "NUMERIC",
+		[INTERNAL_KIND]: "FILTER"
+	};
+	return {
+		subject,
+		operator,
+		value,
+		type: typeof probe === "boolean" ? "BOOLEAN" : Array.isArray(value) ? "ARRAY" : "TEXT",
+		[INTERNAL_KIND]: "FILTER"
+	};
+}
+
+//#endregion
+export { andAll, makeFieldSet, makeSortSet };

package/dist/datasource/filter.d.ts

@@ -0,0 +1,30 @@
+//#region src/datasource/filter.d.ts
+
+type LogicalOperator = "AND" | "OR";
+type FilterOperator = "IS" | "IS_NOT" | "EQUAL" | "NOT_EQUAL" | "IS_EMPTY" | "IS_NOT_EMPTY" | "IS_ONE_OF" | "IS_NONE_OF" | "HAS_ALL_OF" | "CONTAINS" | "INLINE_CONTAINS" | "GT" | "LT" | "GTE" | "LTE" | "BETWEEN" | "IS_NOT_BETWEEN" | "DOES_NOT_CONTAINS" | "STARTS_WITH" | "ENDS_WITH";
+type ConditionFieldType = "TEXT" | "BOOLEAN" | "NUMERIC" | "ARRAY" | "DATE";
+interface Filter {
+  subject: string;
+  operator: FilterOperator;
+  value?: unknown;
+  type: ConditionFieldType;
+}
+type ConstructableFilter = Filter & {
+  [INTERNAL_KIND]: "FILTER";
+};
+type ConstructableFilterGroup = {
+  logicalOperator: LogicalOperator;
+  filters: Array<ConstructableFilter | ConstructableFilterGroup>;
+  [INTERNAL_KIND]: "LOGICAL_GROUP";
+};
+interface SortingOptionItem {
+  sortingField: string;
+  sortType: "ASC" | "DESC";
+}
+type ConstructableOrderBy = SortingOptionItem & {
+  [INTERNAL_KIND]: "ORDER_BY";
+};
+type AnyConstructable = ConstructableFilter | ConstructableFilterGroup;
+declare const INTERNAL_KIND: unique symbol;
+//#endregion
+export { AnyConstructable, ConstructableFilter, ConstructableFilterGroup, ConstructableOrderBy };

package/dist/datasource/filter.js

@@ -0,0 +1,146 @@
+import { assert } from "../assertions.js";
+
+//#region src/datasource/filter.ts
+const INTERNAL_KIND = Symbol("KIND");
+/**
+* Converts filter utility conditions to a format our backend supports.
+*
+* A leaf becomes a group of one, because the wire format has no way to hold a bare
+* condition and a group side by side at the same level.
+*
+* @example
+* ```tsx
+* const json = buildFilterCriteria(fields.title.contains("hello"));
+* // result
+* {
+*   "filterCriteria": {
+*     "filterConditionGroup": {
+*       "logicalOperator": "AND"
+*       "filterGroups": [{
+*         "logicalOperator": "AND",
+*         "filters": [{
+*           "subject": "title",
+*           "type": "TEXT",
+*           "operator": "CONTAINS",
+*           "value": "hello"
+*         }],
+*       }]
+*     }
+*   }
+*  }
+*
+* ```
+*/
+function buildFilterCriteria(input) {
+	assert(INTERNAL_KIND in input, "a filter must come from the callback a read hands you");
+	if (isFilter(input)) return { filterConditionGroup: {
+		logicalOperator: "AND",
+		filterGroups: [{
+			logicalOperator: "AND",
+			filters: [stripInternalKind(input)]
+		}]
+	} };
+	if (isFilterGroup(input)) {
+		if (input.filters.length === 0) return { filterConditionGroup: {
+			logicalOperator: input.logicalOperator,
+			filterGroups: []
+		} };
+		return { filterConditionGroup: {
+			logicalOperator: input.logicalOperator,
+			filterGroups: input.filters.map((inner) => {
+				if (isFilter(inner)) return {
+					logicalOperator: "AND",
+					filters: [stripInternalKind(inner)]
+				};
+				if (!inner.filters.every(isFilter)) throw new Error("Cannot nest filter groups more than three levels deep.");
+				return {
+					logicalOperator: inner.logicalOperator,
+					filters: inner.filters.map(stripInternalKind)
+				};
+			})
+		} };
+	}
+	throw new Error("Unknown filter kind: " + input[INTERNAL_KIND]);
+}
+/**
+* Converts order-by utility conditions to a format our backend supports
+*
+* @example
+* single orderBy
+* ```tsx
+* const orderBy = buildOrderBy(sorts.title.asc);
+* // result: [{ sortingField: "title", sortType: "ASC" }]
+* ```
+*
+* @example
+* multiple orderBys
+* ```tsx
+* const orderBy = buildOrderBy([sorts.createdAt.desc, sorts.title.asc]);
+* // result: [
+* //   { sortingField: "createdAt", sortType: "DESC" },
+* //   { sortingField: "title", sortType: "ASC" }
+* // ]
+* ```
+*/
+function buildOrderBy(input) {
+	const orderBys = Array.isArray(input) ? input : [input];
+	assert(orderBys.every((ob) => ob[INTERNAL_KIND] === "ORDER_BY"), "a sort must come from the callback a read hands you");
+	return orderBys.map((orderBy) => ({
+		sortingField: orderBy.sortingField,
+		sortType: orderBy.sortType
+	}));
+}
+function dealiasOrderBy(orderbys, aliases) {
+	return orderbys.map((orderBy) => {
+		const subject = aliases[orderBy.sortingField];
+		if (!subject) throw new Error(`Could not find an alias for subject "${orderBy.sortingField}"`);
+		return {
+			...orderBy,
+			sortingField: subject
+		};
+	});
+}
+/**
+* Replaces filter subjects with their aliased values.
+*
+* Throws an error if any filter subject does not have a corresponding alias in the provided mapping.
+*
+* @example
+* ```tsx
+* const criteria = buildFilterCriteria(fields.name.contains("John"));
+* const aliases = { name: "abcxy123" };
+* const dealiased = dealiasFilterCriteria(criteria, aliases);
+* // Result: filter subject is now "abcxyz123" instead of "name"
+* ```
+*/
+function dealiasFilterCriteria(criteria, aliases) {
+	if (!criteria.filterConditionGroup) return criteria;
+	return { filterConditionGroup: {
+		...criteria.filterConditionGroup,
+		filterGroups: criteria.filterConditionGroup.filterGroups.map((group) => ({
+			...group,
+			filters: group.filters.map(dealiasFilter)
+		}))
+	} };
+	function dealiasFilter(filter) {
+		const subject = aliases[filter.subject];
+		assert(subject, () => `Could not find an alias for subject "${filter.subject}"`);
+		return {
+			...filter,
+			subject
+		};
+	}
+}
+function stripInternalKind(item) {
+	const { [INTERNAL_KIND]: _,...rest } = item;
+	return rest;
+}
+function isFilterGroup(item) {
+	return item[INTERNAL_KIND] === "LOGICAL_GROUP";
+}
+function isFilter(item) {
+	return item[INTERNAL_KIND] === "FILTER";
+}
+
+//#endregion
+export { INTERNAL_KIND, buildFilterCriteria, buildOrderBy, dealiasFilterCriteria, dealiasOrderBy };

package/dist/datasource/record.d.ts

@@ -0,0 +1,138 @@
+import { Action, ActionData, ActionRecord, ActionShape, ReadShape } from "../action.js";
+import { AnyConstructable, ConstructableOrderBy } from "./filter.js";
+import { FieldSet, SortSet } from "./fields.js";
+
+//#region src/datasource/record.d.ts
+type GetOptions = {
+  id: string;
+};
+type WhereCallback<TShape extends ReadShape> = (q: FieldSet<TShape>) => AnyConstructable;
+type OrderByCallback<TShape extends ReadShape> = (q: SortSet<ActionRecord<TShape>>) => ConstructableOrderBy | Array<ConstructableOrderBy>;
+type ListBuilder<TShape extends ReadShape> = {
+  /**
+   * Narrows down which records come back.
+   *
+   * @example
+   * ds.list(posts).where((q) => q.title.contains("cafe"))
+   */
+  where(build: WhereCallback<TShape>): ListBuilder<TShape>;
+  /**
+   * Sorts the records.
+   *
+   * @example
+   * ds.list(posts).orderBy((q) => q.publishedAt.asc)
+   *
+   * An array can be provided to solve tie-breakers.
+   *
+   * @example
+   * ds.list(posts).orderBy((q) => [q.views.desc, q.publishedAt.asc])
+   */
+  orderBy(build: OrderByCallback<TShape>): ListBuilder<TShape>;
+  /** How many records to return. Defaults to 20, capped at 100. */
+  limit(count: number): ListBuilder<TShape>;
+  /**
+   * Where the page starts. Pass the `nextOffset` of a previous result, or `null` to start
+   * over. A result with `nextOffset: null` is the last page.
+   *
+   * @example
+   * const first = await ds.list(posts).limit(50)
+   * const second = await ds.list(posts).limit(50).offset(first.nextOffset)
+   */
+  offset(offset: number | null): ListBuilder<TShape>;
+} & Promise<ListResult<SoftrRecord<ActionRecord<TShape>>>>;
+/**
+ * One record, fetched when awaited. There is no `orderBy`, `limit` or `offset`. The record is
+ * picked by id, so there is nothing to order or page through.
+ *
+ * @example
+ * const post = await ds.get(postDetail, { id: params.postId })
+ */
+type GetBuilder<TShape extends ReadShape> = {
+  /**
+   * Narrows which record the id may resolve to. A record that does not match the filter
+   * reads as `null`, the same as one that does not exist.
+   *
+   * @example
+   * const post = await ds
+   *   .get(postDetail, { id: params.postId })
+   *   .where((q) => q.author.is(user.id))
+   */
+  where(build: WhereCallback<TShape>): GetBuilder<TShape>;
+} & Promise<SoftrRecord<ActionRecord<TShape>> | null>;
+interface SoftrRecord<TFields extends Record<string, unknown> = Record<string, unknown>> {
+  id: string;
+  fields: TFields;
+}
+interface ListResult<TRecord extends SoftrRecord = SoftrRecord> {
+  records: TRecord[];
+  total: number;
+  nextOffset: number | null;
+}
+/**
+ * Queries a list of records from the datasource.
+ *
+ * @example
+ * const { records, total, nextOffset } = await ds
+ *   .list(posts)
+ *   .where((q) => q.publishedAt.lte(today))
+ *   .orderBy((q) => q.publishedAt.desc)
+ *   .limit(50)
+ */
+declare function listRecords<TShape extends ReadShape>(query: Action<TShape>): ListBuilder<TShape>;
+/**
+ * Gets a single record by ID.
+ *
+ * @example
+ * const record = await ds
+ *   .get(posts, { id: "record-id" })
+ *   .where((q) => q.publishedAt.lte(today))
+ *
+ * A filter may also be provided to narrow down
+ *
+ * @example
+ * const record = await ds
+ *   .get(posts, { id: "record-id" })
+ *   .where((q) => q.publishedAt.lte(today))
+ */
+declare function getRecord<TShape extends ReadShape>(query: Action<TShape>, options: GetOptions): GetBuilder<TShape>;
+/**
+ * Creates a record and returns it.
+ *
+ * @example
+ * const record = await ds.create(newPost, {
+ *   data: { title: "Cafes", publishedAt: today },
+ * })
+ */
+declare function createRecord<TShape extends ActionShape & {
+  operation: "create";
+}>(action: Action<TShape>, options: {
+  data: ActionData<TShape>;
+}): Promise<SoftrRecord<ActionRecord<TShape>>>;
+/**
+ * Updates a record by ID and returns it. Only the fields in `data` change.
+ *
+ * @example
+ * const record = await ds.update(editPost, {
+ *   id: "record-id",
+ *   data: { title: "Cafes" },
+ * })
+ */
+declare function updateRecord<TShape extends ActionShape & {
+  operation: "update";
+}>(action: Action<TShape>, options: {
+  id: string;
+  data: ActionData<TShape>;
+}): Promise<SoftrRecord<ActionRecord<TShape>>>;
+/**
+ * Deletes a record by ID.
+ *
+ * @example
+ * await ds.delete(removePost, { id: "record-id" })
+ */
+declare function deleteRecord<TShape extends ActionShape & {
+  operation: "delete";
+}>(action: Action<TShape>, options: {
+  id: string;
+}): Promise<void>;
+//#endregion
+export { WhereCallback, createRecord, deleteRecord, getRecord, listRecords, updateRecord };

package/dist/datasource/record.js

@@ -0,0 +1,258 @@
+import { assert, panic } from "../assertions.js";
+import { isAction } from "../action.js";
+import { readUserTimezone } from "../cookies.js";
+import { readSessionToken } from "../auth/session.js";
+import { buildFilterCriteria, buildOrderBy, dealiasFilterCriteria, dealiasOrderBy } from "./filter.js";
+import { andAll, makeFieldSet, makeSortSet } from "./fields.js";
+
+//#region src/datasource/record.ts
+const MAX_RECORD_COUNT = 100;
+const dsUrl = (datasourceId) => {
+	const datasourceApiUrl = process.env.SOFTR_DATASOURCE_API_URL;
+	if (!datasourceApiUrl) panic("SOFTR_DATASOURCE_API_URL is not set.");
+	const applicationId = process.env.SOFTR_APPLICATION_ID;
+	if (!applicationId) panic("SOFTR_APPLICATION_ID is not set.");
+	return `${withoutTrailingSlash(datasourceApiUrl)}/v1/datasource/vibe/applications/${applicationId}/datasources/${datasourceId}`;
+};
+/**
+* Queries a list of records from the datasource.
+*
+* @example
+* const { records, total, nextOffset } = await ds
+*   .list(posts)
+*   .where((q) => q.publishedAt.lte(today))
+*   .orderBy((q) => q.publishedAt.desc)
+*   .limit(50)
+*/
+function listRecords(query) {
+	const aliases = Object.keys(resolveTarget(query, "read").select);
+	const args = {
+		filters: [],
+		orderBy: []
+	};
+	let page;
+	const run = () => page ??= executeList(query, args);
+	const builder = {
+		[Symbol.toStringTag]: "RecordListing",
+		where(build) {
+			args.filters.push(build(makeFieldSet(aliases)));
+			return builder;
+		},
+		orderBy(build) {
+			const sorting = build(makeSortSet(aliases));
+			args.orderBy.push(...Array.isArray(sorting) ? sorting : [sorting]);
+			return builder;
+		},
+		limit(count) {
+			args.limit = count;
+			return builder;
+		},
+		offset(offset) {
+			args.offset = offset;
+			return builder;
+		},
+		then(onfulfilled, onrejected) {
+			return run().then(onfulfilled, onrejected);
+		},
+		catch(onrejected) {
+			return run().catch(onrejected);
+		},
+		finally(onfinally) {
+			return run().finally(onfinally);
+		}
+	};
+	return builder;
+}
+async function executeList(query, args) {
+	const { datasourceId, select } = resolveTarget(query, "read");
+	const count = Math.min(args.limit ?? 20, MAX_RECORD_COUNT);
+	const offset = args.offset ?? null;
+	const filterCriteria = args.filters.length ? dealiasFilterCriteria(buildFilterCriteria(andAll(args.filters)), select) : {};
+	const sortingOption = args.orderBy.length ? dealiasOrderBy(buildOrderBy(args.orderBy), select) : void 0;
+	const res = await fetch(`${dsUrl(datasourceId)}/records`, {
+		method: "POST",
+		headers: {
+			"Content-Type": "application/json",
+			"X-User-Timezone": readUserTimezone() ?? "UTC",
+			Authorization: `Bearer ${readSessionToken()}`
+		},
+		body: JSON.stringify({
+			options: { userLocale: "en-US" },
+			filterCriteria,
+			sortingOption,
+			pagingOption: {
+				offset,
+				count
+			}
+		})
+	});
+	if (!res.ok) throw new Error(`Softr datasource list failed for "${datasourceId}": ${res.status}`);
+	const payload = await res.json();
+	const nextOffset = payload.offset < payload.total ? payload.offset : null;
+	return {
+		records: payload.items.map((item) => ({
+			id: item.id,
+			fields: aliasFields(item.fields, select)
+		})),
+		total: payload.total,
+		nextOffset
+	};
+}
+/**
+* Gets a single record by ID.
+*
+* @example
+* const record = await ds
+*   .get(posts, { id: "record-id" })
+*   .where((q) => q.publishedAt.lte(today))
+*
+* A filter may also be provided to narrow down
+*
+* @example
+* const record = await ds
+*   .get(posts, { id: "record-id" })
+*   .where((q) => q.publishedAt.lte(today))
+*/
+function getRecord(query, options) {
+	const aliases = Object.keys(resolveTarget(query, "read").select);
+	const filters = [];
+	let record;
+	const run = () => record ??= executeGet(query, options.id, filters);
+	const builder = {
+		[Symbol.toStringTag]: "RecordFetch",
+		where(build) {
+			filters.push(build(makeFieldSet(aliases)));
+			return builder;
+		},
+		then(onfulfilled, onrejected) {
+			return run().then(onfulfilled, onrejected);
+		},
+		catch(onrejected) {
+			return run().catch(onrejected);
+		},
+		finally(onfinally) {
+			return run().finally(onfinally);
+		}
+	};
+	return builder;
+}
+async function executeGet(query, id, filters) {
+	assert(id, "a record id must not be empty");
+	const { datasourceId, select } = resolveTarget(query, "read");
+	const filterCriteria = filters.length ? dealiasFilterCriteria(buildFilterCriteria(andAll(filters)), select) : {};
+	const res = await fetch(`${dsUrl(datasourceId)}/records/${id}`, {
+		method: "POST",
+		headers: {
+			"Content-Type": "application/json",
+			"X-User-Timezone": readUserTimezone() ?? "UTC",
+			Authorization: `Bearer ${readSessionToken()}`
+		},
+		body: JSON.stringify({
+			options: { userLocale: "en-US" },
+			filterCriteria
+		})
+	});
+	if (!res.ok) throw new Error(`Softr datasource get failed for "${datasourceId}": ${res.status}`);
+	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: aliasFields(record.fields, select)
+	};
+}
+/**
+* Creates a record and returns it.
+*
+* @example
+* const record = await ds.create(newPost, {
+*   data: { title: "Cafes", publishedAt: today },
+* })
+*/
+async function createRecord(action, options) {
+	const { datasourceId, select } = resolveTarget(action, "create");
+	const data = options.data;
+	const rawFields = dealiasData(data, select);
+	const res = await fetch(`${dsUrl(datasourceId)}/records/new`, {
+		method: "POST",
+		headers: {
+			"Content-Type": "application/json",
+			Authorization: `Bearer ${readSessionToken()}`
+		},
+		body: JSON.stringify({ fields: rawFields })
+	});
+	if (!res.ok) throw new Error(`Softr datasource create failed for "${datasourceId}": ${res.status}`);
+	const record = await res.json();
+	return {
+		id: record.id,
+		fields: aliasFields(record.fields, select)
+	};
+}
+/**
+* Updates a record by ID and returns it. Only the fields in `data` change.
+*
+* @example
+* const record = await ds.update(editPost, {
+*   id: "record-id",
+*   data: { title: "Cafes" },
+* })
+*/
+async function updateRecord(action, options) {
+	if (!options.id) throw new Error(`Softr datasource update: id must not be empty`);
+	const { datasourceId, select } = resolveTarget(action, "update");
+	const data = options.data;
+	const rawFields = dealiasData(data, select);
+	const res = await fetch(`${dsUrl(datasourceId)}/records/${options.id}`, {
+		method: "PATCH",
+		headers: {
+			"Content-Type": "application/json",
+			Authorization: `Bearer ${readSessionToken()}`
+		},
+		body: JSON.stringify({ fields: rawFields })
+	});
+	if (!res.ok) throw new Error(`Softr datasource update failed for "${datasourceId}": ${res.status}`);
+	const record = await res.json();
+	return {
+		id: record.id,
+		fields: aliasFields(record.fields, select)
+	};
+}
+/**
+* Deletes a record by ID.
+*
+* @example
+* await ds.delete(removePost, { id: "record-id" })
+*/
+async function deleteRecord(action, options) {
+	const { datasourceId } = resolveTarget(action, "delete");
+	const res = await fetch(`${dsUrl(datasourceId)}/records/${options.id}`, {
+		method: "DELETE",
+		headers: { Authorization: `Bearer ${readSessionToken()}` }
+	});
+	if (!res.ok) throw new Error(`Softr datasource delete failed for "${datasourceId}": ${res.status}`);
+}
+function resolveTarget(subject, operation) {
+	assert(isAction(subject), "a read or a mutation takes an action from defineAction");
+	const action = subject;
+	assert(action.operation === operation, () => `action "${action.id}" is declared as ${action.operation}, not ${operation}`);
+	return {
+		datasourceId: action.datasource,
+		select: action.fields ?? {}
+	};
+}
+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;
+}
+function withoutTrailingSlash(url) {
+	return url.replace(/\/+$/, "");
+}
+
+//#endregion
+export { createRecord, deleteRecord, dsUrl, getRecord, listRecords, resolveTarget, updateRecord };

package/dist/index.d.ts

@@ -1,10 +1,8 @@
-import { q } from "./core/query.js";
 import { SoftrUserGroupId, SoftrUserGroups, User } from "./auth/user.js";
-import { AggregationFunction, ChartOptions, ChartResult, CreateOptions, DatasourcePermissions, DatasourceTypeMap, GetOptions, JsonValue, ListOptions, ListResult, MetricOptions, MetricResult, RecordFieldsFor, SoftrMe, SoftrPermissions, SoftrRecord, SoftrUser, UpdateOptions } from "./types.js";
-import { Permissions } from "./auth/permissions.js";
+import { SoftrDatasources, defineAction } from "./action.js";
 import { SoftrContext } from "./auth/context.js";
-import { AccessBehaviour, AccessCheck, AccessError, AccessReason, RouteVisibility, VisibilityHandle, defineVisibility, isAccessError, isAlreadySignedInError, isForbiddenError, isUnauthenticatedError } from "./routes/visibility.js";
+import { defineVisibility, isAccessError, isAlreadySignedInError, isForbiddenError, isUnauthenticatedError } from "./routes/visibility.js";
 import { getSoftrContext, initialSoftrContext, softrAuthMiddleware, useCurrentUser, usePermissions } from "./auth/isomorphic.js";
 import { useUserTimezone } from "./timezone.js";
 import { DefaultErrorOverlay } from "./default-error-overlay.js";
-export { type AccessBehaviour, type AccessCheck, type AccessError, type AccessReason, type AggregationFunction, type ChartOptions, type ChartResult, type CreateOptions, type DatasourcePermissions, type DatasourceTypeMap, DefaultErrorOverlay, type GetOptions, type JsonValue, type ListOptions, type ListResult, type MetricOptions, type MetricResult, type Permissions, type RecordFieldsFor, type RouteVisibility, type SoftrContext, type SoftrMe, type SoftrPermissions, type SoftrRecord, type SoftrUser, type SoftrUserGroupId, type SoftrUserGroups, type UpdateOptions, type User, type VisibilityHandle, defineVisibility, getSoftrContext, initialSoftrContext, isAccessError, isAlreadySignedInError, isForbiddenError, isUnauthenticatedError, q, softrAuthMiddleware, useCurrentUser, usePermissions, useUserTimezone };
+export { DefaultErrorOverlay, type SoftrContext, type SoftrDatasources, type SoftrUserGroupId, type SoftrUserGroups, type User, defineAction, defineVisibility, getSoftrContext, initialSoftrContext, isAccessError, isAlreadySignedInError, isForbiddenError, isUnauthenticatedError, softrAuthMiddleware, useCurrentUser, usePermissions, useUserTimezone };

package/dist/index.js

@@ -1,7 +1,7 @@
-import { q } from "./core/query.js";
+import { defineAction } from "./action.js";
 import { defineVisibility, isAccessError, isAlreadySignedInError, isForbiddenError, isUnauthenticatedError } from "./routes/visibility.js";
 import { getSoftrContext, initialSoftrContext, softrAuthMiddleware, useCurrentUser, usePermissions } from "./auth/isomorphic.js";
 import { useUserTimezone } from "./timezone.js";
 import { DefaultErrorOverlay } from "./default-error-overlay.js";
 
-export { DefaultErrorOverlay, defineVisibility, getSoftrContext, initialSoftrContext, isAccessError, isAlreadySignedInError, isForbiddenError, isUnauthenticatedError, q, softrAuthMiddleware, useCurrentUser, usePermissions, useUserTimezone };
+export { DefaultErrorOverlay, defineAction, defineVisibility, getSoftrContext, initialSoftrContext, isAccessError, isAlreadySignedInError, isForbiddenError, isUnauthenticatedError, softrAuthMiddleware, useCurrentUser, usePermissions, useUserTimezone };

package/dist/package.js

@@ -0,0 +1,5 @@
+//#region package.json
+var version = "0.0.26";
+
+//#endregion
+export { version };