feat: add querybuilder

packages/sdk/CHANGELOG.md

@@ -7,20 +7,11 @@ See [Conventional Commits](https://conventionalcommits.org) for commit guideline
 
 **Note:** Version bump only for package @dojoengine/sdk
 
-
-
-
-
 # [1.0.0-alpha.30](https://github.com/dojoengine/sdk/compare/v1.0.0-alpha.29...v1.0.0-alpha.30) (2024-11-09)
 
-
 ### Features
 
-* docs ([1bf47fa](https://github.com/dojoengine/sdk/commit/1bf47fae3afef5ab7f02f9ed288141e735ab2788))
-
-
-
-
+-   docs ([1bf47fa](https://github.com/dojoengine/sdk/commit/1bf47fae3afef5ab7f02f9ed288141e735ab2788))
 
 # [1.0.0-alpha.29](https://github.com/dojoengine/sdk/compare/v1.0.0-alpha.28...v1.0.0-alpha.29) (2024-11-08)
 

packages/sdk/src/__example__/index.ts

@@ -1,7 +1,7 @@
 // EXAMPLE FOR NOW
 
 import * as torii from "@dojoengine/torii-client";
-import { init } from "..";
+import { init, QueryBuilder } from "..";
 import { SchemaType } from "../types";
 
 export interface PlayerModel {
@@ -111,73 +111,49 @@ async function exampleUsage() {
         invalidMessage // TypeScript Error
     );
 
-    db.subscribeEntityQuery(
-        {
-            world: {
-                player: {
-                    $: {
-                        where: {
-                            name: { $is: "Alice" },
-                            score: { $is: 10 },
-                        },
-                    },
-                },
-            },
-        },
-        (resp) => {
+    const query = new QueryBuilder<MockSchemaType>().namespace("world", (n) =>
+        n.entity("player", (e) => e.eq("name", "Alice"))
+    );
+
+    db.subscribeEntityQuery(query.build(), (resp) => {
+        if (resp.error) {
+            console.error(
+                "Error querying todos and goals:",
+                resp.error.message
+            );
+            return;
+        }
+        if (resp.data) {
+            console.log(
+                "Queried todos and goals:",
+                resp.data.map((a) => a.models.world)
+            );
+        }
+    });
+    // Example usage of getEntities with where clause
+    try {
+        const eq = new QueryBuilder<MockSchemaType>().namespace("world", (n) =>
+            n
+                .entity("item", (e) =>
+                    e.eq("type", "sword").lt("durability", 5)
+                )
+                .entity("game", (e) => e.eq("status", "completed"))
+        );
+        const entities = await db.getEntities(eq.build(), (resp) => {
             if (resp.error) {
                 console.error(
-                    "Error querying todos and goals:",
+                    "Error querying completed important todos:",
                     resp.error.message
                 );
                 return;
             }
             if (resp.data) {
                 console.log(
-                    "Queried todos and goals:",
-                    resp.data.map((a) => a.models.world)
+                    "Completed important todos:",
+                    resp.data.map((a) => a.models)
                 );
             }
-        }
-    );
-    // Example usage of getEntities with where clause
-    try {
-        const entities = await db.getEntities(
-            {
-                world: {
-                    item: {
-                        $: {
-                            where: {
-                                type: { $eq: "sword" },
-                                durability: { $lt: 5 },
-                            },
-                        },
-                    },
-                    game: {
-                        $: {
-                            where: {
-                                status: { $eq: "completed" },
-                            },
-                        },
-                    },
-                },
-            },
-            (resp) => {
-                if (resp.error) {
-                    console.error(
-                        "Error querying completed important todos:",
-                        resp.error.message
-                    );
-                    return;
-                }
-                if (resp.data) {
-                    console.log(
-                        "Completed important todos:",
-                        resp.data.map((a) => a.models)
-                    );
-                }
-            }
-        );
+        });
         console.log("Queried entities:", entities);
     } catch (error) {
         console.error("Error querying entities:", error);

packages/sdk/src/__tests__/queryBuilder.test.ts

@@ -0,0 +1,37 @@
+import { describe, expect, it } from "vitest";
+import { QueryBuilder } from "../queryBuilder";
+import { MockSchemaType } from "../__example__/index";
+
+describe("QueryBuilder", () => {
+    it("should be implemented", () => {
+        const query = new QueryBuilder().build();
+        expect(query).toStrictEqual({});
+    });
+
+    it("should work with example", () => {
+        const query = new QueryBuilder<MockSchemaType>()
+            .namespace("world", (n) =>
+                n.entity("player", (e) => e.eq("id", "1").eq("name", "Alice"))
+            )
+            .namespace("universe", (n) =>
+                n.entity("galaxy", (e) => e.is("name", "Milky Way"))
+            )
+            .build();
+        const expected = {
+            world: {
+                player: {
+                    $: { where: { id: { $eq: "1" }, name: { $eq: "Alice" } } },
+                },
+            },
+            universe: {
+                galaxy: {
+                    $: {
+                        where: { name: { $is: "Milky Way" } },
+                    },
+                },
+            },
+        };
+
+        expect(query).toStrictEqual(expected);
+    });
+});

packages/sdk/src/index.ts

@@ -9,6 +9,7 @@ import { SchemaType, SDK, SDKConfig, UnionOfModelData } from "./types";
 
 export * from "./types";
 export * from "./state";
+export * from "./queryBuilder";
 
 /**
  * Creates a new Torii client instance.

packages/sdk/src/queryBuilder.ts

@@ -0,0 +1,162 @@
+import { QueryType, SchemaType, SubscriptionQueryType } from "./types";
+
+type NestedKeyOf<ObjectType extends object> = {
+    [Key in keyof ObjectType &
+        (string | number)]: ObjectType[Key] extends object
+        ? `${Key}` | `${Key}.${NestedKeyOf<ObjectType[Key]>}`
+        : `${Key}`;
+}[keyof ObjectType & (string | number)];
+
+export class QueryBuilder<T extends SchemaType> {
+    namespaces: Map<string, Namespace<T>>;
+
+    constructor() {
+        this.namespaces = new Map<string, Namespace<T>>();
+    }
+
+    public namespace(
+        name: keyof T,
+        cb: (ns: Namespace<T>) => void
+    ): Namespace<T> {
+        const ns = new Namespace(this);
+        this.namespaces.set(name as string, ns);
+        cb(ns);
+        return ns;
+    }
+
+    public build(): SubscriptionQueryType<T> {
+        const qt: Record<
+            string,
+            Record<
+                string,
+                { $: { where: Record<string, Record<string, any>> } }
+            >
+        > = {};
+        for (const [ns, namespace] of this.namespaces) {
+            qt[ns] = {};
+            for (const [entity, entityObj] of namespace.entities) {
+                const constraints: Record<string, Record<string, any>> = {};
+                for (const [field, constraint] of entityObj.constraints) {
+                    constraints[field] = {
+                        [`${constraint.operator}`]: constraint.value,
+                    };
+                }
+                qt[ns][entity] = {
+                    $: {
+                        where: {
+                            ...(qt[ns]?.[entity]?.$?.where ?? {}),
+                            ...constraints,
+                        },
+                    },
+                };
+            }
+        }
+        return qt as SubscriptionQueryType<T>;
+    }
+}
+
+class Namespace<T extends SchemaType> {
+    entities: Map<string, QueryEntity<T>>;
+
+    constructor(private parent: QueryBuilder<T>) {
+        this.entities = new Map<string, QueryEntity<T>>();
+    }
+
+    public entity(
+        name: NestedKeyOf<T>,
+        cb: (entity: QueryEntity<T>) => void
+    ): QueryEntity<T> {
+        const entity = new QueryEntity(this);
+        this.entities.set(name, entity);
+        cb(entity);
+        return entity;
+    }
+
+    public namespace(ns: string, cb: (ns: Namespace<T>) => void): Namespace<T> {
+        return this.parent.namespace(ns, cb);
+    }
+
+    public build(): SubscriptionQueryType<T> {
+        return this.parent.build();
+    }
+}
+
+class QueryEntity<T extends SchemaType> {
+    constraints: Map<string, Constraint>;
+
+    constructor(private parent: Namespace<T>) {
+        this.constraints = new Map<string, Constraint>();
+    }
+    public entity(
+        name: NestedKeyOf<T>,
+        cb: (entity: QueryEntity<T>) => void
+    ): QueryEntity<T> {
+        return this.parent.entity(name, cb);
+    }
+
+    public is(field: string, value: any): QueryEntity<T> {
+        return this.addConstraint(field, value, Operator.is);
+    }
+
+    public eq(field: string, value: any): QueryEntity<T> {
+        return this.addConstraint(field, value, Operator.eq);
+    }
+
+    public neq(field: string, value: any): QueryEntity<T> {
+        return this.addConstraint(field, value, Operator.neq);
+    }
+
+    public gt(field: string, value: any): QueryEntity<T> {
+        return this.addConstraint(field, value, Operator.gt);
+    }
+
+    public gte(field: string, value: any): QueryEntity<T> {
+        return this.addConstraint(field, value, Operator.gte);
+    }
+
+    public lt(field: string, value: any): QueryEntity<T> {
+        return this.addConstraint(field, value, Operator.lt);
+    }
+
+    public lte(field: string, value: any): QueryEntity<T> {
+        return this.addConstraint(field, value, Operator.lte);
+    }
+
+    private addConstraint(
+        field: string,
+        value: any,
+        op: Operator
+    ): QueryEntity<T> {
+        this.constraints.set(field, new Constraint(op, value));
+        return this;
+    }
+
+    public build(): QueryType<T> {
+        return this.parent.build();
+    }
+}
+
+class Constraint {
+    constructor(
+        private _operator: Operator,
+        private _value: any
+    ) {}
+
+    get operator(): string {
+        return this._operator.toString();
+    }
+
+    get value(): any {
+        return this._value;
+    }
+}
+
+enum Operator {
+    is = "$is",
+    eq = "$eq",
+    neq = "$neq",
+    gt = "$gt",
+    gte = "$gte",
+    lt = "$lt",
+    lte = "$lte",
+}