feat: types

Author: ponderingdemocritus

examples/clients/react/react-sdk/src/App.tsx

@@ -23,7 +23,7 @@ function App() {
                 {
                     dojo_starter: {
                         Position: [],
-                        // Moves: ["player"],
+                        Moves: ["player"],
                     },
                 },
                 (response) => {

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

@@ -50,7 +50,7 @@ describe("convertQueryToEntityKeyClauses", () => {
     it("should convert query with namespace and model set to true to VariableLen Keys clause", () => {
         const query: SubscriptionQueryType<MockSchemaType> = {
             world: {
-                player: true,
+                player: [],
             },
         };
         const result = convertQueryToEntityKeyClauses(query);
@@ -88,7 +88,7 @@ describe("convertQueryToEntityKeyClauses", () => {
     it("should handle multiple namespaces and models", () => {
         const query: SubscriptionQueryType<MockSchemaType> = {
             world: {
-                player: true,
+                player: [],
                 item: ["id", "type"],
             },
             entityIds: ["hash1"],
@@ -118,7 +118,7 @@ describe("convertQueryToEntityKeyClauses", () => {
         const query: SubscriptionQueryType<MockSchemaType> = {
             entityIds: [],
             world: {
-                player: true,
+                player: [],
             },
         } as unknown as SubscriptionQueryType<MockSchemaType>;
         const result = convertQueryToEntityKeyClauses(query);
@@ -137,7 +137,7 @@ describe("convertQueryToEntityKeyClauses", () => {
     it("should handle multiple models within a single namespace", () => {
         const query: SubscriptionQueryType<MockSchemaType> = {
             world: {
-                player: true,
+                player: [],
                 item: ["id", "type"],
             },
         };

packages/sdk/src/convertQueryToEntityKeyClauses.ts

@@ -25,7 +25,7 @@ export function convertQueryToEntityKeyClauses<T extends SchemaType>(
     Object.entries(namespaces).forEach(([namespace, models]) => {
         if (models && typeof models === "object") {
             Object.entries(models).forEach(([model, value]) => {
-                if (typeof value === "boolean" || Array.isArray(value)) {
+                if (Array.isArray(value)) {
                     const namespaceModel = `${namespace}-${model}`;
                     const clause = createClause(namespaceModel, value);
                     if (clause) {
@@ -47,9 +47,9 @@ export function convertQueryToEntityKeyClauses<T extends SchemaType>(
  */
 function createClause(
     namespaceModel: string,
-    value: boolean | string[]
+    value: string[]
 ): torii.EntityKeysClause | undefined {
-    if (value === true) {
+    if (Array.isArray(value) && value.length === 0) {
         return {
             Keys: {
                 keys: [undefined],

packages/sdk/src/getEntities.ts

@@ -39,8 +39,6 @@ export async function getEntities<T extends SchemaType>(
 ): Promise<StandardizedQueryResult<T>> {
     const clause = convertQueryToClause(query);
 
-    console.log("clause", clause, query);
-
     let cursor = offset;
     let continueFetching = true;
     let allEntities: torii.Entities = {};
@@ -55,8 +53,8 @@ export async function getEntities<T extends SchemaType>(
         try {
             const entities = await client.getEntities(toriiQuery);
 
-            console.log("entities", entities);
             if (options?.logging) {
+                console.log("Clause", clause, "Query", query);
                 console.log(`Fetched entities at offset ${cursor}:`, entities);
             }
 

packages/sdk/src/getEventMessages.ts

@@ -1,8 +1,8 @@
-import { StandardizedQueryResult, QueryType } from "./types";
+import * as torii from "@dojoengine/torii-client";
+
+import { StandardizedQueryResult, QueryType, SchemaType } from "./types";
 import { convertQueryToClause } from "./convertQuerytoClause";
 import { parseEntities } from "./parseEntities";
-import { SchemaType } from "./types";
-import * as torii from "@dojoengine/torii-client";
 
 /**
  * Fetches event messages from the Torii client based on the provided query.
@@ -43,12 +43,9 @@ export async function getEventMessages<T extends SchemaType>(
             clause,
         };
 
-        console.log(toriiQuery);
-
         try {
             const entities = await client.getEventMessages(toriiQuery);
 
-            console.log("entities", entities);
             if (options?.logging) {
                 console.log(`Fetched entities at offset ${cursor}:`, entities);
             }
@@ -57,8 +54,6 @@ export async function getEventMessages<T extends SchemaType>(
 
             const parsedEntities = parseEntities<T>(allEntities);
 
-            console.log("parsedEntities", parsedEntities);
-
             callback({ data: parsedEntities });
 
             if (Object.keys(entities).length < limit) {

packages/sdk/src/index.ts

@@ -25,9 +25,10 @@ export async function init<T extends SchemaType>(
             subscribeEntityQuery(client, query, callback),
         subscribeEventQuery: (query, callback) =>
             subscribeEventQuery(client, query, callback),
-        getEntities: (query, callback) => getEntities(client, query, callback),
-        getEventMessages: (query, callback) =>
-            getEventMessages(client, query, callback),
+        getEntities: (query, callback, limit, offset, options) =>
+            getEntities(client, query, callback, limit, offset, options),
+        getEventMessages: (query, callback, limit, offset, options) =>
+            getEventMessages(client, query, callback, limit, offset, options),
     };
 }
 // // EXAMPLE FOR NOW

packages/sdk/src/subscribeEntityQuery.ts

@@ -35,10 +35,6 @@ export async function subscribeEntityQuery<T extends SchemaType>(
     }) => void,
     options?: { logging?: boolean }
 ): Promise<torii.Subscription> {
-    console.log(
-        "convertQueryToEntityKeyClauses",
-        convertQueryToEntityKeyClauses(query)
-    );
     return client.onEntityUpdated(
         convertQueryToEntityKeyClauses(query),
         (entityId: string, entityData: any) => {
@@ -48,6 +44,10 @@ export async function subscribeEntityQuery<T extends SchemaType>(
                         [entityId]: entityData,
                     });
                     if (options?.logging) {
+                        console.log(
+                            "Converted query to entity key clauses:",
+                            convertQueryToEntityKeyClauses(query)
+                        );
                         console.log("Parsed entity data:", parsedData);
                     }
                     callback({ data: parsedData });

packages/sdk/src/types.ts

@@ -68,7 +68,7 @@ export type SubscriptionQueryType<T extends SchemaType> = {
     entityIds?: string[];
 } & {
     [Entity in keyof T]?: {
-        [Model in keyof T[Entity]]?: true | (keyof T[Entity][Model])[];
+        [Model in keyof T[Entity]]?: (keyof T[Entity][Model])[];
     };
 };
 
@@ -192,9 +192,11 @@ export interface SDK<T extends SchemaType> {
         callback: (response: {
             data?: StandardizedQueryResult<T>;
             error?: Error;
-        }) => void
+        }) => void,
+        limit?: number,
+        offset?: number,
+        options?: { logging?: boolean } // Logging option
     ) => Promise<StandardizedQueryResult<T>>;
-
     /**
      * Fetches event messages from the Torii client based on the provided query.
      *
@@ -212,6 +214,9 @@ export interface SDK<T extends SchemaType> {
         callback: (response: {
             data?: StandardizedQueryResult<T>;
             error?: Error;
-        }) => void
+        }) => void,
+        limit?: number,
+        offset?: number,
+        options?: { logging?: boolean } // Logging option
     ) => Promise<StandardizedQueryResult<T>>;
 }