@settlemint/sdk-hasura 2.4.1-pr6c40584b → 2.4.1-pr79cb50b0

package/README.md

@@ -30,9 +30,7 @@
 - [API Reference](#api-reference)
   - [Functions](#functions)
     - [createHasuraClient()](#createhasuraclient)
-    - [createHasuraMetadataClient()](#createhasurametadataclient)
     - [createPostgresPool()](#createpostgrespool)
-    - [trackAllTables()](#trackalltables)
   - [Type Aliases](#type-aliases)
     - [ClientOptions](#clientoptions)
     - [RequestConfig](#requestconfig)
@@ -53,7 +51,7 @@ The SettleMint Hasura SDK provides a seamless way to interact with Hasura GraphQ
 
 > **createHasuraClient**\<`Setup`\>(`options`, `clientOptions?`, `logger?`): `object`
 
-Defined in: [sdk/hasura/src/hasura.ts:83](https://github.com/settlemint/sdk/blob/v2.4.1/sdk/hasura/src/hasura.ts#L83)
+Defined in: [sdk/hasura/src/hasura.ts:82](https://github.com/settlemint/sdk/blob/v2.4.1/sdk/hasura/src/hasura.ts#L82)
 
 Creates a Hasura GraphQL client with proper type safety using gql.tada
 
@@ -85,8 +83,8 @@ An object containing:
 
 | Name | Type | Defined in |
 | ------ | ------ | ------ |
-| `client` | `GraphQLClient` | [sdk/hasura/src/hasura.ts:88](https://github.com/settlemint/sdk/blob/v2.4.1/sdk/hasura/src/hasura.ts#L88) |
-| `graphql` | `initGraphQLTada`\<`Setup`\> | [sdk/hasura/src/hasura.ts:89](https://github.com/settlemint/sdk/blob/v2.4.1/sdk/hasura/src/hasura.ts#L89) |
+| `client` | `GraphQLClient` | [sdk/hasura/src/hasura.ts:87](https://github.com/settlemint/sdk/blob/v2.4.1/sdk/hasura/src/hasura.ts#L87) |
+| `graphql` | `initGraphQLTada`\<`Setup`\> | [sdk/hasura/src/hasura.ts:88](https://github.com/settlemint/sdk/blob/v2.4.1/sdk/hasura/src/hasura.ts#L88) |
 
 ##### Throws
 
@@ -140,72 +138,6 @@ const result = await client.request(query);
 
 ***
 
-#### createHasuraMetadataClient()
-
-> **createHasuraMetadataClient**(`options`, `logger?`): \<`T`\>(`query`) => `Promise`\<\{ `data`: `T`; `ok`: `boolean`; \}\>
-
-Defined in: [sdk/hasura/src/hasura.ts:132](https://github.com/settlemint/sdk/blob/v2.4.1/sdk/hasura/src/hasura.ts#L132)
-
-Creates a Hasura Metadata client
-
-##### Parameters
-
-| Parameter | Type | Description |
-| ------ | ------ | ------ |
-| `options` | \{ `accessToken?`: `string`; `adminSecret`: `string`; `cache?`: `"default"` \| `"force-cache"` \| `"no-cache"` \| `"no-store"` \| `"only-if-cached"` \| `"reload"`; `instance`: `string`; \} | Configuration options for the client |
-| `options.accessToken?` | `string` | - |
-| `options.adminSecret?` | `string` | - |
-| `options.cache?` | `"default"` \| `"force-cache"` \| `"no-cache"` \| `"no-store"` \| `"only-if-cached"` \| `"reload"` | - |
-| `options.instance?` | `string` | - |
-| `logger?` | `Logger` | Optional logger to use for logging the requests |
-
-##### Returns
-
-A function that can be used to make requests to the Hasura Metadata API
-
-> \<`T`\>(`query`): `Promise`\<\{ `data`: `T`; `ok`: `boolean`; \}\>
-
-###### Type Parameters
-
-| Type Parameter |
-| ------ |
-| `T` |
-
-###### Parameters
-
-| Parameter | Type |
-| ------ | ------ |
-| `query` | `object` |
-
-###### Returns
-
-`Promise`\<\{ `data`: `T`; `ok`: `boolean`; \}\>
-
-##### Throws
-
-Will throw an error if the options fail validation against ClientOptionsSchema
-
-##### Example
-
-```ts
-import { createHasuraMetadataClient } from '@settlemint/sdk-hasura';
-
-const client = createHasuraMetadataClient({
-  instance: process.env.SETTLEMINT_HASURA_ENDPOINT,
-  accessToken: process.env.SETTLEMINT_ACCESS_TOKEN,
-  adminSecret: process.env.SETTLEMINT_HASURA_ADMIN_SECRET,
-});
-
-const result = await client({
-  type: "pg_get_source_tables",
-  args: {
-    source: "default",
-  },
-});
-```
-
-***
-
 #### createPostgresPool()
 
 > **createPostgresPool**(`databaseUrl`): `Pool`
@@ -247,55 +179,13 @@ try {
 }
 ```
 
-***
-
-#### trackAllTables()
-
-> **trackAllTables**(`databaseName`, `client`): `Promise`\<\{ `messages`: `string`[]; `result`: `"success"` \| `"no-tables"`; \}\>
-
-Defined in: [sdk/hasura/src/utils/track-all-tables.ts:25](https://github.com/settlemint/sdk/blob/v2.4.1/sdk/hasura/src/utils/track-all-tables.ts#L25)
-
-Track all tables in a database
-
-##### Parameters
-
-| Parameter | Type | Description |
-| ------ | ------ | ------ |
-| `databaseName` | `string` | The name of the database to track tables for |
-| `client` | \<`T`\>(`query`) => `Promise`\<\{ `data`: `T`; `ok`: `boolean`; \}\> | - |
-
-##### Returns
-
-`Promise`\<\{ `messages`: `string`[]; `result`: `"success"` \| `"no-tables"`; \}\>
-
-A promise that resolves to an object with a result property indicating success or failure
-
-##### Example
-
-```ts
-import { trackAllTables } from "@settlemint/sdk-hasura/utils/track-all-tables";
-
-const client = createHasuraMetadataClient({
-  instance: "http://localhost:8080",
-  accessToken: "test",
-  adminSecret: "test",
-});
-
-const result = await trackAllTables("default", client);
-if (result.result === "success") {
-  console.log("Tables tracked successfully");
-} else {
-  console.error("Failed to track tables");
-}
-```
-
 ### Type Aliases
 
 #### ClientOptions
 
 > **ClientOptions** = `object`
 
-Defined in: [sdk/hasura/src/hasura.ts:28](https://github.com/settlemint/sdk/blob/v2.4.1/sdk/hasura/src/hasura.ts#L28)
+Defined in: [sdk/hasura/src/hasura.ts:27](https://github.com/settlemint/sdk/blob/v2.4.1/sdk/hasura/src/hasura.ts#L27)
 
 Type definition for client options derived from the ClientOptionsSchema.
 
@@ -303,10 +193,10 @@ Type definition for client options derived from the ClientOptionsSchema.
 
 | Name | Type | Default value | Defined in |
 | ------ | ------ | ------ | ------ |
-| <a id="accesstoken"></a> `accessToken?` | `string` | - | [sdk/hasura/src/hasura.ts:20](https://github.com/settlemint/sdk/blob/v2.4.1/sdk/hasura/src/hasura.ts#L20) |
-| <a id="adminsecret"></a> `adminSecret` | `string` | - | [sdk/hasura/src/hasura.ts:21](https://github.com/settlemint/sdk/blob/v2.4.1/sdk/hasura/src/hasura.ts#L21) |
-| <a id="cache"></a> `cache?` | `"default"` \| `"force-cache"` \| `"no-cache"` \| `"no-store"` \| `"only-if-cached"` \| `"reload"` | - | [sdk/hasura/src/hasura.ts:22](https://github.com/settlemint/sdk/blob/v2.4.1/sdk/hasura/src/hasura.ts#L22) |
-| <a id="instance"></a> `instance` | `string` | `UrlOrPathSchema` | [sdk/hasura/src/hasura.ts:19](https://github.com/settlemint/sdk/blob/v2.4.1/sdk/hasura/src/hasura.ts#L19) |
+| <a id="accesstoken"></a> `accessToken?` | `string` | - | [sdk/hasura/src/hasura.ts:19](https://github.com/settlemint/sdk/blob/v2.4.1/sdk/hasura/src/hasura.ts#L19) |
+| <a id="adminsecret"></a> `adminSecret` | `string` | - | [sdk/hasura/src/hasura.ts:20](https://github.com/settlemint/sdk/blob/v2.4.1/sdk/hasura/src/hasura.ts#L20) |
+| <a id="cache"></a> `cache?` | `"default"` \| `"force-cache"` \| `"no-cache"` \| `"no-store"` \| `"only-if-cached"` \| `"reload"` | - | [sdk/hasura/src/hasura.ts:21](https://github.com/settlemint/sdk/blob/v2.4.1/sdk/hasura/src/hasura.ts#L21) |
+| <a id="instance"></a> `instance` | `string` | `UrlOrPathSchema` | [sdk/hasura/src/hasura.ts:18](https://github.com/settlemint/sdk/blob/v2.4.1/sdk/hasura/src/hasura.ts#L18) |
 
 ***
 
@@ -314,7 +204,7 @@ Type definition for client options derived from the ClientOptionsSchema.
 
 > **RequestConfig** = `ConstructorParameters`\<*typeof* `GraphQLClient`\>\[`1`\]
 
-Defined in: [sdk/hasura/src/hasura.ts:13](https://github.com/settlemint/sdk/blob/v2.4.1/sdk/hasura/src/hasura.ts#L13)
+Defined in: [sdk/hasura/src/hasura.ts:12](https://github.com/settlemint/sdk/blob/v2.4.1/sdk/hasura/src/hasura.ts#L12)
 
 Type definition for GraphQL client configuration options
 
@@ -324,7 +214,7 @@ Type definition for GraphQL client configuration options
 
 > `const` **ClientOptionsSchema**: `ZodObject`\<[`ClientOptions`](#clientoptions)\>
 
-Defined in: [sdk/hasura/src/hasura.ts:18](https://github.com/settlemint/sdk/blob/v2.4.1/sdk/hasura/src/hasura.ts#L18)
+Defined in: [sdk/hasura/src/hasura.ts:17](https://github.com/settlemint/sdk/blob/v2.4.1/sdk/hasura/src/hasura.ts#L17)
 
 Schema for validating client options for the Hasura client.
 

package/dist/hasura.cjs

@@ -22,7 +22,6 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 }) : target, mod));
 
 //#endregion
-const __settlemint_sdk_utils = __toESM(require("@settlemint/sdk-utils"));
 const __settlemint_sdk_utils_http = __toESM(require("@settlemint/sdk-utils/http"));
 const __settlemint_sdk_utils_logging = __toESM(require("@settlemint/sdk-utils/logging"));
 const __settlemint_sdk_utils_runtime = __toESM(require("@settlemint/sdk-utils/runtime"));
@@ -31,71 +30,6 @@ const gql_tada = __toESM(require("gql.tada"));
 const graphql_request = __toESM(require("graphql-request"));
 const zod_v4 = __toESM(require("zod/v4"));
 
-//#region src/utils/track-all-tables.ts
-/**
-* Track all tables in a database
-*
-* @param databaseName - The name of the database to track tables for
-* @param options - The client options to use for the Hasura client
-* @returns A promise that resolves to an object with a result property indicating success or failure
-* @example
-* import { trackAllTables } from "@settlemint/sdk-hasura/utils/track-all-tables";
-*
-* const client = createHasuraMetadataClient({
-*   instance: "http://localhost:8080",
-*   accessToken: "test",
-*   adminSecret: "test",
-* });
-*
-* const result = await trackAllTables("default", client);
-* if (result.result === "success") {
-*   console.log("Tables tracked successfully");
-* } else {
-*   console.error("Failed to track tables");
-* }
-*/
-async function trackAllTables(databaseName, client) {
-	const messages = [];
-	const getTablesResult = await client({
-		type: "pg_get_source_tables",
-		args: { source: databaseName }
-	});
-	if (!getTablesResult.ok) {
-		throw new Error(`Failed to get tables: ${JSON.stringify(getTablesResult.data)}`);
-	}
-	const tables = getTablesResult.data;
-	if (tables.length === 0) {
-		return {
-			result: "no-tables",
-			messages
-		};
-	}
-	messages.push(`Found ${tables.length} tables in database "${databaseName}"`);
-	await client({
-		type: "pg_untrack_tables",
-		args: {
-			tables: tables.map((table) => ({ table: table.name })),
-			allow_warnings: true
-		}
-	});
-	const trackResult = await client({
-		type: "pg_track_tables",
-		args: {
-			tables: tables.map((table) => ({ table: table.name })),
-			allow_warnings: true
-		}
-	});
-	if (!trackResult.ok) {
-		throw new Error(`Failed to track tables: ${JSON.stringify(trackResult.data)}`);
-	}
-	messages.push(`Successfully tracked ${tables.length} tables`);
-	return {
-		result: "success",
-		messages
-	};
-}
-
-//#endregion
 //#region src/hasura.ts
 /**
 * Schema for validating client options for the Hasura client.
@@ -183,66 +117,14 @@ function createHasuraClient(options, clientOptions, logger) {
 		graphql
 	};
 }
-/**
-* Creates a Hasura Metadata client
-*
-* @param options - Configuration options for the client
-* @param logger - Optional logger to use for logging the requests
-* @returns A function that can be used to make requests to the Hasura Metadata API
-* @throws Will throw an error if the options fail validation against ClientOptionsSchema
-* @example
-* import { createHasuraMetadataClient } from '@settlemint/sdk-hasura';
-*
-* const client = createHasuraMetadataClient({
-*   instance: process.env.SETTLEMINT_HASURA_ENDPOINT,
-*   accessToken: process.env.SETTLEMINT_ACCESS_TOKEN,
-*   adminSecret: process.env.SETTLEMINT_HASURA_ADMIN_SECRET,
-* });
-*
-* const result = await client({
-*   type: "pg_get_source_tables",
-*   args: {
-*     source: "default",
-*   },
-* });
-*/
-function createHasuraMetadataClient(options, logger) {
-	(0, __settlemint_sdk_utils_runtime.ensureServer)();
-	const validatedOptions = (0, __settlemint_sdk_utils_validation.validate)(ClientOptionsSchema, options);
-	const baseUrl = (0, __settlemint_sdk_utils.extractBaseUrlBeforeSegment)(options.instance, "/v1/graphql");
-	const queryEndpoint = new URL(`${baseUrl}/v1/metadata`).toString();
-	const fetchInstance = logger ? (0, __settlemint_sdk_utils_logging.requestLogger)(logger, "hasura", fetch) : fetch;
-	return async (query) => {
-		const response = await fetchInstance(queryEndpoint, {
-			method: "POST",
-			headers: (0, __settlemint_sdk_utils_http.appendHeaders)({ "Content-Type": "application/json" }, {
-				"x-auth-token": validatedOptions.accessToken,
-				"x-hasura-admin-secret": validatedOptions.adminSecret
-			}),
-			body: JSON.stringify(query)
-		});
-		if (!response.ok) {
-			return {
-				ok: false,
-				data: await response.json()
-			};
-		}
-		return {
-			ok: true,
-			data: await response.json()
-		};
-	};
-}
 
 //#endregion
 exports.ClientOptionsSchema = ClientOptionsSchema;
 exports.createHasuraClient = createHasuraClient;
-exports.createHasuraMetadataClient = createHasuraMetadataClient;
 Object.defineProperty(exports, 'readFragment', {
   enumerable: true,
   get: function () {
     return gql_tada.readFragment;
   }
 });
-exports.trackAllTables = trackAllTables;
 //# sourceMappingURL=hasura.cjs.map

package/dist/hasura.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"hasura.cjs","names":["databaseName: string","client: ReturnType<typeof createHasuraMetadataClient>","messages: string[]","UrlOrPathSchema","options: ClientOptions","clientOptions?: RequestConfig","logger?: Logger","GraphQLClient","query: object"],"sources":["../src/utils/track-all-tables.ts","../src/hasura.ts"],"sourcesContent":["import type { createHasuraMetadataClient } from \"../hasura.js\";\n\n/**\n * Track all tables in a database\n *\n * @param databaseName - The name of the database to track tables for\n * @param options - The client options to use for the Hasura client\n * @returns A promise that resolves to an object with a result property indicating success or failure\n * @example\n * import { trackAllTables } from \"@settlemint/sdk-hasura/utils/track-all-tables\";\n *\n * const client = createHasuraMetadataClient({\n *   instance: \"http://localhost:8080\",\n *   accessToken: \"test\",\n *   adminSecret: \"test\",\n * });\n *\n * const result = await trackAllTables(\"default\", client);\n * if (result.result === \"success\") {\n *   console.log(\"Tables tracked successfully\");\n * } else {\n *   console.error(\"Failed to track tables\");\n * }\n */\nexport async function trackAllTables(\n  databaseName: string,\n  client: ReturnType<typeof createHasuraMetadataClient>,\n): Promise<{ result: \"success\" | \"no-tables\"; messages: string[] }> {\n  const messages: string[] = [];\n\n  // Get all tables using pg_get_source_tables\n  const getTablesResult = await client<\n    Array<{\n      name: string;\n      schema: string;\n    }>\n  >({\n    type: \"pg_get_source_tables\",\n    args: {\n      source: databaseName,\n    },\n  });\n\n  if (!getTablesResult.ok) {\n    throw new Error(`Failed to get tables: ${JSON.stringify(getTablesResult.data)}`);\n  }\n\n  const tables = getTablesResult.data;\n\n  if (tables.length === 0) {\n    return { result: \"no-tables\" as const, messages };\n  }\n\n  messages.push(`Found ${tables.length} tables in database \"${databaseName}\"`);\n\n  // Incase a table is already tracked, untrack it first\n  await client<{ code?: string }>({\n    type: \"pg_untrack_tables\",\n    args: {\n      tables: tables.map((table) => ({\n        table: table.name,\n      })),\n      allow_warnings: true,\n    },\n  });\n\n  // Track all tables\n  const trackResult = await client<{ code?: string }>({\n    type: \"pg_track_tables\",\n    args: {\n      tables: tables.map((table) => ({\n        table: table.name,\n      })),\n      allow_warnings: true,\n    },\n  });\n\n  if (!trackResult.ok) {\n    throw new Error(`Failed to track tables: ${JSON.stringify(trackResult.data)}`);\n  }\n\n  messages.push(`Successfully tracked ${tables.length} tables`);\n\n  return { result: \"success\" as const, messages };\n}\n","import { extractBaseUrlBeforeSegment } from \"@settlemint/sdk-utils\";\nimport { appendHeaders } from \"@settlemint/sdk-utils/http\";\nimport { type Logger, requestLogger } from \"@settlemint/sdk-utils/logging\";\nimport { 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 Hasura client.\n */\nexport const ClientOptionsSchema = z.object({\n  instance: UrlOrPathSchema,\n  accessToken: ApplicationAccessTokenSchema.optional(),\n  adminSecret: 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 * Creates a Hasura GraphQL client with proper type safety using gql.tada\n *\n * @param options - Configuration options for the client\n * @param clientOptions - Optional GraphQL client configuration options\n * @param logger - Optional logger to use for logging the requests\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 { createHasuraClient } from '@settlemint/sdk-hasura';\n * import type { introspection } from \"@schemas/hasura-env\";\n * import { createLogger, requestLogger } from \"@settlemint/sdk-utils/logging\";\n *\n * const logger = createLogger();\n *\n * const { client, graphql } = createHasuraClient<{\n *   introspection: introspection;\n *   disableMasking: true;\n *   scalars: {\n *     timestamp: string;\n *     timestampz: string;\n *     uuid: string;\n *     date: string;\n *     time: string;\n *     jsonb: string;\n *     numeric: string;\n *     interval: string;\n *     geometry: string;\n *     geography: string;\n *   };\n * }>({\n *   instance: process.env.SETTLEMINT_HASURA_ENDPOINT,\n *   accessToken: process.env.SETTLEMINT_ACCESS_TOKEN,\n *   adminSecret: process.env.SETTLEMINT_HASURA_ADMIN_SECRET,\n * }, {\n *   fetch: requestLogger(logger, \"hasura\", fetch) as typeof fetch,\n * });\n *\n * // Making GraphQL queries\n * const query = graphql(`\n *   query GetUsers {\n *     users {\n *       id\n *       name\n *       email\n *     }\n *   }\n * `);\n *\n * const result = await client.request(query);\n */\nexport function createHasuraClient<const Setup extends AbstractSetupSchema>(\n  options: ClientOptions,\n  clientOptions?: RequestConfig,\n  logger?: Logger,\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 = new URL(validatedOptions.instance).toString();\n\n  return {\n    client: new GraphQLClient(fullUrl, {\n      ...clientOptions,\n      headers: appendHeaders(clientOptions?.headers, {\n        \"x-auth-token\": validatedOptions.accessToken,\n        \"x-hasura-admin-secret\": validatedOptions.adminSecret,\n      }),\n      fetch: (logger ? requestLogger(logger, \"hasura\", fetch) : fetch) as typeof fetch,\n    }),\n    graphql,\n  };\n}\n\n/**\n * Creates a Hasura Metadata client\n *\n * @param options - Configuration options for the client\n * @param logger - Optional logger to use for logging the requests\n * @returns A function that can be used to make requests to the Hasura Metadata API\n * @throws Will throw an error if the options fail validation against ClientOptionsSchema\n * @example\n * import { createHasuraMetadataClient } from '@settlemint/sdk-hasura';\n *\n * const client = createHasuraMetadataClient({\n *   instance: process.env.SETTLEMINT_HASURA_ENDPOINT,\n *   accessToken: process.env.SETTLEMINT_ACCESS_TOKEN,\n *   adminSecret: process.env.SETTLEMINT_HASURA_ADMIN_SECRET,\n * });\n *\n * const result = await client({\n *   type: \"pg_get_source_tables\",\n *   args: {\n *     source: \"default\",\n *   },\n * });\n */\nexport function createHasuraMetadataClient(options: ClientOptions, logger?: Logger) {\n  ensureServer();\n  const validatedOptions = validate(ClientOptionsSchema, options);\n  const baseUrl = extractBaseUrlBeforeSegment(options.instance, \"/v1/graphql\");\n  const queryEndpoint = new URL(`${baseUrl}/v1/metadata`).toString();\n  const fetchInstance = logger ? requestLogger(logger, \"hasura\", fetch) : fetch;\n\n  return async <T>(query: object): Promise<{ ok: boolean; data: T }> => {\n    const response = await fetchInstance(queryEndpoint, {\n      method: \"POST\",\n      headers: appendHeaders(\n        { \"Content-Type\": \"application/json\" },\n        {\n          \"x-auth-token\": validatedOptions.accessToken,\n          \"x-hasura-admin-secret\": validatedOptions.adminSecret,\n        },\n      ),\n      body: JSON.stringify(query),\n    });\n\n    if (!response.ok) {\n      return { ok: false, data: (await response.json()) as T };\n    }\n\n    return { ok: true, data: (await response.json()) as T };\n  };\n}\n\nexport type { FragmentOf, ResultOf, VariablesOf } from \"gql.tada\";\nexport { readFragment } from \"gql.tada\";\nexport { trackAllTables } from \"./utils/track-all-tables.js\";\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAwBA,eAAsB,eACpBA,cACAC,QACkE;CAClE,MAAMC,WAAqB,CAAE;CAG7B,MAAM,kBAAkB,MAAM,OAK5B;EACA,MAAM;EACN,MAAM,EACJ,QAAQ,aACT;CACF,EAAC;AAEF,MAAK,gBAAgB,IAAI;AACvB,QAAM,IAAI,OAAO,wBAAwB,KAAK,UAAU,gBAAgB,KAAK,CAAC;CAC/E;CAED,MAAM,SAAS,gBAAgB;AAE/B,KAAI,OAAO,WAAW,GAAG;AACvB,SAAO;GAAE,QAAQ;GAAsB;EAAU;CAClD;AAED,UAAS,MAAM,QAAQ,OAAO,OAAO,uBAAuB,aAAa,GAAG;AAG5E,OAAM,OAA0B;EAC9B,MAAM;EACN,MAAM;GACJ,QAAQ,OAAO,IAAI,CAAC,WAAW,EAC7B,OAAO,MAAM,KACd,GAAE;GACH,gBAAgB;EACjB;CACF,EAAC;CAGF,MAAM,cAAc,MAAM,OAA0B;EAClD,MAAM;EACN,MAAM;GACJ,QAAQ,OAAO,IAAI,CAAC,WAAW,EAC7B,OAAO,MAAM,KACd,GAAE;GACH,gBAAgB;EACjB;CACF,EAAC;AAEF,MAAK,YAAY,IAAI;AACnB,QAAM,IAAI,OAAO,0BAA0B,KAAK,UAAU,YAAY,KAAK,CAAC;CAC7E;AAED,UAAS,MAAM,uBAAuB,OAAO,OAAO,SAAS;AAE7D,QAAO;EAAE,QAAQ;EAAoB;CAAU;AAChD;;;;;;;ACnED,MAAa,sBAAsB,SAAE,OAAO;CAC1C,UAAUC;CACV,aAAa,+DAA6B,UAAU;CACpD,aAAa,SAAE,QAAQ;CACvB,OAAO,SAAE,KAAK;EAAC;EAAW;EAAe;EAAY;EAAY;EAAkB;CAAS,EAAC,CAAC,UAAU;AACzG,EAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4DF,SAAgB,mBACdC,SACAC,eACAC,QAIA;AACA,mDAAc;CACd,MAAM,mBAAmB,gDAAS,qBAAqB,QAAQ;CAC/D,MAAM,UAAU,+BAAwB;CACxC,MAAM,UAAU,IAAI,IAAI,iBAAiB,UAAU,UAAU;AAE7D,QAAO;EACL,QAAQ,IAAIC,8BAAc,SAAS;GACjC,GAAG;GACH,SAAS,+CAAc,eAAe,SAAS;IAC7C,gBAAgB,iBAAiB;IACjC,yBAAyB,iBAAiB;GAC3C,EAAC;GACF,OAAQ,SAAS,kDAAc,QAAQ,UAAU,MAAM,GAAG;EAC3D;EACD;CACD;AACF;;;;;;;;;;;;;;;;;;;;;;;;AAyBD,SAAgB,2BAA2BH,SAAwBE,QAAiB;AAClF,mDAAc;CACd,MAAM,mBAAmB,gDAAS,qBAAqB,QAAQ;CAC/D,MAAM,UAAU,wDAA4B,QAAQ,UAAU,cAAc;CAC5E,MAAM,gBAAgB,IAAI,KAAK,EAAE,QAAQ,eAAe,UAAU;CAClE,MAAM,gBAAgB,SAAS,kDAAc,QAAQ,UAAU,MAAM,GAAG;AAExE,QAAO,OAAUE,UAAqD;EACpE,MAAM,WAAW,MAAM,cAAc,eAAe;GAClD,QAAQ;GACR,SAAS,+CACP,EAAE,gBAAgB,mBAAoB,GACtC;IACE,gBAAgB,iBAAiB;IACjC,yBAAyB,iBAAiB;GAC3C,EACF;GACD,MAAM,KAAK,UAAU,MAAM;EAC5B,EAAC;AAEF,OAAK,SAAS,IAAI;AAChB,UAAO;IAAE,IAAI;IAAO,MAAO,MAAM,SAAS,MAAM;GAAQ;EACzD;AAED,SAAO;GAAE,IAAI;GAAM,MAAO,MAAM,SAAS,MAAM;EAAQ;CACxD;AACF"}
+{"version":3,"file":"hasura.cjs","names":["UrlOrPathSchema","options: ClientOptions","clientOptions?: RequestConfig","logger?: Logger","GraphQLClient"],"sources":["../src/hasura.ts"],"sourcesContent":["import { appendHeaders } from \"@settlemint/sdk-utils/http\";\nimport { type Logger, requestLogger } from \"@settlemint/sdk-utils/logging\";\nimport { 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 Hasura client.\n */\nexport const ClientOptionsSchema = z.object({\n  instance: UrlOrPathSchema,\n  accessToken: ApplicationAccessTokenSchema.optional(),\n  adminSecret: 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 * Creates a Hasura GraphQL client with proper type safety using gql.tada\n *\n * @param options - Configuration options for the client\n * @param clientOptions - Optional GraphQL client configuration options\n * @param logger - Optional logger to use for logging the requests\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 { createHasuraClient } from '@settlemint/sdk-hasura';\n * import type { introspection } from \"@schemas/hasura-env\";\n * import { createLogger, requestLogger } from \"@settlemint/sdk-utils/logging\";\n *\n * const logger = createLogger();\n *\n * const { client, graphql } = createHasuraClient<{\n *   introspection: introspection;\n *   disableMasking: true;\n *   scalars: {\n *     timestamp: string;\n *     timestampz: string;\n *     uuid: string;\n *     date: string;\n *     time: string;\n *     jsonb: string;\n *     numeric: string;\n *     interval: string;\n *     geometry: string;\n *     geography: string;\n *   };\n * }>({\n *   instance: process.env.SETTLEMINT_HASURA_ENDPOINT,\n *   accessToken: process.env.SETTLEMINT_ACCESS_TOKEN,\n *   adminSecret: process.env.SETTLEMINT_HASURA_ADMIN_SECRET,\n * }, {\n *   fetch: requestLogger(logger, \"hasura\", fetch) as typeof fetch,\n * });\n *\n * // Making GraphQL queries\n * const query = graphql(`\n *   query GetUsers {\n *     users {\n *       id\n *       name\n *       email\n *     }\n *   }\n * `);\n *\n * const result = await client.request(query);\n */\nexport function createHasuraClient<const Setup extends AbstractSetupSchema>(\n  options: ClientOptions,\n  clientOptions?: RequestConfig,\n  logger?: Logger,\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 = new URL(validatedOptions.instance).toString();\n\n  return {\n    client: new GraphQLClient(fullUrl, {\n      ...clientOptions,\n      headers: appendHeaders(clientOptions?.headers, {\n        \"x-auth-token\": validatedOptions.accessToken,\n        \"x-hasura-admin-secret\": validatedOptions.adminSecret,\n      }),\n      fetch: (logger ? requestLogger(logger, \"hasura\", fetch) : fetch) as typeof fetch,\n    }),\n    graphql,\n  };\n}\n\nexport { readFragment } from \"gql.tada\";\nexport type { FragmentOf, ResultOf, VariablesOf } from \"gql.tada\";\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgBA,MAAa,sBAAsB,SAAE,OAAO;CAC1C,UAAUA;CACV,aAAa,+DAA6B,UAAU;CACpD,aAAa,SAAE,QAAQ;CACvB,OAAO,SAAE,KAAK;EAAC;EAAW;EAAe;EAAY;EAAY;EAAkB;CAAS,EAAC,CAAC,UAAU;AACzG,EAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4DF,SAAgB,mBACdC,SACAC,eACAC,QAIA;AACA,mDAAc;CACd,MAAM,mBAAmB,gDAAS,qBAAqB,QAAQ;CAC/D,MAAM,UAAU,+BAAwB;CACxC,MAAM,UAAU,IAAI,IAAI,iBAAiB,UAAU,UAAU;AAE7D,QAAO;EACL,QAAQ,IAAIC,8BAAc,SAAS;GACjC,GAAG;GACH,SAAS,+CAAc,eAAe,SAAS;IAC7C,gBAAgB,iBAAiB;IACjC,yBAAyB,iBAAiB;GAC3C,EAAC;GACF,OAAQ,SAAS,kDAAc,QAAQ,UAAU,MAAM,GAAG;EAC3D;EACD;CACD;AACF"}

package/dist/hasura.d.cts

@@ -4,35 +4,6 @@ import { AbstractSetupSchema, FragmentOf, ResultOf, VariablesOf, initGraphQLTada
 import { GraphQLClient } from "graphql-request";
 import { z } from "zod/v4";
 
-//#region src/utils/track-all-tables.d.ts
-
-/**
- * Track all tables in a database
- *
- * @param databaseName - The name of the database to track tables for
- * @param options - The client options to use for the Hasura client
- * @returns A promise that resolves to an object with a result property indicating success or failure
- * @example
- * import { trackAllTables } from "@settlemint/sdk-hasura/utils/track-all-tables";
- *
- * const client = createHasuraMetadataClient({
- *   instance: "http://localhost:8080",
- *   accessToken: "test",
- *   adminSecret: "test",
- * });
- *
- * const result = await trackAllTables("default", client);
- * if (result.result === "success") {
- *   console.log("Tables tracked successfully");
- * } else {
- *   console.error("Failed to track tables");
- * }
- */
-declare function trackAllTables(databaseName: string, client: ReturnType<typeof createHasuraMetadataClient>): Promise<{
-  result: "success" | "no-tables";
-  messages: string[];
-}>;
-//#endregion
 //#region src/hasura.d.ts
 /**
  * Type definition for GraphQL client configuration options
@@ -115,33 +86,6 @@ declare function createHasuraClient<const Setup extends AbstractSetupSchema>(opt
   client: GraphQLClient;
   graphql: initGraphQLTada<Setup>;
 };
-/**
- * Creates a Hasura Metadata client
- *
- * @param options - Configuration options for the client
- * @param logger - Optional logger to use for logging the requests
- * @returns A function that can be used to make requests to the Hasura Metadata API
- * @throws Will throw an error if the options fail validation against ClientOptionsSchema
- * @example
- * import { createHasuraMetadataClient } from '@settlemint/sdk-hasura';
- *
- * const client = createHasuraMetadataClient({
- *   instance: process.env.SETTLEMINT_HASURA_ENDPOINT,
- *   accessToken: process.env.SETTLEMINT_ACCESS_TOKEN,
- *   adminSecret: process.env.SETTLEMINT_HASURA_ADMIN_SECRET,
- * });
- *
- * const result = await client({
- *   type: "pg_get_source_tables",
- *   args: {
- *     source: "default",
- *   },
- * });
- */
-declare function createHasuraMetadataClient(options: ClientOptions, logger?: Logger): <T>(query: object) => Promise<{
-  ok: boolean;
-  data: T;
-}>;
 //#endregion
-export { ClientOptions, ClientOptionsSchema, FragmentOf, RequestConfig, ResultOf, VariablesOf, createHasuraClient, createHasuraMetadataClient, readFragment, trackAllTables };
+export { ClientOptions, ClientOptionsSchema, FragmentOf, RequestConfig, ResultOf, VariablesOf, createHasuraClient, readFragment };
 //# sourceMappingURL=hasura.d.cts.map

package/dist/hasura.d.ts

@@ -4,35 +4,6 @@ import { AbstractSetupSchema, FragmentOf, ResultOf, VariablesOf, initGraphQLTada
 import { GraphQLClient } from "graphql-request";
 import { z } from "zod/v4";
 
-//#region src/utils/track-all-tables.d.ts
-
-/**
- * Track all tables in a database
- *
- * @param databaseName - The name of the database to track tables for
- * @param options - The client options to use for the Hasura client
- * @returns A promise that resolves to an object with a result property indicating success or failure
- * @example
- * import { trackAllTables } from "@settlemint/sdk-hasura/utils/track-all-tables";
- *
- * const client = createHasuraMetadataClient({
- *   instance: "http://localhost:8080",
- *   accessToken: "test",
- *   adminSecret: "test",
- * });
- *
- * const result = await trackAllTables("default", client);
- * if (result.result === "success") {
- *   console.log("Tables tracked successfully");
- * } else {
- *   console.error("Failed to track tables");
- * }
- */
-declare function trackAllTables(databaseName: string, client: ReturnType<typeof createHasuraMetadataClient>): Promise<{
-  result: "success" | "no-tables";
-  messages: string[];
-}>;
-//#endregion
 //#region src/hasura.d.ts
 /**
  * Type definition for GraphQL client configuration options
@@ -115,33 +86,6 @@ declare function createHasuraClient<const Setup extends AbstractSetupSchema>(opt
   client: GraphQLClient;
   graphql: initGraphQLTada<Setup>;
 };
-/**
- * Creates a Hasura Metadata client
- *
- * @param options - Configuration options for the client
- * @param logger - Optional logger to use for logging the requests
- * @returns A function that can be used to make requests to the Hasura Metadata API
- * @throws Will throw an error if the options fail validation against ClientOptionsSchema
- * @example
- * import { createHasuraMetadataClient } from '@settlemint/sdk-hasura';
- *
- * const client = createHasuraMetadataClient({
- *   instance: process.env.SETTLEMINT_HASURA_ENDPOINT,
- *   accessToken: process.env.SETTLEMINT_ACCESS_TOKEN,
- *   adminSecret: process.env.SETTLEMINT_HASURA_ADMIN_SECRET,
- * });
- *
- * const result = await client({
- *   type: "pg_get_source_tables",
- *   args: {
- *     source: "default",
- *   },
- * });
- */
-declare function createHasuraMetadataClient(options: ClientOptions, logger?: Logger): <T>(query: object) => Promise<{
-  ok: boolean;
-  data: T;
-}>;
 //#endregion
-export { ClientOptions, ClientOptionsSchema, FragmentOf, RequestConfig, ResultOf, VariablesOf, createHasuraClient, createHasuraMetadataClient, readFragment, trackAllTables };
+export { ClientOptions, ClientOptionsSchema, FragmentOf, RequestConfig, ResultOf, VariablesOf, createHasuraClient, readFragment };
 //# sourceMappingURL=hasura.d.ts.map

package/dist/hasura.js

@@ -1,5 +1,4 @@
 /* SettleMint Hasura SDK - GraphQL API */
-import { extractBaseUrlBeforeSegment } from "@settlemint/sdk-utils";
 import { appendHeaders } from "@settlemint/sdk-utils/http";
 import { requestLogger } from "@settlemint/sdk-utils/logging";
 import { ensureServer } from "@settlemint/sdk-utils/runtime";
@@ -8,71 +7,6 @@ import { initGraphQLTada, readFragment } from "gql.tada";
 import { GraphQLClient } from "graphql-request";
 import { z } from "zod/v4";
 
-//#region src/utils/track-all-tables.ts
-/**
-* Track all tables in a database
-*
-* @param databaseName - The name of the database to track tables for
-* @param options - The client options to use for the Hasura client
-* @returns A promise that resolves to an object with a result property indicating success or failure
-* @example
-* import { trackAllTables } from "@settlemint/sdk-hasura/utils/track-all-tables";
-*
-* const client = createHasuraMetadataClient({
-*   instance: "http://localhost:8080",
-*   accessToken: "test",
-*   adminSecret: "test",
-* });
-*
-* const result = await trackAllTables("default", client);
-* if (result.result === "success") {
-*   console.log("Tables tracked successfully");
-* } else {
-*   console.error("Failed to track tables");
-* }
-*/
-async function trackAllTables(databaseName, client) {
-	const messages = [];
-	const getTablesResult = await client({
-		type: "pg_get_source_tables",
-		args: { source: databaseName }
-	});
-	if (!getTablesResult.ok) {
-		throw new Error(`Failed to get tables: ${JSON.stringify(getTablesResult.data)}`);
-	}
-	const tables = getTablesResult.data;
-	if (tables.length === 0) {
-		return {
-			result: "no-tables",
-			messages
-		};
-	}
-	messages.push(`Found ${tables.length} tables in database "${databaseName}"`);
-	await client({
-		type: "pg_untrack_tables",
-		args: {
-			tables: tables.map((table) => ({ table: table.name })),
-			allow_warnings: true
-		}
-	});
-	const trackResult = await client({
-		type: "pg_track_tables",
-		args: {
-			tables: tables.map((table) => ({ table: table.name })),
-			allow_warnings: true
-		}
-	});
-	if (!trackResult.ok) {
-		throw new Error(`Failed to track tables: ${JSON.stringify(trackResult.data)}`);
-	}
-	messages.push(`Successfully tracked ${tables.length} tables`);
-	return {
-		result: "success",
-		messages
-	};
-}
-
-//#endregion
 //#region src/hasura.ts
 /**
 * Schema for validating client options for the Hasura client.
@@ -160,57 +94,7 @@ function createHasuraClient(options, clientOptions, logger) {
 		graphql
 	};
 }
-/**
-* Creates a Hasura Metadata client
-*
-* @param options - Configuration options for the client
-* @param logger - Optional logger to use for logging the requests
-* @returns A function that can be used to make requests to the Hasura Metadata API
-* @throws Will throw an error if the options fail validation against ClientOptionsSchema
-* @example
-* import { createHasuraMetadataClient } from '@settlemint/sdk-hasura';
-*
-* const client = createHasuraMetadataClient({
-*   instance: process.env.SETTLEMINT_HASURA_ENDPOINT,
-*   accessToken: process.env.SETTLEMINT_ACCESS_TOKEN,
-*   adminSecret: process.env.SETTLEMINT_HASURA_ADMIN_SECRET,
-* });
-*
-* const result = await client({
-*   type: "pg_get_source_tables",
-*   args: {
-*     source: "default",
-*   },
-* });
-*/
-function createHasuraMetadataClient(options, logger) {
-	ensureServer();
-	const validatedOptions = validate(ClientOptionsSchema, options);
-	const baseUrl = extractBaseUrlBeforeSegment(options.instance, "/v1/graphql");
-	const queryEndpoint = new URL(`${baseUrl}/v1/metadata`).toString();
-	const fetchInstance = logger ? requestLogger(logger, "hasura", fetch) : fetch;
-	return async (query) => {
-		const response = await fetchInstance(queryEndpoint, {
-			method: "POST",
-			headers: appendHeaders({ "Content-Type": "application/json" }, {
-				"x-auth-token": validatedOptions.accessToken,
-				"x-hasura-admin-secret": validatedOptions.adminSecret
-			}),
-			body: JSON.stringify(query)
-		});
-		if (!response.ok) {
-			return {
-				ok: false,
-				data: await response.json()
-			};
-		}
-		return {
-			ok: true,
-			data: await response.json()
-		};
-	};
-}
 
 //#endregion
-export { ClientOptionsSchema, createHasuraClient, createHasuraMetadataClient, readFragment, trackAllTables };
+export { ClientOptionsSchema, createHasuraClient, readFragment };
 //# sourceMappingURL=hasura.js.map

package/dist/hasura.js.map

@@ -1 +1 @@
-{"version":3,"file":"hasura.js","names":["databaseName: string","client: ReturnType<typeof createHasuraMetadataClient>","messages: string[]","options: ClientOptions","clientOptions?: RequestConfig","logger?: Logger","query: object"],"sources":["../src/utils/track-all-tables.ts","../src/hasura.ts"],"sourcesContent":["import type { createHasuraMetadataClient } from \"../hasura.js\";\n\n/**\n * Track all tables in a database\n *\n * @param databaseName - The name of the database to track tables for\n * @param options - The client options to use for the Hasura client\n * @returns A promise that resolves to an object with a result property indicating success or failure\n * @example\n * import { trackAllTables } from \"@settlemint/sdk-hasura/utils/track-all-tables\";\n *\n * const client = createHasuraMetadataClient({\n *   instance: \"http://localhost:8080\",\n *   accessToken: \"test\",\n *   adminSecret: \"test\",\n * });\n *\n * const result = await trackAllTables(\"default\", client);\n * if (result.result === \"success\") {\n *   console.log(\"Tables tracked successfully\");\n * } else {\n *   console.error(\"Failed to track tables\");\n * }\n */\nexport async function trackAllTables(\n  databaseName: string,\n  client: ReturnType<typeof createHasuraMetadataClient>,\n): Promise<{ result: \"success\" | \"no-tables\"; messages: string[] }> {\n  const messages: string[] = [];\n\n  // Get all tables using pg_get_source_tables\n  const getTablesResult = await client<\n    Array<{\n      name: string;\n      schema: string;\n    }>\n  >({\n    type: \"pg_get_source_tables\",\n    args: {\n      source: databaseName,\n    },\n  });\n\n  if (!getTablesResult.ok) {\n    throw new Error(`Failed to get tables: ${JSON.stringify(getTablesResult.data)}`);\n  }\n\n  const tables = getTablesResult.data;\n\n  if (tables.length === 0) {\n    return { result: \"no-tables\" as const, messages };\n  }\n\n  messages.push(`Found ${tables.length} tables in database \"${databaseName}\"`);\n\n  // Incase a table is already tracked, untrack it first\n  await client<{ code?: string }>({\n    type: \"pg_untrack_tables\",\n    args: {\n      tables: tables.map((table) => ({\n        table: table.name,\n      })),\n      allow_warnings: true,\n    },\n  });\n\n  // Track all tables\n  const trackResult = await client<{ code?: string }>({\n    type: \"pg_track_tables\",\n    args: {\n      tables: tables.map((table) => ({\n        table: table.name,\n      })),\n      allow_warnings: true,\n    },\n  });\n\n  if (!trackResult.ok) {\n    throw new Error(`Failed to track tables: ${JSON.stringify(trackResult.data)}`);\n  }\n\n  messages.push(`Successfully tracked ${tables.length} tables`);\n\n  return { result: \"success\" as const, messages };\n}\n","import { extractBaseUrlBeforeSegment } from \"@settlemint/sdk-utils\";\nimport { appendHeaders } from \"@settlemint/sdk-utils/http\";\nimport { type Logger, requestLogger } from \"@settlemint/sdk-utils/logging\";\nimport { 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 Hasura client.\n */\nexport const ClientOptionsSchema = z.object({\n  instance: UrlOrPathSchema,\n  accessToken: ApplicationAccessTokenSchema.optional(),\n  adminSecret: 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 * Creates a Hasura GraphQL client with proper type safety using gql.tada\n *\n * @param options - Configuration options for the client\n * @param clientOptions - Optional GraphQL client configuration options\n * @param logger - Optional logger to use for logging the requests\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 { createHasuraClient } from '@settlemint/sdk-hasura';\n * import type { introspection } from \"@schemas/hasura-env\";\n * import { createLogger, requestLogger } from \"@settlemint/sdk-utils/logging\";\n *\n * const logger = createLogger();\n *\n * const { client, graphql } = createHasuraClient<{\n *   introspection: introspection;\n *   disableMasking: true;\n *   scalars: {\n *     timestamp: string;\n *     timestampz: string;\n *     uuid: string;\n *     date: string;\n *     time: string;\n *     jsonb: string;\n *     numeric: string;\n *     interval: string;\n *     geometry: string;\n *     geography: string;\n *   };\n * }>({\n *   instance: process.env.SETTLEMINT_HASURA_ENDPOINT,\n *   accessToken: process.env.SETTLEMINT_ACCESS_TOKEN,\n *   adminSecret: process.env.SETTLEMINT_HASURA_ADMIN_SECRET,\n * }, {\n *   fetch: requestLogger(logger, \"hasura\", fetch) as typeof fetch,\n * });\n *\n * // Making GraphQL queries\n * const query = graphql(`\n *   query GetUsers {\n *     users {\n *       id\n *       name\n *       email\n *     }\n *   }\n * `);\n *\n * const result = await client.request(query);\n */\nexport function createHasuraClient<const Setup extends AbstractSetupSchema>(\n  options: ClientOptions,\n  clientOptions?: RequestConfig,\n  logger?: Logger,\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 = new URL(validatedOptions.instance).toString();\n\n  return {\n    client: new GraphQLClient(fullUrl, {\n      ...clientOptions,\n      headers: appendHeaders(clientOptions?.headers, {\n        \"x-auth-token\": validatedOptions.accessToken,\n        \"x-hasura-admin-secret\": validatedOptions.adminSecret,\n      }),\n      fetch: (logger ? requestLogger(logger, \"hasura\", fetch) : fetch) as typeof fetch,\n    }),\n    graphql,\n  };\n}\n\n/**\n * Creates a Hasura Metadata client\n *\n * @param options - Configuration options for the client\n * @param logger - Optional logger to use for logging the requests\n * @returns A function that can be used to make requests to the Hasura Metadata API\n * @throws Will throw an error if the options fail validation against ClientOptionsSchema\n * @example\n * import { createHasuraMetadataClient } from '@settlemint/sdk-hasura';\n *\n * const client = createHasuraMetadataClient({\n *   instance: process.env.SETTLEMINT_HASURA_ENDPOINT,\n *   accessToken: process.env.SETTLEMINT_ACCESS_TOKEN,\n *   adminSecret: process.env.SETTLEMINT_HASURA_ADMIN_SECRET,\n * });\n *\n * const result = await client({\n *   type: \"pg_get_source_tables\",\n *   args: {\n *     source: \"default\",\n *   },\n * });\n */\nexport function createHasuraMetadataClient(options: ClientOptions, logger?: Logger) {\n  ensureServer();\n  const validatedOptions = validate(ClientOptionsSchema, options);\n  const baseUrl = extractBaseUrlBeforeSegment(options.instance, \"/v1/graphql\");\n  const queryEndpoint = new URL(`${baseUrl}/v1/metadata`).toString();\n  const fetchInstance = logger ? requestLogger(logger, \"hasura\", fetch) : fetch;\n\n  return async <T>(query: object): Promise<{ ok: boolean; data: T }> => {\n    const response = await fetchInstance(queryEndpoint, {\n      method: \"POST\",\n      headers: appendHeaders(\n        { \"Content-Type\": \"application/json\" },\n        {\n          \"x-auth-token\": validatedOptions.accessToken,\n          \"x-hasura-admin-secret\": validatedOptions.adminSecret,\n        },\n      ),\n      body: JSON.stringify(query),\n    });\n\n    if (!response.ok) {\n      return { ok: false, data: (await response.json()) as T };\n    }\n\n    return { ok: true, data: (await response.json()) as T };\n  };\n}\n\nexport type { FragmentOf, ResultOf, VariablesOf } from \"gql.tada\";\nexport { readFragment } from \"gql.tada\";\nexport { trackAllTables } from \"./utils/track-all-tables.js\";\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAwBA,eAAsB,eACpBA,cACAC,QACkE;CAClE,MAAMC,WAAqB,CAAE;CAG7B,MAAM,kBAAkB,MAAM,OAK5B;EACA,MAAM;EACN,MAAM,EACJ,QAAQ,aACT;CACF,EAAC;AAEF,MAAK,gBAAgB,IAAI;AACvB,QAAM,IAAI,OAAO,wBAAwB,KAAK,UAAU,gBAAgB,KAAK,CAAC;CAC/E;CAED,MAAM,SAAS,gBAAgB;AAE/B,KAAI,OAAO,WAAW,GAAG;AACvB,SAAO;GAAE,QAAQ;GAAsB;EAAU;CAClD;AAED,UAAS,MAAM,QAAQ,OAAO,OAAO,uBAAuB,aAAa,GAAG;AAG5E,OAAM,OAA0B;EAC9B,MAAM;EACN,MAAM;GACJ,QAAQ,OAAO,IAAI,CAAC,WAAW,EAC7B,OAAO,MAAM,KACd,GAAE;GACH,gBAAgB;EACjB;CACF,EAAC;CAGF,MAAM,cAAc,MAAM,OAA0B;EAClD,MAAM;EACN,MAAM;GACJ,QAAQ,OAAO,IAAI,CAAC,WAAW,EAC7B,OAAO,MAAM,KACd,GAAE;GACH,gBAAgB;EACjB;CACF,EAAC;AAEF,MAAK,YAAY,IAAI;AACnB,QAAM,IAAI,OAAO,0BAA0B,KAAK,UAAU,YAAY,KAAK,CAAC;CAC7E;AAED,UAAS,MAAM,uBAAuB,OAAO,OAAO,SAAS;AAE7D,QAAO;EAAE,QAAQ;EAAoB;CAAU;AAChD;;;;;;;ACnED,MAAa,sBAAsB,EAAE,OAAO;CAC1C,UAAU;CACV,aAAa,6BAA6B,UAAU;CACpD,aAAa,EAAE,QAAQ;CACvB,OAAO,EAAE,KAAK;EAAC;EAAW;EAAe;EAAY;EAAY;EAAkB;CAAS,EAAC,CAAC,UAAU;AACzG,EAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4DF,SAAgB,mBACdC,SACAC,eACAC,QAIA;AACA,eAAc;CACd,MAAM,mBAAmB,SAAS,qBAAqB,QAAQ;CAC/D,MAAM,UAAU,iBAAwB;CACxC,MAAM,UAAU,IAAI,IAAI,iBAAiB,UAAU,UAAU;AAE7D,QAAO;EACL,QAAQ,IAAI,cAAc,SAAS;GACjC,GAAG;GACH,SAAS,cAAc,eAAe,SAAS;IAC7C,gBAAgB,iBAAiB;IACjC,yBAAyB,iBAAiB;GAC3C,EAAC;GACF,OAAQ,SAAS,cAAc,QAAQ,UAAU,MAAM,GAAG;EAC3D;EACD;CACD;AACF;;;;;;;;;;;;;;;;;;;;;;;;AAyBD,SAAgB,2BAA2BF,SAAwBE,QAAiB;AAClF,eAAc;CACd,MAAM,mBAAmB,SAAS,qBAAqB,QAAQ;CAC/D,MAAM,UAAU,4BAA4B,QAAQ,UAAU,cAAc;CAC5E,MAAM,gBAAgB,IAAI,KAAK,EAAE,QAAQ,eAAe,UAAU;CAClE,MAAM,gBAAgB,SAAS,cAAc,QAAQ,UAAU,MAAM,GAAG;AAExE,QAAO,OAAUC,UAAqD;EACpE,MAAM,WAAW,MAAM,cAAc,eAAe;GAClD,QAAQ;GACR,SAAS,cACP,EAAE,gBAAgB,mBAAoB,GACtC;IACE,gBAAgB,iBAAiB;IACjC,yBAAyB,iBAAiB;GAC3C,EACF;GACD,MAAM,KAAK,UAAU,MAAM;EAC5B,EAAC;AAEF,OAAK,SAAS,IAAI;AAChB,UAAO;IAAE,IAAI;IAAO,MAAO,MAAM,SAAS,MAAM;GAAQ;EACzD;AAED,SAAO;GAAE,IAAI;GAAM,MAAO,MAAM,SAAS,MAAM;EAAQ;CACxD;AACF"}
+{"version":3,"file":"hasura.js","names":["options: ClientOptions","clientOptions?: RequestConfig","logger?: Logger"],"sources":["../src/hasura.ts"],"sourcesContent":["import { appendHeaders } from \"@settlemint/sdk-utils/http\";\nimport { type Logger, requestLogger } from \"@settlemint/sdk-utils/logging\";\nimport { 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 Hasura client.\n */\nexport const ClientOptionsSchema = z.object({\n  instance: UrlOrPathSchema,\n  accessToken: ApplicationAccessTokenSchema.optional(),\n  adminSecret: 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 * Creates a Hasura GraphQL client with proper type safety using gql.tada\n *\n * @param options - Configuration options for the client\n * @param clientOptions - Optional GraphQL client configuration options\n * @param logger - Optional logger to use for logging the requests\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 { createHasuraClient } from '@settlemint/sdk-hasura';\n * import type { introspection } from \"@schemas/hasura-env\";\n * import { createLogger, requestLogger } from \"@settlemint/sdk-utils/logging\";\n *\n * const logger = createLogger();\n *\n * const { client, graphql } = createHasuraClient<{\n *   introspection: introspection;\n *   disableMasking: true;\n *   scalars: {\n *     timestamp: string;\n *     timestampz: string;\n *     uuid: string;\n *     date: string;\n *     time: string;\n *     jsonb: string;\n *     numeric: string;\n *     interval: string;\n *     geometry: string;\n *     geography: string;\n *   };\n * }>({\n *   instance: process.env.SETTLEMINT_HASURA_ENDPOINT,\n *   accessToken: process.env.SETTLEMINT_ACCESS_TOKEN,\n *   adminSecret: process.env.SETTLEMINT_HASURA_ADMIN_SECRET,\n * }, {\n *   fetch: requestLogger(logger, \"hasura\", fetch) as typeof fetch,\n * });\n *\n * // Making GraphQL queries\n * const query = graphql(`\n *   query GetUsers {\n *     users {\n *       id\n *       name\n *       email\n *     }\n *   }\n * `);\n *\n * const result = await client.request(query);\n */\nexport function createHasuraClient<const Setup extends AbstractSetupSchema>(\n  options: ClientOptions,\n  clientOptions?: RequestConfig,\n  logger?: Logger,\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 = new URL(validatedOptions.instance).toString();\n\n  return {\n    client: new GraphQLClient(fullUrl, {\n      ...clientOptions,\n      headers: appendHeaders(clientOptions?.headers, {\n        \"x-auth-token\": validatedOptions.accessToken,\n        \"x-hasura-admin-secret\": validatedOptions.adminSecret,\n      }),\n      fetch: (logger ? requestLogger(logger, \"hasura\", fetch) : fetch) as typeof fetch,\n    }),\n    graphql,\n  };\n}\n\nexport { readFragment } from \"gql.tada\";\nexport type { FragmentOf, ResultOf, VariablesOf } from \"gql.tada\";\n"],"mappings":";;;;;;;;;;;;;AAgBA,MAAa,sBAAsB,EAAE,OAAO;CAC1C,UAAU;CACV,aAAa,6BAA6B,UAAU;CACpD,aAAa,EAAE,QAAQ;CACvB,OAAO,EAAE,KAAK;EAAC;EAAW;EAAe;EAAY;EAAY;EAAkB;CAAS,EAAC,CAAC,UAAU;AACzG,EAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4DF,SAAgB,mBACdA,SACAC,eACAC,QAIA;AACA,eAAc;CACd,MAAM,mBAAmB,SAAS,qBAAqB,QAAQ;CAC/D,MAAM,UAAU,iBAAwB;CACxC,MAAM,UAAU,IAAI,IAAI,iBAAiB,UAAU,UAAU;AAE7D,QAAO;EACL,QAAQ,IAAI,cAAc,SAAS;GACjC,GAAG;GACH,SAAS,cAAc,eAAe,SAAS;IAC7C,gBAAgB,iBAAiB;IACjC,yBAAyB,iBAAiB;GAC3C,EAAC;GACF,OAAQ,SAAS,cAAc,QAAQ,UAAU,MAAM,GAAG;EAC3D;EACD;CACD;AACF"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@settlemint/sdk-hasura",
   "description": "Hasura and PostgreSQL integration module for SettleMint SDK, enabling database operations and GraphQL queries",
-  "version": "2.4.1-pr6c40584b",
+  "version": "2.4.1-pr79cb50b0",
   "type": "module",
   "private": false,
   "license": "FSL-1.1-MIT",
@@ -66,7 +66,7 @@
   },
   "dependencies": {
     "gql.tada": "^1",
-    "@settlemint/sdk-utils": "2.4.1-pr6c40584b",
+    "@settlemint/sdk-utils": "2.4.1-pr79cb50b0",
     "graphql-request": "^7",
     "zod": "^3.25.0",
     "drizzle-orm": "^0.44.0",