@arkiv-network/sdk 0.1.0 → 0.1.2-dev.0

package/src/clients/createWalletClient.test.ts

@@ -0,0 +1,23 @@
+import { expect, test, vi } from "bun:test"
+import { createTransport, type EIP1193RequestFn } from "viem"
+import { createWalletClient } from "./createWalletClient"
+
+const mockTransport = () =>
+  createTransport({
+    key: "mock",
+    name: "Mock Transport",
+    request: vi.fn(() => null) as unknown as EIP1193RequestFn,
+    type: "mock",
+  })
+
+test("creates", () => {
+  const { uid, ...client } = createWalletClient({
+    transport: mockTransport,
+  })
+
+  expect(uid).toBeDefined()
+  expect(client.getEntity).toBeDefined()
+  expect(typeof client.getEntity).toBe("function")
+  expect(client.createEntity).toBeDefined()
+  expect(typeof client.createEntity).toBe("function")
+})

package/src/query/engine.test.ts

@@ -0,0 +1,288 @@
+import { describe, expect, it, jest } from "bun:test"
+import type { ArkivClient } from "../clients/baseClient"
+import { processQuery } from "./engine"
+import type { Predicate } from "./predicate"
+
+describe("processQuery tests", () => {
+  const client = {
+    request: jest.fn(),
+  } as unknown as ArkivClient
+
+  it("should process single predicate", async () => {
+    const predicates = [{ type: "eq" as const, key: "key", value: "value" }]
+    await processQuery(client, {
+      predicates,
+      limit: undefined,
+      cursor: undefined,
+      ownedBy: undefined,
+      validAtBlock: undefined,
+      withAttributes: undefined,
+      withMetadata: undefined,
+      withPayload: undefined,
+    })
+
+    expect(client.request).lastCalledWith({
+      method: "arkiv_query",
+      params: [
+        `key = "value"`,
+        {
+          includeData: {
+            key: true,
+            attributes: false,
+            contentType: false,
+            payload: false,
+            expiration: false,
+            owner: false,
+          },
+        },
+      ],
+    })
+  })
+
+  it("should process all simple predicates - flat", async () => {
+    const predicates = [
+      { type: "eq" as const, key: "key", value: "value" },
+      { type: "gt" as const, key: "key2", value: 1 },
+      { type: "gte" as const, key: "key3", value: 2 },
+      { type: "lt" as const, key: "key4", value: 3 },
+      { type: "lte" as const, key: "key5", value: 4 },
+      { type: "neq" as const, key: "key6", value: "value6" },
+    ]
+    await processQuery(client, {
+      predicates,
+      limit: undefined,
+      cursor: undefined,
+      ownedBy: undefined,
+      validAtBlock: undefined,
+      withAttributes: undefined,
+      withMetadata: undefined,
+    })
+
+    expect(client.request).lastCalledWith({
+      method: "arkiv_query",
+      params: [
+        `key = "value" && key2 > 1 && key3 >= 2 && key4 < 3 && key5 <= 4 && key6 != "value6"`,
+        {
+          includeData: {
+            key: true,
+            attributes: false,
+            contentType: false,
+            payload: false,
+            expiration: false,
+            owner: false,
+          },
+        },
+      ],
+    })
+  })
+
+  it("should process multiple predicates - nested with or", async () => {
+    const predicates = [
+      { type: "eq" as const, key: "key", value: "value" },
+      {
+        type: "or" as const,
+        predicates: [
+          { type: "eq" as const, key: "key2", value: "value2" },
+          { type: "eq" as const, key: "key3", value: "value3" },
+        ],
+      },
+    ]
+    await processQuery(client, {
+      predicates,
+      limit: undefined,
+      cursor: undefined,
+      ownedBy: undefined,
+      validAtBlock: undefined,
+      withAttributes: undefined,
+      withMetadata: undefined,
+    })
+
+    expect(client.request).lastCalledWith({
+      method: "arkiv_query",
+      params: [
+        `key = "value" && (key2 = "value2" || key3 = "value3")`,
+        {
+          includeData: {
+            key: true,
+            attributes: false,
+            contentType: false,
+            payload: false,
+            expiration: false,
+            owner: false,
+          },
+        },
+      ],
+    })
+  })
+
+  it("should process multiple predicates - nested with and", async () => {
+    const predicates = [
+      { type: "eq" as const, key: "key", value: "value" },
+      {
+        type: "and" as const,
+        predicates: [
+          { type: "eq" as const, key: "key2", value: "value2" },
+          { type: "eq" as const, key: "key3", value: "value3" },
+        ],
+      },
+    ]
+    await processQuery(client, {
+      predicates,
+      limit: undefined,
+      cursor: undefined,
+      ownedBy: undefined,
+      validAtBlock: undefined,
+      withAttributes: undefined,
+      withMetadata: undefined,
+    })
+
+    expect(client.request).lastCalledWith({
+      method: "arkiv_query",
+      params: [
+        `key = "value" && (key2 = "value2" && key3 = "value3")`,
+        {
+          includeData: {
+            key: true,
+            attributes: false,
+            contentType: false,
+            payload: false,
+            expiration: false,
+            owner: false,
+          },
+        },
+      ],
+    })
+  })
+
+  it("should process multiple predicates - nested with and and or", async () => {
+    const predicates = [
+      { type: "eq" as const, key: "key", value: "value" },
+      {
+        type: "and" as const,
+        predicates: [
+          { type: "eq" as const, key: "key2", value: "value2" },
+          {
+            type: "or" as const,
+            predicates: [
+              { type: "eq" as const, key: "key3", value: "value3" },
+              { type: "eq" as const, key: "key4", value: "value4" },
+            ],
+          },
+        ],
+      },
+    ]
+    await processQuery(client, {
+      predicates,
+      limit: undefined,
+      cursor: undefined,
+      ownedBy: undefined,
+      validAtBlock: undefined,
+      withAttributes: undefined,
+      withMetadata: undefined,
+    })
+
+    expect(client.request).lastCalledWith({
+      method: "arkiv_query",
+      params: [
+        `key = "value" && (key2 = "value2" && (key3 = "value3" || key4 = "value4"))`,
+        {
+          includeData: {
+            key: true,
+            attributes: false,
+            contentType: false,
+            payload: false,
+            expiration: false,
+            owner: false,
+          },
+        },
+      ],
+    })
+  })
+
+  it("should process simple predicates with ownedBy", async () => {
+    const predicates = [{ type: "eq" as const, key: "key", value: "value" }]
+    await processQuery(client, {
+      predicates,
+      limit: undefined,
+      cursor: undefined,
+      ownedBy: "0x123",
+    })
+
+    expect(client.request).lastCalledWith({
+      method: "arkiv_query",
+      params: [
+        `key = "value" && $owner=0x123`,
+        {
+          includeData: {
+            key: true,
+            attributes: false,
+            contentType: false,
+            payload: false,
+            expiration: false,
+            owner: false,
+          },
+        },
+      ],
+    })
+  })
+
+  it("should process only ownedBy", async () => {
+    const predicates = [] as Predicate[]
+    await processQuery(client, {
+      predicates,
+      limit: undefined,
+      cursor: undefined,
+      validAtBlock: undefined,
+      withAttributes: undefined,
+      withMetadata: undefined,
+      ownedBy: "0x123",
+    })
+
+    expect(client.request).lastCalledWith({
+      method: "arkiv_query",
+      params: [
+        `$owner=0x123`,
+        {
+          includeData: {
+            key: true,
+            attributes: false,
+            contentType: false,
+            payload: false,
+            expiration: false,
+            owner: false,
+          },
+        },
+      ],
+    })
+  })
+
+  it("should process simple predicate with validAtBlock and paging", async () => {
+    const predicates = [{ type: "eq" as const, key: "key", value: "value" }]
+    await processQuery(client, {
+      predicates,
+      limit: 10,
+      cursor: undefined,
+      validAtBlock: 123n,
+      ownedBy: "0x123",
+    })
+
+    expect(client.request).lastCalledWith({
+      method: "arkiv_query",
+      params: [
+        `key = "value" && $owner=0x123`,
+        {
+          atBlock: 123,
+          resultsPerPage: 10,
+          includeData: {
+            key: true,
+            attributes: false,
+            contentType: false,
+            payload: false,
+            expiration: false,
+            owner: false,
+          },
+        },
+      ],
+    })
+  })
+})