open-index/open-npm huggingface dataset:
npm package: @gregoralbrecht/eslint-config
Description: Personal ESLint config
Author: Gregor Albrecht
Latest version: 1.5.0

# @gregoralbrecht/eslint-config

[![semantic-release](https://img.shields.io/badge/%20%20%F0%9F%93%A6%F0%9F%9A%80-semantic--release-e10079.svg)](https://github.com/semantic-release/semantic-release)
![npm (scoped)](https://img.shields.io/npm/v/@gregoralbrecht/eslint-config)

A simple ESLint configuration for React projects. Although this project is deployed with `semantic-release` for convenience, there's nothing really semantic about the versioning. [Use these commit message conventions.](https://github.com/conventional-changelog/conventional-changelog/tree/master/packages/conventional-changelog-eslint)

## Installation

Install using `yarn`:

```sh
yarn add -D eslint prettier @gregoralbrecht/eslint-config
```

Then extend our ESLint config `.eslintrc.js`:

```js
module.exports = {
  extends: ["@gregoralbrecht/eslint-config"],
};
```
npm package: @gregoryalbouy/ts-datastructures
Description: TypeScript implementation of common data structures
Author: Gregory Albouy
Latest version: 0.5.2

# TypeScript Datastructures

[![Build Status](https://img.shields.io/travis/gregoryalbouy/ts-datastructures/master)](https://travis-ci.org/GregoryAlbouy/ts-datastructures)
[![codecov](https://img.shields.io/codecov/c/github/gregoryalbouy/ts-datastructures)](https://codecov.io/gh/GregoryAlbouy/ts-datastructures/branch/master)
[![NPM version](https://img.shields.io/npm/v/ts-structures)](https://www.npmjs.org/package/ts-structures)
[![NPM downloads](https://img.shields.io/npm/dt/ts-structures)](https://www.npmjs.org/package/ts-structures)

Implementation of common data structures, TypeScript pendant of my [go-datastructures repo](https://github.com/gregoryalbouy/go-datastructures).
(As a huge Go enthusiast, I must admit that working with a language that support Generics is quite a relief for this kind of work)

## About

The package provides ready-to-use and functionnal data structures. It includes linked lists, queues, stack, binary heaps and I intent to implement a lot more.

This project is also a pretext for the student developer I am to learn and practice many aspects of the development process:

- :dna: &nbsp;Understanding data structures
- :vertical_traffic_light: &nbsp;Keeping clean code and good coding practices
- :white_check_mark: &nbsp;Making relevant tests with high coverage rate
- :arrows_counterclockwise: &nbsp;Using Continuous Integration tools
- :blue_book: &nbsp;Maintaining a fully documented codebase

Feedback of any kind is always appreciated!

## Usage

```console
npm i ts-structures
```

```typescript
const { BinarySearchTree } = require('ts-structures')

const tree = new BinarySearchTree()
// ...
```

## Documentation

:point_right: [TypeDoc](https://gregoryalbouy-ts-datastructures.netlify.app)

## Implemented

- [Doubly Linked List](https://gregoryalbouy-ts-datastructures.netlify.app/classes/_list_doubly_linked_list_.doublylinkedlist.html)
- [Queue](https://gregoryalbouy-ts-datastructures.netlify.app/classes/_queue_queue_.queue.html)
- [Priority Queue](https://gregoryalbouy-ts-datastructures.netlify.app/classes/_queue_priority_queue_.priorityqueue.html)
- [Stack](https://gregoryalbouy-ts-datastructures.netlify.app/classes/_stack_stack_.stack.html)
- [Binary Search Tree](https://gregoryalbouy-ts-datastructures.netlify.app/classes/_tree_binary_search_tree_.binarysearchtree.html)
- [Binary Heap](https://gregoryalbouy-ts-datastructures.netlify.app/classes/_heap_binary_heap_.binaryheap.html)
- [Graph](https://gregoryalbouy-ts-datastructures.netlify.app/interfaces/_graph_index_.graph.html)
    - [List Graph](https://gregoryalbouy-ts-datastructures.netlify.app/classes/_graph_list_graph_.listgraph.html) (Adjacency list based graph, optionnally directed or weighted): still needs massive refacto & documentation
    - Matrix Graph (Adjacency matrix based graph): *in progress*

## Todo

- Graph implementation
    - Refacto
    - Documentation
    - MatrixGraph
- More data structures
npm package: @gregoryjenk/aesthetic-scheme-default
Description: The shared NPM package with resources for default personal branding.
Author: Gregory Jenkins
Latest version: 2.0.14
Deprecated: This package is now available at @gregoryjenk/aesthetic-default

# Aesthetic Scheme Default

## Getting Started

1. Update the [default Sass file](./src/styles/default-core-style.scss) with any style changes.
2. Run the `gulp default` command.

Run the `gulp watchSass` command to have changes applied actively.
npm package: @gregsithole/random-quotes
Description: A CLI tool that will generate a random quote
Author: Greg Sithole
Latest version: 1.0.1

# Random Quotes

A simple CLI project that will display a random quotes

### Installation

```
npm install @gregsithole/random-quotes
```

And run with the following command:

```
random-quotes
```

## Built With

* [axios](https://github.com/axios/axios/) - A promise based HTTP client
* [chalk](https://github.com/chalk/chalk) - A terminal styling tool
* [ora](https://github.com/sindresorhus/ora) - An elegant terminal spinner
* [quotable](https://github.com/lukePeavey/quotable) - An API for Quotes.

## Authors

* **Greg Sithole** - [GregSithole](https://github.com/GregSithole)

## License

This project is licensed under the MIT License - see the [LICENSE.md](LICENSE.md) file for details

## Acknowledgments
npm package: @greguintow/apollo-reporting-protobuf
Description: Protobuf format for Apollo usage reporting
Author: Apollo
Latest version: 3.0.9

# `apollo-reporting-protobuf`

> **Note:** The Apollo usage reporting API is subject to change.  We strongly
> encourage developers to contact Apollo support at `support@apollographql.com`
> to discuss their use case prior to building their own reporting agent using
> this module.

This module provides JavaScript/TypeScript
[Protocol buffer](https://developers.google.com/protocol-buffers/) definitions
for the Apollo usage reporting API.  These definitions are generated for
consumption from the `reports.proto` file which is defined internally within
Apollo.

## Development

> **Note:** Due to a dependency on Unix tools (e.g. `bash`, `grep`, etc.), the
> development of this module requires a Unix system.  There is no reason why
> this can't be avoided, the time just hasn't been taken to make those changes.
> We'd happily accept a PR which makes the appropriate changes!

Currently, this package generates a majority of its code with
`@apollo/protobufjs` (a fork of
[`protobufjs`](https://www.npmjs.com/package/protobufjs) that we maintain
specifically for this package) based on the `reports.proto` file. The output is
generated with the `generate` npm script.

The root of the repository provides some `devDependencies` necessary to build
these definitions qand the `prepare` npm script is invoked programmatically via
the monorepo tooling (e.g. Lerna) thanks to _this_ module's `postinstall`
script.  Therefore, when making changes to this module, run scripts via `npx
lerna run SCRIPTNAME` in the **root** of this monorepo in order to update the
definitions in _this_ module.

To update `reports.proto` to the current version recognized by the Studio usage
reporting ingress, run `lerna run update-proto`. To then regenerate the JS and
TS files, run `npx lerna run generate`. We check in the generated code and only
regenerate it manually, partially to make builds faster (no need to run pbjs on
every `npm install`) and partially so that we don't have to make sure that
`pbjs` runs on every Node version that we support.
npm package: @greguintow/apollo-server-caching
Description: [![npm version](https://badge.fury.io/js/apollo-server-caching.svg)](https://badge.fury.io/js/apollo-server-caching) [![Build Status](https://circleci.com/gh/apollographql/apollo-server/tree/main.svg?style=svg)](https://circleci.com/gh/apollographql/apoll
Author: Apollo
Latest version: 3.2.3

# apollo-server-caching

[![npm version](https://badge.fury.io/js/apollo-server-caching.svg)](https://badge.fury.io/js/apollo-server-caching)
[![Build Status](https://circleci.com/gh/apollographql/apollo-server/tree/main.svg?style=svg)](https://circleci.com/gh/apollographql/apollo-server)

## Implementing your own Cache

Internally, Apollo Server uses the `KeyValueCache` interface to provide a caching store for the Data Sources. An in-memory LRU cache is used by default, and we provide connectors for [Memcached](../apollo-server-cache-memcached)/[Redis](../apollo-server-cache-redis) backends.

Built with extensibility in mind, you can also implement your own cache to use with Apollo Server, in a way that best suits your application needs. It needs to implement the following interface that can be exported from `apollo-server-caching`:

```typescript
export interface KeyValueCache {
  get(key: string): Promise<string | undefined>;
  set(key: string, value: string, options?: { ttl?: number }): Promise<void>;
}
```

> The `ttl` value for the `set` method's `options` is specified in __seconds__.

## Testing cache implementations

### Test helpers

`apollo-server-caching` exports a function that you can run within a test suite to validate your implementation. It throws on failure. If you want to test expiration, then mock out `Date` and `setTimeout` (probably with `@sinonjs/fake-timers`) and pass a `tick` can be called to advance the fake time. (If you don't pass `tick`, it won't test expiration.) Other than that, it has no dependencies and can work in any test system and shouldn't require any particular build configuration to use from jest. Here's an example of how to use it with jest:

```typescript
// ../__tests__/YourKeyValueCache.test.ts

import YourKeyValueCache from '../src/YourKeyValueCache';
import { runKeyValueCacheTests } from 'apollo-server-caching';
import FakeTimers from '@sinonjs/fake-timers';

describe('YourKeyValueCache', () => {
  it('run apollo-server-caching test suite', async () => {
    const cache = new YourKeyValueCache();
    const clock = FakeTimers.install();
    try {
      await runKeyValueCacheTests(cache, (ms: number) => clock.tick(ms));
    } finally {
      clock.uninstall();
      await cache.close();
    }
  });
});
```

For more details, consult the [source for `apollo-server-caching`](./src/testsuite.ts).

### Running tests

Run tests with `jest --verbose`
npm package: @greguintow/apollo-server-express
Description: Production-ready Node.js GraphQL server for Express
Author: Apollo
Latest version: 3.3.9

[![npm version](https://badge.fury.io/js/apollo-server-express.svg)](https://badge.fury.io/js/apollo-server-express)
[![Build Status](https://circleci.com/gh/apollographql/apollo-server/tree/main.svg?style=svg)](https://circleci.com/gh/apollographql/apollo-server)
[![Join the community forum](https://img.shields.io/badge/join%20the%20community-forum-blueviolet)](https://community.apollographql.com)
[![Read CHANGELOG](https://img.shields.io/badge/read-changelog-blue)](https://github.com/apollographql/apollo-server/blob/HEAD/CHANGELOG.md)


This is the Express integration of Apollo Server. Apollo Server is a community-maintained open-source GraphQL server that works with many Node.js HTTP server frameworks. [Read the docs](https://www.apollographql.com/docs/apollo-server/). [Read the CHANGELOG.](https://github.com/apollographql/apollo-server/blob/main/CHANGELOG.md)


A full example of how to use `apollo-server-express` can be found in [the docs](https://www.apollographql.com/docs/apollo-server/integrations/middleware/#apollo-server-express).

Before Apollo Server 3, we officially supported using this package with `connect` as well. `connect` is an older framework that `express` evolved from. For now, we believe that this package is still compatible with `connect` and we even run tests against `connect`, but we may choose to break this compatibility at some point without a major version bump. If you rely on the ability to use Apollo Server with `connect`, you may wish to make your own integration.

## Principles

GraphQL Server is built with the following principles in mind:

* **By the community, for the community**: GraphQL Server's development is driven by the needs of developers
* **Simplicity**: by keeping things simple, GraphQL Server is easier to use, easier to contribute to, and more secure
* **Performance**: GraphQL Server is well-tested and production-ready - no modifications needed

Anyone is welcome to contribute to GraphQL Server, just read [CONTRIBUTING.md](https://github.com/apollographql/apollo-server/blob/main/CONTRIBUTING.md), take a look at the [roadmap](https://github.com/apollographql/apollo-server/blob/main/ROADMAP.md) and make your first PR!
npm package: @greguintow/apollo-server-plugin-operation-registry
Description: Apollo Server operation registry
Author: Apollo
Latest version: 3.3.8

# Operation Registry Plugin

The operation registry plugin is the interface into the Apollo Platform's **operation registry** and enables operation **safelisting**, which allows selective execution based on the operation. Safelisting eliminates the risk of unexpected operations that could cause downtime from being run against a graph.

In order to enable safelisting, follow the [step by step guide in the Apollo docs](https://www.apollographql.com/docs/studio/operation-registry/). These steps describe how to extract and upload operations defined within client applications to [Apollo Studio](https://studio.apollographql.com) using the Apollo CLI. Once operations have been registered, this plugin for Apollo Server fetches the manifest of these operations from [Apollo Studio](https://studio.apollographql.com) and forbids the execution of any operations that are not in that manifest.

### Usage

The following example shows basic usage of the plugin with Apollo Server. First, add the plugin to your project's `package.json`:

```bash
npm install apollo-server-plugin-operation-registry
```

Then, ensure Apollo Server has access to an [API key](https://www.apollographql.com/docs/studio/operation-registry/#6-start-apollo-server-with-apollo-studio-enabled), for example as the `APOLLO_KEY` environment variable:

```bash
APOLLO_KEY=<API_KEY> npm start
```

Next, enable the plugin by adding it to the `plugins` parameter to the Apollo Server options:

```js
const server = new ApolloServer({
  typeDefs,
  resolvers,
  subscriptions: false,
  plugins: [
    require("apollo-server-plugin-operation-registry")({
      forbidUnregisteredOperations: true
    })
  ]
});
```

<details><summary>With federation, the setup follows the same `plugins` configuration:</summary>

```js
const { ApolloServer } = require("apollo-server");
const { ApolloGateway } = require("@apollo/gateway");

const gateway = new ApolloGateway({
  serviceList: [ /* services */ ],
});

const server = new ApolloServer({
  gateway,
  subscriptions: false,
  plugins: [
    require("apollo-server-plugin-operation-registry")({
      forbidUnregisteredOperations: true
    })
  ]
});

server.listen().then(({ url }) => {
  console.log(`🚀 Server ready at ${url}`);
});
```
</details>

#### Variant

Clients can register their operations to a specific variant, so the plugin contains the `graphVariant` field to specify which variant to pull operation manifests from.

```js
const server = new ApolloServer({
  plugins: [
    require("apollo-server-plugin-operation-registry")({
      graphVariant: "production"
    })
  ]
});
```


### Metrics

The plugin will transmit metrics regarding unregistered operations which can be viewed within [Apollo Studio](https://studio.apollographql.com). The following example shows the unregistered operations sent by a particular client:

<p align="center">
  <img
    src="https://cl.ly/2a5b9c82287d/download/clients-page.png"
    alt="The clients page showing unregistered operations"
  />
</p>
npm package: @greguintow/graphql-load-files
Description: A set of utils for faster development of GraphQL tools
Author: Dotan Simha
Latest version: 7.0.2

Check API Reference for more information about this package;
https://www.graphql-tools.com/docs/api/modules/load_files_src

You can also learn more about File Loading in this chapter;
https://www.graphql-tools.com/docs/schema-merging#file-loading
npm package: @greguintow/mercurius
Description: Fastify GraphQL adapter with gateway and subscription support
Author: Matteo Collina
Latest version: 9.1.4


![Mercurius Logo](https://github.com/mercurius-js/graphics/blob/main/mercurius-horizontal.svg)

# mercurius

![CI workflow](https://github.com/mercurius-js/mercurius/workflows/CI%20workflow/badge.svg)

Mercurius is a [**GraphQL**](https://graphql.org/) adapter for [**Fastify**](https://www.fastify.io)

Features:

- Caching of query parsing and validation.
- Automatic loader integration to avoid 1 + N queries.
- Just-In-Time compiler via [graphql-jit](http://npm.im/graphql-jit).
- Subscriptions.
- Federation support.
- Federated subscriptions support.
- Gateway implementation, including Subscriptions.
- Batched query support.
- Customisable persisted queries.

## Docs

- [Install](#install)
- [Quick Start](#quick-start)
- [Examples](#examples)
- [API](docs/api/options.md)
- [Context](docs/context.md)
- [Loaders](docs/loaders.md)
- [Hooks](docs/hooks.md)
- [Lifecycle](docs/lifecycle.md)
- [Federation](docs/federation.md)
- [Subscriptions](docs/subscriptions.md)
- [Batched Queries](docs/batched-queries.md)
- [Persisted Queries](docs/persisted-queries.md)
- [TypeScript Usage](/docs/typescript.md)
- [Integrations](docs/integrations/)
- [Related Plugins](docs/plugins.md)
- [Protocol Extensions](/docs/protocol-extension.md)
- [Faq](/docs/faq.md)
- [HTTP](/docs/http.md)
- [Acknowledgements](#acknowledgements)
- [License](#license)

## Install

```bash
npm i fastify mercurius graphql
# or
yarn add fastify mercurius graphql
```

The previous name of this module was [fastify-gql](http://npm.im/fastify-gql) (< 6.0.0).

## Quick Start

```js
'use strict'

const Fastify = require('fastify')
const mercurius = require('mercurius')

const app = Fastify()

const schema = `
  type Query {
    add(x: Int, y: Int): Int
  }
`

const resolvers = {
  Query: {
    add: async (_, { x, y }) => x + y
  }
}

app.register(mercurius, {
  schema,
  resolvers
})

app.get('/', async function (req, reply) {
  const query = '{ add(x: 2, y: 2) }'
  return reply.graphql(query)
})

app.listen(3000)
```

## Examples

Check [GitHub repo](https://github.com/mercurius-js/mercurius/tree/master/examples) for more examples.

## Acknowledgements

The project is kindly sponsored by:

- [NearForm](https://www.nearform.com) for [Matteo](https://github.com/mcollina)'s time in maintaining this module.

The Mercurius name was gracefully donated by [Marco Castelluccio](https://github.com/marco-c).
The usage of that library was described in https://hacks.mozilla.org/2015/12/web-push-notifications-from-irssi/, and
you can find that codebase in https://github.com/marco-c/mercurius.

## License

MIT