@settlemint/sdk-hasura 2.4.1-pr9f357314 → 2.4.1-pra16d0163

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-pr9f357314",
+  "version": "2.4.1-pra16d0163",
   "type": "module",
   "private": false,
   "license": "FSL-1.1-MIT",
@@ -66,7 +66,7 @@
   },
   "dependencies": {
     "gql.tada": "^1",
-    "@settlemint/sdk-utils": "2.4.1-pr9f357314",
+    "@settlemint/sdk-utils": "2.4.1-pra16d0163",
     "graphql-request": "^7",
     "zod": "^3.25.0",
     "drizzle-orm": "^0.44.0",