@codex-data/sdk 0.5.7

package/src/sdk/index.ts

@@ -0,0 +1,100 @@
+import { TypedDocumentNode } from "@graphql-typed-document-node/core";
+import { GraphQLClient, Variables } from "graphql-request";
+import { VariablesAndRequestHeadersArgs } from "graphql-request/build/esm/types";
+import {
+  Client as GraphQLWsClient,
+  createClient,
+  ExecutionResult,
+  Sink,
+} from "graphql-ws";
+import WebSocket from "isomorphic-ws";
+
+import { invariant } from "./invariant";
+import { Mutation } from "./Mutation";
+import { Query } from "./Query";
+import { Subscribe } from "./Subscribe";
+
+export type CleanupFunction = () => void;
+
+export class Codex {
+  private client: GraphQLClient;
+  private wsClient: GraphQLWsClient;
+  public queries: Query;
+  public mutations: Mutation;
+  public subscriptions: Subscribe;
+
+  constructor(
+    private apiKey: string,
+    private apiUrl: string = `https://graph.codex.io/graphql`,
+    private apiRealtimeUrl: string = `wss://graph.codex.io/graphql`,
+  ) {
+    invariant(this.apiKey, "apiKey must be defined");
+    this.queries = new Query(this);
+    this.mutations = new Mutation(this);
+    this.subscriptions = new Subscribe(this);
+    this.client = new GraphQLClient(this.apiUrl, {
+      method: "POST",
+      headers: new Headers({
+        "Content-Type": "application/json",
+        Authorization: this.apiKey,
+        "X-Apollo-Operation-Name": "query",
+      }),
+    });
+    this.wsClient = createClient({
+      webSocketImpl: WebSocket,
+      url: this.apiRealtimeUrl,
+      connectionParams: {
+        Authorization: this.apiKey,
+      },
+    });
+  }
+
+  public async query<TResults, TVars extends Variables>(
+    doc: TypedDocumentNode<TResults, TVars>,
+    args: TVars = {} as TVars,
+  ) {
+    const res = await this.client.request<typeof doc, TVars>(
+      doc,
+      ...([args] as unknown as VariablesAndRequestHeadersArgs<TVars>),
+    );
+    return res as TResults;
+  }
+
+  public async mutation<TResults, TVars extends Variables>(
+    doc: TypedDocumentNode<TResults, TVars>,
+    args: TVars = {} as TVars,
+  ) {
+    const res = await this.client.request<typeof doc, TVars>(
+      doc,
+      ...([args] as unknown as VariablesAndRequestHeadersArgs<TVars>),
+    );
+    return res as TResults;
+  }
+
+  // Very simple network based fetch implementation, no compilation required
+  public async send<TResults, V extends Variables = Variables>(
+    gqlString: string,
+    args: V = {} as V,
+  ) {
+    const res = await this.client.request<TResults>(gqlString, args);
+    return res;
+  }
+
+  public subscribe<
+    TResults,
+    TVars extends Record<string, unknown> = Record<string, never>,
+  >(
+    doc: string,
+    args: TVars,
+    sink: Sink<ExecutionResult<TResults>>,
+  ): CleanupFunction {
+    const cleanup = this.wsClient.subscribe<TResults>(
+      {
+        query: doc,
+        variables: args,
+      },
+      sink,
+    );
+    return cleanup;
+  }
+}

package/src/sdk/invariant.ts

@@ -0,0 +1,34 @@
+const isProduction: boolean = process.env.NODE_ENV === "production";
+const prefix = "Invariant failed";
+
+// Throw an error if the condition fails
+// Strip out error messages for production
+// > Not providing an inline default argument for message as the result is smaller
+export function invariant(
+  condition: unknown,
+  // Can provide a string, or a function that returns a string for cases where
+  // the message takes a fair amount of effort to compute
+  message?: string | (() => string),
+): asserts condition {
+  if (condition) {
+    return;
+  }
+  // Condition not passed
+
+  // In production we strip the message but still throw
+  if (isProduction) {
+    throw new Error(prefix);
+  }
+
+  // When not in production we allow the message to pass through
+  // *This block will be removed in production builds*
+
+  const provided: string | undefined =
+    typeof message === "function" ? message() : message;
+
+  // Options:
+  // 1. message provided: `${prefix}: ${provided}`
+  // 2. message not provided: prefix
+  const value: string = provided ? `${prefix}: ${provided}` : prefix;
+  throw new Error(value);
+}