@softr/sdk 0.0.11 → 0.0.13

package/dist/index.js

@@ -1,1020 +1,5 @@
-import { a as readSessionToken, c as writeCookies, i as readSessionData, l as assert, n as makeSessionDataCookie, o as fetchVisitor, t as clearSession } from "./session-GUEI96C8.js";
-import { redirect } from "@tanstack/react-router";
-import { createMiddleware, createServerFn, getGlobalStartContext } from "@tanstack/react-start";
+import { q } from "./core/query.js";
+import { defineVisibility, isAccessError, isAlreadySignedInError, isForbiddenError, isUnauthenticatedError } from "./routes/visibility.js";
+import { getSoftrContext, initialSoftrContext, softrAuthMiddleware, useCurrentUser, usePermissions } from "./auth/isomorphic.js";
 
-//#region src/core/query.ts
-const INTERNAL_KIND = Symbol("KIND");
-/**
-* Query builder for filter queries. This exist to alleviate the (LLM?) mental overhead. API filter schema is a bit
-* verbose and confusing, even when dealing with very basic queries. So to fall into the pit of success, aim here
-* is to simplify filtering as much as possible.
-*
-* @example
-* single filter
-* ```tsx
-* const query = q.text("title").contains("hello");
-*
-* const json = buildFilterCriteria(query);
-* // result
-* {
-*   "filterCriteria": {
-*     "filterConditionGroup": {
-*       "logicalOperator": "AND"
-*       "filterGroups": [{
-*         "logicalOperator": "AND",
-*         "filters": [{
-*           "subject": "title",
-*           "type": "TEXT",
-*           "operator": "CONTAINS",
-*           "value": "hello"
-*         }],
-*       }]
-*     }
-*   }
-*  }
-*
-* ```
-*
-* @example
-* combining multiple filters
-* ```tsx
-* const query = q.and(
-*   q.text("title").contains("hello"),
-*   q.number("views").is(100),
-*   q.or(
-*     q.text("author").is("John"),
-*     q.boolean("isPublished").is(true)
-*   )
-* );
-* ```
-*/
-const q = {
-	select(mapping) {
-		return mapping;
-	},
-	and(...filters) {
-		return {
-			logicalOperator: "AND",
-			filters,
-			[INTERNAL_KIND]: "LOGICAL_GROUP"
-		};
-	},
-	or(...filters) {
-		return {
-			logicalOperator: "OR",
-			filters,
-			[INTERNAL_KIND]: "LOGICAL_GROUP"
-		};
-	},
-	text(subject) {
-		const filter = {
-			subject,
-			type: "TEXT",
-			[INTERNAL_KIND]: "FILTER"
-		};
-		return {
-			is(value) {
-				return {
-					...filter,
-					operator: "IS",
-					value
-				};
-			},
-			isNot(value) {
-				return {
-					...filter,
-					operator: "IS_NOT",
-					value
-				};
-			},
-			contains(value) {
-				return {
-					...filter,
-					operator: "CONTAINS",
-					value
-				};
-			},
-			isOneOf(value) {
-				return {
-					...filter,
-					operator: "IS_ONE_OF",
-					value
-				};
-			},
-			isNoneOf(value) {
-				return {
-					...filter,
-					operator: "IS_NONE_OF",
-					value
-				};
-			},
-			startsWith(value) {
-				return {
-					...filter,
-					operator: "STARTS_WITH",
-					value
-				};
-			},
-			endsWith(value) {
-				return {
-					...filter,
-					operator: "ENDS_WITH",
-					value
-				};
-			},
-			hasAllOf(value) {
-				return {
-					...filter,
-					operator: "HAS_ALL_OF",
-					value
-				};
-			},
-			isEmpty() {
-				return {
-					...filter,
-					operator: "IS_EMPTY"
-				};
-			},
-			isNotEmpty() {
-				return {
-					...filter,
-					operator: "IS_NOT_EMPTY"
-				};
-			}
-		};
-	},
-	boolean(subject) {
-		const filter = {
-			subject,
-			type: "BOOLEAN",
-			[INTERNAL_KIND]: "FILTER"
-		};
-		return {
-			is(value) {
-				return {
-					...filter,
-					operator: "IS",
-					value
-				};
-			},
-			isNot(value) {
-				return {
-					...filter,
-					operator: "IS_NOT",
-					value
-				};
-			},
-			isEmpty() {
-				return {
-					...filter,
-					operator: "IS_EMPTY"
-				};
-			},
-			isNotEmpty() {
-				return {
-					...filter,
-					operator: "IS_NOT_EMPTY"
-				};
-			}
-		};
-	},
-	number(subject) {
-		const filter = {
-			subject,
-			type: "NUMERIC",
-			[INTERNAL_KIND]: "FILTER"
-		};
-		return {
-			is(value) {
-				return {
-					...filter,
-					operator: "IS",
-					value: value.toString()
-				};
-			},
-			isNot(value) {
-				return {
-					...filter,
-					operator: "IS_NOT",
-					value: value.toString()
-				};
-			},
-			gt(value) {
-				return {
-					...filter,
-					operator: "GT",
-					value: value.toString()
-				};
-			},
-			gte(value) {
-				return {
-					...filter,
-					operator: "GTE",
-					value: value.toString()
-				};
-			},
-			lt(value) {
-				return {
-					...filter,
-					operator: "LT",
-					value: value.toString()
-				};
-			},
-			lte(value) {
-				return {
-					...filter,
-					operator: "LTE",
-					value: value.toString()
-				};
-			},
-			between(start, end) {
-				return {
-					...filter,
-					operator: "BETWEEN",
-					value: [start.toString(), end.toString()]
-				};
-			},
-			isEmpty() {
-				return {
-					...filter,
-					operator: "IS_EMPTY"
-				};
-			},
-			isNotEmpty() {
-				return {
-					...filter,
-					operator: "IS_NOT_EMPTY"
-				};
-			}
-		};
-	},
-	array(subject) {
-		const filter = {
-			subject,
-			type: "ARRAY",
-			[INTERNAL_KIND]: "FILTER"
-		};
-		return {
-			is(value) {
-				return {
-					...filter,
-					operator: "IS",
-					value
-				};
-			},
-			isOneOf(value) {
-				return {
-					...filter,
-					operator: "IS_ONE_OF",
-					value
-				};
-			},
-			isNoneOf(value) {
-				return {
-					...filter,
-					operator: "IS_NONE_OF",
-					value
-				};
-			},
-			hasAllOf(value) {
-				return {
-					...filter,
-					operator: "HAS_ALL_OF",
-					value
-				};
-			},
-			isEmpty() {
-				return {
-					...filter,
-					operator: "IS_EMPTY"
-				};
-			},
-			isNotEmpty() {
-				return {
-					...filter,
-					operator: "IS_NOT_EMPTY"
-				};
-			}
-		};
-	},
-	date(subject) {
-		const filter = {
-			subject,
-			type: "DATE",
-			[INTERNAL_KIND]: "FILTER"
-		};
-		return {
-			is(value) {
-				return {
-					...filter,
-					operator: "IS",
-					value
-				};
-			},
-			isNot(value) {
-				return {
-					...filter,
-					operator: "IS_NOT",
-					value
-				};
-			},
-			gt(value) {
-				return {
-					...filter,
-					operator: "GT",
-					value
-				};
-			},
-			gte(value) {
-				return {
-					...filter,
-					operator: "GTE",
-					value
-				};
-			},
-			lt(value) {
-				return {
-					...filter,
-					operator: "LT",
-					value
-				};
-			},
-			lte(value) {
-				return {
-					...filter,
-					operator: "LTE",
-					value
-				};
-			},
-			between(start, end) {
-				return {
-					...filter,
-					operator: "BETWEEN",
-					value: [start, end]
-				};
-			},
-			isNotBetween(start, end) {
-				return {
-					...filter,
-					operator: "IS_NOT_BETWEEN",
-					value: [start, end]
-				};
-			},
-			isEmpty() {
-				return {
-					...filter,
-					operator: "IS_EMPTY"
-				};
-			},
-			isNotEmpty() {
-				return {
-					...filter,
-					operator: "IS_NOT_EMPTY"
-				};
-			}
-		};
-	},
-	asc(subject) {
-		return {
-			sortingField: subject,
-			sortType: "ASC",
-			[INTERNAL_KIND]: "ORDER_BY"
-		};
-	},
-	desc(subject) {
-		return {
-			sortingField: subject,
-			sortType: "DESC",
-			[INTERNAL_KIND]: "ORDER_BY"
-		};
-	}
-};
-/**
-* Converts filter utility conditions to a format our backend supports
-*
-* @example
-* ```tsx
-* const query = q.text("title").contains("hello");
-*
-* const json = buildFilterCriteria(query);
-* // result
-* {
-*   "filterCriteria": {
-*     "filterConditionGroup": {
-*       "logicalOperator": "AND"
-*       "filterGroups": [{
-*         "logicalOperator": "AND",
-*         "filters": [{
-*           "subject": "title",
-*           "type": "TEXT",
-*           "operator": "CONTAINS",
-*           "value": "hello"
-*         }],
-*       }]
-*     }
-*   }
-*  }
-*
-* ```
-*/
-function buildFilterCriteria(input) {
-	if (!(INTERNAL_KIND in input)) throw new Error("Filters cannot be constructed manually. Use the 'q' helper.");
-	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(q.asc("title"));
-* // result: [{ sortingField: "title", sortType: "ASC" }]
-* ```
-*
-* @example
-* multiple orderBys
-* ```tsx
-* const orderBy = buildOrderBy([q.desc("createdAt"), q.asc("title")]);
-* // result: [
-* //   { sortingField: "createdAt", sortType: "DESC" },
-* //   { sortingField: "title", sortType: "ASC" }
-* // ]
-* ```
-*/
-function buildOrderBy(input) {
-	const orderBys = Array.isArray(input) ? input : [input];
-	if (!orderBys.every((ob) => ob[INTERNAL_KIND] === "ORDER_BY")) throw new Error("orderBy conditions cannot be constructed manually. Use the 'q' helper.");
-	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(q.text("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];
-		if (!subject) throw new Error(`Could not find an alias for subject "${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
-//#region src/routes/visibility.ts
-/**
-* Why a visitor was denied.
-*
-* - `unauthenticated` — the route needs a signed-in visitor and there is none.
-* - `forbidden` — signed in, but in none of the groups the route names.
-* - `alreadySignedIn` — the route is for signed-out visitors only.
-*/
-const ACCESS_REASONS = [
-	"unauthenticated",
-	"forbidden",
-	"alreadySignedIn"
-];
-/** Decides whether a visitor passes a visibility rule, without throwing. */
-function checkAccess(rule, context) {
-	const { user } = context;
-	switch (rule.userGroup) {
-		case "ALL_USERS": return { ok: true };
-		case "NON_LOGGED_IN_USERS": return user === null ? { ok: true } : {
-			ok: false,
-			reason: "alreadySignedIn"
-		};
-		case "LOGGED_IN_USERS": {
-			if (user === null) return {
-				ok: false,
-				reason: "unauthenticated"
-			};
-			const required = rule.userGroupIds ?? [];
-			if (required.length === 0) return { ok: true };
-			return required.some((id) => user.userGroupIds.includes(id)) ? { ok: true } : {
-				ok: false,
-				reason: "forbidden"
-			};
-		}
-	}
-}
-function isAccessReason(value) {
-	return ACCESS_REASONS.some((reason) => reason === value);
-}
-/**
-* True for any access error thrown by a guard, whatever its reason.
-*
-* An access error arrives as `unknown` — hydrated from the page, or thrown by
-* anything else at all — so every field is checked before it is narrowed.
-*/
-function isAccessError(error) {
-	if (typeof error !== "object" || error === null) return false;
-	const candidate = error;
-	if (candidate.type !== "access_error") return false;
-	return isAccessReason(candidate.reason);
-}
-function isReason(error, reason) {
-	return isAccessError(error) && error.reason === reason;
-}
-/** True for an access error thrown because nobody was signed in. */
-function isUnauthenticatedError(error) {
-	return isReason(error, "unauthenticated");
-}
-/** True for an access error thrown because the visitor was in none of the groups. */
-function isForbiddenError(error) {
-	return isReason(error, "forbidden");
-}
-/** True for an access error thrown because a signed-out-only route saw a user. */
-function isAlreadySignedInError(error) {
-	return isReason(error, "alreadySignedIn");
-}
-const DEFAULT_ACCESS_BEHAVIOUR = {
-	unauthenticated: {
-		strategy: "redirect",
-		to: "/login"
-	},
-	forbidden: { strategy: "throw" },
-	alreadySignedIn: {
-		strategy: "redirect",
-		to: "/"
-	}
-};
-/** What a guard throws for a reason: a redirect, or an {@link AccessError}. */
-function thrownFor(reason, overrides) {
-	const behaviour = overrides?.[reason] ?? DEFAULT_ACCESS_BEHAVIOUR[reason];
-	const resolved = typeof behaviour === "string" ? {
-		strategy: "redirect",
-		to: behaviour
-	} : behaviour;
-	if (resolved.strategy === "redirect") return redirect({ to: resolved.to });
-	return {
-		type: "access_error",
-		reason
-	};
-}
-/**
-* Declares who may see a route, and returns the handle that enforces it.
-*
-* One call per route file, at module scope: the build reads these declarations
-* to publish the app's route visibility, so the rule must be a literal.
-*
-* @example
-* const visibility = defineVisibility({ userGroup: "LOGGED_IN_USERS" })
-*
-* export const Route = createFileRoute("/about")({
-*   beforeLoad: visibility.guard(),
-*   component: About,
-* })
-*/
-function defineVisibility(rule) {
-	return {
-		guard: (overrides) => ({ context }) => {
-			const result = checkAccess(rule, context);
-			if (result.ok) return;
-			throw thrownFor(result.reason, overrides);
-		},
-		assert: (context) => {
-			const result = checkAccess(rule, context);
-			if (result.ok) return;
-			throw thrownFor(result.reason, void 0);
-		},
-		isAuthorized: (context) => checkAccess(rule, context).ok,
-		check: (context) => checkAccess(rule, context)
-	};
-}
-
-//#endregion
-//#region src/auth/isomorphic.ts
-/**
-* Resolves the Softr visitor for every request, so that `getSoftrUser` and the
-* route guards have someone to check.
-*
-* Register it once, as a global request middleware in the app's `src/start.ts`.
-* It touches nothing but the visitor.
-*
-* @example
-* export const startInstance = createStart(() => ({
-*   requestMiddleware: [softrAuthMiddleware()],
-* }))
-*/
-function softrAuthMiddleware() {
-	return createMiddleware({ type: "request" }).server(async ({ next }) => {
-		async function getUser() {
-			const token = readSessionToken();
-			if (token === null) return null;
-			const cached = readSessionData(token);
-			if (cached !== null) return cached;
-			const user = await fetchVisitor(token);
-			if (user === null) {
-				clearSession();
-				return null;
-			}
-			writeCookies([makeSessionDataCookie(user, token)]);
-			return user;
-		}
-		return next({ context: { user: await getUser() } });
-	});
-}
-/**
-* Returns the signed-in visitor, or `null` when nobody is signed in.
-*
-* Await it in the root route's `beforeLoad` to publish the visitor as route
-* context, which every `defineVisibility` guard then reads. It requires
-* {@link softrAuthMiddleware} to be registered.
-*
-* @example
-* export const Route = createRootRouteWithContext<SoftrContext>()({
-*   beforeLoad: async () => ({ user: await getSoftrUser() }),
-* })
-*/
-const getSoftrUser = createServerFn({ method: "GET" }).handler(async () => {
-	const context = getGlobalStartContext();
-	assert(typeof context === "object" && context !== null && "user" in context, "softrAuthMiddleware has not run: the Start global context carries no `user`. Register it as a global request middleware, e.g. createStart(() => ({ requestMiddleware: [softrAuthMiddleware()] })).");
-	return context.user ?? null;
-});
-
-//#endregion
-//#region src/core/datasource.ts
-const MAX_RECORD_COUNT = 100;
-const COUNT_CNT = "COUNT_CNT";
-var DatasourceAPIImpl = class {
-	id;
-	fetch;
-	userTimezone;
-	constructor(id, fetch$1, userTimezone = "UTC") {
-		this.id = id;
-		this.fetch = fetch$1;
-		this.userTimezone = userTimezone;
-	}
-	async list(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 this.fetch(`/api/datasources/${this.id}/records`, {
-			method: "POST",
-			headers: {
-				"Content-Type": "application/json",
-				"X-User-Timezone": options.timeZone ?? this.userTimezone
-			},
-			body: JSON.stringify({
-				options: { userLocale: "en-US" },
-				filterCriteria,
-				sortingOption,
-				pagingOption: {
-					offset,
-					count
-				}
-			})
-		});
-		if (!res.ok) throw new Error(`Softr datasource list failed for "${this.id}": ${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: select ? aliasFields(item.fields, select) : item.fields
-			})),
-			total: payload.total,
-			nextOffset
-		};
-	}
-	async get(options) {
-		if (options.id !== void 0) {
-			if (!options.id) throw new Error(`Softr datasource get: id must not be empty`);
-			const res = await this.fetch(`/api/datasources/${this.id}/records/${options.id}`, {
-				method: "POST",
-				headers: {
-					"Content-Type": "application/json",
-					"X-User-Timezone": options.timeZone ?? this.userTimezone
-				},
-				body: JSON.stringify({ options: { userLocale: "en-US" } })
-			});
-			if (!res.ok) throw new Error(`Softr datasource get failed for "${this.id}": ${res.status}`);
-			const contentLength = res.headers.get("Content-Length");
-			if (contentLength && parseInt(contentLength, 10) === 0) return null;
-			return res.json();
-		}
-		return (await this.list({
-			where: options.where,
-			limit: 1,
-			timeZone: options.timeZone
-		})).records[0] ?? null;
-	}
-	async create(options) {
-		const res = await this.fetch(`/api/datasources/${this.id}/records`, {
-			method: "POST",
-			headers: { "Content-Type": "application/json" },
-			body: JSON.stringify({ fields: options.fields })
-		});
-		if (!res.ok) throw new Error(`Softr datasource create failed for "${this.id}": ${res.status}`);
-		return (await res.json()).record;
-	}
-	async update(options) {
-		if (!options.id) throw new Error(`Softr datasource update: id must not be empty`);
-		const res = await this.fetch(`/api/datasources/${this.id}/records/${options.id}`, {
-			method: "PATCH",
-			headers: { "Content-Type": "application/json" },
-			body: JSON.stringify({ fields: options.fields })
-		});
-		if (!res.ok) throw new Error(`Softr datasource update failed for "${this.id}": ${res.status}`);
-		return (await res.json()).record;
-	}
-	async delete(id) {
-		const res = await this.fetch(`/api/datasources/${this.id}/records/${id}`, { method: "DELETE" });
-		if (!res.ok) throw new Error(`Softr datasource delete failed for "${this.id}": ${res.status}`);
-	}
-	async metric(options) {
-		const { select, where, aggregation, field } = options;
-		const fieldId = field ? select?.[field] ?? field : void 0;
-		const filterCriteria = where ? dealiasFilterCriteria(buildFilterCriteria(where), select ?? {}) : {};
-		const res = await this.fetch(`/api/datasources/${this.id}/chartMetricData`, {
-			method: "POST",
-			headers: {
-				"Content-Type": "application/json",
-				"X-User-Timezone": options.timeZone ?? this.userTimezone
-			},
-			body: JSON.stringify({
-				options: { userLocale: "en-US" },
-				calculationField: {
-					field: fieldId,
-					aggregation
-				},
-				filterCriteria
-			})
-		});
-		if (!res.ok) throw new Error(`Softr datasource metric failed for "${this.id}": ${res.status}`);
-		const payload = await res.json();
-		const executionTimestamp = /* @__PURE__ */ new Date(payload.executionTimestamp * 1e3);
-		let value;
-		if (aggregation === "COUNT") value = payload.data.find((item) => COUNT_CNT in item)?.[COUNT_CNT] ?? null;
-		else {
-			if (!fieldId) throw new Error(`field is required for aggregation "${aggregation}"`);
-			value = payload.data.find((item) => fieldId in item)?.[fieldId] ?? null;
-		}
-		return {
-			value,
-			executionTimestamp
-		};
-	}
-	async chartData(options) {
-		const { select, where, groupBy, metrics, orderBy } = options;
-		const filterCriteria = where ? dealiasFilterCriteria(buildFilterCriteria(where), select ?? {}) : {};
-		const sortingOption = orderBy ? dealiasOrderBy(buildOrderBy(orderBy), select ?? {})[0] : 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
-		}));
-		const res = await this.fetch(`/api/datasources/${this.id}/chartData`, {
-			method: "POST",
-			headers: {
-				"Content-Type": "application/json",
-				"X-User-Timezone": options.timeZone ?? this.userTimezone
-			},
-			body: JSON.stringify({
-				options: { userLocale: "en-US" },
-				filterCriteria,
-				sortingOption,
-				xAxisFields: groupByFields,
-				yAxisFields
-			})
-		});
-		if (!res.ok) throw new Error(`Softr datasource chartData failed for "${this.id}": ${res.status}`);
-		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;
-}
-
-//#endregion
-//#region src/core/integration.ts
-var IntegrationAPIImpl = class {
-	id;
-	request;
-	constructor(id, fetch$1) {
-		this.id = id;
-		this.request = fetch$1;
-	}
-	async fetch(input, init) {
-		const req = new Request(input, init);
-		if (req.signal.aborted) throw req.signal.reason ?? new DOMException("The operation was aborted.", "AbortError");
-		const headers = {};
-		new Headers(req.headers).forEach((value, key) => {
-			headers[key] = value;
-		});
-		const payload = {
-			method: req.method,
-			url: req.url,
-			headers
-		};
-		const method = req.method.toUpperCase();
-		if (method !== "GET" && method !== "HEAD" && req.body !== null) payload.body = await req.clone().text();
-		return this.request(`/api/integrations/${this.id}/proxy`, {
-			method: "POST",
-			headers: { "Content-Type": "application/json" },
-			body: JSON.stringify(payload),
-			signal: req.signal
-		});
-	}
-};
-
-//#endregion
-//#region src/core/workflow.ts
-var WorkflowAPIImpl = class {
-	id;
-	fetch;
-	constructor(id, fetch$1) {
-		this.id = id;
-		this.fetch = fetch$1;
-	}
-	async trigger(payload) {
-		const res = await this.fetch(`/api/workflows/${this.id}/trigger`, {
-			method: "POST",
-			...payload ? {
-				headers: { "Content-Type": "application/json" },
-				body: JSON.stringify(payload)
-			} : {}
-		});
-		if (!res.ok) throw new Error(`Softr workflow trigger failed: ${res.status}`);
-	}
-};
-
-//#endregion
-//#region src/core/sdk.ts
-var SoftrSDKImpl = class {
-	baseUrl;
-	userTimezone;
-	extraHeaders;
-	cachedMe = null;
-	constructor(config) {
-		this.baseUrl = config.baseUrl.replace(/\/$/, "");
-		this.userTimezone = config.userTimezone ?? import.meta.env.VITE_APP_TIMEZONE ?? "UTC";
-		this.extraHeaders = config.headers;
-	}
-	async me() {
-		if (this.cachedMe) return this.cachedMe;
-		const res = await this._fetch("/me");
-		if (!res.ok) throw new Error(`Softr /me failed: ${res.status}`);
-		this.cachedMe = await res.json();
-		return this.cachedMe;
-	}
-	auth = {
-		login: async ({ email, password }) => {
-			const res = await this._fetch("/auth/login", {
-				method: "POST",
-				headers: { "Content-Type": "application/json" },
-				body: JSON.stringify({
-					email,
-					password
-				})
-			});
-			if (!res.ok) throw new Error(`Login failed: ${res.status}`);
-			this.cachedMe = null;
-		},
-		logout: async () => {
-			const res = await this._fetch("/auth/logout", { method: "POST" });
-			if (!res.ok) throw new Error(`Logout failed: ${res.status}`);
-			this.cachedMe = null;
-		}
-	};
-	datasource(id) {
-		return new DatasourceAPIImpl(id, this._fetch.bind(this), this.userTimezone);
-	}
-	integration(id) {
-		return new IntegrationAPIImpl(id, this._fetch.bind(this));
-	}
-	workflow(id) {
-		return new WorkflowAPIImpl(id, this._fetch.bind(this));
-	}
-	_fetch(path, init) {
-		const headers = new Headers(this.extraHeaders);
-		if (init?.headers) new Headers(init.headers).forEach((v, k) => headers.set(k, v));
-		const isServer = typeof window === "undefined";
-		return fetch(`${this.baseUrl}${path}`, {
-			...init,
-			credentials: isServer ? "omit" : "include",
-			headers
-		});
-	}
-};
-function createSoftrSDKFromRequest(request, baseUrl) {
-	const cookieHeader = request.headers.get("cookie") ?? "";
-	return new SoftrSDKImpl({
-		baseUrl,
-		userTimezone: parseCookie(cookieHeader, "user-timezone"),
-		headers: { cookie: cookieHeader }
-	});
-}
-function parseCookie(cookieHeader, name) {
-	return cookieHeader.split(";").map((c) => c.trim().split("=")).find(([k]) => k === name)?.[1];
-}
-
-//#endregion
-//#region src/core/middleware.ts
-/**
-* TanStack Start middleware. Injects a per-request Softr SDK instance with
-* cookies forwarded automatically. The base URL is read from VITE_SOFTR_BASE_URL.
-*
-* @example
-* import { withSDK } from '@softr/sdk'
-*
-* export const getProjects = createServerFn()
-*   .middleware([withSDK])
-*   .handler(({ context }) => context.sdk.datasource('ds_projects').list())
-*/
-const withSDK = createMiddleware().server(({ next, request }) => next({ context: { sdk: createSoftrSDKFromRequest(request, import.meta.env.VITE_SOFTR_BASE_URL) } }));
-
-//#endregion
-export { defineVisibility, getSoftrUser, isAccessError, isAlreadySignedInError, isForbiddenError, isUnauthenticatedError, q, softrAuthMiddleware, withSDK };
+export { defineVisibility, getSoftrContext, initialSoftrContext, isAccessError, isAlreadySignedInError, isForbiddenError, isUnauthenticatedError, q, softrAuthMiddleware, useCurrentUser, usePermissions };