@strata-sync/client 0.1.0

package/src/query.ts

@@ -0,0 +1,224 @@
+import type { IdentityMap } from "./identity-map";
+import type { QueryOptions, QueryResult } from "./types";
+
+/**
+ * Executes a query against an identity map
+ */
+export function executeQuery<T extends Record<string, unknown>>(
+  map: IdentityMap<T>,
+  options: QueryOptions<T> = {}
+): QueryResult<T> {
+  let results = map.values();
+
+  // Filter by predicate
+  if (options.where) {
+    results = results.filter(options.where);
+  }
+
+  // Filter archived unless explicitly included
+  if (!options.includeArchived) {
+    results = results.filter((item) => !item.archivedAt);
+  }
+
+  // Get total count before pagination
+  const totalCount = results.length;
+
+  // Sort results
+  if (options.orderBy) {
+    results = results.sort(options.orderBy);
+  }
+
+  // Apply offset
+  if (options.offset && options.offset > 0) {
+    results = results.slice(options.offset);
+  }
+
+  // Apply limit
+  let hasMore = false;
+  if (options.limit && options.limit > 0) {
+    hasMore = results.length > options.limit;
+    results = results.slice(0, options.limit);
+  }
+
+  return {
+    data: results,
+    hasMore,
+    totalCount,
+  };
+}
+
+/**
+ * Sorts by a field name
+ */
+export function sortBy<T>(
+  field: keyof T,
+  direction: "asc" | "desc" = "asc"
+): (a: T, b: T) => number {
+  return (a: T, b: T) => {
+    const aVal = a[field];
+    const bVal = b[field];
+
+    if (aVal === bVal) {
+      return 0;
+    }
+    if (aVal === null || aVal === undefined) {
+      return 1;
+    }
+    if (bVal === null || bVal === undefined) {
+      return -1;
+    }
+
+    let result: number;
+    if (typeof aVal === "string" && typeof bVal === "string") {
+      result = aVal.localeCompare(bVal);
+    } else if (typeof aVal === "number" && typeof bVal === "number") {
+      result = aVal - bVal;
+    } else if (aVal instanceof Date && bVal instanceof Date) {
+      result = aVal.getTime() - bVal.getTime();
+    } else {
+      result = String(aVal).localeCompare(String(bVal));
+    }
+
+    return direction === "desc" ? -result : result;
+  };
+}
+
+/**
+ * Combines multiple sort functions
+ */
+export function combineSorts<T>(
+  ...sorts: Array<(a: T, b: T) => number>
+): (a: T, b: T) => number {
+  return (a: T, b: T) => {
+    for (const sort of sorts) {
+      const result = sort(a, b);
+      if (result !== 0) {
+        return result;
+      }
+    }
+    return 0;
+  };
+}
+
+/**
+ * Creates a filter for equality
+ */
+export function eq<T, K extends keyof T>(
+  field: K,
+  value: T[K]
+): (item: T) => boolean {
+  return (item: T) => item[field] === value;
+}
+
+/**
+ * Creates a filter for not equal
+ */
+export function neq<T, K extends keyof T>(
+  field: K,
+  value: T[K]
+): (item: T) => boolean {
+  return (item: T) => item[field] !== value;
+}
+
+/**
+ * Creates a filter for greater than
+ */
+export function gt<T, K extends keyof T>(
+  field: K,
+  value: T[K]
+): (item: T) => boolean {
+  return (item: T) => {
+    const itemVal = item[field];
+    if (typeof itemVal === "number" && typeof value === "number") {
+      return itemVal > value;
+    }
+    return false;
+  };
+}
+
+/**
+ * Creates a filter for less than
+ */
+export function lt<T, K extends keyof T>(
+  field: K,
+  value: T[K]
+): (item: T) => boolean {
+  return (item: T) => {
+    const itemVal = item[field];
+    if (typeof itemVal === "number" && typeof value === "number") {
+      return itemVal < value;
+    }
+    return false;
+  };
+}
+
+/**
+ * Creates a filter for inclusion in a list
+ */
+export function isIn<T, K extends keyof T>(
+  field: K,
+  values: T[K][]
+): (item: T) => boolean {
+  const valueSet = new Set(values);
+  return (item: T) => valueSet.has(item[field]);
+}
+
+/**
+ * Creates a filter for substring matching
+ */
+export function contains<T>(
+  field: keyof T,
+  substring: string,
+  caseSensitive = false
+): (item: T) => boolean {
+  const searchStr = caseSensitive ? substring : substring.toLowerCase();
+  return (item: T) => {
+    const value = item[field];
+    if (typeof value !== "string") {
+      return false;
+    }
+    const compareVal = caseSensitive ? value : value.toLowerCase();
+    return compareVal.includes(searchStr);
+  };
+}
+
+/**
+ * Creates a filter for regex matching
+ */
+export function matches<T>(
+  field: keyof T,
+  pattern: RegExp
+): (item: T) => boolean {
+  return (item: T) => {
+    const value = item[field];
+    if (typeof value !== "string") {
+      return false;
+    }
+    return pattern.test(value);
+  };
+}
+
+/**
+ * Combines multiple filters with AND logic
+ */
+export function and<T>(
+  ...filters: Array<(item: T) => boolean>
+): (item: T) => boolean {
+  return (item: T) => filters.every((f) => f(item));
+}
+
+/**
+ * Combines multiple filters with OR logic
+ */
+export function or<T>(
+  ...filters: Array<(item: T) => boolean>
+): (item: T) => boolean {
+  return (item: T) => filters.some((f) => f(item));
+}
+
+/**
+ * Negates a filter
+ */
+export function not<T>(filter: (item: T) => boolean): (item: T) => boolean {
+  return (item: T) => !filter(item);
+}