@0xobelisk/graphql-client 1.2.0-pre.24

package/dist/index.mjs

@@ -0,0 +1,1560 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined")
+    return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+
+// src/client.ts
+import {
+  ApolloClient,
+  InMemoryCache,
+  gql,
+  createHttpLink,
+  split,
+  Observable,
+  from
+} from "@apollo/client";
+import { RetryLink } from "@apollo/client/link/retry";
+import { GraphQLWsLink } from "@apollo/client/link/subscriptions";
+import { getMainDefinition } from "@apollo/client/utilities";
+
+// ../../node_modules/.pnpm/graphql-ws@6.0.5_graphql@15.10.1_ws@8.18.2/node_modules/graphql-ws/dist/common-CGW11Fyb.js
+function extendedTypeof(val) {
+  if (val === null) {
+    return "null";
+  }
+  if (Array.isArray(val)) {
+    return "array";
+  }
+  return typeof val;
+}
+function isObject(val) {
+  return extendedTypeof(val) === "object";
+}
+function areGraphQLFormattedErrors(obj) {
+  return Array.isArray(obj) && // must be at least one error
+  obj.length > 0 && // error has at least a message
+  obj.every((ob) => "message" in ob);
+}
+function limitCloseReason(reason, whenTooLong) {
+  return reason.length < 124 ? reason : whenTooLong;
+}
+var GRAPHQL_TRANSPORT_WS_PROTOCOL = "graphql-transport-ws";
+var CloseCode = /* @__PURE__ */ ((CloseCode2) => {
+  CloseCode2[CloseCode2["InternalServerError"] = 4500] = "InternalServerError";
+  CloseCode2[CloseCode2["InternalClientError"] = 4005] = "InternalClientError";
+  CloseCode2[CloseCode2["BadRequest"] = 4400] = "BadRequest";
+  CloseCode2[CloseCode2["BadResponse"] = 4004] = "BadResponse";
+  CloseCode2[CloseCode2["Unauthorized"] = 4401] = "Unauthorized";
+  CloseCode2[CloseCode2["Forbidden"] = 4403] = "Forbidden";
+  CloseCode2[CloseCode2["SubprotocolNotAcceptable"] = 4406] = "SubprotocolNotAcceptable";
+  CloseCode2[CloseCode2["ConnectionInitialisationTimeout"] = 4408] = "ConnectionInitialisationTimeout";
+  CloseCode2[CloseCode2["ConnectionAcknowledgementTimeout"] = 4504] = "ConnectionAcknowledgementTimeout";
+  CloseCode2[CloseCode2["SubscriberAlreadyExists"] = 4409] = "SubscriberAlreadyExists";
+  CloseCode2[CloseCode2["TooManyInitialisationRequests"] = 4429] = "TooManyInitialisationRequests";
+  return CloseCode2;
+})(CloseCode || {});
+var MessageType = /* @__PURE__ */ ((MessageType2) => {
+  MessageType2["ConnectionInit"] = "connection_init";
+  MessageType2["ConnectionAck"] = "connection_ack";
+  MessageType2["Ping"] = "ping";
+  MessageType2["Pong"] = "pong";
+  MessageType2["Subscribe"] = "subscribe";
+  MessageType2["Next"] = "next";
+  MessageType2["Error"] = "error";
+  MessageType2["Complete"] = "complete";
+  return MessageType2;
+})(MessageType || {});
+function validateMessage(val) {
+  if (!isObject(val)) {
+    throw new Error(
+      `Message is expected to be an object, but got ${extendedTypeof(val)}`
+    );
+  }
+  if (!val.type) {
+    throw new Error(`Message is missing the 'type' property`);
+  }
+  if (typeof val.type !== "string") {
+    throw new Error(
+      `Message is expects the 'type' property to be a string, but got ${extendedTypeof(
+        val.type
+      )}`
+    );
+  }
+  switch (val.type) {
+    case "connection_init":
+    case "connection_ack":
+    case "ping":
+    case "pong": {
+      if (val.payload != null && !isObject(val.payload)) {
+        throw new Error(
+          `"${val.type}" message expects the 'payload' property to be an object or nullish or missing, but got "${val.payload}"`
+        );
+      }
+      break;
+    }
+    case "subscribe": {
+      if (typeof val.id !== "string") {
+        throw new Error(
+          `"${val.type}" message expects the 'id' property to be a string, but got ${extendedTypeof(
+            val.id
+          )}`
+        );
+      }
+      if (!val.id) {
+        throw new Error(
+          `"${val.type}" message requires a non-empty 'id' property`
+        );
+      }
+      if (!isObject(val.payload)) {
+        throw new Error(
+          `"${val.type}" message expects the 'payload' property to be an object, but got ${extendedTypeof(
+            val.payload
+          )}`
+        );
+      }
+      if (typeof val.payload.query !== "string") {
+        throw new Error(
+          `"${val.type}" message payload expects the 'query' property to be a string, but got ${extendedTypeof(
+            val.payload.query
+          )}`
+        );
+      }
+      if (val.payload.variables != null && !isObject(val.payload.variables)) {
+        throw new Error(
+          `"${val.type}" message payload expects the 'variables' property to be a an object or nullish or missing, but got ${extendedTypeof(
+            val.payload.variables
+          )}`
+        );
+      }
+      if (val.payload.operationName != null && extendedTypeof(val.payload.operationName) !== "string") {
+        throw new Error(
+          `"${val.type}" message payload expects the 'operationName' property to be a string or nullish or missing, but got ${extendedTypeof(
+            val.payload.operationName
+          )}`
+        );
+      }
+      if (val.payload.extensions != null && !isObject(val.payload.extensions)) {
+        throw new Error(
+          `"${val.type}" message payload expects the 'extensions' property to be a an object or nullish or missing, but got ${extendedTypeof(
+            val.payload.extensions
+          )}`
+        );
+      }
+      break;
+    }
+    case "next": {
+      if (typeof val.id !== "string") {
+        throw new Error(
+          `"${val.type}" message expects the 'id' property to be a string, but got ${extendedTypeof(
+            val.id
+          )}`
+        );
+      }
+      if (!val.id) {
+        throw new Error(
+          `"${val.type}" message requires a non-empty 'id' property`
+        );
+      }
+      if (!isObject(val.payload)) {
+        throw new Error(
+          `"${val.type}" message expects the 'payload' property to be an object, but got ${extendedTypeof(
+            val.payload
+          )}`
+        );
+      }
+      break;
+    }
+    case "error": {
+      if (typeof val.id !== "string") {
+        throw new Error(
+          `"${val.type}" message expects the 'id' property to be a string, but got ${extendedTypeof(
+            val.id
+          )}`
+        );
+      }
+      if (!val.id) {
+        throw new Error(
+          `"${val.type}" message requires a non-empty 'id' property`
+        );
+      }
+      if (!areGraphQLFormattedErrors(val.payload)) {
+        throw new Error(
+          `"${val.type}" message expects the 'payload' property to be an array of GraphQL errors, but got ${JSON.stringify(
+            val.payload
+          )}`
+        );
+      }
+      break;
+    }
+    case "complete": {
+      if (typeof val.id !== "string") {
+        throw new Error(
+          `"${val.type}" message expects the 'id' property to be a string, but got ${extendedTypeof(
+            val.id
+          )}`
+        );
+      }
+      if (!val.id) {
+        throw new Error(
+          `"${val.type}" message requires a non-empty 'id' property`
+        );
+      }
+      break;
+    }
+    default:
+      throw new Error(`Invalid message 'type' property "${val.type}"`);
+  }
+  return val;
+}
+function parseMessage(data, reviver) {
+  return validateMessage(
+    typeof data === "string" ? JSON.parse(data, reviver) : data
+  );
+}
+function stringifyMessage(msg, replacer) {
+  validateMessage(msg);
+  return JSON.stringify(msg, replacer);
+}
+
+// ../../node_modules/.pnpm/graphql-ws@6.0.5_graphql@15.10.1_ws@8.18.2/node_modules/graphql-ws/dist/client.js
+function createClient(options) {
+  const {
+    url,
+    connectionParams,
+    lazy = true,
+    onNonLazyError = console.error,
+    lazyCloseTimeout: lazyCloseTimeoutMs = 0,
+    keepAlive = 0,
+    disablePong,
+    connectionAckWaitTimeout = 0,
+    retryAttempts = 5,
+    retryWait = async function randomisedExponentialBackoff(retries2) {
+      const retryDelaySeconds = Math.pow(2, retries2);
+      await new Promise(
+        (resolve) => setTimeout(
+          resolve,
+          retryDelaySeconds * 1e3 + // add random timeout from 300ms to 3s
+          Math.floor(Math.random() * (3e3 - 300) + 300)
+        )
+      );
+    },
+    shouldRetry = isLikeCloseEvent,
+    on,
+    webSocketImpl,
+    /**
+     * Generates a v4 UUID to be used as the ID using `Math`
+     * as the random number generator. Supply your own generator
+     * in case you need more uniqueness.
+     *
+     * Reference: https://gist.github.com/jed/982883
+     */
+    generateID = function generateUUID() {
+      return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
+        const r = Math.random() * 16 | 0, v = c == "x" ? r : r & 3 | 8;
+        return v.toString(16);
+      });
+    },
+    jsonMessageReplacer: replacer,
+    jsonMessageReviver: reviver
+  } = options;
+  let ws;
+  if (webSocketImpl) {
+    if (!isWebSocket(webSocketImpl)) {
+      throw new Error("Invalid WebSocket implementation provided");
+    }
+    ws = webSocketImpl;
+  } else if (typeof WebSocket !== "undefined") {
+    ws = WebSocket;
+  } else if (typeof global !== "undefined") {
+    ws = global.WebSocket || // @ts-expect-error: Support more browsers
+    global.MozWebSocket;
+  } else if (typeof window !== "undefined") {
+    ws = window.WebSocket || // @ts-expect-error: Support more browsers
+    window.MozWebSocket;
+  }
+  if (!ws)
+    throw new Error(
+      "WebSocket implementation missing; on Node you can `import WebSocket from 'ws';` and pass `webSocketImpl: WebSocket` to `createClient`"
+    );
+  const WebSocketImpl = ws;
+  const emitter = (() => {
+    const message = /* @__PURE__ */ (() => {
+      const listeners2 = {};
+      return {
+        on(id, listener) {
+          listeners2[id] = listener;
+          return () => {
+            delete listeners2[id];
+          };
+        },
+        emit(message2) {
+          if ("id" in message2)
+            listeners2[message2.id]?.(message2);
+        }
+      };
+    })();
+    const listeners = {
+      connecting: on?.connecting ? [on.connecting] : [],
+      opened: on?.opened ? [on.opened] : [],
+      connected: on?.connected ? [on.connected] : [],
+      ping: on?.ping ? [on.ping] : [],
+      pong: on?.pong ? [on.pong] : [],
+      message: on?.message ? [message.emit, on.message] : [message.emit],
+      closed: on?.closed ? [on.closed] : [],
+      error: on?.error ? [on.error] : []
+    };
+    return {
+      onMessage: message.on,
+      on(event, listener) {
+        const l = listeners[event];
+        l.push(listener);
+        return () => {
+          l.splice(l.indexOf(listener), 1);
+        };
+      },
+      emit(event, ...args) {
+        for (const listener of [...listeners[event]]) {
+          listener(...args);
+        }
+      }
+    };
+  })();
+  function errorOrClosed(cb) {
+    const listening = [
+      // errors are fatal and more critical than close events, throw them first
+      emitter.on("error", (err) => {
+        listening.forEach((unlisten) => unlisten());
+        cb(err);
+      }),
+      // closes can be graceful and not fatal, throw them second (if error didnt throw)
+      emitter.on("closed", (event) => {
+        listening.forEach((unlisten) => unlisten());
+        cb(event);
+      })
+    ];
+  }
+  let connecting, locks = 0, lazyCloseTimeout, retrying = false, retries = 0, disposed = false;
+  async function connect() {
+    clearTimeout(lazyCloseTimeout);
+    const [socket, throwOnClose] = await (connecting ?? (connecting = new Promise(
+      (connected, denied) => (async () => {
+        if (retrying) {
+          await retryWait(retries);
+          if (!locks) {
+            connecting = void 0;
+            return denied({ code: 1e3, reason: "All Subscriptions Gone" });
+          }
+          retries++;
+        }
+        emitter.emit("connecting", retrying);
+        const socket2 = new WebSocketImpl(
+          typeof url === "function" ? await url() : url,
+          GRAPHQL_TRANSPORT_WS_PROTOCOL
+        );
+        let connectionAckTimeout, queuedPing;
+        function enqueuePing() {
+          if (isFinite(keepAlive) && keepAlive > 0) {
+            clearTimeout(queuedPing);
+            queuedPing = setTimeout(() => {
+              if (socket2.readyState === WebSocketImpl.OPEN) {
+                socket2.send(stringifyMessage({ type: MessageType.Ping }));
+                emitter.emit("ping", false, void 0);
+              }
+            }, keepAlive);
+          }
+        }
+        errorOrClosed((errOrEvent) => {
+          connecting = void 0;
+          clearTimeout(connectionAckTimeout);
+          clearTimeout(queuedPing);
+          denied(errOrEvent);
+          if (errOrEvent instanceof TerminatedCloseEvent) {
+            socket2.close(4499, "Terminated");
+            socket2.onerror = null;
+            socket2.onclose = null;
+          }
+        });
+        socket2.onerror = (err) => emitter.emit("error", err);
+        socket2.onclose = (event) => emitter.emit("closed", event);
+        socket2.onopen = async () => {
+          try {
+            emitter.emit("opened", socket2);
+            const payload = typeof connectionParams === "function" ? await connectionParams() : connectionParams;
+            if (socket2.readyState !== WebSocketImpl.OPEN)
+              return;
+            socket2.send(
+              stringifyMessage(
+                payload ? {
+                  type: MessageType.ConnectionInit,
+                  payload
+                } : {
+                  type: MessageType.ConnectionInit
+                  // payload is completely absent if not provided
+                },
+                replacer
+              )
+            );
+            if (isFinite(connectionAckWaitTimeout) && connectionAckWaitTimeout > 0) {
+              connectionAckTimeout = setTimeout(() => {
+                socket2.close(
+                  CloseCode.ConnectionAcknowledgementTimeout,
+                  "Connection acknowledgement timeout"
+                );
+              }, connectionAckWaitTimeout);
+            }
+            enqueuePing();
+          } catch (err) {
+            emitter.emit("error", err);
+            socket2.close(
+              CloseCode.InternalClientError,
+              limitCloseReason(
+                err instanceof Error ? err.message : String(err),
+                "Internal client error"
+              )
+            );
+          }
+        };
+        let acknowledged = false;
+        socket2.onmessage = ({ data }) => {
+          try {
+            const message = parseMessage(data, reviver);
+            emitter.emit("message", message);
+            if (message.type === "ping" || message.type === "pong") {
+              emitter.emit(message.type, true, message.payload);
+              if (message.type === "pong") {
+                enqueuePing();
+              } else if (!disablePong) {
+                socket2.send(
+                  stringifyMessage(
+                    message.payload ? {
+                      type: MessageType.Pong,
+                      payload: message.payload
+                    } : {
+                      type: MessageType.Pong
+                      // payload is completely absent if not provided
+                    }
+                  )
+                );
+                emitter.emit("pong", false, message.payload);
+              }
+              return;
+            }
+            if (acknowledged)
+              return;
+            if (message.type !== MessageType.ConnectionAck)
+              throw new Error(
+                `First message cannot be of type ${message.type}`
+              );
+            clearTimeout(connectionAckTimeout);
+            acknowledged = true;
+            emitter.emit("connected", socket2, message.payload, retrying);
+            retrying = false;
+            retries = 0;
+            connected([
+              socket2,
+              new Promise((_, reject) => errorOrClosed(reject))
+            ]);
+          } catch (err) {
+            socket2.onmessage = null;
+            emitter.emit("error", err);
+            socket2.close(
+              CloseCode.BadResponse,
+              limitCloseReason(
+                err instanceof Error ? err.message : String(err),
+                "Bad response"
+              )
+            );
+          }
+        };
+      })()
+    )));
+    if (socket.readyState === WebSocketImpl.CLOSING)
+      await throwOnClose;
+    let release = () => {
+    };
+    const released = new Promise((resolve) => release = resolve);
+    return [
+      socket,
+      release,
+      Promise.race([
+        // wait for
+        released.then(() => {
+          if (!locks) {
+            const complete = () => socket.close(1e3, "Normal Closure");
+            if (isFinite(lazyCloseTimeoutMs) && lazyCloseTimeoutMs > 0) {
+              lazyCloseTimeout = setTimeout(() => {
+                if (socket.readyState === WebSocketImpl.OPEN)
+                  complete();
+              }, lazyCloseTimeoutMs);
+            } else {
+              complete();
+            }
+          }
+        }),
+        // or
+        throwOnClose
+      ])
+    ];
+  }
+  function shouldRetryConnectOrThrow(errOrCloseEvent) {
+    if (isLikeCloseEvent(errOrCloseEvent) && (isFatalInternalCloseCode(errOrCloseEvent.code) || [
+      CloseCode.InternalServerError,
+      CloseCode.InternalClientError,
+      CloseCode.BadRequest,
+      CloseCode.BadResponse,
+      CloseCode.Unauthorized,
+      // CloseCode.Forbidden, might grant access out after retry
+      CloseCode.SubprotocolNotAcceptable,
+      // CloseCode.ConnectionInitialisationTimeout, might not time out after retry
+      // CloseCode.ConnectionAcknowledgementTimeout, might not time out after retry
+      CloseCode.SubscriberAlreadyExists,
+      CloseCode.TooManyInitialisationRequests
+      // 4499, // Terminated, probably because the socket froze, we want to retry
+    ].includes(errOrCloseEvent.code)))
+      throw errOrCloseEvent;
+    if (disposed)
+      return false;
+    if (isLikeCloseEvent(errOrCloseEvent) && errOrCloseEvent.code === 1e3)
+      return locks > 0;
+    if (!retryAttempts || retries >= retryAttempts)
+      throw errOrCloseEvent;
+    if (!shouldRetry(errOrCloseEvent))
+      throw errOrCloseEvent;
+    return retrying = true;
+  }
+  if (!lazy) {
+    (async () => {
+      locks++;
+      for (; ; ) {
+        try {
+          const [, , throwOnClose] = await connect();
+          await throwOnClose;
+        } catch (errOrCloseEvent) {
+          try {
+            if (!shouldRetryConnectOrThrow(errOrCloseEvent))
+              return;
+          } catch (errOrCloseEvent2) {
+            return onNonLazyError?.(errOrCloseEvent2);
+          }
+        }
+      }
+    })();
+  }
+  function subscribe(payload, sink) {
+    const id = generateID(payload);
+    let done = false, errored = false, releaser = () => {
+      locks--;
+      done = true;
+    };
+    (async () => {
+      locks++;
+      for (; ; ) {
+        try {
+          const [socket, release, waitForReleaseOrThrowOnClose] = await connect();
+          if (done)
+            return release();
+          const unlisten = emitter.onMessage(id, (message) => {
+            switch (message.type) {
+              case MessageType.Next: {
+                sink.next(message.payload);
+                return;
+              }
+              case MessageType.Error: {
+                errored = true, done = true;
+                sink.error(message.payload);
+                releaser();
+                return;
+              }
+              case MessageType.Complete: {
+                done = true;
+                releaser();
+                return;
+              }
+            }
+          });
+          socket.send(
+            stringifyMessage(
+              {
+                id,
+                type: MessageType.Subscribe,
+                payload
+              },
+              replacer
+            )
+          );
+          releaser = () => {
+            if (!done && socket.readyState === WebSocketImpl.OPEN)
+              socket.send(
+                stringifyMessage(
+                  {
+                    id,
+                    type: MessageType.Complete
+                  },
+                  replacer
+                )
+              );
+            locks--;
+            done = true;
+            release();
+          };
+          await waitForReleaseOrThrowOnClose.finally(unlisten);
+          return;
+        } catch (errOrCloseEvent) {
+          if (!shouldRetryConnectOrThrow(errOrCloseEvent))
+            return;
+        }
+      }
+    })().then(() => {
+      if (!errored)
+        sink.complete();
+    }).catch((err) => {
+      sink.error(err);
+    });
+    return () => {
+      if (!done)
+        releaser();
+    };
+  }
+  return {
+    on: emitter.on,
+    subscribe,
+    iterate(request) {
+      const pending = [];
+      const deferred = {
+        done: false,
+        error: null,
+        resolve: () => {
+        }
+      };
+      const dispose = subscribe(request, {
+        next(val) {
+          pending.push(val);
+          deferred.resolve();
+        },
+        error(err) {
+          deferred.done = true;
+          deferred.error = err;
+          deferred.resolve();
+        },
+        complete() {
+          deferred.done = true;
+          deferred.resolve();
+        }
+      });
+      const iterator = async function* iterator2() {
+        for (; ; ) {
+          if (!pending.length) {
+            await new Promise((resolve) => deferred.resolve = resolve);
+          }
+          while (pending.length) {
+            yield pending.shift();
+          }
+          if (deferred.error) {
+            throw deferred.error;
+          }
+          if (deferred.done) {
+            return;
+          }
+        }
+      }();
+      iterator.throw = async (err) => {
+        if (!deferred.done) {
+          deferred.done = true;
+          deferred.error = err;
+          deferred.resolve();
+        }
+        return { done: true, value: void 0 };
+      };
+      iterator.return = async () => {
+        dispose();
+        return { done: true, value: void 0 };
+      };
+      return iterator;
+    },
+    async dispose() {
+      disposed = true;
+      if (connecting) {
+        const [socket] = await connecting;
+        socket.close(1e3, "Normal Closure");
+      }
+    },
+    terminate() {
+      if (connecting) {
+        emitter.emit("closed", new TerminatedCloseEvent());
+      }
+    }
+  };
+}
+var TerminatedCloseEvent = class extends Error {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "name", "TerminatedCloseEvent");
+    __publicField(this, "message", "4499: Terminated");
+    __publicField(this, "code", 4499);
+    __publicField(this, "reason", "Terminated");
+    __publicField(this, "wasClean", false);
+  }
+};
+function isLikeCloseEvent(val) {
+  return isObject(val) && "code" in val && "reason" in val;
+}
+function isFatalInternalCloseCode(code) {
+  if ([
+    1e3,
+    // Normal Closure is not an erroneous close code
+    1001,
+    // Going Away
+    1006,
+    // Abnormal Closure
+    1005,
+    // No Status Received
+    1012,
+    // Service Restart
+    1013,
+    // Try Again Later
+    1014
+    // Bad Gateway
+  ].includes(code))
+    return false;
+  return code >= 1e3 && code <= 1999;
+}
+function isWebSocket(val) {
+  return typeof val === "function" && "constructor" in val && "CLOSED" in val && "CLOSING" in val && "CONNECTING" in val && "OPEN" in val;
+}
+
+// ../../node_modules/.pnpm/graphql-ws@6.0.5_graphql@15.10.1_ws@8.18.2/node_modules/graphql-ws/dist/index.js
+import "graphql";
+
+// src/client.ts
+import pluralize from "pluralize";
+function mapCachePolicyToFetchPolicy(cachePolicy) {
+  switch (cachePolicy) {
+    case "cache-first":
+      return "cache-first";
+    case "network-only":
+      return "network-only";
+    case "cache-only":
+      return "cache-only";
+    case "no-cache":
+      return "no-cache";
+    case "standby":
+      return "standby";
+    default:
+      return "cache-first";
+  }
+}
+var DubheGraphqlClient = class {
+  constructor(config) {
+    this.parsedTables = /* @__PURE__ */ new Map();
+    this.dubheMetadata = config.dubheMetadata;
+    if (this.dubheMetadata) {
+      this.parseTableInfoFromConfig();
+    }
+    const httpLink = createHttpLink({
+      uri: config.endpoint,
+      headers: config.headers,
+      fetch: (input, init) => fetch(input, { ...config.fetchOptions, ...init })
+    });
+    const retryLink = new RetryLink({
+      delay: {
+        // Initial retry delay time (milliseconds)
+        initial: config.retryOptions?.delay?.initial || 300,
+        // Maximum retry delay time (milliseconds)
+        max: config.retryOptions?.delay?.max || 5e3,
+        // Whether to add random jitter to avoid thundering herd, enabled by default
+        jitter: config.retryOptions?.delay?.jitter !== false
+      },
+      attempts: {
+        // Maximum number of attempts (including initial request)
+        max: config.retryOptions?.attempts?.max || 5,
+        // Custom retry condition function
+        retryIf: config.retryOptions?.attempts?.retryIf || ((error, _operation) => {
+          return Boolean(
+            error && (error.networkError || error.graphQLErrors && error.graphQLErrors.length === 0)
+          );
+        })
+      }
+    });
+    const httpWithRetryLink = from([retryLink, httpLink]);
+    let link = httpWithRetryLink;
+    if (config.subscriptionEndpoint) {
+      let webSocketImpl;
+      try {
+        if (typeof window === "undefined" && typeof global !== "undefined") {
+          const wsModule = __require("ws");
+          webSocketImpl = wsModule.default || wsModule;
+          if (typeof global.WebSocket === "undefined") {
+            global.WebSocket = webSocketImpl;
+          }
+        } else {
+          webSocketImpl = WebSocket;
+        }
+      } catch (error) {
+      }
+      const clientOptions = {
+        url: config.subscriptionEndpoint,
+        connectionParams: {
+          headers: config.headers
+        }
+      };
+      if (webSocketImpl && typeof window === "undefined") {
+        clientOptions.webSocketImpl = webSocketImpl;
+      }
+      this.subscriptionClient = createClient(clientOptions);
+      const wsLink = new GraphQLWsLink(this.subscriptionClient);
+      link = split(
+        ({ query }) => {
+          const definition = getMainDefinition(query);
+          return definition.kind === "OperationDefinition" && definition.operation === "subscription";
+        },
+        wsLink,
+        httpWithRetryLink
+      );
+    }
+    this.apolloClient = new ApolloClient({
+      link,
+      cache: config.cacheConfig?.paginatedTables && config.cacheConfig.paginatedTables.length > 0 ? new InMemoryCache({
+        typePolicies: {
+          // Configure cache strategy for Connection type
+          Query: {
+            fields: this.buildCacheFields(config.cacheConfig)
+          }
+        }
+      }) : new InMemoryCache(),
+      // Use simple cache by default
+      defaultOptions: {
+        watchQuery: {
+          errorPolicy: "all",
+          notifyOnNetworkStatusChange: true
+        },
+        query: {
+          errorPolicy: "all"
+        }
+      }
+    });
+  }
+  /**
+   * Execute GraphQL query
+   */
+  async query(query, variables, options) {
+    try {
+      const result = await this.apolloClient.query({
+        query,
+        variables,
+        fetchPolicy: options?.cachePolicy ? mapCachePolicyToFetchPolicy(options.cachePolicy) : "no-cache",
+        // : 'cache-first',
+        notifyOnNetworkStatusChange: options?.notifyOnNetworkStatusChange,
+        pollInterval: options?.pollInterval
+      });
+      return {
+        data: result.data,
+        loading: result.loading,
+        error: result.error,
+        networkStatus: result.networkStatus,
+        refetch: () => this.query(query, variables, options)
+      };
+    } catch (error) {
+      return {
+        data: void 0,
+        loading: false,
+        error,
+        networkStatus: 8,
+        // NetworkStatus.error
+        refetch: () => this.query(query, variables, options)
+      };
+    }
+  }
+  /**
+   * Execute GraphQL subscription
+   */
+  subscribe(subscription, variables, options) {
+    return new Observable((observer) => {
+      const sub = this.apolloClient.subscribe({
+        query: subscription,
+        variables
+      }).subscribe({
+        next: (result) => {
+          const subscriptionResult = {
+            data: result.data,
+            loading: false,
+            error: result.errors?.[0]
+          };
+          observer.next(subscriptionResult);
+          options?.onData?.(result.data);
+        },
+        error: (error) => {
+          const subscriptionResult = {
+            data: void 0,
+            loading: false,
+            error
+          };
+          observer.next(subscriptionResult);
+          options?.onError?.(error);
+        },
+        complete: () => {
+          observer.complete();
+          options?.onComplete?.();
+        }
+      });
+      return () => sub.unsubscribe();
+    });
+  }
+  /**
+   * Query all table data - Adapted to API without store prefix
+   *
+   * OrderBy field name support:
+   * - camelCase: { field: 'updatedAt', direction: 'DESC' } → UPDATED_AT_DESC
+   * - snake_case: { field: 'updated_at', direction: 'DESC' } → UPDATED_AT_DESC
+   *
+   * Usage examples:
+   * ```ts
+   * // Using camelCase field names
+   * const result = await client.getAllTables('account', {
+   *   orderBy: [{ field: 'updatedAt', direction: 'DESC' }]
+   * });
+   *
+   * // Using snake_case field names
+   * const result = await client.getAllTables('account', {
+   *   orderBy: [{ field: 'updated_at', direction: 'DESC' }]
+   * });
+   *
+   * // Mixed usage
+   * const result = await client.getAllTables('account', {
+   *   orderBy: [
+   *     { field: 'updatedAt', direction: 'DESC' },
+   *     { field: 'created_at', direction: 'ASC' }
+   *   ]
+   * });
+   * ```
+   */
+  async getAllTables(tableName, params) {
+    const pluralTableName = this.getPluralTableName(tableName);
+    const orderByEnums = convertOrderByToEnum(params?.orderBy);
+    const query = gql`
+      query GetAllTables(
+        $first: Int
+        $last: Int
+        $after: Cursor
+        $before: Cursor
+        $filter: ${this.getFilterTypeName(tableName)}
+        $orderBy: [${this.getOrderByTypeName(tableName)}!]
+      ) {
+        ${pluralTableName}(
+          first: $first
+          last: $last
+          after: $after
+          before: $before
+          filter: $filter
+          orderBy: $orderBy
+        ) {
+          totalCount
+          pageInfo {
+            hasNextPage
+            hasPreviousPage
+            startCursor
+            endCursor
+          }
+          edges {
+            cursor
+            node {
+              ${this.convertTableFields(tableName, params?.fields)}
+            }
+          }
+        }
+      }
+    `;
+    const queryParams = {
+      first: params?.first,
+      last: params?.last,
+      after: params?.after,
+      before: params?.before,
+      filter: params?.filter,
+      orderBy: orderByEnums
+    };
+    const result = await this.query(query, queryParams);
+    if (result.error) {
+      throw result.error;
+    }
+    return result.data?.[pluralTableName] || {
+      edges: [],
+      pageInfo: { hasNextPage: false, hasPreviousPage: false }
+    };
+  }
+  /**
+   * Get single table record by condition - Adapted to API without store prefix
+   */
+  async getTableByCondition(tableName, condition, fields) {
+    const conditionKeys = Object.keys(condition);
+    const singularTableName = this.getSingularTableName(tableName);
+    const query = gql`
+      query GetTableByCondition(${conditionKeys.map((key, index) => `$${key}: String!`).join(", ")}) {
+        ${singularTableName}(${conditionKeys.map((key) => `${key}: $${key}`).join(", ")}) {
+          ${this.convertTableFields(tableName, fields)}
+        }
+      }
+    `;
+    const result = await this.query(query, condition);
+    if (result.error) {
+      throw result.error;
+    }
+    return result.data?.[singularTableName] || null;
+  }
+  /**
+   * Subscribe to table data changes - Using PostGraphile's listen subscription feature
+   */
+  subscribeToTableChanges(tableName, options) {
+    const topic = options?.topicPrefix ? `${options.topicPrefix}${tableName}` : `store_${this.getSingularTableName(tableName)}`;
+    const pluralTableName = this.getPluralTableName(tableName);
+    const fields = this.convertTableFields(tableName, options?.fields);
+    const subscription = gql`
+      subscription ListenToTableChanges($topic: String!, $initialEvent: Boolean) {
+        listen(topic: $topic, initialEvent: $initialEvent) {
+          query {
+            ${pluralTableName}(first: ${options?.first || 10}, orderBy: UPDATED_AT_DESC) {
+              totalCount
+              nodes {
+                ${fields}
+              }
+              pageInfo {
+                hasNextPage
+                endCursor
+              }
+            }
+          }
+        }
+      }
+    `;
+    return this.subscribe(
+      subscription,
+      {
+        topic,
+        initialEvent: options?.initialEvent || false
+      },
+      options
+    );
+  }
+  /**
+   * Advanced listen subscription - Support custom queries
+   */
+  subscribeWithListen(topic, query, options) {
+    const subscription = gql`
+      subscription CustomListenSubscription($topic: String!, $initialEvent: Boolean) {
+        listen(topic: $topic, initialEvent: $initialEvent) {
+          query {
+            ${query}
+          }
+        }
+      }
+    `;
+    return this.subscribe(
+      subscription,
+      {
+        topic,
+        initialEvent: options?.initialEvent || false,
+        ...options?.variables
+      },
+      options
+    );
+  }
+  /**
+   * Subscribe to data changes with specific conditions
+   */
+  subscribeToFilteredTableChanges(tableName, filter, options) {
+    const topic = options?.topicPrefix ? `${options.topicPrefix}${tableName}` : `store_${this.getSingularTableName(tableName)}`;
+    const pluralTableName = this.getPluralTableName(tableName);
+    const fields = this.convertTableFields(tableName, options?.fields);
+    const orderByEnum = convertOrderByToEnum(options?.orderBy);
+    const first = options?.first || 10;
+    const subscription = gql`
+      subscription FilteredListenSubscription(
+        $topic: String!, 
+        $initialEvent: Boolean,
+        $filter: ${this.getFilterTypeName(tableName)},
+        $orderBy: [${this.getOrderByTypeName(tableName)}!],
+        $first: Int
+      ) {
+        listen(topic: $topic, initialEvent: $initialEvent) {
+          query {
+            ${pluralTableName}(
+              first: $first, 
+              filter: $filter, 
+              orderBy: $orderBy
+            ) {
+              totalCount
+              nodes {
+                ${fields}
+              }
+              pageInfo {
+                hasNextPage
+                endCursor
+              }
+            }
+          }
+        }
+      }
+    `;
+    return this.subscribe(
+      subscription,
+      {
+        topic,
+        initialEvent: options?.initialEvent || false,
+        filter,
+        orderBy: orderByEnum,
+        first
+      },
+      options
+    );
+  }
+  /**
+   * Subscribe to multiple table data changes - Support batch subscription of table name list
+   */
+  subscribeToMultipleTables(tableConfigs, globalOptions) {
+    return new Observable((observer) => {
+      const subscriptions = [];
+      const latestData = {};
+      tableConfigs.forEach(({ tableName, options }) => {
+        const subscription = this.subscribeToFilteredTableChanges(
+          tableName,
+          options?.filter,
+          {
+            ...options,
+            onData: (data) => {
+              latestData[tableName] = data;
+              if (options?.onData) {
+                options.onData(data);
+              }
+              if (globalOptions?.onData) {
+                globalOptions.onData(latestData);
+              }
+              observer.next({ ...latestData });
+            },
+            onError: (error) => {
+              if (options?.onError) {
+                options.onError(error);
+              }
+              if (globalOptions?.onError) {
+                globalOptions.onError(error);
+              }
+              observer.error(error);
+            }
+          }
+        );
+        subscriptions.push({ tableName, subscription });
+      });
+      const activeSubscriptions = subscriptions.map(
+        ({ subscription }) => subscription.subscribe()
+      );
+      return () => {
+        activeSubscriptions.forEach((sub) => sub.unsubscribe());
+        if (globalOptions?.onComplete) {
+          globalOptions.onComplete();
+        }
+      };
+    });
+  }
+  /**
+   * Simplified multi-table subscription - Support table name array and unified configuration
+   */
+  subscribeToTableList(tableNames, options) {
+    const tableConfigs = tableNames.map(
+      (tableName) => ({
+        tableName,
+        options: {
+          ...options,
+          // Use same configuration for each table
+          fields: options?.fields,
+          filter: options?.filter,
+          initialEvent: options?.initialEvent,
+          first: options?.first,
+          topicPrefix: options?.topicPrefix
+        }
+      })
+    );
+    return this.subscribeToMultipleTables(tableConfigs, options);
+  }
+  /**
+   * Build dynamic query - Adapted to API without store prefix
+   */
+  buildQuery(tableName, fields, params) {
+    const pluralTableName = this.getPluralTableName(tableName);
+    const fieldSelection = fields.join("\n        ");
+    return gql`
+      query DynamicQuery(
+        $first: Int
+        $after: Cursor
+        $filter: ${this.getFilterTypeName(tableName)}
+        $orderBy: [${this.getOrderByTypeName(tableName)}!]
+      ) {
+        ${pluralTableName}(
+          first: $first
+          after: $after
+          filter: $filter
+          orderBy: $orderBy
+        ) {
+          totalCount
+          pageInfo {
+            hasNextPage
+            endCursor
+          }
+          edges {
+            cursor
+            node {
+              ${fieldSelection}
+            }
+          }
+        }
+      }
+    `;
+  }
+  /**
+   * Batch query multiple tables - Adapted to API without store prefix
+   */
+  async batchQuery(queries) {
+    const batchPromises = queries.map(async ({ key, tableName, params }) => {
+      const result = await this.getAllTables(tableName, params);
+      return { key, result };
+    });
+    const results = await Promise.all(batchPromises);
+    return results.reduce(
+      (acc, { key, result }) => {
+        acc[key] = result;
+        return acc;
+      },
+      {}
+    );
+  }
+  /**
+   * Real-time data stream listener - Adapted to API without store prefix
+   */
+  createRealTimeDataStream(tableName, initialQuery) {
+    return new Observable((observer) => {
+      this.getAllTables(tableName, initialQuery).then((initialData) => {
+        observer.next(initialData);
+      }).catch((error) => observer.error(error));
+      const subscription = this.subscribeToTableChanges(tableName, {
+        onData: () => {
+          this.getAllTables(tableName, initialQuery).then((updatedData) => {
+            observer.next(updatedData);
+          }).catch((error) => observer.error(error));
+        },
+        onError: (error) => observer.error(error)
+      });
+      return () => subscription.subscribe().unsubscribe();
+    });
+  }
+  // Improved table name handling methods
+  getFilterTypeName(tableName) {
+    const singularName = this.getSingularTableName(tableName);
+    const pascalCaseName = this.toPascalCase(singularName);
+    if (pascalCaseName.startsWith("Store")) {
+      return `${pascalCaseName}Filter`;
+    }
+    return `Store${pascalCaseName}Filter`;
+  }
+  getOrderByTypeName(tableName) {
+    const pluralName = this.getPluralTableName(tableName);
+    const pascalCaseName = this.toPascalCase(pluralName);
+    if (pascalCaseName.startsWith("Store")) {
+      return `${pascalCaseName}OrderBy`;
+    }
+    return `Store${pascalCaseName}OrderBy`;
+  }
+  /**
+   * Convert singular table name to plural form (using pluralize library for correctness)
+   */
+  getPluralTableName(tableName) {
+    const camelCaseName = this.toCamelCase(tableName);
+    return pluralize.plural(camelCaseName);
+  }
+  /**
+   * Convert plural table name to singular form (using pluralize library for correctness)
+   */
+  getSingularTableName(tableName) {
+    const camelCaseName = this.toCamelCase(tableName);
+    return pluralize.singular(camelCaseName);
+  }
+  /**
+   * Convert snake_case to camelCase
+   */
+  toCamelCase(str) {
+    return str.replace(/_([a-z])/g, (_, letter) => letter.toUpperCase());
+  }
+  /**
+   * Convert snake_case to PascalCase
+   */
+  toPascalCase(str) {
+    const camelCase = this.toCamelCase(str);
+    return camelCase.charAt(0).toUpperCase() + camelCase.slice(1);
+  }
+  /**
+   * Convert camelCase or snake_case to SNAKE_CASE (for GraphQL enum values)
+   * Example: updatedAt -> UPDATED_AT, updated_at -> UPDATED_AT
+   */
+  toSnakeCase(str) {
+    if (str.includes("_")) {
+      return str.toUpperCase();
+    }
+    return str.replace(/([A-Z])/g, "_$1").toLowerCase().replace(/^_/, "").toUpperCase();
+  }
+  // private buildSingleQueryName(
+  //   tableName: string,
+  //   conditionKeys: string[]
+  // ): string {
+  //   // Use camelCase conversion
+  //   const camelCaseTableName = this.toCamelCase(tableName);
+  //   const capitalizedKeys = conditionKeys.map(
+  //     (key) => key.charAt(0).toUpperCase() + key.slice(1)
+  //   );
+  //   return `${camelCaseTableName}By${capitalizedKeys.join('And')}`;
+  // }
+  /**
+   * Clear Apollo Client cache
+   */
+  async clearCache() {
+    await this.apolloClient.clearStore();
+  }
+  /**
+   * Reset Apollo Client cache
+   */
+  async resetCache() {
+    await this.apolloClient.resetStore();
+  }
+  /**
+   * Get Apollo Client instance (for advanced usage)
+   */
+  getApolloClient() {
+    return this.apolloClient;
+  }
+  /**
+   * Close client connection
+   */
+  close() {
+    if (this.subscriptionClient) {
+      this.subscriptionClient.dispose();
+    }
+  }
+  /**
+   * Get Dubhe metadata
+   */
+  getDubheMetadata() {
+    return this.dubheMetadata;
+  }
+  /**
+   * Build dynamic cache field configuration
+   */
+  buildCacheFields(cacheConfig) {
+    const fields = {};
+    if (!cacheConfig) {
+      return fields;
+    }
+    if (cacheConfig.paginatedTables) {
+      cacheConfig.paginatedTables.forEach((tableName) => {
+        const pluralTableName = this.getPluralTableName(tableName);
+        const customStrategy = cacheConfig.customMergeStrategies?.[pluralTableName];
+        fields[pluralTableName] = {
+          keyArgs: customStrategy?.keyArgs || ["filter", "orderBy"],
+          merge: customStrategy?.merge || this.defaultMergeStrategy
+        };
+      });
+    }
+    if (cacheConfig.customMergeStrategies) {
+      Object.entries(cacheConfig.customMergeStrategies).forEach(
+        ([tableName, strategy]) => {
+          if (!fields[tableName]) {
+            fields[tableName] = {
+              keyArgs: strategy.keyArgs || ["filter", "orderBy"],
+              merge: strategy.merge || this.defaultMergeStrategy
+            };
+          }
+        }
+      );
+    }
+    return fields;
+  }
+  /**
+   * Default pagination merge strategy
+   */
+  defaultMergeStrategy(existing = { edges: [] }, incoming) {
+    if (!incoming || !Array.isArray(incoming.edges)) {
+      return existing;
+    }
+    return {
+      ...incoming,
+      edges: [...existing.edges || [], ...incoming.edges]
+    };
+  }
+  /**
+   * Parse table information from dubhe metadata
+   */
+  parseTableInfoFromConfig() {
+    if (!this.dubheMetadata) {
+      return;
+    }
+    const { components = [], resources = [], enums = [] } = this.dubheMetadata;
+    components.forEach((componentObj) => {
+      Object.entries(componentObj).forEach(
+        ([componentName, componentData]) => {
+          this.processTableData(componentName, componentData, enums);
+        }
+      );
+    });
+    resources.forEach((resourceObj) => {
+      Object.entries(resourceObj).forEach(
+        ([resourceName, resourceData]) => {
+          this.processTableData(resourceName, resourceData, enums);
+        }
+      );
+    });
+  }
+  /**
+   * Process data for a single table
+   */
+  processTableData(tableName, tableData, enums) {
+    const snakeTableName = this.toSnakeCase(tableName);
+    const fields = [];
+    const enumFields = {};
+    if (tableData.fields && Array.isArray(tableData.fields)) {
+      tableData.fields.forEach((fieldObj) => {
+        Object.entries(fieldObj).forEach(
+          ([fieldName, fieldType]) => {
+            const fieldNameCamelCase = this.toCamelCase(fieldName);
+            fields.push(fieldNameCamelCase);
+          }
+        );
+      });
+    }
+    fields.push("createdAt", "updatedAt");
+    const primaryKeys = tableData.keys.map(
+      (key) => this.toCamelCase(key)
+    );
+    const tableInfo = {
+      tableName: snakeTableName,
+      fields: [...new Set(fields)],
+      // Remove duplicates
+      primaryKeys,
+      enumFields
+    };
+    this.parsedTables.set(snakeTableName, tableInfo);
+    this.parsedTables.set(this.toCamelCase(snakeTableName), tableInfo);
+  }
+  /**
+   * Get table field information
+   */
+  getTableFields(tableName) {
+    return this.getMinimalFields(tableName);
+  }
+  /**
+   * Get table primary key information
+   */
+  getTablePrimaryKeys(tableName) {
+    const tableInfo = this.parsedTables.get(tableName) || this.parsedTables.get(this.toSnakeCase(tableName));
+    return tableInfo?.primaryKeys || [];
+  }
+  /**
+   * Get table enum field information
+   */
+  getTableEnumFields(tableName) {
+    const tableInfo = this.parsedTables.get(tableName) || this.parsedTables.get(this.toSnakeCase(tableName));
+    return tableInfo?.enumFields || {};
+  }
+  /**
+   * Get all parsed table information
+   */
+  getAllTableInfo() {
+    return new Map(this.parsedTables);
+  }
+  /**
+   * Get table's minimal field set (for fallback)
+   */
+  getMinimalFields(tableName) {
+    const tableInfo = this.parsedTables.get(tableName) || this.parsedTables.get(this.toSnakeCase(tableName));
+    if (tableInfo) {
+      return tableInfo.fields;
+    }
+    return ["createdAt", "updatedAt"];
+  }
+  /**
+   * Convert table fields to GraphQL query string
+   */
+  convertTableFields(tableName, customFields) {
+    let fields;
+    if (customFields && customFields.length > 0) {
+      fields = customFields;
+    } else {
+      const autoFields = this.getTableFields(tableName);
+      if (autoFields.length > 0) {
+        fields = autoFields;
+      } else {
+        fields = ["createdAt", "updatedAt"];
+      }
+    }
+    return fields.join("\n      ");
+  }
+};
+function createDubheGraphqlClient(config) {
+  return new DubheGraphqlClient(config);
+}
+var QueryBuilders = {
+  // Build basic query - Adapted to API without store prefix
+  basic: (tableName, fields = ["createdAt", "updatedAt"]) => gql`
+    query Basic${tableName.charAt(0).toUpperCase() + tableName.slice(1)}Query(
+      $first: Int
+      $after: String
+      $filter: ${tableName.charAt(0).toUpperCase() + tableName.slice(1)}Filter
+    ) {
+      ${tableName}(first: $first, after: $after, filter: $filter) {
+        totalCount
+        pageInfo {
+          hasNextPage
+          endCursor
+        }
+        edges {
+          cursor
+          node {
+            ${fields.join("\n            ")}
+          }
+        }
+      }
+    }
+  `,
+  // Build subscription query - Adapted to API without store prefix
+  subscription: (tableName) => gql`
+    subscription ${tableName.charAt(0).toUpperCase() + tableName.slice(1)}Subscription {
+      ${tableName.charAt(0).toLowerCase() + tableName.slice(1)}Changed {
+        createdAt
+        updatedAt
+      }
+    }
+  `
+};
+function convertOrderByToEnum(orderBy) {
+  if (!orderBy || orderBy.length === 0) {
+    return ["NATURAL"];
+  }
+  return orderBy.map((order) => {
+    const field = toSnakeCaseForEnum(order.field);
+    const direction = order.direction === "DESC" ? "DESC" : "ASC";
+    return `${field}_${direction}`;
+  });
+}
+function toSnakeCaseForEnum(str) {
+  if (str.includes("_")) {
+    return str.toUpperCase();
+  }
+  return str.replace(/([A-Z])/g, "_$1").toLowerCase().replace(/^_/, "").toUpperCase();
+}
+export {
+  DubheGraphqlClient,
+  QueryBuilders,
+  createDubheGraphqlClient
+};
+//# sourceMappingURL=index.mjs.map