@softr/sdk 0.0.25 → 0.0.26

package/dist/core/query.js

@@ -1,528 +0,0 @@
-//#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/utils.js

@@ -1,14 +0,0 @@
-//#region src/core/utils.ts
-async function assertResponseOk(res, message) {
-	if (!res.ok) {
-		let fullMessage = `${message}: ${res.status}`;
-		if (process.env.NODE_ENV !== "production") {
-			const body = await res.text().catch(() => "");
-			if (body) fullMessage += `\n\n${body}`;
-		}
-		throw new Error(fullMessage);
-	}
-}
-
-//#endregion
-export { assertResponseOk };

package/dist/types.d.ts

@@ -1,128 +0,0 @@
-import { AnyConstructable, ConstructableOrderBy } from "./core/query.js";
-import { SoftrUserGroupId } from "./auth/user.js";
-
-//#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;
-  select?: Record<string, string>;
-};
-type GetByWhereOptions = {
-  id?: never;
-  where: AnyConstructable;
-  timeZone?: string;
-  select?: Record<string, 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;
-}
-type JsonValue = string | number | boolean | null | JsonValue[] | {
-  [key: string]: JsonValue;
-};
-interface SoftrRecord<T extends Record<string, JsonValue> = Record<string, JsonValue>> {
-  id: string;
-  fields: T;
-}
-interface ListResult<T extends SoftrRecord = 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;
-}
-/**
- * Augment this interface in a generated datasource-types file to enable
- * typed `ds.list()` / `ds.get()` return values per datasource ID.
- * Maps datasource ID → raw field shape (keyed by field ID).
- */
-interface DatasourceTypeMap {}
-type AliasedFields<Sel extends Record<string, string>, Raw extends Record<string, JsonValue>> = { [K in keyof Sel]: Sel[K] extends keyof Raw ? Raw[Sel[K]] : JsonValue };
-type RecordFieldsFor<Id extends string, Sel extends Record<string, string>> = Id extends keyof DatasourceTypeMap ? [keyof Sel] extends [never] ? DatasourceTypeMap[Id] : AliasedFields<Sel, DatasourceTypeMap[Id]> : Record<string, JsonValue>;
-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 ChartOptions {
-  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 ChartResult {
-  data: Record<string, JsonValue>[];
-  executionTimestamp: Date;
-}
-interface CreateOptions {
-  /**
-   * Maps human-readable aliases to Softr field IDs.
-   * When provided, `data` keys are interpreted as aliases.
-   */
-  select?: Record<string, string>;
-  data: Record<string, JsonValue>;
-}
-interface UpdateOptions {
-  id: string;
-  /**
-   * Maps human-readable aliases to Softr field IDs.
-   * When provided, `data` keys are interpreted as aliases.
-   */
-  select?: Record<string, string>;
-  data: Record<string, JsonValue>;
-}
-//#endregion
-export { AggregationFunction, ChartOptions, ChartResult, CreateOptions, DatasourcePermissions, DatasourceTypeMap, GetOptions, JsonValue, ListOptions, ListResult, MetricOptions, MetricResult, RecordFieldsFor, SoftrMe, SoftrPermissions, SoftrRecord, SoftrUser, UpdateOptions };