@settlemint/sdk-hasura 2.4.1 → 2.5.1-maine2c05e47

package/README.md

@@ -30,7 +30,9 @@
 - [API Reference](#api-reference)
   - [Functions](#functions)
     - [createHasuraClient()](#createhasuraclient)
+    - [createHasuraMetadataClient()](#createhasurametadataclient)
     - [createPostgresPool()](#createpostgrespool)
+    - [trackAllTables()](#trackalltables)
   - [Type Aliases](#type-aliases)
     - [ClientOptions](#clientoptions)
     - [RequestConfig](#requestconfig)
@@ -51,7 +53,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:82](https://github.com/settlemint/sdk/blob/v2.4.1/sdk/hasura/src/hasura.ts#L82)
+Defined in: [sdk/hasura/src/hasura.ts:83](https://github.com/settlemint/sdk/blob/v2.5.1/sdk/hasura/src/hasura.ts#L83)
 
 Creates a Hasura GraphQL client with proper type safety using gql.tada
 
@@ -83,8 +85,8 @@ An object containing:
 
 | Name | Type | Defined in |
 | ------ | ------ | ------ |
-| `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) |
+| `client` | `GraphQLClient` | [sdk/hasura/src/hasura.ts:88](https://github.com/settlemint/sdk/blob/v2.5.1/sdk/hasura/src/hasura.ts#L88) |
+| `graphql` | `initGraphQLTada`\<`Setup`\> | [sdk/hasura/src/hasura.ts:89](https://github.com/settlemint/sdk/blob/v2.5.1/sdk/hasura/src/hasura.ts#L89) |
 
 ##### Throws
 
@@ -138,11 +140,77 @@ 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.5.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`
 
-Defined in: [sdk/hasura/src/postgres.ts:107](https://github.com/settlemint/sdk/blob/v2.4.1/sdk/hasura/src/postgres.ts#L107)
+Defined in: [sdk/hasura/src/postgres.ts:107](https://github.com/settlemint/sdk/blob/v2.5.1/sdk/hasura/src/postgres.ts#L107)
 
 Creates a PostgreSQL connection pool with error handling and retry mechanisms
 
@@ -179,13 +247,60 @@ try {
 }
 ```
 
+***
+
+#### trackAllTables()
+
+> **trackAllTables**(`databaseName`, `client`, `tableOptions`): `Promise`\<\{ `messages`: `string`[]; `result`: `"success"` \| `"no-tables"`; \}\>
+
+Defined in: [sdk/hasura/src/utils/track-all-tables.ts:30](https://github.com/settlemint/sdk/blob/v2.5.1/sdk/hasura/src/utils/track-all-tables.ts#L30)
+
+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`; \}\> | The client options to use for the Hasura client |
+| `tableOptions` | \{ `excludeSchemas?`: `string`[]; `includeSchemas?`: `string`[]; \} | The options to use for the table tracking |
+| `tableOptions.excludeSchemas?` | `string`[] | The schemas to exclude from the tracking |
+| `tableOptions.includeSchemas?` | `string`[] | The schemas to include in the tracking |
+
+##### 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, {
+  excludeSchemas: ["drizzle"],
+});
+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:27](https://github.com/settlemint/sdk/blob/v2.4.1/sdk/hasura/src/hasura.ts#L27)
+Defined in: [sdk/hasura/src/hasura.ts:28](https://github.com/settlemint/sdk/blob/v2.5.1/sdk/hasura/src/hasura.ts#L28)
 
 Type definition for client options derived from the ClientOptionsSchema.
 
@@ -193,10 +308,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: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) |
+| <a id="accesstoken"></a> `accessToken?` | `string` | - | [sdk/hasura/src/hasura.ts:20](https://github.com/settlemint/sdk/blob/v2.5.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.5.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.5.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.5.1/sdk/hasura/src/hasura.ts#L19) |
 
 ***
 
@@ -204,7 +319,7 @@ Type definition for client options derived from the ClientOptionsSchema.
 
 > **RequestConfig** = `ConstructorParameters`\<*typeof* `GraphQLClient`\>\[`1`\]
 
-Defined in: [sdk/hasura/src/hasura.ts:12](https://github.com/settlemint/sdk/blob/v2.4.1/sdk/hasura/src/hasura.ts#L12)
+Defined in: [sdk/hasura/src/hasura.ts:13](https://github.com/settlemint/sdk/blob/v2.5.1/sdk/hasura/src/hasura.ts#L13)
 
 Type definition for GraphQL client configuration options
 
@@ -214,7 +329,7 @@ Type definition for GraphQL client configuration options
 
 > `const` **ClientOptionsSchema**: `ZodObject`\<[`ClientOptions`](#clientoptions)\>
 
-Defined in: [sdk/hasura/src/hasura.ts:17](https://github.com/settlemint/sdk/blob/v2.4.1/sdk/hasura/src/hasura.ts#L17)
+Defined in: [sdk/hasura/src/hasura.ts:18](https://github.com/settlemint/sdk/blob/v2.5.1/sdk/hasura/src/hasura.ts#L18)
 
 Schema for validating client options for the Hasura client.
 

package/dist/hasura.cjs

@@ -22,6 +22,7 @@ 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"));
@@ -30,6 +31,89 @@ 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 client - The client options to use for the Hasura client
+* @param tableOptions - The options to use for the table tracking
+* @param tableOptions.includeSchemas - The schemas to include in the tracking
+* @param tableOptions.excludeSchemas - The schemas to exclude from the tracking
+* @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, {
+*   excludeSchemas: ["drizzle"],
+* });
+* if (result.result === "success") {
+*   console.log("Tables tracked successfully");
+* } else {
+*   console.error("Failed to track tables");
+* }
+*/
+async function trackAllTables(databaseName, client, tableOptions = {
+	includeSchemas: undefined,
+	excludeSchemas: undefined
+}) {
+	const messages = [];
+	const { includeSchemas, excludeSchemas } = tableOptions;
+	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 })),
+			allow_warnings: true
+		}
+	});
+	const tablesToTrack = tables.filter((table) => {
+		if (Array.isArray(includeSchemas)) {
+			return includeSchemas.includes(table.schema);
+		}
+		if (Array.isArray(excludeSchemas)) {
+			return !excludeSchemas.includes(table.schema);
+		}
+		return true;
+	});
+	const trackResult = await client({
+		type: "pg_track_tables",
+		args: {
+			tables: tablesToTrack.map((table) => ({ table })),
+			allow_warnings: true
+		}
+	});
+	if (!trackResult.ok) {
+		throw new Error(`Failed to track tables: ${JSON.stringify(trackResult.data)}`);
+	}
+	messages.push(`Successfully tracked ${tablesToTrack.length} tables`);
+	return {
+		result: "success",
+		messages
+	};
+}
+
+//#endregion
 //#region src/hasura.ts
 /**
 * Schema for validating client options for the Hasura client.
@@ -117,14 +201,66 @@ 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":["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"}
+{"version":3,"file":"hasura.cjs","names":["databaseName: string","client: ReturnType<typeof createHasuraMetadataClient>","tableOptions: {\n    includeSchemas?: string[];\n    excludeSchemas?: string[];\n  }","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 client - The client options to use for the Hasura client\n * @param tableOptions - The options to use for the table tracking\n * @param tableOptions.includeSchemas - The schemas to include in the tracking\n * @param tableOptions.excludeSchemas - The schemas to exclude from the tracking\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 *   excludeSchemas: [\"drizzle\"],\n * });\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  tableOptions: {\n    includeSchemas?: string[];\n    excludeSchemas?: string[];\n  } = {\n    includeSchemas: undefined,\n    excludeSchemas: undefined,\n  },\n): Promise<{ result: \"success\" | \"no-tables\"; messages: string[] }> {\n  const messages: string[] = [];\n\n  const { includeSchemas, excludeSchemas } = tableOptions;\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,\n      })),\n      allow_warnings: true,\n    },\n  });\n\n  const tablesToTrack = tables.filter((table) => {\n    if (Array.isArray(includeSchemas)) {\n      return includeSchemas.includes(table.schema);\n    }\n    if (Array.isArray(excludeSchemas)) {\n      return !excludeSchemas.includes(table.schema);\n    }\n    return true;\n  });\n\n  // Track all tables\n  const trackResult = await client<{ code?: string }>({\n    type: \"pg_track_tables\",\n    args: {\n      tables: tablesToTrack.map((table) => ({\n        table: table,\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 ${tablesToTrack.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":"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"}

package/dist/hasura.d.cts

@@ -4,6 +4,43 @@ 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 client - The client options to use for the Hasura client
+ * @param tableOptions - The options to use for the table tracking
+ * @param tableOptions.includeSchemas - The schemas to include in the tracking
+ * @param tableOptions.excludeSchemas - The schemas to exclude from the tracking
+ * @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, {
+ *   excludeSchemas: ["drizzle"],
+ * });
+ * 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>, tableOptions?: {
+  includeSchemas?: string[];
+  excludeSchemas?: string[];
+}): Promise<{
+  result: "success" | "no-tables";
+  messages: string[];
+}>;
+//#endregion
 //#region src/hasura.d.ts
 /**
  * Type definition for GraphQL client configuration options
@@ -86,6 +123,33 @@ 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, readFragment };
+export { ClientOptions, ClientOptionsSchema, FragmentOf, RequestConfig, ResultOf, VariablesOf, createHasuraClient, createHasuraMetadataClient, readFragment, trackAllTables };
 //# sourceMappingURL=hasura.d.cts.map

package/dist/hasura.d.ts

@@ -4,6 +4,43 @@ 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 client - The client options to use for the Hasura client
+ * @param tableOptions - The options to use for the table tracking
+ * @param tableOptions.includeSchemas - The schemas to include in the tracking
+ * @param tableOptions.excludeSchemas - The schemas to exclude from the tracking
+ * @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, {
+ *   excludeSchemas: ["drizzle"],
+ * });
+ * 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>, tableOptions?: {
+  includeSchemas?: string[];
+  excludeSchemas?: string[];
+}): Promise<{
+  result: "success" | "no-tables";
+  messages: string[];
+}>;
+//#endregion
 //#region src/hasura.d.ts
 /**
  * Type definition for GraphQL client configuration options
@@ -86,6 +123,33 @@ 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, readFragment };
+export { ClientOptions, ClientOptionsSchema, FragmentOf, RequestConfig, ResultOf, VariablesOf, createHasuraClient, createHasuraMetadataClient, readFragment, trackAllTables };
 //# sourceMappingURL=hasura.d.ts.map

package/dist/hasura.js

@@ -1,4 +1,5 @@
 /* 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";
@@ -7,6 +8,89 @@ 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 client - The client options to use for the Hasura client
+* @param tableOptions - The options to use for the table tracking
+* @param tableOptions.includeSchemas - The schemas to include in the tracking
+* @param tableOptions.excludeSchemas - The schemas to exclude from the tracking
+* @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, {
+*   excludeSchemas: ["drizzle"],
+* });
+* if (result.result === "success") {
+*   console.log("Tables tracked successfully");
+* } else {
+*   console.error("Failed to track tables");
+* }
+*/
+async function trackAllTables(databaseName, client, tableOptions = {
+	includeSchemas: undefined,
+	excludeSchemas: undefined
+}) {
+	const messages = [];
+	const { includeSchemas, excludeSchemas } = tableOptions;
+	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 })),
+			allow_warnings: true
+		}
+	});
+	const tablesToTrack = tables.filter((table) => {
+		if (Array.isArray(includeSchemas)) {
+			return includeSchemas.includes(table.schema);
+		}
+		if (Array.isArray(excludeSchemas)) {
+			return !excludeSchemas.includes(table.schema);
+		}
+		return true;
+	});
+	const trackResult = await client({
+		type: "pg_track_tables",
+		args: {
+			tables: tablesToTrack.map((table) => ({ table })),
+			allow_warnings: true
+		}
+	});
+	if (!trackResult.ok) {
+		throw new Error(`Failed to track tables: ${JSON.stringify(trackResult.data)}`);
+	}
+	messages.push(`Successfully tracked ${tablesToTrack.length} tables`);
+	return {
+		result: "success",
+		messages
+	};
+}
+
+//#endregion
 //#region src/hasura.ts
 /**
 * Schema for validating client options for the Hasura client.
@@ -94,7 +178,57 @@ 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, readFragment };
+export { ClientOptionsSchema, createHasuraClient, createHasuraMetadataClient, readFragment, trackAllTables };
 //# sourceMappingURL=hasura.js.map

package/dist/hasura.js.map

@@ -1 +1 @@
-{"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"}
+{"version":3,"file":"hasura.js","names":["databaseName: string","client: ReturnType<typeof createHasuraMetadataClient>","tableOptions: {\n    includeSchemas?: string[];\n    excludeSchemas?: string[];\n  }","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 client - The client options to use for the Hasura client\n * @param tableOptions - The options to use for the table tracking\n * @param tableOptions.includeSchemas - The schemas to include in the tracking\n * @param tableOptions.excludeSchemas - The schemas to exclude from the tracking\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 *   excludeSchemas: [\"drizzle\"],\n * });\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  tableOptions: {\n    includeSchemas?: string[];\n    excludeSchemas?: string[];\n  } = {\n    includeSchemas: undefined,\n    excludeSchemas: undefined,\n  },\n): Promise<{ result: \"success\" | \"no-tables\"; messages: string[] }> {\n  const messages: string[] = [];\n\n  const { includeSchemas, excludeSchemas } = tableOptions;\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,\n      })),\n      allow_warnings: true,\n    },\n  });\n\n  const tablesToTrack = tables.filter((table) => {\n    if (Array.isArray(includeSchemas)) {\n      return includeSchemas.includes(table.schema);\n    }\n    if (Array.isArray(excludeSchemas)) {\n      return !excludeSchemas.includes(table.schema);\n    }\n    return true;\n  });\n\n  // Track all tables\n  const trackResult = await client<{ code?: string }>({\n    type: \"pg_track_tables\",\n    args: {\n      tables: tablesToTrack.map((table) => ({\n        table: table,\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 ${tablesToTrack.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":"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"}

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