jazz-tools 0.18.14 → 0.18.16

package/src/better-auth/database-adapter/utils.ts

@@ -0,0 +1,178 @@
+import { CleanedWhere } from "better-auth/adapters";
+
+export function filterListByWhere<T>(
+  data: T[],
+  where: CleanedWhere[] | undefined,
+): T[] {
+  if (!Array.isArray(data)) {
+    throw new Error("Expected data to be an array");
+  }
+
+  if (where === undefined) {
+    return data;
+  }
+
+  if (!Array.isArray(where)) {
+    throw new Error("Expected where to be an array");
+  }
+
+  // Helper to evaluate a single condition
+  function evaluateCondition(item: any, condition: CleanedWhere): boolean {
+    const { field, operator, value } = condition;
+    const itemValue = field === "id" ? item.$jazz.id : item[field];
+
+    switch (operator) {
+      case "eq":
+        return itemValue === value;
+      case "ne":
+        return itemValue !== value;
+      case "lt":
+        return value !== null && itemValue < value;
+      case "lte":
+        return value !== null && itemValue <= value;
+      case "gt":
+        return value !== null && itemValue > value;
+      case "gte":
+        return value !== null && itemValue >= value;
+      case "in":
+        return Array.isArray(value)
+          ? (value as (string | number | boolean | Date)[]).includes(itemValue)
+          : false;
+      case "contains":
+        return typeof itemValue === "string" && typeof value === "string"
+          ? itemValue.includes(value)
+          : false;
+      case "starts_with":
+        return typeof itemValue === "string" && typeof value === "string"
+          ? itemValue.startsWith(value)
+          : false;
+      case "ends_with":
+        return typeof itemValue === "string" && typeof value === "string"
+          ? itemValue.endsWith(value)
+          : false;
+      default:
+        throw new Error(`Unsupported operator: ${operator}`);
+    }
+  }
+
+  // Group conditions by connector (AND/OR)
+  // If no connector, default to AND between all
+  return data.filter((item) => {
+    let result: boolean = true;
+    for (let i = 0; i < where.length; i++) {
+      const condition = where[i]!;
+      const matches = evaluateCondition(item, condition);
+      if (i === 0) {
+        result = matches;
+      } else {
+        const connector = condition.connector || "AND";
+        if (connector === "AND") {
+          result = result && matches;
+        } else if (connector === "OR") {
+          result = result || matches;
+        } else {
+          throw new Error(`Unsupported connector: ${connector}`);
+        }
+      }
+    }
+    return result;
+  });
+}
+
+export function sortListByField<T extends Record<string, any> | null>(
+  data: T[],
+  sort?: { field: string; direction: "asc" | "desc" },
+): T[] {
+  if (!sort) {
+    return data;
+  }
+
+  const { field, direction } = sort;
+
+  data.sort((a, b) => {
+    if (a === null || b === null) {
+      return 0;
+    }
+
+    if (typeof a[field] === "string" && typeof b[field] === "string") {
+      return direction === "asc"
+        ? a[field].localeCompare(b[field])
+        : b[field].localeCompare(a[field]);
+    }
+
+    return direction === "asc" ? a[field] - b[field] : b[field] - a[field];
+  });
+
+  return data;
+}
+
+export function paginateList<T>(
+  data: T[],
+  limit: number | undefined,
+  offset: number | undefined,
+): T[] {
+  if (offset === undefined && limit === undefined) {
+    return data;
+  }
+
+  if (limit === 0) {
+    return [];
+  }
+
+  let start = offset ?? 0;
+  if (start < 0) {
+    start = 0;
+  }
+
+  const end = limit ? start + limit : undefined;
+  return data.slice(start, end);
+}
+
+function isWhereByField(field: string, where: CleanedWhere): boolean {
+  return (
+    where.field === field &&
+    where.operator === "eq" &&
+    where.connector === "AND"
+  );
+}
+
+export function isWhereBySingleField<T extends string>(
+  field: T,
+  where: CleanedWhere[] | undefined,
+): where is [{ field: T; operator: "eq"; value: string; connector: "AND" }] {
+  if (where === undefined || where.length !== 1) {
+    return false;
+  }
+
+  const [cond] = where;
+  if (!cond) {
+    return false;
+  }
+
+  return isWhereByField(field, cond);
+}
+
+export function containWhereByField<T extends string>(
+  field: T,
+  where: CleanedWhere[] | undefined,
+): boolean {
+  if (where === undefined) {
+    return false;
+  }
+
+  return where.some((cond) => isWhereByField(field, cond));
+}
+
+export function extractWhereByField<T extends string>(
+  field: T,
+  where: CleanedWhere[] | undefined,
+): [CleanedWhere | undefined, CleanedWhere[]] {
+  if (where === undefined) {
+    return [undefined, []];
+  }
+
+  return [
+    where.find((cond) => isWhereByField(field, cond)),
+    where.filter((cond) => !isWhereByField(field, cond)),
+  ];
+}

package/src/worker/edge-wasm.ts

@@ -0,0 +1,5 @@
+// InitWasm allow to load the wasm code in edge runtimes (ex. cloudflare worker and vercel edge functions)
+import { init as InitWasm } from "cojson/crypto/WasmCrypto/edge";
+import { WasmCrypto } from "cojson/crypto/WasmCrypto";
+
+WasmCrypto.setInit(InitWasm);

package/tsup.config.ts

@@ -135,6 +135,7 @@ export default defineConfig([
     ...cfg,
     entry: {
       index: "src/worker/index.ts",
+      "edge-wasm": "src/worker/edge-wasm.ts",
     },
     outDir: "dist/worker",
   },
@@ -147,4 +148,11 @@ export default defineConfig([
     },
     outDir: "dist/better-auth/auth",
   },
+  {
+    ...cfg,
+    entry: {
+      index: "src/better-auth/database-adapter/index.ts",
+    },
+    outDir: "dist/better-auth/database-adapter",
+  },
 ]);