@softr/sdk 0.0.11 → 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/core/query.d.ts

@@ -0,0 +1,354 @@
+//#region src/core/query.d.ts
+
+type LogicalOperator = "AND" | "OR";
+type FilterOperator = "IS" | "IS_NOT" | "EQUAL" | "NOT_EQUAL" | "IS_EMPTY" | "IS_NOT_EMPTY" | "IS_ONE_OF" | "IS_NONE_OF" | "HAS_ALL_OF" | "HAS_ONE_OF" | "HAS_NONE_OF" | "CONTAINS" | "INLINE_CONTAINS" | "GT" | "LT" | "GTE" | "LTE" | "BETWEEN" | "IS_NOT_BETWEEN" | "DOES_NOT_CONTAINS" | "STARTS_WITH" | "ENDS_WITH";
+type ConditionFieldType = "TEXT" | "BOOLEAN" | "NUMERIC" | "ARRAY" | "DATE";
+interface Filter {
+  subject: string;
+  operator: FilterOperator;
+  value?: unknown;
+  type: ConditionFieldType;
+}
+type ConstructableFilter = Filter & {
+  [INTERNAL_KIND]: "FILTER";
+};
+type ConstructableFilterGroup = {
+  logicalOperator: LogicalOperator;
+  filters: Array<ConstructableFilter | ConstructableFilterGroup>;
+  [INTERNAL_KIND]: "LOGICAL_GROUP";
+};
+interface SortingOptionItem {
+  sortingField: string;
+  sortType: "ASC" | "DESC";
+}
+type ConstructableOrderBy = SortingOptionItem & {
+  [INTERNAL_KIND]: "ORDER_BY";
+};
+type AnyConstructable = ConstructableFilter | ConstructableFilterGroup;
+declare const INTERNAL_KIND: unique symbol;
+/**
+ * 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)
+ *   )
+ * );
+ * ```
+ */
+declare const q: {
+  select<T extends Record<string, string>>(mapping: T): T;
+  and(...filters: AnyConstructable[]): ConstructableFilterGroup;
+  or(...filters: AnyConstructable[]): ConstructableFilterGroup;
+  text(subject: string): {
+    is(value: string): {
+      operator: "IS";
+      value: string;
+      subject: string;
+      type: "TEXT";
+      [INTERNAL_KIND]: "FILTER";
+    };
+    isNot(value: string): {
+      operator: "IS_NOT";
+      value: string;
+      subject: string;
+      type: "TEXT";
+      [INTERNAL_KIND]: "FILTER";
+    };
+    contains(value: string): {
+      operator: "CONTAINS";
+      value: string;
+      subject: string;
+      type: "TEXT";
+      [INTERNAL_KIND]: "FILTER";
+    };
+    isOneOf(value: string[]): {
+      operator: "IS_ONE_OF";
+      value: string[];
+      subject: string;
+      type: "TEXT";
+      [INTERNAL_KIND]: "FILTER";
+    };
+    isNoneOf(value: string[]): {
+      operator: "IS_NONE_OF";
+      value: string[];
+      subject: string;
+      type: "TEXT";
+      [INTERNAL_KIND]: "FILTER";
+    };
+    startsWith(value: string): {
+      operator: "STARTS_WITH";
+      value: string;
+      subject: string;
+      type: "TEXT";
+      [INTERNAL_KIND]: "FILTER";
+    };
+    endsWith(value: string): {
+      operator: "ENDS_WITH";
+      value: string;
+      subject: string;
+      type: "TEXT";
+      [INTERNAL_KIND]: "FILTER";
+    };
+    hasAllOf(value: string[]): {
+      operator: "HAS_ALL_OF";
+      value: string[];
+      subject: string;
+      type: "TEXT";
+      [INTERNAL_KIND]: "FILTER";
+    };
+    isEmpty(): {
+      operator: "IS_EMPTY";
+      subject: string;
+      type: "TEXT";
+      [INTERNAL_KIND]: "FILTER";
+    };
+    isNotEmpty(): {
+      operator: "IS_NOT_EMPTY";
+      subject: string;
+      type: "TEXT";
+      [INTERNAL_KIND]: "FILTER";
+    };
+  };
+  boolean(subject: string): {
+    is(value: boolean): {
+      operator: "IS";
+      value: boolean;
+      subject: string;
+      type: "BOOLEAN";
+      [INTERNAL_KIND]: "FILTER";
+    };
+    isNot(value: boolean): {
+      operator: "IS_NOT";
+      value: boolean;
+      subject: string;
+      type: "BOOLEAN";
+      [INTERNAL_KIND]: "FILTER";
+    };
+    isEmpty(): {
+      operator: "IS_EMPTY";
+      subject: string;
+      type: "BOOLEAN";
+      [INTERNAL_KIND]: "FILTER";
+    };
+    isNotEmpty(): {
+      operator: "IS_NOT_EMPTY";
+      subject: string;
+      type: "BOOLEAN";
+      [INTERNAL_KIND]: "FILTER";
+    };
+  };
+  number(subject: string): {
+    is(value: number): {
+      operator: "IS";
+      value: string;
+      subject: string;
+      type: "NUMERIC";
+      [INTERNAL_KIND]: "FILTER";
+    };
+    isNot(value: number): {
+      operator: "IS_NOT";
+      value: string;
+      subject: string;
+      type: "NUMERIC";
+      [INTERNAL_KIND]: "FILTER";
+    };
+    gt(value: number): {
+      operator: "GT";
+      value: string;
+      subject: string;
+      type: "NUMERIC";
+      [INTERNAL_KIND]: "FILTER";
+    };
+    gte(value: number): {
+      operator: "GTE";
+      value: string;
+      subject: string;
+      type: "NUMERIC";
+      [INTERNAL_KIND]: "FILTER";
+    };
+    lt(value: number): {
+      operator: "LT";
+      value: string;
+      subject: string;
+      type: "NUMERIC";
+      [INTERNAL_KIND]: "FILTER";
+    };
+    lte(value: number): {
+      operator: "LTE";
+      value: string;
+      subject: string;
+      type: "NUMERIC";
+      [INTERNAL_KIND]: "FILTER";
+    };
+    between(start: number, end: number): {
+      operator: "BETWEEN";
+      value: string[];
+      subject: string;
+      type: "NUMERIC";
+      [INTERNAL_KIND]: "FILTER";
+    };
+    isEmpty(): {
+      operator: "IS_EMPTY";
+      subject: string;
+      type: "NUMERIC";
+      [INTERNAL_KIND]: "FILTER";
+    };
+    isNotEmpty(): {
+      operator: "IS_NOT_EMPTY";
+      subject: string;
+      type: "NUMERIC";
+      [INTERNAL_KIND]: "FILTER";
+    };
+  };
+  array(subject: string): {
+    is(value: string[]): {
+      operator: "IS";
+      value: string[];
+      subject: string;
+      type: "ARRAY";
+      [INTERNAL_KIND]: "FILTER";
+    };
+    isOneOf(value: string[]): {
+      operator: "IS_ONE_OF";
+      value: string[];
+      subject: string;
+      type: "ARRAY";
+      [INTERNAL_KIND]: "FILTER";
+    };
+    isNoneOf(value: string[]): {
+      operator: "IS_NONE_OF";
+      value: string[];
+      subject: string;
+      type: "ARRAY";
+      [INTERNAL_KIND]: "FILTER";
+    };
+    hasAllOf(value: string[]): {
+      operator: "HAS_ALL_OF";
+      value: string[];
+      subject: string;
+      type: "ARRAY";
+      [INTERNAL_KIND]: "FILTER";
+    };
+    isEmpty(): {
+      operator: "IS_EMPTY";
+      subject: string;
+      type: "ARRAY";
+      [INTERNAL_KIND]: "FILTER";
+    };
+    isNotEmpty(): {
+      operator: "IS_NOT_EMPTY";
+      subject: string;
+      type: "ARRAY";
+      [INTERNAL_KIND]: "FILTER";
+    };
+  };
+  date(subject: string): {
+    is(value: string): {
+      operator: "IS";
+      value: string;
+      subject: string;
+      type: "DATE";
+      [INTERNAL_KIND]: "FILTER";
+    };
+    isNot(value: string): {
+      operator: "IS_NOT";
+      value: string;
+      subject: string;
+      type: "DATE";
+      [INTERNAL_KIND]: "FILTER";
+    };
+    gt(value: string): {
+      operator: "GT";
+      value: string;
+      subject: string;
+      type: "DATE";
+      [INTERNAL_KIND]: "FILTER";
+    };
+    gte(value: string): {
+      operator: "GTE";
+      value: string;
+      subject: string;
+      type: "DATE";
+      [INTERNAL_KIND]: "FILTER";
+    };
+    lt(value: string): {
+      operator: "LT";
+      value: string;
+      subject: string;
+      type: "DATE";
+      [INTERNAL_KIND]: "FILTER";
+    };
+    lte(value: string): {
+      operator: "LTE";
+      value: string;
+      subject: string;
+      type: "DATE";
+      [INTERNAL_KIND]: "FILTER";
+    };
+    between(start: string, end: string): {
+      operator: "BETWEEN";
+      value: string[];
+      subject: string;
+      type: "DATE";
+      [INTERNAL_KIND]: "FILTER";
+    };
+    isNotBetween(start: string, end: string): {
+      operator: "IS_NOT_BETWEEN";
+      value: string[];
+      subject: string;
+      type: "DATE";
+      [INTERNAL_KIND]: "FILTER";
+    };
+    isEmpty(): {
+      operator: "IS_EMPTY";
+      subject: string;
+      type: "DATE";
+      [INTERNAL_KIND]: "FILTER";
+    };
+    isNotEmpty(): {
+      operator: "IS_NOT_EMPTY";
+      subject: string;
+      type: "DATE";
+      [INTERNAL_KIND]: "FILTER";
+    };
+  };
+  asc(subject: string): ConstructableOrderBy;
+  desc(subject: string): ConstructableOrderBy;
+};
+//#endregion
+export { AnyConstructable, ConstructableOrderBy, q };