graphql-http

import {
  createHandler,
  useGraphQLPlayground,
} from "https://deno.land/x/graphql_http@$VERSION/mod.ts";
import { serve, Status } from "https://deno.land/std@$VERSION/http/mod.ts";
import { buildSchema } from "https://esm.sh/graphql@$VERSION";

const schema = buildSchema(`type Query {
    hello: String!
  }`);

let handler = createHandler(schema, {
  rootValue: {
    hello: "world",
  },
});
handler = useGraphQLPlayground(handler);

serve((req) => {
  const { pathname } = new URL(req.url);
  if (pathname === "/graphql") {
    return handler(req);
  }
  return new Response("Not Found", {
    status: Status.NotFound,
  });
});
// Listening on <BASE_URL>

import { gqlFetch } from "https://deno.land/x/graphql_http@$VERSION/mod.ts";

const { data, errors, extensions } = await gqlFetch({
  url: `<BASE_URL>/graphql`,
  query: `query { hello }`,
});

import { createHandler } from "https://deno.land/x/graphql_http@$VERSION/mod.ts";
import { buildSchema } from "https://esm.sh/graphql@$VERSION";

const schema = buildSchema(`type Query {
    hello: String!
  }`);

const handler = createHandler(schema, {
  rootValue: {
    hello: "world",
  },
});
const req = new Request("<ENDPOINT>");
const res = await handler(req);

import { gqlFetch } from "https://deno.land/x/graphql_http@$VERSION/mod.ts";

const { data, errors, extensions } = await gqlFetch({
  url: `<graphql-endpoint>`,
  query: `query Greet(name: $name) {
    hello(name: $name)
  }`,
}, {
  variables: {
    name: "Bob",
  },
  operationName: "Greet",
  method: "GET",
});

type json =
  | string
  | number
  | boolean
  | null
  | { [k: string]: json }
  | json[];

type jsonObject = {
  [k: string]: json;
};

import {
  createHandler,
  useGraphQLPlayground,
} from "https://deno.land/x/graphql_http@$VERSION/mod.ts";
import { buildSchema } from "https://esm.sh/graphql@$VERSION";

const schema = buildSchema(`type Query {
    hello: String!
  }`);

let handler = createHandler(schema, {
  rootValue: {
    hello: "world",
  },
});
handler = useGraphQLPlayground(handler);
const req = new Request("<ENDPOINT>");
const res = await handler(req);

interface ISettings {
  "editor.cursorShape": "line" | "block" | "underline";
  "editor.fontFamily": string;
  "editor.fontSize": number;
  "editor.reuseHeaders": boolean;
  "editor.theme": "dark" | "light";
  "general.betaUpdates": boolean;
  "prettier.printWidth": number;
  "prettier.tabWidth": number;
  "prettier.useTabs": boolean;
  "request.credentials": "omit" | "include" | "same-origin";
  "request.globalHeaders": { [key: string]: string };
  "schema.polling.enable": boolean;
  "schema.polling.endpointFilter": string;
  "schema.polling.interval": number;
  "schema.disableComments": boolean;
  "tracing.hideTracingResponse": boolean;
  "tracing.tracingSupported": boolean;
}
interface Tab {
  endpoint: string;
  query: string;
  name?: string;
  variables?: string;
  responses?: string[];
  headers?: {
    [key: string]: string;
  };
}
interface EditorColours {
  property: string;
  comment: string;
  punctuation: string;
  keyword: string;
  def: string;
  qualifier: string;
  attribute: string;
  number: string;
  string: string;
  builtin: string;
  string2: string;
  variable: string;
  meta: string;
  atom: string;
  ws: string;
  selection: string;
  cursorColor: string;
  editorBackground: string;
  resultBackground: string;
  leftDrawerBackground: string;
  rightDrawerBackground: string;
}

import { createRequest } from "https://deno.land/x/graphql_http@$VERSION/mod.ts";

const [request, err] = createRequest({
  url: "<graphql-endpoint>",
  query: `query Greet(name: $name) {
    hello(name: $name)
  }`,
  method: "GET",
});

if (!err) {
  const res = await fetch(request);
}

import {
  resolveRequest,
} from "https://deno.land/x/graphql_http@$VERSION/mod.ts";

const req = new Request("<graphql-endpoint>"); // any Request
const [data, err] = await resolveRequest(req);
if (data) {
  const { query, variableValues, operationName, extensions } = data;
}

import {
  createResponse,
} from "https://deno.land/x/graphql_http@$VERSION/mod.ts";
import { buildSchema } from "https://esm.sh/graphql@$VERSION";

const schema = buildSchema(`query {
  hello: String!
}`);

const res = createResponse({
  schema,
  source: `query { hello }`,
  method: "POST",
}, {
  rootValue: {
    hello: "world",
  },
});

import {
  resolveResponse,
} from "https://deno.land/x/graphql_http@$VERSION/mod.ts";

const res = new Response(); // any Response
const { data, errors, extensions } = await resolveResponse(res);

import { GraphQLError } from "https://esm.sh/graphql@$VERSION";
import { json } from "https://deno.land/x/pure_json@$VERSION/mod.ts";
type PickBy<T, K> = {
  [k in keyof T as (K extends T[k] ? k : never)]: T[k];
};

type SerializedGraphQLError = PickBy<GraphQLError, json | undefined>;
type Result<
  T extends Record<string, unknown> = Record<string, unknown>,
> = {
  data?: T;
  errors?: SerializedGraphQLError[];
  extensions?: unknown;
};

import { gql } from "https://deno.land/x/graphql_http@$VERSION/mod.ts";
import { assertEquals } from "https://deno.land/std@$VERSION/testing/asserts.ts";

const query = gql`query Test {
  hello
}`;
assertEquals(query, "query Test{hello}");