@arkiv-network/sdk 0.7.0-dev.1 → 0.8.0-dev.1

package/src/query/predicate.test.ts

@@ -1,461 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import { and, eq, gt, gte, lt, lte, neq, not, or, type Predicate } from "./predicate"
-
-describe("Predicate Factory Functions", () => {
-  describe("eq()", () => {
-    test("creates equality predicate with string value", () => {
-      const result = eq("name", "john")
-
-      expect(result).toEqual({
-        type: "eq",
-        key: "name",
-        value: "john",
-      })
-    })
-
-    test("creates equality predicate with numeric value", () => {
-      const result = eq("age", 25)
-
-      expect(result).toEqual({
-        type: "eq",
-        key: "age",
-        value: 25,
-      })
-    })
-
-    test("creates equality predicate with zero", () => {
-      const result = eq("count", 0)
-
-      expect(result).toEqual({
-        type: "eq",
-        key: "count",
-        value: 0,
-      })
-    })
-
-    test("creates equality predicate with empty string", () => {
-      const result = eq("name", "")
-
-      expect(result).toEqual({
-        type: "eq",
-        key: "name",
-        value: "",
-      })
-    })
-  })
-
-  describe("neq()", () => {
-    test("creates not equal predicate with string value", () => {
-      const result = neq("status", "inactive")
-
-      expect(result).toEqual({
-        type: "neq",
-        key: "status",
-        value: "inactive",
-      })
-    })
-
-    test("creates not equal predicate with numeric value", () => {
-      const result = neq("count", 0)
-
-      expect(result).toEqual({
-        type: "neq",
-        key: "count",
-        value: 0,
-      })
-    })
-  })
-
-  describe("gt()", () => {
-    test("creates greater than predicate with numeric value", () => {
-      const result = gt("age", 18)
-
-      expect(result).toEqual({
-        type: "gt",
-        key: "age",
-        value: 18,
-      })
-    })
-
-    test("creates greater than predicate with negative number", () => {
-      const result = gt("balance", -100)
-
-      expect(result).toEqual({
-        type: "gt",
-        key: "balance",
-        value: -100,
-      })
-    })
-
-    test("creates greater than predicate with string value", () => {
-      const result = gt("name", "abc")
-
-      expect(result).toEqual({
-        type: "gt",
-        key: "name",
-        value: "abc",
-      })
-    })
-  })
-
-  describe("gte()", () => {
-    test("creates greater than or equal predicate with numeric value", () => {
-      const result = gte("age", 18)
-
-      expect(result).toEqual({
-        type: "gte",
-        key: "age",
-        value: 18,
-      })
-    })
-
-    test("creates greater than or equal predicate with negative number", () => {
-      const result = gte("temperature", -10)
-
-      expect(result).toEqual({
-        type: "gte",
-        key: "temperature",
-        value: -10,
-      })
-    })
-
-    test("creates greater than or equal predicate with string value", () => {
-      const result = gte("version", "1.0.0")
-
-      expect(result).toEqual({
-        type: "gte",
-        key: "version",
-        value: "1.0.0",
-      })
-    })
-  })
-
-  describe("lt()", () => {
-    test("creates less than predicate with numeric value", () => {
-      const result = lt("age", 65)
-
-      expect(result).toEqual({
-        type: "lt",
-        key: "age",
-        value: 65,
-      })
-    })
-
-    test("creates less than predicate with string value", () => {
-      const result = lt("priority", "high")
-
-      expect(result).toEqual({
-        type: "lt",
-        key: "priority",
-        value: "high",
-      })
-    })
-  })
-
-  describe("lte()", () => {
-    test("creates less than or equal predicate with numeric value", () => {
-      const result = lte("score", 100)
-
-      expect(result).toEqual({
-        type: "lte",
-        key: "score",
-        value: 100,
-      })
-    })
-
-    test("creates less than or equal predicate with string value", () => {
-      const result = lte("date", "2023-12-31")
-
-      expect(result).toEqual({
-        type: "lte",
-        key: "date",
-        value: "2023-12-31",
-      })
-    })
-  })
-
-  describe("not()", () => {
-    test("creates not predicate", () => {
-      const result = not("deleted")
-
-      expect(result).toEqual({
-        type: "not",
-        key: "deleted",
-        value: "",
-      })
-    })
-
-    test("creates not predicate with different key", () => {
-      const result = not("archived")
-
-      expect(result).toEqual({
-        type: "not",
-        key: "archived",
-        value: "",
-      })
-    })
-  })
-
-  describe("or()", () => {
-    test("creates or predicate with two simple predicates", () => {
-      const predicates = [eq("type", "admin"), eq("type", "moderator")]
-      const result = or(predicates)
-
-      expect(result).toEqual({
-        type: "or",
-        predicates: [
-          { type: "eq", key: "type", value: "admin" },
-          { type: "eq", key: "type", value: "moderator" },
-        ],
-      })
-    })
-
-    test("creates or predicate with mixed predicate types", () => {
-      const predicates = [eq("status", "active"), gte("score", 100), neq("role", "guest")]
-      const result = or(predicates)
-
-      expect(result).toEqual({
-        type: "or",
-        predicates: [
-          { type: "eq", key: "status", value: "active" },
-          { type: "gte", key: "score", value: 100 },
-          { type: "neq", key: "role", value: "guest" },
-        ],
-      })
-    })
-
-    test("creates or predicate with single predicate", () => {
-      const predicates = [eq("enabled", 1)]
-      const result = or(predicates)
-
-      expect(result).toEqual({
-        type: "or",
-        predicates: [{ type: "eq", key: "enabled", value: 1 }],
-      })
-    })
-
-    test("creates or predicate with empty array", () => {
-      const predicates: Predicate[] = []
-      const result = or(predicates)
-
-      expect(result).toEqual({
-        type: "or",
-        predicates: [],
-      })
-    })
-
-    test("creates or predicate from varargs", () => {
-      const result = or(eq("type", "admin"), eq("type", "moderator"))
-
-      expect(result).toEqual({
-        type: "or",
-        predicates: [
-          { type: "eq", key: "type", value: "admin" },
-          { type: "eq", key: "type", value: "moderator" },
-        ],
-      })
-    })
-
-    test("creates or predicate with no arguments", () => {
-      const result = or()
-
-      expect(result).toEqual({
-        type: "or",
-        predicates: [],
-      })
-    })
-
-    test("creates or predicate with nested and", () => {
-      const nestedAnd = and([eq("verified", 1), gte("age", 18)])
-      const predicates = [eq("status", "premium"), nestedAnd]
-      const result = or(predicates)
-
-      expect(result).toEqual({
-        type: "or",
-        predicates: [
-          { type: "eq", key: "status", value: "premium" },
-          {
-            type: "and",
-            predicates: [
-              { type: "eq", key: "verified", value: 1 },
-              { type: "gte", key: "age", value: 18 },
-            ],
-          },
-        ],
-      })
-    })
-  })
-
-  describe("and()", () => {
-    test("creates and predicate with two simple predicates", () => {
-      const predicates = [eq("status", "active"), eq("verified", 1)]
-      const result = and(predicates)
-
-      expect(result).toEqual({
-        type: "and",
-        predicates: [
-          { type: "eq", key: "status", value: "active" },
-          { type: "eq", key: "verified", value: 1 },
-        ],
-      })
-    })
-
-    test("creates and predicate with mixed predicate types", () => {
-      const predicates = [eq("active", 1), gte("age", 18), lt("age", 65), neq("role", "guest")]
-      const result = and(predicates)
-
-      expect(result).toEqual({
-        type: "and",
-        predicates: [
-          { type: "eq", key: "active", value: 1 },
-          { type: "gte", key: "age", value: 18 },
-          { type: "lt", key: "age", value: 65 },
-          { type: "neq", key: "role", value: "guest" },
-        ],
-      })
-    })
-
-    test("creates and predicate with single predicate", () => {
-      const predicates = [eq("enabled", 1)]
-      const result = and(predicates)
-
-      expect(result).toEqual({
-        type: "and",
-        predicates: [{ type: "eq", key: "enabled", value: 1 }],
-      })
-    })
-
-    test("creates and predicate with empty array", () => {
-      const predicates: Predicate[] = []
-      const result = and(predicates)
-
-      expect(result).toEqual({
-        type: "and",
-        predicates: [],
-      })
-    })
-
-    test("creates and predicate from varargs", () => {
-      const result = and(eq("status", "active"), gte("age", 18), not("deleted"))
-
-      expect(result).toEqual({
-        type: "and",
-        predicates: [
-          { type: "eq", key: "status", value: "active" },
-          { type: "gte", key: "age", value: 18 },
-          { type: "not", key: "deleted", value: "" },
-        ],
-      })
-    })
-
-    test("creates and predicate with no arguments", () => {
-      const result = and()
-
-      expect(result).toEqual({
-        type: "and",
-        predicates: [],
-      })
-    })
-
-    test("creates and predicate with nested or", () => {
-      const nestedOr = or([eq("type", "admin"), eq("type", "moderator")])
-      const predicates = [eq("active", 1), nestedOr]
-      const result = and(predicates)
-
-      expect(result).toEqual({
-        type: "and",
-        predicates: [
-          { type: "eq", key: "active", value: 1 },
-          {
-            type: "or",
-            predicates: [
-              { type: "eq", key: "type", value: "admin" },
-              { type: "eq", key: "type", value: "moderator" },
-            ],
-          },
-        ],
-      })
-    })
-  })
-
-  describe("Complex Nested Predicates", () => {
-    test("creates deeply nested predicate structure", () => {
-      const innerOr = or([eq("role", "admin"), eq("role", "moderator")])
-      const innerAnd = and([eq("verified", 1), gte("reputation", 1000)])
-      const outerOr = or([innerAnd, innerOr])
-      const result = and([eq("active", 1), outerOr, neq("banned", 1)])
-
-      expect(result).toEqual({
-        type: "and",
-        predicates: [
-          { type: "eq", key: "active", value: 1 },
-          {
-            type: "or",
-            predicates: [
-              {
-                type: "and",
-                predicates: [
-                  { type: "eq", key: "verified", value: 1 },
-                  { type: "gte", key: "reputation", value: 1000 },
-                ],
-              },
-              {
-                type: "or",
-                predicates: [
-                  { type: "eq", key: "role", value: "admin" },
-                  { type: "eq", key: "role", value: "moderator" },
-                ],
-              },
-            ],
-          },
-          { type: "neq", key: "banned", value: 1 },
-        ],
-      })
-    })
-
-    test("creates predicate with multiple comparison types", () => {
-      const result = and([
-        gte("age", 18),
-        lt("age", 65),
-        lte("score", 100),
-        neq("status", "suspended"),
-        not("deleted"),
-      ])
-
-      expect(result).toEqual({
-        type: "and",
-        predicates: [
-          { type: "gte", key: "age", value: 18 },
-          { type: "lt", key: "age", value: 65 },
-          { type: "lte", key: "score", value: 100 },
-          { type: "neq", key: "status", value: "suspended" },
-          { type: "not", key: "deleted", value: "" },
-        ],
-      })
-    })
-  })
-
-  describe("Type Safety", () => {
-    test("predicates maintain correct type information", () => {
-      const stringPred = eq("name", "test")
-      const numPred = eq("count", 42)
-      const orPred = or([stringPred, numPred])
-      const andPred = and([stringPred, numPred])
-
-      // Type assertions to ensure TypeScript types are correct
-      expect(stringPred.type).toBe("eq")
-      expect(numPred.type).toBe("eq")
-      expect(orPred.type).toBe("or")
-      expect(andPred.type).toBe("and")
-
-      // Verify container predicates have predicates array
-      if (orPred.type === "or" || orPred.type === "and") {
-        expect(Array.isArray(orPred.predicates)).toBe(true)
-      }
-
-      if (andPred.type === "or" || andPred.type === "and") {
-        expect(Array.isArray(andPred.predicates)).toBe(true)
-      }
-    })
-  })
-})

package/src/query/predicate.ts

@@ -1,144 +0,0 @@
-export type PredicateType = "eq" | "neq" | "gt" | "gte" | "lt" | "lte" | "not"
-export type PredicateContainerType = "or" | "and"
-
-export type Predicate =
-  | {
-      type: PredicateType
-      key: string
-      value: string | number
-    }
-  | {
-      type: PredicateContainerType
-      predicates: Predicate[]
-    }
-
-/**
- * Creates an OR predicate
- * @param predicates - The predicates to combine, either as a single array or as separate arguments
- * @returns The OR predicate
- *
- * @example
- * const result = or(eq("name", "John"), eq("age", 30))
- * // or equivalently: or([eq("name", "John"), eq("age", 30)])
- * // result = { type: "or", predicates: [eq("name", "John"), eq("age", 30)] }
- *
- */
-export function or(predicates: Predicate[]): Predicate
-export function or(...predicates: Predicate[]): Predicate
-export function or(...predicates: (Predicate | Predicate[])[]): Predicate {
-  return { type: "or", predicates: predicates.flat() }
-}
-
-/**
- * Creates an AND predicate
- * @param predicates - The predicates to combine, either as a single array or as separate arguments
- * @returns The AND predicate
- *
- * @example
- * const result = and(eq("name", "John"), eq("age", 30))
- * // or equivalently: and([eq("name", "John"), eq("age", 30)])
- * // result = { type: "and", predicates: [eq("name", "John"), eq("age", 30)] }
- *
- */
-export function and(predicates: Predicate[]): Predicate
-export function and(...predicates: Predicate[]): Predicate
-export function and(...predicates: (Predicate | Predicate[])[]): Predicate {
-  return { type: "and", predicates: predicates.flat() }
-}
-
-/**
- * Creates an equality predicate
- * @param key - The key to compare
- * @param value - The value to compare
- * @returns The equality predicate
- *
- * @example
- * const predicate = eq("name", "John")
- * // result = { type: "eq", key: "name", value: "John" }
- */
-export function eq(key: string, value: string | number): Predicate {
-  return { type: "eq", key, value }
-}
-
-/**
- * Creates a not equal predicate
- * @param key - The key to compare
- * @param value - The value to compare
- * @returns The not equal predicate
- *
- * @example
- * const predicate = neq("name", "John")
- * // result = { type: "neq", key: "name", value: "John" }
- */
-export function neq(key: string, value: string | number): Predicate {
-  return { type: "neq", key, value }
-}
-
-/**
- * Creates a greater than predicate
- * @param key - The key to compare
- * @param value - The value to compare
- * @returns The greater than predicate
- *
- * @example
- * const predicate = gt("name", "John")
- * // result = { type: "gt", key: "name", value: "John" }
- */
-export function gt(key: string, value: string | number): Predicate {
-  return { type: "gt", key, value }
-}
-
-/**
- * Creates a greater than or equal predicate
- * @param key - The key to compare
- * @param value - The value to compare
- * @returns The greater than or equal predicate
- *
- * @example
- * const predicate = gte("name", "John")
- * // result = { type: "gte", key: "name", value: "John" }
- */
-export function gte(key: string, value: string | number): Predicate {
-  return { type: "gte", key, value }
-}
-
-/**
- * Creates a less than predicate
- * @param key - The key to compare
- * @param value - The value to compare
- * @returns The less than predicate
- *
- * @example
- * const predicate = lt("name", "John")
- * // result = { type: "lt", key: "name", value: "John" }
- */
-export function lt(key: string, value: string | number): Predicate {
-  return { type: "lt", key, value }
-}
-
-/**
- * Creates a less than or equal predicate
- * @param key - The key to compare
- * @param value - The value to compare
- * @returns The less than or equal predicate
- *
- * @example
- * const predicate = lte("name", "John")
- * // result = { type: "lte", key: "name", value: "John" }
- */
-export function lte(key: string, value: string | number): Predicate {
-  return { type: "lte", key, value }
-}
-
-/**
- * Creates a not predicate
- * @param key - The key to compare
- * @returns The not predicate
- *
- * @example
- * const predicate = not("name")
- * // result = { type: "not", key: "name", value: "" }
- */
-export function not(key: string): Predicate {
-  return { type: "not", key, value: "" }
-}