@settlemint/sdk-thegraph 2.3.2-pref75df5f → 2.3.2-preff27199

package/README.md

@@ -111,7 +111,7 @@ const { client, graphql } = createTheGraphClient<{
   };
 }>({
   instances: JSON.parse(process.env.SETTLEMINT_THEGRAPH_SUBGRAPHS_ENDPOINTS || '[]'),
-  accessToken: process.env.SETTLEMINT_ACCESS_TOKEN!,
+  accessToken: process.env.SETTLEMINT_ACCESS_TOKEN,
   subgraphName: 'kits'
 }, {
   fetch: requestLogger(logger, "the-graph-kits", fetch) as typeof fetch,

package/dist/browser/thegraph.d.ts

@@ -0,0 +1,88 @@
+import { AbstractSetupSchema, FragmentOf, ResultOf, VariablesOf, initGraphQLTada, readFragment } from "gql.tada";
+import { GraphQLClient } from "graphql-request";
+import { z } from "zod/v4";
+
+//#region src/thegraph.d.ts
+/**
+* Type definition for GraphQL client configuration options
+*/
+/**
+ * Type definition for GraphQL client configuration options
+ */
+type RequestConfig = ConstructorParameters<typeof GraphQLClient>[1];
+/**
+ * Schema for validating client options for the TheGraph client.
+ */
+declare const ClientOptionsSchema: z.ZodObject<{
+  instances: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodString]>>;
+  accessToken: z.ZodString;
+  subgraphName: z.ZodString;
+  cache: z.ZodOptional<z.ZodEnum<{
+    default: "default";
+    "force-cache": "force-cache";
+    "no-cache": "no-cache";
+    "no-store": "no-store";
+    "only-if-cached": "only-if-cached";
+    reload: "reload";
+  }>>;
+}, z.core.$strip>;
+/**
+ * Type definition for client options derived from the ClientOptionsSchema
+ */
+type ClientOptions = z.infer<typeof ClientOptionsSchema>;
+/**
+ * Creates a TheGraph GraphQL client with proper type safety using gql.tada
+ *
+ * @param options - Configuration options for the client including instance URLs,
+ *                  access token and subgraph name
+ * @param clientOptions - Optional GraphQL client configuration options
+ * @returns An object containing:
+ *          - client: The configured GraphQL client instance
+ *          - graphql: The initialized gql.tada function for type-safe queries
+ * @throws Will throw an error if the options fail validation against ClientOptionsSchema
+ * @example
+ * import { createTheGraphClient } from '@settlemint/sdk-thegraph';
+ * import type { introspection } from '@schemas/the-graph-env-kits';
+ * import { createLogger, requestLogger } from '@settlemint/sdk-utils/logging';
+ *
+ * const logger = createLogger();
+ *
+ * const { client, graphql } = createTheGraphClient<{
+ *   introspection: introspection;
+ *   disableMasking: true;
+ *   scalars: {
+ *     Bytes: string;
+ *     Int8: string;
+ *     BigInt: string;
+ *     BigDecimal: string;
+ *     Timestamp: string;
+ *   };
+ * }>({
+ *   instances: JSON.parse(process.env.SETTLEMINT_THEGRAPH_SUBGRAPHS_ENDPOINTS || '[]'),
+ *   accessToken: process.env.SETTLEMINT_ACCESS_TOKEN,
+ *   subgraphName: 'kits'
+ * }, {
+ *   fetch: requestLogger(logger, "the-graph-kits", fetch) as typeof fetch,
+ * });
+ *
+ * // Making GraphQL queries
+ * const query = graphql(`
+ *   query SearchAssets {
+ *     assets {
+ *       id
+ *       name
+ *       symbol
+ *     }
+ *   }
+ * `);
+ *
+ * const result = await client.request(query);
+ */
+declare function createTheGraphClient<const Setup extends AbstractSetupSchema>(options: ClientOptions, clientOptions?: RequestConfig): {
+  client: GraphQLClient;
+  graphql: initGraphQLTada<Setup>;
+};
+
+//#endregion
+export { ClientOptions, ClientOptionsSchema, FragmentOf, RequestConfig, ResultOf, VariablesOf, createTheGraphClient, readFragment };
+//# sourceMappingURL=thegraph.d.ts.map

package/dist/browser/thegraph.js

@@ -0,0 +1,105 @@
+import { ensureServer } from "@settlemint/sdk-utils/runtime";
+import { ApplicationAccessTokenSchema, UrlOrPathSchema, validate } from "@settlemint/sdk-utils/validation";
+import { initGraphQLTada, readFragment } from "gql.tada";
+import { GraphQLClient } from "graphql-request";
+import { z } from "zod/v4";
+
+//#region src/thegraph.ts
+/**
+* Schema for validating client options for the TheGraph client.
+*/
+const ClientOptionsSchema = z.object({
+	instances: z.array(UrlOrPathSchema),
+	accessToken: ApplicationAccessTokenSchema,
+	subgraphName: z.string(),
+	cache: z.enum([
+		"default",
+		"force-cache",
+		"no-cache",
+		"no-store",
+		"only-if-cached",
+		"reload"
+	]).optional()
+});
+/**
+* Constructs the full URL for TheGraph GraphQL API based on the provided options
+*
+* @param options - The client options for configuring TheGraph client
+* @returns The complete GraphQL API URL as a string
+* @throws Will throw an error if no matching instance is found for the specified subgraph
+*/
+function getFullUrl(options) {
+	const instance = options.instances.find((instance$1) => instance$1.endsWith(`/${options.subgraphName}`));
+	if (!instance) {
+		throw new Error(`Instance for subgraph ${options.subgraphName} not found`);
+	}
+	return new URL(instance).toString();
+}
+/**
+* Creates a TheGraph GraphQL client with proper type safety using gql.tada
+*
+* @param options - Configuration options for the client including instance URLs,
+*                  access token and subgraph name
+* @param clientOptions - Optional GraphQL client configuration options
+* @returns An object containing:
+*          - client: The configured GraphQL client instance
+*          - graphql: The initialized gql.tada function for type-safe queries
+* @throws Will throw an error if the options fail validation against ClientOptionsSchema
+* @example
+* import { createTheGraphClient } from '@settlemint/sdk-thegraph';
+* import type { introspection } from '@schemas/the-graph-env-kits';
+* import { createLogger, requestLogger } from '@settlemint/sdk-utils/logging';
+*
+* const logger = createLogger();
+*
+* const { client, graphql } = createTheGraphClient<{
+*   introspection: introspection;
+*   disableMasking: true;
+*   scalars: {
+*     Bytes: string;
+*     Int8: string;
+*     BigInt: string;
+*     BigDecimal: string;
+*     Timestamp: string;
+*   };
+* }>({
+*   instances: JSON.parse(process.env.SETTLEMINT_THEGRAPH_SUBGRAPHS_ENDPOINTS || '[]'),
+*   accessToken: process.env.SETTLEMINT_ACCESS_TOKEN,
+*   subgraphName: 'kits'
+* }, {
+*   fetch: requestLogger(logger, "the-graph-kits", fetch) as typeof fetch,
+* });
+*
+* // Making GraphQL queries
+* const query = graphql(`
+*   query SearchAssets {
+*     assets {
+*       id
+*       name
+*       symbol
+*     }
+*   }
+* `);
+*
+* const result = await client.request(query);
+*/
+function createTheGraphClient(options, clientOptions) {
+	ensureServer();
+	const validatedOptions = validate(ClientOptionsSchema, options);
+	const graphql = initGraphQLTada();
+	const fullUrl = getFullUrl(validatedOptions);
+	return {
+		client: new GraphQLClient(fullUrl, {
+			...clientOptions,
+			headers: {
+				...clientOptions?.headers ?? {},
+				"x-auth-token": validatedOptions.accessToken
+			}
+		}),
+		graphql
+	};
+}
+
+//#endregion
+export { ClientOptionsSchema, createTheGraphClient, readFragment };
+//# sourceMappingURL=thegraph.js.map

package/dist/browser/thegraph.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"thegraph.js","names":["options: ClientOptions","instance","clientOptions?: RequestConfig"],"sources":["../../src/thegraph.ts"],"sourcesContent":["import { ensureServer } from \"@settlemint/sdk-utils/runtime\";\nimport { ApplicationAccessTokenSchema, UrlOrPathSchema, validate } from \"@settlemint/sdk-utils/validation\";\nimport { type AbstractSetupSchema, initGraphQLTada } from \"gql.tada\";\nimport { GraphQLClient } from \"graphql-request\";\nimport { z } from \"zod/v4\";\n\n/**\n * Type definition for GraphQL client configuration options\n */\nexport type RequestConfig = ConstructorParameters<typeof GraphQLClient>[1];\n\n/**\n * Schema for validating client options for the TheGraph client.\n */\nexport const ClientOptionsSchema = z.object({\n  instances: z.array(UrlOrPathSchema),\n  accessToken: ApplicationAccessTokenSchema,\n  subgraphName: z.string(),\n  cache: z.enum([\"default\", \"force-cache\", \"no-cache\", \"no-store\", \"only-if-cached\", \"reload\"]).optional(),\n});\n\n/**\n * Type definition for client options derived from the ClientOptionsSchema\n */\nexport type ClientOptions = z.infer<typeof ClientOptionsSchema>;\n\n/**\n * Constructs the full URL for TheGraph GraphQL API based on the provided options\n *\n * @param options - The client options for configuring TheGraph client\n * @returns The complete GraphQL API URL as a string\n * @throws Will throw an error if no matching instance is found for the specified subgraph\n */\nfunction getFullUrl(options: ClientOptions): string {\n  const instance = options.instances.find((instance) => instance.endsWith(`/${options.subgraphName}`));\n  if (!instance) {\n    throw new Error(`Instance for subgraph ${options.subgraphName} not found`);\n  }\n  return new URL(instance).toString();\n}\n\n/**\n * Creates a TheGraph GraphQL client with proper type safety using gql.tada\n *\n * @param options - Configuration options for the client including instance URLs,\n *                  access token and subgraph name\n * @param clientOptions - Optional GraphQL client configuration options\n * @returns An object containing:\n *          - client: The configured GraphQL client instance\n *          - graphql: The initialized gql.tada function for type-safe queries\n * @throws Will throw an error if the options fail validation against ClientOptionsSchema\n * @example\n * import { createTheGraphClient } from '@settlemint/sdk-thegraph';\n * import type { introspection } from '@schemas/the-graph-env-kits';\n * import { createLogger, requestLogger } from '@settlemint/sdk-utils/logging';\n *\n * const logger = createLogger();\n *\n * const { client, graphql } = createTheGraphClient<{\n *   introspection: introspection;\n *   disableMasking: true;\n *   scalars: {\n *     Bytes: string;\n *     Int8: string;\n *     BigInt: string;\n *     BigDecimal: string;\n *     Timestamp: string;\n *   };\n * }>({\n *   instances: JSON.parse(process.env.SETTLEMINT_THEGRAPH_SUBGRAPHS_ENDPOINTS || '[]'),\n *   accessToken: process.env.SETTLEMINT_ACCESS_TOKEN,\n *   subgraphName: 'kits'\n * }, {\n *   fetch: requestLogger(logger, \"the-graph-kits\", fetch) as typeof fetch,\n * });\n *\n * // Making GraphQL queries\n * const query = graphql(`\n *   query SearchAssets {\n *     assets {\n *       id\n *       name\n *       symbol\n *     }\n *   }\n * `);\n *\n * const result = await client.request(query);\n */\nexport function createTheGraphClient<const Setup extends AbstractSetupSchema>(\n  options: ClientOptions,\n  clientOptions?: RequestConfig,\n): {\n  client: GraphQLClient;\n  graphql: initGraphQLTada<Setup>;\n} {\n  ensureServer();\n  const validatedOptions = validate(ClientOptionsSchema, options);\n  const graphql = initGraphQLTada<Setup>();\n  const fullUrl = getFullUrl(validatedOptions);\n\n  return {\n    client: new GraphQLClient(fullUrl, {\n      ...clientOptions,\n      headers: {\n        ...(clientOptions?.headers ?? {}),\n        \"x-auth-token\": validatedOptions.accessToken,\n      },\n    }),\n    graphql,\n  };\n}\n\nexport { readFragment } from \"gql.tada\";\nexport type { FragmentOf, ResultOf, VariablesOf } from \"gql.tada\";\n"],"mappings":";;;;;;;;;;AAcA,MAAa,sBAAsB,EAAE,OAAO;CAC1C,WAAW,EAAE,MAAM,gBAAgB;CACnC,aAAa;CACb,cAAc,EAAE,QAAQ;CACxB,OAAO,EAAE,KAAK;EAAC;EAAW;EAAe;EAAY;EAAY;EAAkB;CAAS,EAAC,CAAC,UAAU;AACzG,EAAC;;;;;;;;AAcF,SAAS,WAAWA,SAAgC;CAClD,MAAM,WAAW,QAAQ,UAAU,KAAK,CAACC,eAAa,WAAS,UAAU,GAAG,QAAQ,aAAa,EAAE,CAAC;AACpG,MAAK,UAAU;AACb,QAAM,IAAI,OAAO,wBAAwB,QAAQ,aAAa;CAC/D;AACD,QAAO,IAAI,IAAI,UAAU,UAAU;AACpC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkDD,SAAgB,qBACdD,SACAE,eAIA;AACA,eAAc;CACd,MAAM,mBAAmB,SAAS,qBAAqB,QAAQ;CAC/D,MAAM,UAAU,iBAAwB;CACxC,MAAM,UAAU,WAAW,iBAAiB;AAE5C,QAAO;EACL,QAAQ,IAAI,cAAc,SAAS;GACjC,GAAG;GACH,SAAS;IACP,GAAI,eAAe,WAAW,CAAE;IAChC,gBAAgB,iBAAiB;GAClC;EACF;EACD;CACD;AACF"}

package/dist/thegraph.cjs

@@ -1,69 +1,135 @@
-"use strict";
+//#region rolldown:runtime
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
 var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
 };
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
 
-// src/thegraph.ts
-var thegraph_exports = {};
-__export(thegraph_exports, {
-  ClientOptionsSchema: () => ClientOptionsSchema,
-  createTheGraphClient: () => createTheGraphClient,
-  readFragment: () => import_gql2.readFragment
-});
-module.exports = __toCommonJS(thegraph_exports);
-var import_runtime = require("@settlemint/sdk-utils/runtime");
-var import_validation = require("@settlemint/sdk-utils/validation");
-var import_gql = require("gql.tada");
-var import_graphql_request = require("graphql-request");
-var import_v4 = require("zod/v4");
-var import_gql2 = require("gql.tada");
-var ClientOptionsSchema = import_v4.z.object({
-  instances: import_v4.z.array(import_validation.UrlOrPathSchema),
-  accessToken: import_validation.ApplicationAccessTokenSchema,
-  subgraphName: import_v4.z.string(),
-  cache: import_v4.z.enum(["default", "force-cache", "no-cache", "no-store", "only-if-cached", "reload"]).optional()
+//#endregion
+const __settlemint_sdk_utils_runtime = __toESM(require("@settlemint/sdk-utils/runtime"));
+const __settlemint_sdk_utils_validation = __toESM(require("@settlemint/sdk-utils/validation"));
+const gql_tada = __toESM(require("gql.tada"));
+const graphql_request = __toESM(require("graphql-request"));
+const zod_v4 = __toESM(require("zod/v4"));
+
+//#region src/thegraph.ts
+/**
+* Schema for validating client options for the TheGraph client.
+*/
+const ClientOptionsSchema = zod_v4.z.object({
+	instances: zod_v4.z.array(__settlemint_sdk_utils_validation.UrlOrPathSchema),
+	accessToken: __settlemint_sdk_utils_validation.ApplicationAccessTokenSchema,
+	subgraphName: zod_v4.z.string(),
+	cache: zod_v4.z.enum([
+		"default",
+		"force-cache",
+		"no-cache",
+		"no-store",
+		"only-if-cached",
+		"reload"
+	]).optional()
 });
+/**
+* Constructs the full URL for TheGraph GraphQL API based on the provided options
+*
+* @param options - The client options for configuring TheGraph client
+* @returns The complete GraphQL API URL as a string
+* @throws Will throw an error if no matching instance is found for the specified subgraph
+*/
 function getFullUrl(options) {
-  const instance = options.instances.find((instance2) => instance2.endsWith(`/${options.subgraphName}`));
-  if (!instance) {
-    throw new Error(`Instance for subgraph ${options.subgraphName} not found`);
-  }
-  return new URL(instance).toString();
+	const instance = options.instances.find((instance$1) => instance$1.endsWith(`/${options.subgraphName}`));
+	if (!instance) {
+		throw new Error(`Instance for subgraph ${options.subgraphName} not found`);
+	}
+	return new URL(instance).toString();
 }
+/**
+* Creates a TheGraph GraphQL client with proper type safety using gql.tada
+*
+* @param options - Configuration options for the client including instance URLs,
+*                  access token and subgraph name
+* @param clientOptions - Optional GraphQL client configuration options
+* @returns An object containing:
+*          - client: The configured GraphQL client instance
+*          - graphql: The initialized gql.tada function for type-safe queries
+* @throws Will throw an error if the options fail validation against ClientOptionsSchema
+* @example
+* import { createTheGraphClient } from '@settlemint/sdk-thegraph';
+* import type { introspection } from '@schemas/the-graph-env-kits';
+* import { createLogger, requestLogger } from '@settlemint/sdk-utils/logging';
+*
+* const logger = createLogger();
+*
+* const { client, graphql } = createTheGraphClient<{
+*   introspection: introspection;
+*   disableMasking: true;
+*   scalars: {
+*     Bytes: string;
+*     Int8: string;
+*     BigInt: string;
+*     BigDecimal: string;
+*     Timestamp: string;
+*   };
+* }>({
+*   instances: JSON.parse(process.env.SETTLEMINT_THEGRAPH_SUBGRAPHS_ENDPOINTS || '[]'),
+*   accessToken: process.env.SETTLEMINT_ACCESS_TOKEN,
+*   subgraphName: 'kits'
+* }, {
+*   fetch: requestLogger(logger, "the-graph-kits", fetch) as typeof fetch,
+* });
+*
+* // Making GraphQL queries
+* const query = graphql(`
+*   query SearchAssets {
+*     assets {
+*       id
+*       name
+*       symbol
+*     }
+*   }
+* `);
+*
+* const result = await client.request(query);
+*/
 function createTheGraphClient(options, clientOptions) {
-  (0, import_runtime.ensureServer)();
-  const validatedOptions = (0, import_validation.validate)(ClientOptionsSchema, options);
-  const graphql = (0, import_gql.initGraphQLTada)();
-  const fullUrl = getFullUrl(validatedOptions);
-  return {
-    client: new import_graphql_request.GraphQLClient(fullUrl, {
-      ...clientOptions,
-      headers: {
-        ...clientOptions?.headers ?? {},
-        "x-auth-token": validatedOptions.accessToken
-      }
-    }),
-    graphql
-  };
+	(0, __settlemint_sdk_utils_runtime.ensureServer)();
+	const validatedOptions = (0, __settlemint_sdk_utils_validation.validate)(ClientOptionsSchema, options);
+	const graphql = (0, gql_tada.initGraphQLTada)();
+	const fullUrl = getFullUrl(validatedOptions);
+	return {
+		client: new graphql_request.GraphQLClient(fullUrl, {
+			...clientOptions,
+			headers: {
+				...clientOptions?.headers ?? {},
+				"x-auth-token": validatedOptions.accessToken
+			}
+		}),
+		graphql
+	};
 }
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  ClientOptionsSchema,
-  createTheGraphClient,
-  readFragment
+
+//#endregion
+exports.ClientOptionsSchema = ClientOptionsSchema;
+exports.createTheGraphClient = createTheGraphClient;
+Object.defineProperty(exports, 'readFragment', {
+  enumerable: true,
+  get: function () {
+    return gql_tada.readFragment;
+  }
 });
 //# sourceMappingURL=thegraph.cjs.map

package/dist/thegraph.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/thegraph.ts"],"sourcesContent":["import { ensureServer } from \"@settlemint/sdk-utils/runtime\";\nimport { ApplicationAccessTokenSchema, UrlOrPathSchema, validate } from \"@settlemint/sdk-utils/validation\";\nimport { type AbstractSetupSchema, initGraphQLTada } from \"gql.tada\";\nimport { GraphQLClient } from \"graphql-request\";\nimport { z } from \"zod/v4\";\n\n/**\n * Type definition for GraphQL client configuration options\n */\nexport type RequestConfig = ConstructorParameters<typeof GraphQLClient>[1];\n\n/**\n * Schema for validating client options for the TheGraph client.\n */\nexport const ClientOptionsSchema = z.object({\n  instances: z.array(UrlOrPathSchema),\n  accessToken: ApplicationAccessTokenSchema,\n  subgraphName: z.string(),\n  cache: z.enum([\"default\", \"force-cache\", \"no-cache\", \"no-store\", \"only-if-cached\", \"reload\"]).optional(),\n});\n\n/**\n * Type definition for client options derived from the ClientOptionsSchema\n */\nexport type ClientOptions = z.infer<typeof ClientOptionsSchema>;\n\n/**\n * Constructs the full URL for TheGraph GraphQL API based on the provided options\n *\n * @param options - The client options for configuring TheGraph client\n * @returns The complete GraphQL API URL as a string\n * @throws Will throw an error if no matching instance is found for the specified subgraph\n */\nfunction getFullUrl(options: ClientOptions): string {\n  const instance = options.instances.find((instance) => instance.endsWith(`/${options.subgraphName}`));\n  if (!instance) {\n    throw new Error(`Instance for subgraph ${options.subgraphName} not found`);\n  }\n  return new URL(instance).toString();\n}\n\n/**\n * Creates a TheGraph GraphQL client with proper type safety using gql.tada\n *\n * @param options - Configuration options for the client including instance URLs,\n *                  access token and subgraph name\n * @param clientOptions - Optional GraphQL client configuration options\n * @returns An object containing:\n *          - client: The configured GraphQL client instance\n *          - graphql: The initialized gql.tada function for type-safe queries\n * @throws Will throw an error if the options fail validation against ClientOptionsSchema\n * @example\n * import { createTheGraphClient } from '@settlemint/sdk-thegraph';\n * import type { introspection } from '@schemas/the-graph-env-kits';\n * import { createLogger, requestLogger } from '@settlemint/sdk-utils/logging';\n *\n * const logger = createLogger();\n *\n * const { client, graphql } = createTheGraphClient<{\n *   introspection: introspection;\n *   disableMasking: true;\n *   scalars: {\n *     Bytes: string;\n *     Int8: string;\n *     BigInt: string;\n *     BigDecimal: string;\n *     Timestamp: string;\n *   };\n * }>({\n *   instances: JSON.parse(process.env.SETTLEMINT_THEGRAPH_SUBGRAPHS_ENDPOINTS || '[]'),\n *   accessToken: process.env.SETTLEMINT_ACCESS_TOKEN!,\n *   subgraphName: 'kits'\n * }, {\n *   fetch: requestLogger(logger, \"the-graph-kits\", fetch) as typeof fetch,\n * });\n *\n * // Making GraphQL queries\n * const query = graphql(`\n *   query SearchAssets {\n *     assets {\n *       id\n *       name\n *       symbol\n *     }\n *   }\n * `);\n *\n * const result = await client.request(query);\n */\nexport function createTheGraphClient<const Setup extends AbstractSetupSchema>(\n  options: ClientOptions,\n  clientOptions?: RequestConfig,\n): {\n  client: GraphQLClient;\n  graphql: initGraphQLTada<Setup>;\n} {\n  ensureServer();\n  const validatedOptions = validate(ClientOptionsSchema, options);\n  const graphql = initGraphQLTada<Setup>();\n  const fullUrl = getFullUrl(validatedOptions);\n\n  return {\n    client: new GraphQLClient(fullUrl, {\n      ...clientOptions,\n      headers: {\n        ...(clientOptions?.headers ?? {}),\n        \"x-auth-token\": validatedOptions.accessToken,\n      },\n    }),\n    graphql,\n  };\n}\n\nexport { readFragment } from \"gql.tada\";\nexport type { FragmentOf, ResultOf, VariablesOf } from \"gql.tada\";\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,qBAA6B;AAC7B,wBAAwE;AACxE,iBAA0D;AAC1D,6BAA8B;AAC9B,gBAAkB;AA6GlB,IAAAA,cAA6B;AAnGtB,IAAM,sBAAsB,YAAE,OAAO;AAAA,EAC1C,WAAW,YAAE,MAAM,iCAAe;AAAA,EAClC,aAAa;AAAA,EACb,cAAc,YAAE,OAAO;AAAA,EACvB,OAAO,YAAE,KAAK,CAAC,WAAW,eAAe,YAAY,YAAY,kBAAkB,QAAQ,CAAC,EAAE,SAAS;AACzG,CAAC;AAcD,SAAS,WAAW,SAAgC;AAClD,QAAM,WAAW,QAAQ,UAAU,KAAK,CAACC,cAAaA,UAAS,SAAS,IAAI,QAAQ,YAAY,EAAE,CAAC;AACnG,MAAI,CAAC,UAAU;AACb,UAAM,IAAI,MAAM,yBAAyB,QAAQ,YAAY,YAAY;AAAA,EAC3E;AACA,SAAO,IAAI,IAAI,QAAQ,EAAE,SAAS;AACpC;AAkDO,SAAS,qBACd,SACA,eAIA;AACA,mCAAa;AACb,QAAM,uBAAmB,4BAAS,qBAAqB,OAAO;AAC9D,QAAM,cAAU,4BAAuB;AACvC,QAAM,UAAU,WAAW,gBAAgB;AAE3C,SAAO;AAAA,IACL,QAAQ,IAAI,qCAAc,SAAS;AAAA,MACjC,GAAG;AAAA,MACH,SAAS;AAAA,QACP,GAAI,eAAe,WAAW,CAAC;AAAA,QAC/B,gBAAgB,iBAAiB;AAAA,MACnC;AAAA,IACF,CAAC;AAAA,IACD;AAAA,EACF;AACF;","names":["import_gql","instance"]}
+{"version":3,"file":"thegraph.cjs","names":["UrlOrPathSchema","ApplicationAccessTokenSchema","options: ClientOptions","instance","clientOptions?: RequestConfig","GraphQLClient"],"sources":["../src/thegraph.ts"],"sourcesContent":["import { ensureServer } from \"@settlemint/sdk-utils/runtime\";\nimport { ApplicationAccessTokenSchema, UrlOrPathSchema, validate } from \"@settlemint/sdk-utils/validation\";\nimport { type AbstractSetupSchema, initGraphQLTada } from \"gql.tada\";\nimport { GraphQLClient } from \"graphql-request\";\nimport { z } from \"zod/v4\";\n\n/**\n * Type definition for GraphQL client configuration options\n */\nexport type RequestConfig = ConstructorParameters<typeof GraphQLClient>[1];\n\n/**\n * Schema for validating client options for the TheGraph client.\n */\nexport const ClientOptionsSchema = z.object({\n  instances: z.array(UrlOrPathSchema),\n  accessToken: ApplicationAccessTokenSchema,\n  subgraphName: z.string(),\n  cache: z.enum([\"default\", \"force-cache\", \"no-cache\", \"no-store\", \"only-if-cached\", \"reload\"]).optional(),\n});\n\n/**\n * Type definition for client options derived from the ClientOptionsSchema\n */\nexport type ClientOptions = z.infer<typeof ClientOptionsSchema>;\n\n/**\n * Constructs the full URL for TheGraph GraphQL API based on the provided options\n *\n * @param options - The client options for configuring TheGraph client\n * @returns The complete GraphQL API URL as a string\n * @throws Will throw an error if no matching instance is found for the specified subgraph\n */\nfunction getFullUrl(options: ClientOptions): string {\n  const instance = options.instances.find((instance) => instance.endsWith(`/${options.subgraphName}`));\n  if (!instance) {\n    throw new Error(`Instance for subgraph ${options.subgraphName} not found`);\n  }\n  return new URL(instance).toString();\n}\n\n/**\n * Creates a TheGraph GraphQL client with proper type safety using gql.tada\n *\n * @param options - Configuration options for the client including instance URLs,\n *                  access token and subgraph name\n * @param clientOptions - Optional GraphQL client configuration options\n * @returns An object containing:\n *          - client: The configured GraphQL client instance\n *          - graphql: The initialized gql.tada function for type-safe queries\n * @throws Will throw an error if the options fail validation against ClientOptionsSchema\n * @example\n * import { createTheGraphClient } from '@settlemint/sdk-thegraph';\n * import type { introspection } from '@schemas/the-graph-env-kits';\n * import { createLogger, requestLogger } from '@settlemint/sdk-utils/logging';\n *\n * const logger = createLogger();\n *\n * const { client, graphql } = createTheGraphClient<{\n *   introspection: introspection;\n *   disableMasking: true;\n *   scalars: {\n *     Bytes: string;\n *     Int8: string;\n *     BigInt: string;\n *     BigDecimal: string;\n *     Timestamp: string;\n *   };\n * }>({\n *   instances: JSON.parse(process.env.SETTLEMINT_THEGRAPH_SUBGRAPHS_ENDPOINTS || '[]'),\n *   accessToken: process.env.SETTLEMINT_ACCESS_TOKEN,\n *   subgraphName: 'kits'\n * }, {\n *   fetch: requestLogger(logger, \"the-graph-kits\", fetch) as typeof fetch,\n * });\n *\n * // Making GraphQL queries\n * const query = graphql(`\n *   query SearchAssets {\n *     assets {\n *       id\n *       name\n *       symbol\n *     }\n *   }\n * `);\n *\n * const result = await client.request(query);\n */\nexport function createTheGraphClient<const Setup extends AbstractSetupSchema>(\n  options: ClientOptions,\n  clientOptions?: RequestConfig,\n): {\n  client: GraphQLClient;\n  graphql: initGraphQLTada<Setup>;\n} {\n  ensureServer();\n  const validatedOptions = validate(ClientOptionsSchema, options);\n  const graphql = initGraphQLTada<Setup>();\n  const fullUrl = getFullUrl(validatedOptions);\n\n  return {\n    client: new GraphQLClient(fullUrl, {\n      ...clientOptions,\n      headers: {\n        ...(clientOptions?.headers ?? {}),\n        \"x-auth-token\": validatedOptions.accessToken,\n      },\n    }),\n    graphql,\n  };\n}\n\nexport { readFragment } from \"gql.tada\";\nexport type { FragmentOf, ResultOf, VariablesOf } from \"gql.tada\";\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAcA,MAAa,sBAAsB,SAAE,OAAO;CAC1C,WAAW,SAAE,MAAMA,kDAAgB;CACnC,aAAaC;CACb,cAAc,SAAE,QAAQ;CACxB,OAAO,SAAE,KAAK;EAAC;EAAW;EAAe;EAAY;EAAY;EAAkB;CAAS,EAAC,CAAC,UAAU;AACzG,EAAC;;;;;;;;AAcF,SAAS,WAAWC,SAAgC;CAClD,MAAM,WAAW,QAAQ,UAAU,KAAK,CAACC,eAAa,WAAS,UAAU,GAAG,QAAQ,aAAa,EAAE,CAAC;AACpG,MAAK,UAAU;AACb,QAAM,IAAI,OAAO,wBAAwB,QAAQ,aAAa;CAC/D;AACD,QAAO,IAAI,IAAI,UAAU,UAAU;AACpC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkDD,SAAgB,qBACdD,SACAE,eAIA;AACA,mDAAc;CACd,MAAM,mBAAmB,gDAAS,qBAAqB,QAAQ;CAC/D,MAAM,UAAU,+BAAwB;CACxC,MAAM,UAAU,WAAW,iBAAiB;AAE5C,QAAO;EACL,QAAQ,IAAIC,8BAAc,SAAS;GACjC,GAAG;GACH,SAAS;IACP,GAAI,eAAe,WAAW,CAAE;IAChC,gBAAgB,iBAAiB;GAClC;EACF;EACD;CACD;AACF"}

package/dist/thegraph.d.cts

@@ -1,8 +1,11 @@
-import { AbstractSetupSchema, initGraphQLTada } from 'gql.tada';
-export { FragmentOf, ResultOf, VariablesOf, readFragment } from 'gql.tada';
-import { GraphQLClient } from 'graphql-request';
-import { z } from 'zod/v4';
+import { AbstractSetupSchema, FragmentOf, ResultOf, VariablesOf, initGraphQLTada, readFragment } from "gql.tada";
+import { GraphQLClient } from "graphql-request";
+import { z } from "zod/v4";
 
+//#region src/thegraph.d.ts
+/**
+* Type definition for GraphQL client configuration options
+*/
 /**
  * Type definition for GraphQL client configuration options
  */
@@ -11,17 +14,17 @@ type RequestConfig = ConstructorParameters<typeof GraphQLClient>[1];
  * Schema for validating client options for the TheGraph client.
  */
 declare const ClientOptionsSchema: z.ZodObject<{
-    instances: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodString]>>;
-    accessToken: z.ZodString;
-    subgraphName: z.ZodString;
-    cache: z.ZodOptional<z.ZodEnum<{
-        default: "default";
-        "force-cache": "force-cache";
-        "no-cache": "no-cache";
-        "no-store": "no-store";
-        "only-if-cached": "only-if-cached";
-        reload: "reload";
-    }>>;
+  instances: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodString]>>;
+  accessToken: z.ZodString;
+  subgraphName: z.ZodString;
+  cache: z.ZodOptional<z.ZodEnum<{
+    default: "default";
+    "force-cache": "force-cache";
+    "no-cache": "no-cache";
+    "no-store": "no-store";
+    "only-if-cached": "only-if-cached";
+    reload: "reload";
+  }>>;
 }, z.core.$strip>;
 /**
  * Type definition for client options derived from the ClientOptionsSchema
@@ -56,7 +59,7 @@ type ClientOptions = z.infer<typeof ClientOptionsSchema>;
  *   };
  * }>({
  *   instances: JSON.parse(process.env.SETTLEMINT_THEGRAPH_SUBGRAPHS_ENDPOINTS || '[]'),
- *   accessToken: process.env.SETTLEMINT_ACCESS_TOKEN!,
+ *   accessToken: process.env.SETTLEMINT_ACCESS_TOKEN,
  *   subgraphName: 'kits'
  * }, {
  *   fetch: requestLogger(logger, "the-graph-kits", fetch) as typeof fetch,
@@ -76,8 +79,10 @@ type ClientOptions = z.infer<typeof ClientOptionsSchema>;
  * const result = await client.request(query);
  */
 declare function createTheGraphClient<const Setup extends AbstractSetupSchema>(options: ClientOptions, clientOptions?: RequestConfig): {
-    client: GraphQLClient;
-    graphql: initGraphQLTada<Setup>;
+  client: GraphQLClient;
+  graphql: initGraphQLTada<Setup>;
 };
 
-export { type ClientOptions, ClientOptionsSchema, type RequestConfig, createTheGraphClient };
+//#endregion
+export { ClientOptions, ClientOptionsSchema, FragmentOf, RequestConfig, ResultOf, VariablesOf, createTheGraphClient, readFragment };
+//# sourceMappingURL=thegraph.d.cts.map

package/dist/thegraph.d.ts

@@ -1,8 +1,11 @@
-import { AbstractSetupSchema, initGraphQLTada } from 'gql.tada';
-export { FragmentOf, ResultOf, VariablesOf, readFragment } from 'gql.tada';
-import { GraphQLClient } from 'graphql-request';
-import { z } from 'zod/v4';
+import { AbstractSetupSchema, FragmentOf, ResultOf, VariablesOf, initGraphQLTada, readFragment } from "gql.tada";
+import { GraphQLClient } from "graphql-request";
+import { z } from "zod/v4";
 
+//#region src/thegraph.d.ts
+/**
+* Type definition for GraphQL client configuration options
+*/
 /**
  * Type definition for GraphQL client configuration options
  */
@@ -11,17 +14,17 @@ type RequestConfig = ConstructorParameters<typeof GraphQLClient>[1];
  * Schema for validating client options for the TheGraph client.
  */
 declare const ClientOptionsSchema: z.ZodObject<{
-    instances: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodString]>>;
-    accessToken: z.ZodString;
-    subgraphName: z.ZodString;
-    cache: z.ZodOptional<z.ZodEnum<{
-        default: "default";
-        "force-cache": "force-cache";
-        "no-cache": "no-cache";
-        "no-store": "no-store";
-        "only-if-cached": "only-if-cached";
-        reload: "reload";
-    }>>;
+  instances: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodString]>>;
+  accessToken: z.ZodString;
+  subgraphName: z.ZodString;
+  cache: z.ZodOptional<z.ZodEnum<{
+    default: "default";
+    "force-cache": "force-cache";
+    "no-cache": "no-cache";
+    "no-store": "no-store";
+    "only-if-cached": "only-if-cached";
+    reload: "reload";
+  }>>;
 }, z.core.$strip>;
 /**
  * Type definition for client options derived from the ClientOptionsSchema
@@ -56,7 +59,7 @@ type ClientOptions = z.infer<typeof ClientOptionsSchema>;
  *   };
  * }>({
  *   instances: JSON.parse(process.env.SETTLEMINT_THEGRAPH_SUBGRAPHS_ENDPOINTS || '[]'),
- *   accessToken: process.env.SETTLEMINT_ACCESS_TOKEN!,
+ *   accessToken: process.env.SETTLEMINT_ACCESS_TOKEN,
  *   subgraphName: 'kits'
  * }, {
  *   fetch: requestLogger(logger, "the-graph-kits", fetch) as typeof fetch,
@@ -76,8 +79,10 @@ type ClientOptions = z.infer<typeof ClientOptionsSchema>;
  * const result = await client.request(query);
  */
 declare function createTheGraphClient<const Setup extends AbstractSetupSchema>(options: ClientOptions, clientOptions?: RequestConfig): {
-    client: GraphQLClient;
-    graphql: initGraphQLTada<Setup>;
+  client: GraphQLClient;
+  graphql: initGraphQLTada<Setup>;
 };
 
-export { type ClientOptions, ClientOptionsSchema, type RequestConfig, createTheGraphClient };
+//#endregion
+export { ClientOptions, ClientOptionsSchema, FragmentOf, RequestConfig, ResultOf, VariablesOf, createTheGraphClient, readFragment };
+//# sourceMappingURL=thegraph.d.ts.map

package/dist/thegraph.js

@@ -0,0 +1,105 @@
+import { ensureServer } from "@settlemint/sdk-utils/runtime";
+import { ApplicationAccessTokenSchema, UrlOrPathSchema, validate } from "@settlemint/sdk-utils/validation";
+import { initGraphQLTada, readFragment } from "gql.tada";
+import { GraphQLClient } from "graphql-request";
+import { z } from "zod/v4";
+
+//#region src/thegraph.ts
+/**
+* Schema for validating client options for the TheGraph client.
+*/
+const ClientOptionsSchema = z.object({
+	instances: z.array(UrlOrPathSchema),
+	accessToken: ApplicationAccessTokenSchema,
+	subgraphName: z.string(),
+	cache: z.enum([
+		"default",
+		"force-cache",
+		"no-cache",
+		"no-store",
+		"only-if-cached",
+		"reload"
+	]).optional()
+});
+/**
+* Constructs the full URL for TheGraph GraphQL API based on the provided options
+*
+* @param options - The client options for configuring TheGraph client
+* @returns The complete GraphQL API URL as a string
+* @throws Will throw an error if no matching instance is found for the specified subgraph
+*/
+function getFullUrl(options) {
+	const instance = options.instances.find((instance$1) => instance$1.endsWith(`/${options.subgraphName}`));
+	if (!instance) {
+		throw new Error(`Instance for subgraph ${options.subgraphName} not found`);
+	}
+	return new URL(instance).toString();
+}
+/**
+* Creates a TheGraph GraphQL client with proper type safety using gql.tada
+*
+* @param options - Configuration options for the client including instance URLs,
+*                  access token and subgraph name
+* @param clientOptions - Optional GraphQL client configuration options
+* @returns An object containing:
+*          - client: The configured GraphQL client instance
+*          - graphql: The initialized gql.tada function for type-safe queries
+* @throws Will throw an error if the options fail validation against ClientOptionsSchema
+* @example
+* import { createTheGraphClient } from '@settlemint/sdk-thegraph';
+* import type { introspection } from '@schemas/the-graph-env-kits';
+* import { createLogger, requestLogger } from '@settlemint/sdk-utils/logging';
+*
+* const logger = createLogger();
+*
+* const { client, graphql } = createTheGraphClient<{
+*   introspection: introspection;
+*   disableMasking: true;
+*   scalars: {
+*     Bytes: string;
+*     Int8: string;
+*     BigInt: string;
+*     BigDecimal: string;
+*     Timestamp: string;
+*   };
+* }>({
+*   instances: JSON.parse(process.env.SETTLEMINT_THEGRAPH_SUBGRAPHS_ENDPOINTS || '[]'),
+*   accessToken: process.env.SETTLEMINT_ACCESS_TOKEN,
+*   subgraphName: 'kits'
+* }, {
+*   fetch: requestLogger(logger, "the-graph-kits", fetch) as typeof fetch,
+* });
+*
+* // Making GraphQL queries
+* const query = graphql(`
+*   query SearchAssets {
+*     assets {
+*       id
+*       name
+*       symbol
+*     }
+*   }
+* `);
+*
+* const result = await client.request(query);
+*/
+function createTheGraphClient(options, clientOptions) {
+	ensureServer();
+	const validatedOptions = validate(ClientOptionsSchema, options);
+	const graphql = initGraphQLTada();
+	const fullUrl = getFullUrl(validatedOptions);
+	return {
+		client: new GraphQLClient(fullUrl, {
+			...clientOptions,
+			headers: {
+				...clientOptions?.headers ?? {},
+				"x-auth-token": validatedOptions.accessToken
+			}
+		}),
+		graphql
+	};
+}
+
+//#endregion
+export { ClientOptionsSchema, createTheGraphClient, readFragment };
+//# sourceMappingURL=thegraph.js.map

package/dist/thegraph.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"thegraph.js","names":["options: ClientOptions","instance","clientOptions?: RequestConfig"],"sources":["../src/thegraph.ts"],"sourcesContent":["import { ensureServer } from \"@settlemint/sdk-utils/runtime\";\nimport { ApplicationAccessTokenSchema, UrlOrPathSchema, validate } from \"@settlemint/sdk-utils/validation\";\nimport { type AbstractSetupSchema, initGraphQLTada } from \"gql.tada\";\nimport { GraphQLClient } from \"graphql-request\";\nimport { z } from \"zod/v4\";\n\n/**\n * Type definition for GraphQL client configuration options\n */\nexport type RequestConfig = ConstructorParameters<typeof GraphQLClient>[1];\n\n/**\n * Schema for validating client options for the TheGraph client.\n */\nexport const ClientOptionsSchema = z.object({\n  instances: z.array(UrlOrPathSchema),\n  accessToken: ApplicationAccessTokenSchema,\n  subgraphName: z.string(),\n  cache: z.enum([\"default\", \"force-cache\", \"no-cache\", \"no-store\", \"only-if-cached\", \"reload\"]).optional(),\n});\n\n/**\n * Type definition for client options derived from the ClientOptionsSchema\n */\nexport type ClientOptions = z.infer<typeof ClientOptionsSchema>;\n\n/**\n * Constructs the full URL for TheGraph GraphQL API based on the provided options\n *\n * @param options - The client options for configuring TheGraph client\n * @returns The complete GraphQL API URL as a string\n * @throws Will throw an error if no matching instance is found for the specified subgraph\n */\nfunction getFullUrl(options: ClientOptions): string {\n  const instance = options.instances.find((instance) => instance.endsWith(`/${options.subgraphName}`));\n  if (!instance) {\n    throw new Error(`Instance for subgraph ${options.subgraphName} not found`);\n  }\n  return new URL(instance).toString();\n}\n\n/**\n * Creates a TheGraph GraphQL client with proper type safety using gql.tada\n *\n * @param options - Configuration options for the client including instance URLs,\n *                  access token and subgraph name\n * @param clientOptions - Optional GraphQL client configuration options\n * @returns An object containing:\n *          - client: The configured GraphQL client instance\n *          - graphql: The initialized gql.tada function for type-safe queries\n * @throws Will throw an error if the options fail validation against ClientOptionsSchema\n * @example\n * import { createTheGraphClient } from '@settlemint/sdk-thegraph';\n * import type { introspection } from '@schemas/the-graph-env-kits';\n * import { createLogger, requestLogger } from '@settlemint/sdk-utils/logging';\n *\n * const logger = createLogger();\n *\n * const { client, graphql } = createTheGraphClient<{\n *   introspection: introspection;\n *   disableMasking: true;\n *   scalars: {\n *     Bytes: string;\n *     Int8: string;\n *     BigInt: string;\n *     BigDecimal: string;\n *     Timestamp: string;\n *   };\n * }>({\n *   instances: JSON.parse(process.env.SETTLEMINT_THEGRAPH_SUBGRAPHS_ENDPOINTS || '[]'),\n *   accessToken: process.env.SETTLEMINT_ACCESS_TOKEN,\n *   subgraphName: 'kits'\n * }, {\n *   fetch: requestLogger(logger, \"the-graph-kits\", fetch) as typeof fetch,\n * });\n *\n * // Making GraphQL queries\n * const query = graphql(`\n *   query SearchAssets {\n *     assets {\n *       id\n *       name\n *       symbol\n *     }\n *   }\n * `);\n *\n * const result = await client.request(query);\n */\nexport function createTheGraphClient<const Setup extends AbstractSetupSchema>(\n  options: ClientOptions,\n  clientOptions?: RequestConfig,\n): {\n  client: GraphQLClient;\n  graphql: initGraphQLTada<Setup>;\n} {\n  ensureServer();\n  const validatedOptions = validate(ClientOptionsSchema, options);\n  const graphql = initGraphQLTada<Setup>();\n  const fullUrl = getFullUrl(validatedOptions);\n\n  return {\n    client: new GraphQLClient(fullUrl, {\n      ...clientOptions,\n      headers: {\n        ...(clientOptions?.headers ?? {}),\n        \"x-auth-token\": validatedOptions.accessToken,\n      },\n    }),\n    graphql,\n  };\n}\n\nexport { readFragment } from \"gql.tada\";\nexport type { FragmentOf, ResultOf, VariablesOf } from \"gql.tada\";\n"],"mappings":";;;;;;;;;;AAcA,MAAa,sBAAsB,EAAE,OAAO;CAC1C,WAAW,EAAE,MAAM,gBAAgB;CACnC,aAAa;CACb,cAAc,EAAE,QAAQ;CACxB,OAAO,EAAE,KAAK;EAAC;EAAW;EAAe;EAAY;EAAY;EAAkB;CAAS,EAAC,CAAC,UAAU;AACzG,EAAC;;;;;;;;AAcF,SAAS,WAAWA,SAAgC;CAClD,MAAM,WAAW,QAAQ,UAAU,KAAK,CAACC,eAAa,WAAS,UAAU,GAAG,QAAQ,aAAa,EAAE,CAAC;AACpG,MAAK,UAAU;AACb,QAAM,IAAI,OAAO,wBAAwB,QAAQ,aAAa;CAC/D;AACD,QAAO,IAAI,IAAI,UAAU,UAAU;AACpC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkDD,SAAgB,qBACdD,SACAE,eAIA;AACA,eAAc;CACd,MAAM,mBAAmB,SAAS,qBAAqB,QAAQ;CAC/D,MAAM,UAAU,iBAAwB;CACxC,MAAM,UAAU,WAAW,iBAAiB;AAE5C,QAAO;EACL,QAAQ,IAAI,cAAc,SAAS;GACjC,GAAG;GACH,SAAS;IACP,GAAI,eAAe,WAAW,CAAE;IAChC,gBAAgB,iBAAiB;GAClC;EACF;EACD;CACD;AACF"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@settlemint/sdk-thegraph",
   "description": "TheGraph integration module for SettleMint SDK, enabling querying and indexing of blockchain data through subgraphs",
-  "version": "2.3.2-pref75df5f",
+  "version": "2.3.2-preff27199",
   "type": "module",
   "private": false,
   "license": "FSL-1.1-MIT",
@@ -22,14 +22,14 @@
   },
   "files": ["dist"],
   "main": "./dist/thegraph.cjs",
-  "module": "./dist/thegraph.mjs",
+  "module": "./dist/thegraph.js",
   "types": "./dist/thegraph.d.ts",
   "exports": {
     "./package.json": "./package.json",
     ".": {
       "import": {
         "types": "./dist/thegraph.d.ts",
-        "default": "./dist/thegraph.mjs"
+        "default": "./dist/thegraph.js"
       },
       "require": {
         "types": "./dist/thegraph.d.cts",
@@ -38,8 +38,8 @@
     }
   },
   "scripts": {
-    "build": "tsup-node",
-    "dev": "tsup-node --watch",
+    "build": "tsdown",
+    "dev": "tsdown --watch",
     "publint": "publint run --strict",
     "attw": "attw --pack .",
     "test": "bun test",
@@ -52,7 +52,7 @@
   "devDependencies": {},
   "dependencies": {
     "gql.tada": "^1",
-    "@settlemint/sdk-utils": "2.3.2-pref75df5f",
+    "@settlemint/sdk-utils": "2.3.2-preff27199",
     "graphql-request": "^7",
     "zod": "^3.25.0"
   },

package/dist/thegraph.mjs

@@ -1,42 +0,0 @@
-// src/thegraph.ts
-import { ensureServer } from "@settlemint/sdk-utils/runtime";
-import { ApplicationAccessTokenSchema, UrlOrPathSchema, validate } from "@settlemint/sdk-utils/validation";
-import { initGraphQLTada } from "gql.tada";
-import { GraphQLClient } from "graphql-request";
-import { z } from "zod/v4";
-import { readFragment } from "gql.tada";
-var ClientOptionsSchema = z.object({
-  instances: z.array(UrlOrPathSchema),
-  accessToken: ApplicationAccessTokenSchema,
-  subgraphName: z.string(),
-  cache: z.enum(["default", "force-cache", "no-cache", "no-store", "only-if-cached", "reload"]).optional()
-});
-function getFullUrl(options) {
-  const instance = options.instances.find((instance2) => instance2.endsWith(`/${options.subgraphName}`));
-  if (!instance) {
-    throw new Error(`Instance for subgraph ${options.subgraphName} not found`);
-  }
-  return new URL(instance).toString();
-}
-function createTheGraphClient(options, clientOptions) {
-  ensureServer();
-  const validatedOptions = validate(ClientOptionsSchema, options);
-  const graphql = initGraphQLTada();
-  const fullUrl = getFullUrl(validatedOptions);
-  return {
-    client: new GraphQLClient(fullUrl, {
-      ...clientOptions,
-      headers: {
-        ...clientOptions?.headers ?? {},
-        "x-auth-token": validatedOptions.accessToken
-      }
-    }),
-    graphql
-  };
-}
-export {
-  ClientOptionsSchema,
-  createTheGraphClient,
-  readFragment
-};
-//# sourceMappingURL=thegraph.mjs.map

package/dist/thegraph.mjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/thegraph.ts"],"sourcesContent":["import { ensureServer } from \"@settlemint/sdk-utils/runtime\";\nimport { ApplicationAccessTokenSchema, UrlOrPathSchema, validate } from \"@settlemint/sdk-utils/validation\";\nimport { type AbstractSetupSchema, initGraphQLTada } from \"gql.tada\";\nimport { GraphQLClient } from \"graphql-request\";\nimport { z } from \"zod/v4\";\n\n/**\n * Type definition for GraphQL client configuration options\n */\nexport type RequestConfig = ConstructorParameters<typeof GraphQLClient>[1];\n\n/**\n * Schema for validating client options for the TheGraph client.\n */\nexport const ClientOptionsSchema = z.object({\n  instances: z.array(UrlOrPathSchema),\n  accessToken: ApplicationAccessTokenSchema,\n  subgraphName: z.string(),\n  cache: z.enum([\"default\", \"force-cache\", \"no-cache\", \"no-store\", \"only-if-cached\", \"reload\"]).optional(),\n});\n\n/**\n * Type definition for client options derived from the ClientOptionsSchema\n */\nexport type ClientOptions = z.infer<typeof ClientOptionsSchema>;\n\n/**\n * Constructs the full URL for TheGraph GraphQL API based on the provided options\n *\n * @param options - The client options for configuring TheGraph client\n * @returns The complete GraphQL API URL as a string\n * @throws Will throw an error if no matching instance is found for the specified subgraph\n */\nfunction getFullUrl(options: ClientOptions): string {\n  const instance = options.instances.find((instance) => instance.endsWith(`/${options.subgraphName}`));\n  if (!instance) {\n    throw new Error(`Instance for subgraph ${options.subgraphName} not found`);\n  }\n  return new URL(instance).toString();\n}\n\n/**\n * Creates a TheGraph GraphQL client with proper type safety using gql.tada\n *\n * @param options - Configuration options for the client including instance URLs,\n *                  access token and subgraph name\n * @param clientOptions - Optional GraphQL client configuration options\n * @returns An object containing:\n *          - client: The configured GraphQL client instance\n *          - graphql: The initialized gql.tada function for type-safe queries\n * @throws Will throw an error if the options fail validation against ClientOptionsSchema\n * @example\n * import { createTheGraphClient } from '@settlemint/sdk-thegraph';\n * import type { introspection } from '@schemas/the-graph-env-kits';\n * import { createLogger, requestLogger } from '@settlemint/sdk-utils/logging';\n *\n * const logger = createLogger();\n *\n * const { client, graphql } = createTheGraphClient<{\n *   introspection: introspection;\n *   disableMasking: true;\n *   scalars: {\n *     Bytes: string;\n *     Int8: string;\n *     BigInt: string;\n *     BigDecimal: string;\n *     Timestamp: string;\n *   };\n * }>({\n *   instances: JSON.parse(process.env.SETTLEMINT_THEGRAPH_SUBGRAPHS_ENDPOINTS || '[]'),\n *   accessToken: process.env.SETTLEMINT_ACCESS_TOKEN!,\n *   subgraphName: 'kits'\n * }, {\n *   fetch: requestLogger(logger, \"the-graph-kits\", fetch) as typeof fetch,\n * });\n *\n * // Making GraphQL queries\n * const query = graphql(`\n *   query SearchAssets {\n *     assets {\n *       id\n *       name\n *       symbol\n *     }\n *   }\n * `);\n *\n * const result = await client.request(query);\n */\nexport function createTheGraphClient<const Setup extends AbstractSetupSchema>(\n  options: ClientOptions,\n  clientOptions?: RequestConfig,\n): {\n  client: GraphQLClient;\n  graphql: initGraphQLTada<Setup>;\n} {\n  ensureServer();\n  const validatedOptions = validate(ClientOptionsSchema, options);\n  const graphql = initGraphQLTada<Setup>();\n  const fullUrl = getFullUrl(validatedOptions);\n\n  return {\n    client: new GraphQLClient(fullUrl, {\n      ...clientOptions,\n      headers: {\n        ...(clientOptions?.headers ?? {}),\n        \"x-auth-token\": validatedOptions.accessToken,\n      },\n    }),\n    graphql,\n  };\n}\n\nexport { readFragment } from \"gql.tada\";\nexport type { FragmentOf, ResultOf, VariablesOf } from \"gql.tada\";\n"],"mappings":";AAAA,SAAS,oBAAoB;AAC7B,SAAS,8BAA8B,iBAAiB,gBAAgB;AACxE,SAAmC,uBAAuB;AAC1D,SAAS,qBAAqB;AAC9B,SAAS,SAAS;AA6GlB,SAAS,oBAAoB;AAnGtB,IAAM,sBAAsB,EAAE,OAAO;AAAA,EAC1C,WAAW,EAAE,MAAM,eAAe;AAAA,EAClC,aAAa;AAAA,EACb,cAAc,EAAE,OAAO;AAAA,EACvB,OAAO,EAAE,KAAK,CAAC,WAAW,eAAe,YAAY,YAAY,kBAAkB,QAAQ,CAAC,EAAE,SAAS;AACzG,CAAC;AAcD,SAAS,WAAW,SAAgC;AAClD,QAAM,WAAW,QAAQ,UAAU,KAAK,CAACA,cAAaA,UAAS,SAAS,IAAI,QAAQ,YAAY,EAAE,CAAC;AACnG,MAAI,CAAC,UAAU;AACb,UAAM,IAAI,MAAM,yBAAyB,QAAQ,YAAY,YAAY;AAAA,EAC3E;AACA,SAAO,IAAI,IAAI,QAAQ,EAAE,SAAS;AACpC;AAkDO,SAAS,qBACd,SACA,eAIA;AACA,eAAa;AACb,QAAM,mBAAmB,SAAS,qBAAqB,OAAO;AAC9D,QAAM,UAAU,gBAAuB;AACvC,QAAM,UAAU,WAAW,gBAAgB;AAE3C,SAAO;AAAA,IACL,QAAQ,IAAI,cAAc,SAAS;AAAA,MACjC,GAAG;AAAA,MACH,SAAS;AAAA,QACP,GAAI,eAAe,WAAW,CAAC;AAAA,QAC/B,gBAAgB,iBAAiB;AAAA,MACnC;AAAA,IACF,CAAC;AAAA,IACD;AAAA,EACF;AACF;","names":["instance"]}