@codex-data/sdk 0.5.7

package/src/sdk/Mutation.ts

@@ -0,0 +1,15 @@
+import { DeleteWebhooksInput } from "../resources/graphql";
+import {
+  CreateWebhooksDocument,
+  CreateWebhooksInput,
+  DeleteWebhooksDocument,
+} from "./generated/graphql";
+import { Codex } from "./index";
+
+export class Mutation {
+  constructor(private sdk: Codex) {}
+  createWebhooks = async (vars: { input: CreateWebhooksInput }) =>
+    this.sdk.mutation(CreateWebhooksDocument, vars);
+  deleteWebhooks = async (vars: { input: DeleteWebhooksInput }) =>
+    this.sdk.mutation(DeleteWebhooksDocument, vars);
+}

package/src/sdk/Query.test.ts

@@ -0,0 +1,40 @@
+import { Event } from "../resources/graphql";
+import { Codex } from "./index";
+
+describe("Query", () => {
+  const sdk = new Codex("dummy-key");
+
+  it("should set up queries", async () => {
+    jest.spyOn(sdk, "query").mockResolvedValue({
+      pairEvents: {
+        items: [
+          {
+            address: "0x1234",
+          },
+        ] as Event[],
+      },
+    });
+    const res = await sdk.queries.pairEvents({
+      query: { address: "0x1234", networkId: 1 },
+    });
+    expect(res.pairEvents?.items?.[0]?.address).toEqual("0x1234");
+    expect(sdk.queries).toBeDefined();
+  });
+
+  it("should have a pairEvents query", async () => {
+    jest.spyOn(sdk, "query").mockResolvedValue({
+      pairEvents: {
+        items: [
+          {
+            address: "0x1234",
+          },
+        ] as Event[],
+      },
+    });
+    const res = await sdk.queries.pairEvents({
+      query: { address: "0x1234", networkId: 1 },
+    });
+    expect(res.pairEvents?.items?.[0]?.address).toEqual("0x1234");
+    expect(sdk.queries).toBeDefined();
+  });
+});

package/src/sdk/Query.ts

@@ -0,0 +1,65 @@
+import {
+  FilterExchangesDocument,
+  FilterExchangesQueryVariables,
+  FilterPairsDocument,
+  FilterPairsQueryVariables,
+  FilterTokensDocument,
+  FilterTokensQueryVariables,
+  GetBarsDocument,
+  GetDetailedPairStatsDocument,
+  GetNetworksDocument,
+  GetNetworkStatusDocument,
+  GetSparklinesDocument,
+  GetSparklinesQueryVariables,
+  GetSymbolDocument,
+  GetSymbolQueryVariables,
+  GetTokenPriceDocument,
+  GetTokensDocument,
+  GetWebhooksDocument,
+  ListPairsForTokenDocument,
+  ListPairsForTokenQueryVariables,
+  ListTopTokensDocument,
+  PairEventsDocument,
+  PairEventsQueryVariables,
+  QueryGetBarsArgs,
+  QueryGetDetailedPairStatsArgs,
+  QueryGetNetworkStatusArgs,
+  QueryGetTokenPricesArgs,
+  QueryGetWebhooksArgs,
+  QueryListTopTokensArgs,
+  QueryTokenArgs,
+} from "./generated/graphql";
+import { Codex } from "./index";
+
+export class Query {
+  constructor(private sdk: Codex) {}
+  pairEvents = async (vars: PairEventsQueryVariables) =>
+    this.sdk.query(PairEventsDocument, vars);
+  sparklines = async (vars: GetSparklinesQueryVariables) =>
+    this.sdk.query(GetSparklinesDocument, vars);
+  token = async (vars: QueryTokenArgs) =>
+    this.sdk.query(GetTokensDocument, vars);
+  price = async (vars: QueryGetTokenPricesArgs) =>
+    this.sdk.query(GetTokenPriceDocument, vars);
+  detailedPairStats = async (vars: QueryGetDetailedPairStatsArgs) =>
+    this.sdk.query(GetDetailedPairStatsDocument, vars);
+  bars = async (vars: QueryGetBarsArgs) =>
+    this.sdk.query(GetBarsDocument, vars);
+  topTokens = async (vars: QueryListTopTokensArgs) =>
+    this.sdk.query(ListTopTokensDocument, vars);
+  filterTokens = async (vars: FilterTokensQueryVariables) =>
+    this.sdk.query(FilterTokensDocument, vars);
+  filterPairs = async (vars: FilterPairsQueryVariables) =>
+    this.sdk.query(FilterPairsDocument, vars);
+  listPairsForToken = async (vars: ListPairsForTokenQueryVariables) =>
+    this.sdk.query(ListPairsForTokenDocument, vars);
+  filterExchanges = async (vars: FilterExchangesQueryVariables) =>
+    this.sdk.query(FilterExchangesDocument, vars);
+  symbol = async (vars: GetSymbolQueryVariables) =>
+    this.sdk.query(GetSymbolDocument, vars);
+  networks = async () => this.sdk.query(GetNetworksDocument);
+  networkStatus = async (vars: QueryGetNetworkStatusArgs) =>
+    this.sdk.query(GetNetworkStatusDocument, vars);
+  getWebhooks = async (vars: QueryGetWebhooksArgs) =>
+    this.sdk.query(GetWebhooksDocument, vars);
+}

package/src/sdk/Subscribe.ts

@@ -0,0 +1,61 @@
+import { ExecutionResult, print } from "graphql";
+import { Sink } from "graphql-ws";
+
+import {
+  SubscriptionOnDetailedStatsUpdatedArgs,
+  SubscriptionOnNftAssetsCreatedArgs,
+  SubscriptionOnNftEventsCreatedArgs,
+} from "../resources/graphql";
+import {
+  OnBarsUpdatedDocument,
+  OnBarsUpdatedSubscription,
+  OnDetailedStatsUpdatedDocument,
+  OnDetailedStatsUpdatedSubscription,
+  OnEventsCreatedDocument,
+  OnEventsCreatedSubscription,
+  OnNftAssetsCreatedDocument,
+  OnNftAssetsCreatedSubscription,
+  OnNftEventsCreatedDocument,
+  OnNftEventsCreatedSubscription,
+  OnPairMetadataUpdatedDocument,
+  OnPairMetadataUpdatedSubscription,
+  OnPriceUpdatedDocument,
+  OnPriceUpdatedSubscription,
+  SubscriptionOnBarsUpdatedArgs,
+  SubscriptionOnEventsCreatedArgs,
+  SubscriptionOnPairMetadataUpdatedArgs,
+  SubscriptionOnPriceUpdatedArgs,
+} from "./generated/graphql";
+import { Codex } from "./index";
+
+export class Subscribe {
+  constructor(private sdk: Codex) {}
+  tokenPrices = async (
+    vars: SubscriptionOnPriceUpdatedArgs,
+    sink: Sink<ExecutionResult<OnPriceUpdatedSubscription>>,
+  ) => this.sdk.subscribe(print(OnPriceUpdatedDocument), vars, sink);
+  tokenEvents = async (
+    vars: SubscriptionOnEventsCreatedArgs,
+    sink: Sink<ExecutionResult<OnEventsCreatedSubscription>>,
+  ) => this.sdk.subscribe(print(OnEventsCreatedDocument), vars, sink);
+  bars = async (
+    vars: SubscriptionOnBarsUpdatedArgs,
+    sink: Sink<ExecutionResult<OnBarsUpdatedSubscription>>,
+  ) => this.sdk.subscribe(print(OnBarsUpdatedDocument), vars, sink);
+  detailedPairStats = async (
+    vars: SubscriptionOnDetailedStatsUpdatedArgs,
+    sink: Sink<ExecutionResult<OnDetailedStatsUpdatedSubscription>>,
+  ) => this.sdk.subscribe(print(OnDetailedStatsUpdatedDocument), vars, sink);
+  pairMetadata = async (
+    vars: SubscriptionOnPairMetadataUpdatedArgs,
+    sink: Sink<ExecutionResult<OnPairMetadataUpdatedSubscription>>,
+  ) => this.sdk.subscribe(print(OnPairMetadataUpdatedDocument), vars, sink);
+  nftAssets = async (
+    vars: SubscriptionOnNftAssetsCreatedArgs,
+    sink: Sink<ExecutionResult<OnNftAssetsCreatedSubscription>>,
+  ) => this.sdk.subscribe(print(OnNftAssetsCreatedDocument), vars, sink);
+  nftEvents = async (
+    vars: SubscriptionOnNftEventsCreatedArgs,
+    sink: Sink<ExecutionResult<OnNftEventsCreatedSubscription>>,
+  ) => this.sdk.subscribe(print(OnNftEventsCreatedDocument), vars, sink);
+}

package/src/sdk/generated/fragment-masking.ts

@@ -0,0 +1,66 @@
+import { ResultOf, DocumentTypeDecoration, TypedDocumentNode } from '@graphql-typed-document-node/core';
+import { FragmentDefinitionNode } from 'graphql';
+import { Incremental } from './graphql';
+
+
+export type FragmentType<TDocumentType extends DocumentTypeDecoration<any, any>> = TDocumentType extends DocumentTypeDecoration<
+  infer TType,
+  any
+>
+  ? [TType] extends [{ ' $fragmentName'?: infer TKey }]
+    ? TKey extends string
+      ? { ' $fragmentRefs'?: { [key in TKey]: TType } }
+      : never
+    : never
+  : never;
+
+// return non-nullable if `fragmentType` is non-nullable
+export function useFragment<TType>(
+  _documentNode: DocumentTypeDecoration<TType, any>,
+  fragmentType: FragmentType<DocumentTypeDecoration<TType, any>>
+): TType;
+// return nullable if `fragmentType` is nullable
+export function useFragment<TType>(
+  _documentNode: DocumentTypeDecoration<TType, any>,
+  fragmentType: FragmentType<DocumentTypeDecoration<TType, any>> | null | undefined
+): TType | null | undefined;
+// return array of non-nullable if `fragmentType` is array of non-nullable
+export function useFragment<TType>(
+  _documentNode: DocumentTypeDecoration<TType, any>,
+  fragmentType: ReadonlyArray<FragmentType<DocumentTypeDecoration<TType, any>>>
+): ReadonlyArray<TType>;
+// return array of nullable if `fragmentType` is array of nullable
+export function useFragment<TType>(
+  _documentNode: DocumentTypeDecoration<TType, any>,
+  fragmentType: ReadonlyArray<FragmentType<DocumentTypeDecoration<TType, any>>> | null | undefined
+): ReadonlyArray<TType> | null | undefined;
+export function useFragment<TType>(
+  _documentNode: DocumentTypeDecoration<TType, any>,
+  fragmentType: FragmentType<DocumentTypeDecoration<TType, any>> | ReadonlyArray<FragmentType<DocumentTypeDecoration<TType, any>>> | null | undefined
+): TType | ReadonlyArray<TType> | null | undefined {
+  return fragmentType as any;
+}
+
+
+export function makeFragmentData<
+  F extends DocumentTypeDecoration<any, any>,
+  FT extends ResultOf<F>
+>(data: FT, _fragment: F): FragmentType<F> {
+  return data as FragmentType<F>;
+}
+export function isFragmentReady<TQuery, TFrag>(
+  queryNode: DocumentTypeDecoration<TQuery, any>,
+  fragmentNode: TypedDocumentNode<TFrag>,
+  data: FragmentType<TypedDocumentNode<Incremental<TFrag>, any>> | null | undefined
+): data is FragmentType<typeof fragmentNode> {
+  const deferredFields = (queryNode as { __meta__?: { deferredFields: Record<string, (keyof TFrag)[]> } }).__meta__
+    ?.deferredFields;
+
+  if (!deferredFields) return true;
+
+  const fragDef = fragmentNode.definitions[0] as FragmentDefinitionNode | undefined;
+  const fragName = fragDef?.name?.value;
+
+  const fields = (fragName && deferredFields[fragName]) || [];
+  return fields.length > 0 && fields.every(field => data && field in data);
+}