@codex-data/sdk 2.3.43 → 2.4.1

package/dist/sdk/edge.d.ts

@@ -0,0 +1,24 @@
+import { type Client, type ClientOptions, createClient, type Event, type EventListener, type ExecutionResult, type Sink, type SubscribePayload } from "graphql-ws";
+export { createClient };
+export declare const DEFAULT_EDGE_URL = "wss://fra.edge.codex.io/graphql";
+export interface SubscriptionOptions {
+    /** Experimental: use edge for supported Solana streams whose commitments include Processed. */
+    useEdge?: boolean;
+}
+export interface ClientWithEdge extends Client {
+    /** Observe both transports, or select one with useEdge. */
+    on<E extends Event>(event: E, listener: EventListener<E>, options?: SubscriptionOptions): () => void;
+    subscribe<Data = Record<string, unknown>, Extensions = unknown>(payload: SubscribePayload, sink: Sink<ExecutionResult<Data, Extensions>>, options?: SubscriptionOptions): () => void;
+}
+export interface EdgeClientOptions extends Omit<ClientOptions, "url"> {
+    /** Defaults to the regional edge endpoint. */
+    url?: ClientOptions["url"];
+}
+/** Create a transport that connects only to edge. */
+export declare function createEdgeClient(options: EdgeClientOptions): Client;
+/** Snapshot and validate the arguments that will actually be sent to edge. */
+export declare function prepareEdgeSubscription(payload: SubscribePayload, replacer?: ClientOptions["jsonMessageReplacer"]): SubscribePayload;
+/** Add per-subscription edge routing to an existing GraphQL client. */
+export declare function withEdge(main: Client, options: ClientOptions & {
+    edgeUrl?: string;
+}): ClientWithEdge;

package/dist/sdk/edge.js

@@ -0,0 +1,111 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_EDGE_URL = exports.createClient = void 0;
+exports.createEdgeClient = createEdgeClient;
+exports.prepareEdgeSubscription = prepareEdgeSubscription;
+exports.withEdge = withEdge;
+const graphql_ws_1 = require("graphql-ws");
+Object.defineProperty(exports, "createClient", { enumerable: true, get: function () { return graphql_ws_1.createClient; } });
+const edgeSubscription_1 = require("./edgeSubscription");
+exports.DEFAULT_EDGE_URL = "wss://fra.edge.codex.io/graphql";
+/** Create a transport that connects only to edge. */
+function createEdgeClient(options) {
+    var _a;
+    return (0, graphql_ws_1.createClient)(Object.assign(Object.assign({}, options), { url: (_a = options.url) !== null && _a !== void 0 ? _a : exports.DEFAULT_EDGE_URL }));
+}
+/** Snapshot and validate the arguments that will actually be sent to edge. */
+function prepareEdgeSubscription(payload, replacer) {
+    const snapshot = JSON.parse(JSON.stringify(payload, replacer));
+    (0, edgeSubscription_1.assertEdgeSubscription)(snapshot);
+    return snapshot;
+}
+/** Add per-subscription edge routing to an existing GraphQL client. */
+function withEdge(main, options) {
+    const { edgeUrl = exports.DEFAULT_EDGE_URL } = options, wsOptions = __rest(options, ["edgeUrl"]);
+    const mainHandlers = new Set();
+    const edgeHandlers = new Set(wsOptions.on ? [wsOptions.on] : []);
+    const handlersFor = (useEdge) => {
+        const handlers = () => Array.from(useEdge ? edgeHandlers : mainHandlers);
+        // Install before createClient so even non-lazy connection events are observed.
+        return {
+            connecting: (...args) => handlers().forEach((on) => { var _a; return (_a = on === null || on === void 0 ? void 0 : on.connecting) === null || _a === void 0 ? void 0 : _a.call(on, ...args); }),
+            opened: (...args) => handlers().forEach((on) => { var _a; return (_a = on === null || on === void 0 ? void 0 : on.opened) === null || _a === void 0 ? void 0 : _a.call(on, ...args); }),
+            connected: (...args) => handlers().forEach((on) => { var _a; return (_a = on === null || on === void 0 ? void 0 : on.connected) === null || _a === void 0 ? void 0 : _a.call(on, ...args); }),
+            ping: (...args) => handlers().forEach((on) => { var _a; return (_a = on === null || on === void 0 ? void 0 : on.ping) === null || _a === void 0 ? void 0 : _a.call(on, ...args); }),
+            pong: (...args) => handlers().forEach((on) => { var _a; return (_a = on === null || on === void 0 ? void 0 : on.pong) === null || _a === void 0 ? void 0 : _a.call(on, ...args); }),
+            message: (...args) => handlers().forEach((on) => { var _a; return (_a = on === null || on === void 0 ? void 0 : on.message) === null || _a === void 0 ? void 0 : _a.call(on, ...args); }),
+            closed: (...args) => handlers().forEach((on) => { var _a; return (_a = on === null || on === void 0 ? void 0 : on.closed) === null || _a === void 0 ? void 0 : _a.call(on, ...args); }),
+            error: (...args) => handlers().forEach((on) => { var _a; return (_a = on === null || on === void 0 ? void 0 : on.error) === null || _a === void 0 ? void 0 : _a.call(on, ...args); }),
+        };
+    };
+    const mainEvents = handlersFor(false);
+    main.on("connecting", mainEvents.connecting);
+    main.on("opened", mainEvents.opened);
+    main.on("connected", mainEvents.connected);
+    main.on("ping", mainEvents.ping);
+    main.on("pong", mainEvents.pong);
+    main.on("message", mainEvents.message);
+    main.on("closed", mainEvents.closed);
+    main.on("error", mainEvents.error);
+    let edge;
+    let disposed = false;
+    return Object.assign(Object.assign({}, main), { on: (event, listener, subscriptionOptions = {}) => {
+            const handlers = { [event]: listener };
+            if (subscriptionOptions.useEdge !== true)
+                mainHandlers.add(handlers);
+            if (subscriptionOptions.useEdge !== false)
+                edgeHandlers.add(handlers);
+            return () => {
+                mainHandlers.delete(handlers);
+                edgeHandlers.delete(handlers);
+            };
+        }, subscribe: (payload, sink, subscriptionOptions = {}) => {
+            if (disposed)
+                throw new Error("Edge client has been disposed");
+            if (!subscriptionOptions.useEdge)
+                return main.subscribe(payload, sink);
+            // Reject before creating an edge client or opening any upstream operation.
+            const snapshot = prepareEdgeSubscription(payload, wsOptions.jsonMessageReplacer);
+            if (!edge) {
+                // Edge payloads are serialized once, before validation. Preserve custom
+                // serialization for handshakes without transforming subscriptions again.
+                let subscriptionMessage = false;
+                edge = createEdgeClient(Object.assign(Object.assign({}, wsOptions), { url: edgeUrl, on: handlersFor(true), jsonMessageReplacer: function (key, value) {
+                        if (key === "")
+                            subscriptionMessage = (value === null || value === void 0 ? void 0 : value.type) === "subscribe";
+                        return subscriptionMessage
+                            ? value
+                            : wsOptions.jsonMessageReplacer
+                                ? wsOptions.jsonMessageReplacer.call(this, key, value)
+                                : value;
+                    } }));
+            }
+            return edge.subscribe(snapshot, sink);
+        }, terminate: () => {
+            main.terminate();
+            edge === null || edge === void 0 ? void 0 : edge.terminate();
+        }, dispose: () => __awaiter(this, void 0, void 0, function* () {
+            disposed = true;
+            yield Promise.all([main.dispose(), edge === null || edge === void 0 ? void 0 : edge.dispose()]);
+        }) });
+}

package/dist/sdk/edge.mjs

@@ -0,0 +1,95 @@
+import { createClient, } from "graphql-ws";
+import { assertEdgeSubscription } from "./edgeSubscription";
+export { createClient };
+export const DEFAULT_EDGE_URL = "wss://fra.edge.codex.io/graphql";
+/** Create a transport that connects only to edge. */
+export function createEdgeClient(options) {
+    return createClient({ ...options, url: options.url ?? DEFAULT_EDGE_URL });
+}
+/** Snapshot and validate the arguments that will actually be sent to edge. */
+export function prepareEdgeSubscription(payload, replacer) {
+    const snapshot = JSON.parse(JSON.stringify(payload, replacer));
+    assertEdgeSubscription(snapshot);
+    return snapshot;
+}
+/** Add per-subscription edge routing to an existing GraphQL client. */
+export function withEdge(main, options) {
+    const { edgeUrl = DEFAULT_EDGE_URL, ...wsOptions } = options;
+    const mainHandlers = new Set();
+    const edgeHandlers = new Set(wsOptions.on ? [wsOptions.on] : []);
+    const handlersFor = (useEdge) => {
+        const handlers = () => Array.from(useEdge ? edgeHandlers : mainHandlers);
+        // Install before createClient so even non-lazy connection events are observed.
+        return {
+            connecting: (...args) => handlers().forEach((on) => on?.connecting?.(...args)),
+            opened: (...args) => handlers().forEach((on) => on?.opened?.(...args)),
+            connected: (...args) => handlers().forEach((on) => on?.connected?.(...args)),
+            ping: (...args) => handlers().forEach((on) => on?.ping?.(...args)),
+            pong: (...args) => handlers().forEach((on) => on?.pong?.(...args)),
+            message: (...args) => handlers().forEach((on) => on?.message?.(...args)),
+            closed: (...args) => handlers().forEach((on) => on?.closed?.(...args)),
+            error: (...args) => handlers().forEach((on) => on?.error?.(...args)),
+        };
+    };
+    const mainEvents = handlersFor(false);
+    main.on("connecting", mainEvents.connecting);
+    main.on("opened", mainEvents.opened);
+    main.on("connected", mainEvents.connected);
+    main.on("ping", mainEvents.ping);
+    main.on("pong", mainEvents.pong);
+    main.on("message", mainEvents.message);
+    main.on("closed", mainEvents.closed);
+    main.on("error", mainEvents.error);
+    let edge;
+    let disposed = false;
+    return {
+        ...main,
+        on: (event, listener, subscriptionOptions = {}) => {
+            const handlers = { [event]: listener };
+            if (subscriptionOptions.useEdge !== true)
+                mainHandlers.add(handlers);
+            if (subscriptionOptions.useEdge !== false)
+                edgeHandlers.add(handlers);
+            return () => {
+                mainHandlers.delete(handlers);
+                edgeHandlers.delete(handlers);
+            };
+        },
+        subscribe: (payload, sink, subscriptionOptions = {}) => {
+            if (disposed)
+                throw new Error("Edge client has been disposed");
+            if (!subscriptionOptions.useEdge)
+                return main.subscribe(payload, sink);
+            // Reject before creating an edge client or opening any upstream operation.
+            const snapshot = prepareEdgeSubscription(payload, wsOptions.jsonMessageReplacer);
+            if (!edge) {
+                // Edge payloads are serialized once, before validation. Preserve custom
+                // serialization for handshakes without transforming subscriptions again.
+                let subscriptionMessage = false;
+                edge = createEdgeClient({
+                    ...wsOptions,
+                    url: edgeUrl,
+                    on: handlersFor(true),
+                    jsonMessageReplacer: function (key, value) {
+                        if (key === "")
+                            subscriptionMessage = value?.type === "subscribe";
+                        return subscriptionMessage
+                            ? value
+                            : wsOptions.jsonMessageReplacer
+                                ? wsOptions.jsonMessageReplacer.call(this, key, value)
+                                : value;
+                    },
+                });
+            }
+            return edge.subscribe(snapshot, sink);
+        },
+        terminate: () => {
+            main.terminate();
+            edge?.terminate();
+        },
+        dispose: async () => {
+            disposed = true;
+            await Promise.all([main.dispose(), edge?.dispose()]);
+        },
+    };
+}

package/dist/sdk/edgeSubscription.d.ts

@@ -0,0 +1,3 @@
+import type { SubscribePayload } from "graphql-ws";
+/** Validate the actual GraphQL arguments, including literals and variable defaults. */
+export declare function assertEdgeSubscription(payload: SubscribePayload): void;

package/dist/sdk/edgeSubscription.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertEdgeSubscription = assertEdgeSubscription;
+const graphql_1 = require("graphql");
+const SOLANA_NETWORK_ID = 1399811149;
+const SUPPORTED_OPERATIONS = new Set([
+    "onEventsCreated",
+    "onTokenEventsCreated",
+    "onBarsUpdated",
+    "onTokenBarsUpdated",
+]);
+/** Validate the actual GraphQL arguments, including literals and variable defaults. */
+function assertEdgeSubscription(payload) {
+    var _a, _b, _c;
+    function fail() {
+        throw new Error("useEdge requires a supported Solana subscription with commitmentLevel including Processed");
+    }
+    const document = (0, graphql_1.parse)(payload.query);
+    const operation = (0, graphql_1.getOperationAST)(document, payload.operationName);
+    if (!operation || operation.operation !== "subscription")
+        fail();
+    // Edge executes a single root field; root fragments and conditional roots
+    // are not supported by its current customer transport.
+    const selections = operation.selectionSet.selections;
+    if (selections.length !== 1)
+        fail();
+    const field = selections[0];
+    if (field.kind !== graphql_1.Kind.FIELD || !SUPPORTED_OPERATIONS.has(field.name.value))
+        fail();
+    if ((_a = field.directives) === null || _a === void 0 ? void 0 : _a.length)
+        fail();
+    const variables = Object.assign({}, payload.variables);
+    for (const definition of (_b = operation.variableDefinitions) !== null && _b !== void 0 ? _b : []) {
+        const name = definition.variable.name.value;
+        if (variables[name] === undefined &&
+            definition.defaultValue !== undefined) {
+            variables[name] = (0, graphql_1.valueFromASTUntyped)(definition.defaultValue);
+        }
+    }
+    const args = Object.fromEntries(((_c = field.arguments) !== null && _c !== void 0 ? _c : []).map((argument) => [
+        argument.name.value,
+        (0, graphql_1.valueFromASTUntyped)(argument.value, variables),
+    ]));
+    const levels = Array.isArray(args.commitmentLevel)
+        ? args.commitmentLevel
+        : [args.commitmentLevel];
+    if (!levels.includes("Processed") ||
+        [...levels].some((level) => level !== "Processed" &&
+            level !== "Confirmed" &&
+            level !== "Preprocessed"))
+        fail();
+    const networks = [];
+    const collect = (value) => {
+        if (!value || typeof value !== "object" || Array.isArray(value))
+            return;
+        for (const [name, item] of Object.entries(value)) {
+            if (name === "networkId" && item != null)
+                networks.push(item);
+            if (["id", "pairId", "tokenId"].includes(name) && item != null) {
+                if (typeof item !== "string" || !/^[^:]+:\d+$/.test(item))
+                    fail();
+                networks.push(Number(item.slice(item.lastIndexOf(":") + 1)));
+            }
+            if (name === "input")
+                collect(item);
+        }
+    };
+    collect(args);
+    if (!networks.length ||
+        networks.some((network) => network !== SOLANA_NETWORK_ID))
+        fail();
+    // Without an explicit quote, edge proxies this request back to Oregon.
+    if (field.name.value === "onBarsUpdated" && args.quoteToken == null) {
+        throw new Error("useEdge onBarsUpdated requires an explicit quoteToken");
+    }
+}

package/dist/sdk/edgeSubscription.mjs

@@ -0,0 +1,72 @@
+import { getOperationAST, Kind, parse, valueFromASTUntyped } from "graphql";
+const SOLANA_NETWORK_ID = 1399811149;
+const SUPPORTED_OPERATIONS = new Set([
+    "onEventsCreated",
+    "onTokenEventsCreated",
+    "onBarsUpdated",
+    "onTokenBarsUpdated",
+]);
+/** Validate the actual GraphQL arguments, including literals and variable defaults. */
+export function assertEdgeSubscription(payload) {
+    function fail() {
+        throw new Error("useEdge requires a supported Solana subscription with commitmentLevel including Processed");
+    }
+    const document = parse(payload.query);
+    const operation = getOperationAST(document, payload.operationName);
+    if (!operation || operation.operation !== "subscription")
+        fail();
+    // Edge executes a single root field; root fragments and conditional roots
+    // are not supported by its current customer transport.
+    const selections = operation.selectionSet.selections;
+    if (selections.length !== 1)
+        fail();
+    const field = selections[0];
+    if (field.kind !== Kind.FIELD || !SUPPORTED_OPERATIONS.has(field.name.value))
+        fail();
+    if (field.directives?.length)
+        fail();
+    const variables = { ...payload.variables };
+    for (const definition of operation.variableDefinitions ?? []) {
+        const name = definition.variable.name.value;
+        if (variables[name] === undefined &&
+            definition.defaultValue !== undefined) {
+            variables[name] = valueFromASTUntyped(definition.defaultValue);
+        }
+    }
+    const args = Object.fromEntries((field.arguments ?? []).map((argument) => [
+        argument.name.value,
+        valueFromASTUntyped(argument.value, variables),
+    ]));
+    const levels = Array.isArray(args.commitmentLevel)
+        ? args.commitmentLevel
+        : [args.commitmentLevel];
+    if (!levels.includes("Processed") ||
+        [...levels].some((level) => level !== "Processed" &&
+            level !== "Confirmed" &&
+            level !== "Preprocessed"))
+        fail();
+    const networks = [];
+    const collect = (value) => {
+        if (!value || typeof value !== "object" || Array.isArray(value))
+            return;
+        for (const [name, item] of Object.entries(value)) {
+            if (name === "networkId" && item != null)
+                networks.push(item);
+            if (["id", "pairId", "tokenId"].includes(name) && item != null) {
+                if (typeof item !== "string" || !/^[^:]+:\d+$/.test(item))
+                    fail();
+                networks.push(Number(item.slice(item.lastIndexOf(":") + 1)));
+            }
+            if (name === "input")
+                collect(item);
+        }
+    };
+    collect(args);
+    if (!networks.length ||
+        networks.some((network) => network !== SOLANA_NETWORK_ID))
+        fail();
+    // Without an explicit quote, edge proxies this request back to Oregon.
+    if (field.name.value === "onBarsUpdated" && args.quoteToken == null) {
+        throw new Error("useEdge onBarsUpdated requires an explicit quoteToken");
+    }
+}