@softr/sdk 0.0.12 → 0.0.13

package/dist/core/integration.js

@@ -0,0 +1,32 @@
+import { readSessionToken } from "../auth/session.js";
+
+//#region src/core/integration.ts
+const BASE_URL = () => (import.meta.env.VITE_SOFTR_BASE_URL ?? "").replace(/\/$/, "");
+async function integrationFetch(integrationId, input, init) {
+	const req = new Request(input, init);
+	if (req.signal.aborted) throw req.signal.reason ?? new DOMException("The operation was aborted.", "AbortError");
+	const reqHeaders = {};
+	new Headers(req.headers).forEach((value, key) => {
+		reqHeaders[key] = value;
+	});
+	const payload = {
+		method: req.method,
+		url: req.url,
+		headers: reqHeaders
+	};
+	const method = req.method.toUpperCase();
+	if (method !== "GET" && method !== "HEAD" && req.body !== null) payload.body = await req.clone().text();
+	return fetch(`${BASE_URL()}/api/integrations/${integrationId}/proxy`, {
+		method: "POST",
+		headers: {
+			"Content-Type": "application/json",
+			"Authorization": `Bearer ${readSessionToken()}`
+		},
+		body: JSON.stringify(payload),
+		signal: req.signal
+	});
+}
+const integration = { fetch: integrationFetch };
+
+//#endregion
+export { integration };

package/dist/{types-n-Sir_Y2.d.ts → core/query.d.ts}

@@ -351,132 +351,4 @@ declare const q: {
   desc(subject: string): ConstructableOrderBy;
 };
 //#endregion
-//#region src/auth/user.d.ts
-/**
- * Declare this interface in your app to narrow every group id the SDK takes and
- * returns. Without a declaration, a group id is a plain `string`.
- *
- * @example
- * declare module "@softr/sdk" {
- *   interface SoftrUserGroups {
- *     ids:
- *       | "b1f2c3d4-5e6f-4a7b-8c9d-0e1f2a3b4c5d"
- *       | "f9e8d7c6-5b4a-4938-8271-605f4e3d2c1b"
- *   }
- * }
- */
-interface SoftrUserGroups {}
-/** A Softr user group id, narrowed to your own ids if you declare {@link SoftrUserGroups}. */
-type SoftrUserGroupId = SoftrUserGroups extends {
-  ids: infer Id extends string;
-} ? Id : string;
-/** The signed-in visitor. */
-type User = {
-  id: string;
-  email: string;
-  name: string;
-  userGroupIds: Array<SoftrUserGroupId>;
-};
-//#endregion
-//#region src/types.d.ts
-interface SoftrUser {
-  id: string;
-  email: string;
-  name: string;
-  userGroupIds: Array<SoftrUserGroupId>;
-}
-interface DatasourcePermissions {
-  read: boolean;
-  create: boolean;
-  update: boolean;
-  delete: boolean;
-}
-interface SoftrPermissions {
-  datasources: Record<string, DatasourcePermissions>;
-  workflows: Record<string, boolean>;
-}
-interface SoftrMe {
-  user: SoftrUser | null;
-  permissions: SoftrPermissions;
-}
-type GetByIdOptions = {
-  id: string;
-  where?: never;
-  timeZone?: string;
-};
-type GetByWhereOptions = {
-  id?: never;
-  where: AnyConstructable;
-  timeZone?: string;
-};
-type GetOptions = GetByIdOptions | GetByWhereOptions;
-interface ListOptions {
-  /**
-   * Maps human-readable aliases to Softr field IDs.
-   * When provided, returned fields are keyed by alias instead of raw field ID.
-   */
-  select?: Record<string, string>;
-  where?: AnyConstructable;
-  orderBy?: ConstructableOrderBy | ConstructableOrderBy[];
-  /**
-   * Number of records to return per page. Defaults to 20, max 100.
-   */
-  limit?: number;
-  /**
-   * Offset to start from. Pass the `nextOffset` from a previous result to paginate.
-   * Omit or pass `null` to start from the beginning.
-   */
-  offset?: number | null;
-  /** Override the timezone for this request. */
-  timeZone?: string;
-}
-interface ListResult<T = SoftrRecord> {
-  records: T[];
-  total: number;
-  /** Offset to pass as `offset` in the next call, or `null` when there are no more pages. */
-  nextOffset: number | null;
-}
-interface SoftrRecord {
-  id: string;
-  fields: Record<string, unknown>;
-}
-type AggregationFunction = 'SUM' | 'AVG' | 'MAX' | 'MIN' | 'COUNT' | 'DISTINCT';
-interface MetricOptions {
-  select?: Record<string, string>;
-  where?: AnyConstructable;
-  aggregation: AggregationFunction;
-  /** Field alias (resolved via select) or raw field ID. Not required for COUNT. */
-  field?: string;
-  /** Override the timezone for this request. */
-  timeZone?: string;
-}
-interface MetricResult {
-  value: number | null;
-  executionTimestamp: Date;
-}
-interface ChartDataOptions {
-  select?: Record<string, string>;
-  where?: AnyConstructable;
-  /** Field alias (resolved via select) or raw field ID. */
-  groupBy: string | string[];
-  metrics: Record<string, {
-    field?: string;
-    aggregation: AggregationFunction;
-  }>;
-  orderBy?: ConstructableOrderBy;
-  /** Override the timezone for this request. */
-  timeZone?: string;
-}
-interface ChartDataResult {
-  data: Record<string, unknown>[];
-  executionTimestamp: Date;
-}
-interface CreateOptions {
-  fields: Record<string, unknown>;
-}
-interface UpdateOptions {
-  id: string;
-  fields: Record<string, unknown>;
-}
-//#endregion
-export { SoftrUserGroups as _, DatasourcePermissions as a, ListResult as c, SoftrMe as d, SoftrPermissions as f, SoftrUserGroupId as g, UpdateOptions as h, CreateOptions as i, MetricOptions as l, SoftrUser as m, ChartDataOptions as n, GetOptions as o, SoftrRecord as p, ChartDataResult as r, ListOptions as s, AggregationFunction as t, MetricResult as u, User as v, q as y };
+export { AnyConstructable, ConstructableOrderBy, q };

package/dist/core/query.js

@@ -0,0 +1,528 @@
+//#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
+export { buildFilterCriteria, buildOrderBy, dealiasFilterCriteria, dealiasOrderBy, q };

package/dist/core/workflow.d.ts

@@ -0,0 +1,7 @@
+//#region src/core/workflow.d.ts
+declare function triggerWorkflow(workflowId: string, payload?: Record<string, unknown>): Promise<void>;
+declare const workflow: {
+  trigger: typeof triggerWorkflow;
+};
+//#endregion
+export { workflow };

package/dist/core/workflow.js

@@ -0,0 +1,19 @@
+import { readSessionToken } from "../auth/session.js";
+
+//#region src/core/workflow.ts
+const BASE_URL = () => (import.meta.env.VITE_SOFTR_BASE_URL ?? "").replace(/\/$/, "");
+async function triggerWorkflow(workflowId, payload) {
+	const res = await fetch(`${BASE_URL()}/api/workflows/${workflowId}/trigger`, {
+		method: "POST",
+		headers: {
+			"Authorization": `Bearer ${readSessionToken()}`,
+			...payload ? { "Content-Type": "application/json" } : {}
+		},
+		...payload ? { body: JSON.stringify(payload) } : {}
+	});
+	if (!res.ok) throw new Error(`Softr workflow trigger failed: ${res.status}`);
+}
+const workflow = { trigger: triggerWorkflow };
+
+//#endregion
+export { workflow };