@softr/sdk 0.0.4 → 0.0.5

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { C as isAccessError, E as isUnauthenticatedError, S as defineVisibility, T as isForbiddenError, _ as SoftrContext, a as ListResult, b as User, c as SoftrRecord, d as WorkflowAPI, f as AccessBehaviour, g as RouteVisibility, h as AccessReason, i as ListOptions, l as SoftrSDK, m as AccessError, n as DatasourceAPI, o as SoftrMe, p as AccessCheck, r as DatasourcePermissions, s as SoftrPermissions, t as AuthAPI, u as SoftrUser, v as SoftrUserGroupId, w as isAlreadySignedInError, x as VisibilityHandle, y as SoftrUserGroups } from "./types-DCiIbAw_.js";
+import { A as defineVisibility, C as AccessReason, D as SoftrUserGroups, E as SoftrUserGroupId, F as q, M as isAlreadySignedInError, N as isForbiddenError, O as User, P as isUnauthenticatedError, S as AccessError, T as SoftrContext, _ as SoftrUser, a as CreateOptions, b as AccessBehaviour, c as GetOptions, d as MetricOptions, f as MetricResult, g as SoftrSDK, h as SoftrRecord, i as ChartDataResult, j as isAccessError, k as VisibilityHandle, l as ListOptions, m as SoftrPermissions, n as AuthAPI, o as DatasourceAPI, p as SoftrMe, r as ChartDataOptions, s as DatasourcePermissions, t as AggregationFunction, u as ListResult, v as UpdateOptions, w as RouteVisibility, x as AccessCheck, y as WorkflowAPI } from "./types-BYfW8LV3.js";
 import * as _tanstack_react_start0 from "@tanstack/react-start";
 
 //#region src/auth/session.d.ts
@@ -34,4 +34,4 @@ declare function softrAuthMiddleware(): _tanstack_react_start0.RequestMiddleware
   user: User | null;
 }>;
 //#endregion
-export { type AccessBehaviour, type AccessCheck, type AccessError, type AccessReason, type AuthAPI, type DatasourceAPI, type DatasourcePermissions, type ListOptions, type ListResult, type RouteVisibility, type SoftrContext, type SoftrMe, type SoftrPermissions, type SoftrRecord, type SoftrSDK, type SoftrUser, type SoftrUserGroupId, type SoftrUserGroups, type User, type VisibilityHandle, type WorkflowAPI, defineVisibility, getSoftrUser, isAccessError, isAlreadySignedInError, isForbiddenError, isUnauthenticatedError, softrAuthMiddleware };
+export { type AccessBehaviour, type AccessCheck, type AccessError, type AccessReason, type AggregationFunction, type AuthAPI, type ChartDataOptions, type ChartDataResult, type CreateOptions, type DatasourceAPI, type DatasourcePermissions, type GetOptions, type ListOptions, type ListResult, type MetricOptions, type MetricResult, type RouteVisibility, type SoftrContext, type SoftrMe, type SoftrPermissions, type SoftrRecord, type SoftrSDK, type SoftrUser, type SoftrUserGroupId, type SoftrUserGroups, type UpdateOptions, type User, type VisibilityHandle, type WorkflowAPI, defineVisibility, getSoftrUser, isAccessError, isAlreadySignedInError, isForbiddenError, isUnauthenticatedError, q, softrAuthMiddleware };

package/dist/index.js

@@ -1,3 +1,4 @@
+import { a as q } from "./query-C6022JhD.js";
 import { redirect } from "@tanstack/react-router";
 import { createMiddleware, createServerFn, getGlobalStartContext } from "@tanstack/react-start";
 
@@ -166,4 +167,4 @@ function softrAuthMiddleware() {
 }
 
 //#endregion
-export { defineVisibility, getSoftrUser, isAccessError, isAlreadySignedInError, isForbiddenError, isUnauthenticatedError, softrAuthMiddleware };
+export { defineVisibility, getSoftrUser, isAccessError, isAlreadySignedInError, isForbiddenError, isUnauthenticatedError, q, softrAuthMiddleware };

package/dist/query-C6022JhD.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 { q as a, dealiasOrderBy as i, buildOrderBy as n, dealiasFilterCriteria as r, buildFilterCriteria as t };

package/dist/tanstack.d.ts

@@ -1,4 +1,4 @@
-import { l as SoftrSDK } from "./types-DCiIbAw_.js";
+import { g as SoftrSDK } from "./types-BYfW8LV3.js";
 
 //#region src/tanstack.d.ts