@softr/sdk 0.0.7 → 0.0.11

package/dist/index.js

@@ -1,7 +1,534 @@
-import { a as q } from "./query-C6022JhD.js";
+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";
 
+//#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.
@@ -124,13 +651,36 @@ function defineVisibility(rule) {
 }
 
 //#endregion
-//#region src/auth/session.ts
-async function resolveVisitor(_request) {
-	return null;
-}
-function visitorFromContext(context) {
-	if (typeof context !== "object" || context === null || !("user" in context)) throw new Error("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;
+//#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.
@@ -144,27 +694,327 @@ function visitorFromContext(context) {
 *   beforeLoad: async () => ({ user: await getSoftrUser() }),
 * })
 */
-const getSoftrUser = createServerFn({ method: "GET" }).handler(async () => visitorFromContext(getGlobalStartContext()));
+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/auth/middleware.ts
+//#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
 /**
-* 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.
+* 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
-* export const startInstance = createStart(() => ({
-*   requestMiddleware: [softrAuthMiddleware()],
-* }))
+* import { withSDK } from '@softr/sdk'
+*
+* export const getProjects = createServerFn()
+*   .middleware([withSDK])
+*   .handler(({ context }) => context.sdk.datasource('ds_projects').list())
 */
-function softrAuthMiddleware() {
-	return createMiddleware({ type: "request" }).server(async ({ request, next }) => {
-		return next({ context: { user: await resolveVisitor(request) } });
-	});
-}
+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 };
+export { defineVisibility, getSoftrUser, isAccessError, isAlreadySignedInError, isForbiddenError, isUnauthenticatedError, q, softrAuthMiddleware, withSDK };