npm package discovery and stats viewer.

Discover Tips

  • General search

    [free text search, go nuts!]

  • Package details

    pkg:[package-name]

  • User packages

    @[username]

Sponsor

Optimize Toolset

I’ve always been into building performant and accessible sites, but lately I’ve been taking it extremely seriously. So much so that I’ve been building a tool to help me optimize and monitor the sites that I build to make sure that I’m making an attempt to offer the best experience to those who visit them. If you’re into performant, accessible and SEO friendly sites, you might like it too! You can check it out at Optimize Toolset.

About

Hi, 👋, I’m Ryan Hefner  and I built this site for me, and you! The goal of this site was to provide an easy way for me to check the stats on my npm packages, both for prioritizing issues and updates, and to give me a little kick in the pants to keep up on stuff.

As I was building it, I realized that I was actually using the tool to build the tool, and figured I might as well put this out there and hopefully others will find it to be a fast and useful way to search and browse npm packages as I have.

If you’re interested in other things I’m working on, follow me on Twitter or check out the open source projects I’ve been publishing on GitHub.

I am also working on a Twitter bot for this site to tweet the most popular, newest, random packages from npm. Please follow that account now and it will start sending out packages soon–ish.

Open Software & Tools

This site wouldn’t be possible without the immense generosity and tireless efforts from the people who make contributions to the world and share their work via open source initiatives. Thank you 🙏

© 2024 – Pkg Stats / Ryan Hefner

@devtea2025/voluptatibus-vero-magni-rerum

v1.0.0

Published

Downloads

5

Maintainers

tranvuchinh5538tranvuchinh5538

Keywords

jsdommobileredux-toolkitobjectzoddeletearraybufferglaciertouchWebSocket__proto__react-hook-formgraphql$.extendhasOwnpromisescolumnses7httpscryptwarningemojiagentwritecolourmkdirpES2021getoptintrinsicterminalUint32ArrayrangeerrorwidthkeyfindLastIndexregularglobalsa11yObservablesprotocol-buffersproxyinputvariables in csstestassertloadbalancingtypeerrorcode pointsio-tsUint16Arrayfast-clonedebugtslibcss-in-jsroute53jestArray.prototype.findLastmiddlewarewaitcontainsmime-dbgetPrototypeOfreact-testing-libraryxhrstringfpschinesePromisesetstatejapanesetypedprogressfileless compilerclassesjsdiffauthenticationtypecss lessprettyless csscodeserrorloggervisualrgbexpressrequestworkerkinesisduplexsymlinkslockfileelmsequencees8stylingfilterlinewrapdescriptoryamlES3sortedYAMLObject.definePropertystablearktypeArray.prototype.contains_.extendhelperstimecheck@@toStringTagansiRxJSfullwidtheventEmittermake dirObject.entriesoutputscheme-validationes-shimsnested cssformstreamextensionsymbolselectrontyped arraystatelessworkspace:*getOwnPropertyDescriptorwalkargslimitdependency managertelephoneprunefsdeterministicmomentmapuninstallslotpropertyunicodevalidebscommandfind-updependenciesgradients cssclientveststyleguideparsespecsliceratewritableRegExp.prototype.flagsauthIteratorclitoobjectcloudtrailpipeeast-asian-widthArray.prototype.includesstyleindicatorconcurrencyenvironmentsbootstrap cssdomdiffaccessorbindenumerableArray.prototype.flattenassignphoneavatypesfetcheslintmergegradients css3browseriterateinternal slotES2016cloudfrontstatusreadstringifyUint8ClampedArraypropinspectforEachES2022redactrapidpostcss-pluginequalbrowserlistpredictablemovereducerclonetextmodulesajvdiroffsetinternalRFC-6455PushsqselbargparsebluebirdreadablecommanderidentifiersyuptostringtagfromwatchpluginreusereplaytrimEndstringifierlistenersidhasOwnPropertyFunction.prototype.nametapeframeworkaccessibilitygetterrestfulutilitiesflatcallbindremovecssregexpquerystringcloudformationawaitpatchguidrequireistapoptimistregular expressionsReactiveXsetPrototypeOfcollectionUnderscoreexit-codedescriptorsSymbolES2023call-boundsuperstructcensorarraychromesidepromisehttpsharedasciitrimStartAsyncIteratorESchromiumnegative zerodatelesscssartmochapostcssECMAScript 2021runtimestreams2queueMicrotaskpropertiesfseventslrushrinkwraptraverselesswordwrapbatchhandlersflagsmatchses.envFloat32ArraybusykarmagdprHyBiefficientMapsymlinkdeepcloneautoscalingajaxassertiones-abstractjoiisConcatSpreadablekoreanpicomatchimmerbytelook-upgetintrinsicdropsigtermfullinferencebyteLengthjavascriptECMAScript 2023deep-copyURLSearchParamsdefinetoArrayzeroowncloudwatchES7react-hookslimited0MicrosoftflatMapes2016flagconfigurablefixed-widthcorestreamsirqfastcopybuffercloudsearchlazyArray.prototype.flatMapcharactervalidationgetObject.fromEntriesfastifyes2015formattingdeepecmascriptWeakMapdataViewWebSocketssymbolWeakSetonceinstallsharedarraybufferpackage.jsonES5structuredClonestdlibjslinuxes2018awesomesauceautoprefixerhas-ownbreakless.jsCSSimportexportString.prototype.trimsinatraeventDispatchercallbackwrapObject.keysES2015jasmineminimalstyleschannelapolloexitweaksetgenericscore-jsworkflowarraysidleparentestreevaluesTypeScriptfunctionlintapies6shamdotenvfindupdatamimestyled-componentscallcss variablewgetnegativermdirbufferses-shim APIcolorsschemaloggingESnextreal-timejsonES2020fast-copynumberextendeslint-pluginsetImmediatecomparegroupcompilereslintconfigFloat64ArrayTypeBoxspeedObject.assignfast-deep-copycurltrimRightparseriterationtaskrobustiteratorsettertoStringTagformsES2019ieargumentinappchaiupimportclass-validatorfull-widthsignalastenvObjectpreserve-symlinkstsresolveRxwordbreakvalidatequoterm -frmixinsconsoleObject.isSetliveArrayglobaldataviewboundutilStyleSheetstylesheeteslintpluginReactiveExtensionsECMAScript 7css nestingwatcheroptimizerkeysfluxemitsyntaxerrorregexes5rdsnopespinnermruttybannerencryptionpackagesfastclonecall-bindtermserializationthrottleargvflattenendpointbcryptextrahasrfc4122protodynamodbasynccharactersrmES2018toSortedimmutablesiginttypanionopenbeanstalkArrayBufferwhichclassnamesInt16Arraycachei18ninterrupts[[Prototype]]libphonenumberdirectoryexpressionconnectECMAScript 2022256rm -rfmulti-packagepasswordhigher-ordercompile lesscjkhooksglobmoduleoptionsameValueZeroenvironmentfindLastregular expressionlooknativeString.prototype.matchAllmatchesfigletserializerdefinePropertyBigUint64Arrayhottestingbootstrap lessmkdirvpcURLshebangratelimitdescriptionnpmrecursiveshimpackage managersnstrimLeftRegExp#flagsnameconfigcomputed-typesECMAScript 5s3walkingparsingprototypewatchingponyfillparentsprivatehardlinkstc39Object.valueslogdebuggerexecECMAScript 2016syntaxsortevery

Readme

Continuous integration @devtea2025/voluptatibus-vero-magni-rerum

Quickly check for compliance? Visit @devtea2025/voluptatibus-vero-magni-rerum.com!

Want a full-featured server? See the servers section!

Need subscriptions? Try graphql-ws or graphql-sse instead!

Getting started

Install

yarn add @devtea2025/voluptatibus-vero-magni-rerum

Create a GraphQL schema

import { GraphQLSchema, GraphQLObjectType, GraphQLString } from 'graphql';

/**
 * Construct a GraphQL schema and define the necessary resolvers.
 *
 * type Query {
 *   hello: String
 * }
 */
const schema = new GraphQLSchema({
  query: new GraphQLObjectType({
    name: 'Query',
    fields: {
      hello: {
        type: GraphQLString,
        resolve: () => 'world',
      },
    },
  }),
});

Start the server

With http
import http from 'http';
import { createHandler } from '@devtea2025/voluptatibus-vero-magni-rerum/lib/use/http';
import { schema } from './previous-step';

// Create the GraphQL over HTTP Node request handler
const handler = createHandler({ schema });

// Create a HTTP server using the listener on `/graphql`
const server = http.createServer((req, res) => {
  if (req.url.startsWith('/graphql')) {
    handler(req, res);
  } else {
    res.writeHead(404).end();
  }
});

server.listen(4000);
console.log('Listening to port 4000');
With http2

Browsers might complain about self-signed SSL/TLS certificates. Help can be found on StackOverflow.

$ openssl req -x509 -newkey rsa:2048 -nodes -sha256 -subj '/CN=localhost' \
  -keyout localhost-privkey.pem -out localhost-cert.pem
import fs from 'fs';
import http2 from 'http2';
import { createHandler } from '@devtea2025/voluptatibus-vero-magni-rerum/lib/use/http2';
import { schema } from './previous-step';

// Create the GraphQL over HTTP Node request handler
const handler = createHandler({ schema });

// Create a HTTP/2 server using the handler on `/graphql`
const server = http2.createSecureServer(
  {
    key: fs.readFileSync('localhost-privkey.pem'),
    cert: fs.readFileSync('localhost-cert.pem'),
  },
  (req, res) => {
    if (req.url.startsWith('/graphql')) {
      handler(req, res);
    } else {
      res.writeHead(404).end();
    }
  },
);

server.listen(4000);
console.log('Listening to port 4000');
With express
import express from 'express'; // yarn add express
import { createHandler } from '@devtea2025/voluptatibus-vero-magni-rerum/lib/use/express';
import { schema } from './previous-step';

// Create a express instance serving all methods on `/graphql`
// where the GraphQL over HTTP express request handler is
const app = express();
app.all('/graphql', createHandler({ schema }));

app.listen({ port: 4000 });
console.log('Listening to port 4000');
With fastify
import Fastify from 'fastify'; // yarn add fastify
import { createHandler } from '@devtea2025/voluptatibus-vero-magni-rerum/lib/use/fastify';
import { schema } from './previous-step';

// Create a fastify instance serving all methods on `/graphql`
// where the GraphQL over HTTP fastify request handler is
const fastify = Fastify();
fastify.all('/graphql', createHandler({ schema }));

fastify.listen({ port: 4000 });
console.log('Listening to port 4000');
With Koa
import Koa from 'koa'; // yarn add koa
import mount from 'koa-mount'; // yarn add koa-mount
import { createHandler } from '@devtea2025/voluptatibus-vero-magni-rerum/lib/use/koa';
import { schema } from './previous-step';

const app = new Koa();
app.use(mount('/graphql', createHandler({ schema })));

app.listen({ port: 4000 });
console.log('Listening to port 4000');
With uWebSockets.js
import uWS from 'uWebSockets.js'; // yarn add uWebSockets.js@uNetworking/uWebSockets.js#<version>
import { createHandler } from '@devtea2025/voluptatibus-vero-magni-rerum/lib/use/uWebSockets';
import { schema } from './previous-step';

uWS
  .App()
  .any('/graphql', createHandler({ schema }))
  .listen(4000, () => {
    console.log('Listening to port 4000');
  });
With Deno
import { serve } from 'https://deno.land/[email protected]/http/server.ts';
import { createHandler } from 'https://esm.sh/@devtea2025/voluptatibus-vero-magni-rerum/lib/use/fetch';
import { schema } from './previous-step';

// Create the GraphQL over HTTP native fetch handler
const handler = createHandler({ schema });

// Start serving on `/graphql` using the handler
await serve(
  (req: Request) => {
    const [path, _search] = req.url.split('?');
    if (path.endsWith('/graphql')) {
      return handler(req);
    } else {
      return new Response(null, { status: 404 });
    }
  },
  {
    port: 4000, // Listening to port 4000
  },
);
With Bun
import { createHandler } from '@devtea2025/voluptatibus-vero-magni-rerum/lib/use/fetch'; // bun install @devtea2025/voluptatibus-vero-magni-rerum
import { schema } from './previous-step';

// Create the GraphQL over HTTP native fetch handler
const handler = createHandler({ schema });

// Start serving on `/graphql` using the handler
export default {
  port: 4000, // Listening to port 4000
  fetch(req) {
    const [path, _search] = req.url.split('?');
    if (path.endsWith('/graphql')) {
      return handler(req);
    } else {
      return new Response(null, { status: 404 });
    }
  },
};
With Netlify Functions
import { createHandler } from '@devtea2025/voluptatibus-vero-magni-rerum/lib/use/@netlify/functions'; // yarn add @netlify/functions
import { schema } from './previous-step';

// Create the GraphQL over HTTP native fetch handler
export const handler = createHandler({ schema });

Use the client

import { createClient } from '@devtea2025/voluptatibus-vero-magni-rerum';

const client = createClient({
  url: 'http://localhost:4000/graphql',
});

(async () => {
  let cancel = () => {
    /* abort the request if it is in-flight */
  };

  const result = await new Promise((resolve, reject) => {
    let result;
    cancel = client.subscribe(
      {
        query: '{ hello }',
      },
      {
        next: (data) => (result = data),
        error: reject,
        complete: () => resolve(result),
      },
    );
  });

  expect(result).toEqual({ hello: 'world' });
})();

Serve GraphiQL

Thanks to ruru, serving GraphiQL is as easy as running:

npx ruru -SP -p 4001 -e http://localhost:4000/graphql

Open http://localhost:4001 in the browser to use it.

Recipes

import { ExecutionResult } from 'graphql';
import { createClient, RequestParams } from '@devtea2025/voluptatibus-vero-magni-rerum';
import { getSession } from './my-auth';

const client = createClient({
  url: 'http://hey.there:4000/graphql',
  headers: async () => {
    const session = await getSession();
    if (session) {
      return {
        Authorization: `Bearer ${session.token}`,
      };
    }
  },
});

function execute<Data, Extensions>(
  params: RequestParams,
): [request: Promise<ExecutionResult<Data, Extensions>>, cancel: () => void] {
  let cancel!: () => void;
  const request = new Promise<ExecutionResult<Data, Extensions>>(
    (resolve, reject) => {
      let result: ExecutionResult<Data, Extensions>;
      cancel = client.subscribe<Data, Extensions>(params, {
        next: (data) => (result = data),
        error: reject,
        complete: () => resolve(result),
      });
    },
  );
  return [request, cancel];
}

(async () => {
  const [request, cancel] = execute({
    query: '{ hello }',
  });

  // just an example, not a real function
  onUserLeavePage(() => {
    cancel();
  });

  const result = await request;

  expect(result).toBe({ data: { hello: 'world' } });
})();
import { Observable } from 'relay-runtime';
// or
import { Observable } from '@apollo/client/core';
// or
import { Observable } from 'rxjs';
// or
import Observable from 'zen-observable';
// or any other lib which implements Observables as per the ECMAScript proposal: https://github.com/tc39/proposal-observable
import { createClient } from '@devtea2025/voluptatibus-vero-magni-rerum';
import { getSession } from './my-auth';

const client = createClient({
  url: 'http://graphql.loves:4000/observables',
  headers: async () => {
    const session = await getSession();
    if (session) {
      return {
        Authorization: `Bearer ${session.token}`,
      };
    }
  },
});

const observable = new Observable((observer) =>
  client.subscribe({ query: '{ hello }' }, observer),
);

const subscription = observable.subscribe({
  next: (result) => {
    expect(result).toBe({ data: { hello: 'world' } });
  },
});

// unsubscribe will cancel the request if it is pending
subscription.unsubscribe();
import { GraphQLError } from 'graphql';
import {
  Network,
  Observable,
  RequestParameters,
  Variables,
} from 'relay-runtime';
import { createClient } from '@devtea2025/voluptatibus-vero-magni-rerum';
import { getSession } from './my-auth';

const client = createClient({
  url: 'http://i.love:4000/graphql',
  headers: async () => {
    const session = await getSession();
    if (session) {
      return {
        Authorization: `Bearer ${session.token}`,
      };
    }
  },
});

function fetch(operation: RequestParameters, variables: Variables) {
  return Observable.create((sink) => {
    if (!operation.text) {
      return sink.error(new Error('Operation text cannot be empty'));
    }
    return client.subscribe(
      {
        operationName: operation.name,
        query: operation.text,
        variables,
      },
      sink,
    );
  });
}

export const network = Network.create(fetch);
import {
  ApolloLink,
  Operation,
  FetchResult,
  Observable,
} from '@apollo/client/core';
import { print, GraphQLError } from 'graphql';
import { createClient, ClientOptions, Client } from '@devtea2025/voluptatibus-vero-magni-rerum';
import { getSession } from './my-auth';

class HTTPLink extends ApolloLink {
  private client: Client;

  constructor(options: ClientOptions) {
    super();
    this.client = createClient(options);
  }

  public request(operation: Operation): Observable<FetchResult> {
    return new Observable((sink) => {
      return this.client.subscribe<FetchResult>(
        { ...operation, query: print(operation.query) },
        {
          next: sink.next.bind(sink),
          complete: sink.complete.bind(sink),
          error: sink.error.bind(sink),
        },
      );
    });
  }
}

const link = new HTTPLink({
  url: 'http://where.is:4000/graphql',
  headers: async () => {
    const session = await getSession();
    if (session) {
      return {
        Authorization: `Bearer ${session.token}`,
      };
    }
  },
});
import { createClient, NetworkError } from '@devtea2025/voluptatibus-vero-magni-rerum';

const client = createClient({
  url: 'http://unstable.service:4000/graphql',
  shouldRetry: async (err: NetworkError, retries: number) => {
    if (retries > 3) {
      // max 3 retries and then report service down
      return false;
    }

    // try again when service unavailable, could be temporary
    if (err.response?.status === 503) {
      // wait one second (you can alternatively time the promise resolution to your preference)
      await new Promise((resolve) => setTimeout(resolve, 1000));
      return true;
    }

    // otherwise report error immediately
    return false;
  },
});
<!doctype html>
<html>
  <head>
    <meta charset="utf-8" />
    <title>GraphQL over HTTP</title>
    <script
      type="text/javascript"
      src="https://unpkg.com/@devtea2025/voluptatibus-vero-magni-rerum/umd/@devtea2025/voluptatibus-vero-magni-rerum.min.js"
    ></script>
  </head>
  <body>
    <script type="text/javascript">
      const client = graphqlHttp.createClient({
        url: 'http://umdfor.the:4000/win/graphql',
      });

      // consider other recipes for usage inspiration
    </script>
  </body>
</html>
const fetch = require('node-fetch'); // yarn add node-fetch
const { AbortController } = require('node-abort-controller'); // (node < v15) yarn add node-abort-controller
const { createClient } = require('@devtea2025/voluptatibus-vero-magni-rerum');

const client = createClient({
  url: 'http://no.browser:4000/graphql',
  fetchFn: fetch,
  abortControllerImpl: AbortController, // node < v15
});

// consider other recipes for usage inspiration
import { createClient } from 'https://esm.sh/@devtea2025/voluptatibus-vero-magni-rerum';

const client = createClient({
  url: 'http://deno.earth:4000/graphql',
});

// consider other recipes for usage inspiration
import { createClient } from '@devtea2025/voluptatibus-vero-magni-rerum'; // bun install @devtea2025/voluptatibus-vero-magni-rerum

const client = createClient({
  url: 'http://bun.bread:4000/graphql',
});

// consider other recipes for usage inspiration
import express from 'express';
import { schema } from './my-graphql-schema';

-import { graphqlHTTP } from 'express-graphql';
+import { createHandler } from '@devtea2025/voluptatibus-vero-magni-rerum/lib/use/express';

const app = express();

app.use(
  '/graphql',
-  graphqlHTTP({ schema }),
+  createHandler({ schema }),
);

app.listen(4000);

Authenticate the user within @devtea2025/voluptatibus-vero-magni-rerum during GraphQL execution context assembly. This is a approach is less safe compared to early authentication (see early authentication in Node) because some GraphQL preparations or operations are executed even if the user is not unauthorized.

import { createHandler } from '@devtea2025/voluptatibus-vero-magni-rerum';
import {
  schema,
  getUserFromCookies,
  getUserFromAuthorizationHeader,
} from './my-graphql';

const handler = createHandler({
  schema,
  context: async (req) => {
    // process token, authenticate user and attach it to your graphql context
    const userId = await getUserFromCookies(req.headers.cookie);
    // or
    const userId = await getUserFromAuthorizationHeader(
      req.headers.authorization,
    );

    // respond with 401 if the user was not authenticated
    if (!userId) {
      return [null, { status: 401, statusText: 'Unauthorized' }];
    }

    // otherwise attach the user to the graphql context
    return { userId };
  },
});
import { createHandler } from '@devtea2025/voluptatibus-vero-magni-rerum';
import { schema, getDynamicContext } from './my-graphql';

const handler = createHandler({
  schema,
  context: async (req, args) => {
    return getDynamicContext(req, args);
  },
  // or static context by supplying the value directly
});
import { parse } from 'graphql';
import { createHandler } from '@devtea2025/voluptatibus-vero-magni-rerum';
import { getSchemaForRequest, myValidationRules } from './my-graphql';

const handler = createHandler({
  onSubscribe: async (req, params) => {
    const schema = await getSchemaForRequest(req);

    const args = {
      schema,
      operationName: params.operationName,
      document: parse(params.query),
      variableValues: params.variables,
    };

    return args;
  },
});

Authenticate the user early, before reaching @devtea2025/voluptatibus-vero-magni-rerum. This is the recommended approach because no GraphQL preparations or operations are executed if the user is not authorized.

import { createHandler } from '@devtea2025/voluptatibus-vero-magni-rerum';
import {
  schema,
  getUserFromCookies,
  getUserFromAuthorizationHeader,
} from './my-graphql';

const handler = createHandler({
  schema,
  context: async (req) => {
    // user is authenticated early (see below), simply attach it to the graphql context
    return { userId: req.raw.userId };
  },
});

const server = http.createServer(async (req, res) => {
  if (!req.url.startsWith('/graphql')) {
    return res.writeHead(404).end();
  }

  try {
    // process token, authenticate user and attach it to the request
    req.userId = await getUserFromCookies(req.headers.cookie);
    // or
    req.userId = await getUserFromAuthorizationHeader(
      req.headers.authorization,
    );

    // respond with 401 if the user was not authenticated
    if (!req.userId) {
      return res.writeHead(401, 'Unauthorized').end();
    }

    const [body, init] = await handler({
      url: req.url,
      method: req.method,
      headers: req.headers,
      body: () =>
        new Promise((resolve) => {
          let body = '';
          req.on('data', (chunk) => (body += chunk));
          req.on('end', () => resolve(body));
        }),
      raw: req,
    });
    res.writeHead(init.status, init.statusText, init.headers).end(body);
  } catch (err) {
    res.writeHead(500).end(err.message);
  }
});

server.listen(4000);
console.log('Listening to port 4000');
import http from 'http';
import { createHandler } from '@devtea2025/voluptatibus-vero-magni-rerum/lib/use/http';
import processRequest from 'graphql-upload/processRequest.mjs'; // yarn add graphql-upload
import { schema } from './my-graphql';

const handler = createHandler({
  schema,
  async parseRequestParams(req) {
    const params = await processRequest(req.raw, req.context.res);
    if (Array.isArray(params)) {
      throw new Error('Batching is not supported');
    }
    return {
      ...params,
      // variables must be an object as per the GraphQL over HTTP spec
      variables: Object(params.variables),
    };
  },
});

const server = http.createServer((req, res) => {
  if (req.url.startsWith('/graphql')) {
    handler(req, res);
  } else {
    res.writeHead(404).end();
  }
});

server.listen(4000);
console.log('Listening to port 4000');
import express from 'express'; // yarn add express
import { createHandler } from '@devtea2025/voluptatibus-vero-magni-rerum/lib/use/express';
import processRequest from 'graphql-upload/processRequest.mjs'; // yarn add graphql-upload
import { schema } from './my-graphql';

const app = express();
app.all(
  '/graphql',
  createHandler({
    schema,
    async parseRequestParams(req) {
      const params = await processRequest(req.raw, req.context.res);
      if (Array.isArray(params)) {
        throw new Error('Batching is not supported');
      }
      return {
        ...params,
        // variables must be an object as per the GraphQL over HTTP spec
        variables: Object(params.variables),
      };
    },
  }),
);

app.listen({ port: 4000 });
console.log('Listening to port 4000');
import { fetch } from '@whatwg-node/fetch';
import { serverAudits } from '@devtea2025/voluptatibus-vero-magni-rerum';

for (const audit of serverAudits({
  url: 'http://localhost:4000/graphql',
  fetchFn: fetch,
})) {
  test(audit.name, async () => {
    const result = await audit.fn();
    if (result.status === 'error') {
      throw result.reason;
    }
    if (result.status === 'warn') {
      console.warn(result.reason); // or throw if you want full compliance (warnings are not requirements)
    }
    // result.status === 'ok'
  });
}
import { serverAudits } from 'npm:@devtea2025/voluptatibus-vero-magni-rerum';

for (const audit of serverAudits({
  url: 'http://localhost:4000/graphql',
  fetchFn: fetch,
})) {
  Deno.test(audit.name, async () => {
    const result = await audit.fn();
    if (result.status === 'error') {
      throw result.reason;
    }
    if (result.status === 'warn') {
      console.warn(result.reason); // or throw if you want full compliance (warnings are not requirements)
    }
    // Avoid leaking resources
    if ('body' in result && result.body instanceof ReadableStream) {
      await result.body.cancel();
    }
  });
}

Put the above contents in a file and run it with deno test --allow-net.

Only GraphQL over HTTP

This is the official GraphQL over HTTP spec reference implementation and as such follows the specification strictly without any additional features (like playgrounds or GUIs, file uploads, @stream/@defer directives and subscriptions).

Having said this, @devtea2025/voluptatibus-vero-magni-rerum is mostly aimed for library authors and simple server setups, where the requirements are exact to what the aforementioned spec offers.

Servers

If you want a feature-full server with bleeding edge technologies, you're recommended to use one of the following servers.

Their compliance with the GraphQL over HTTP spec is checked automatically and updated regularly.

| Name | Audit | |------|-------| | apollo-server | ✅ Compliant | | deno | ✅ Compliant | | graph-client | ✅ Compliant | | graphql-helix | ✅ Compliant | | graphql-yoga | ✅ Compliant | | hotchocolate | ✅ Compliant | | lighthouse | ✅ Compliant | | pioneer | ✅ Compliant | | postgraphile | ✅ Compliant |

Documentation

Check the docs folder out for TypeDoc generated documentation.

Audits

Inspect audits of other implementations in the implementations folder. Adding your implementation is very welcome, see how!

Want to help?

File a bug, contribute with code, or improve documentation? Read more in CONTRIBUTING.md.

If your company benefits from GraphQL and you would like to provide essential financial support for the systems and people that power our community, please also consider membership in the GraphQL Foundation.