open-index/open-npm huggingface dataset:
npm package: @jmedranocdlx/graphql-validate-fixtures
Description: Validates JSON fixtures for GraphQL responses against the associated operations and schema
Author: Shopify Inc.
Latest version: 3.1.11

# `graphql-validate-fixtures`

[![Build Status](https://github.com/Shopify/quilt/workflows/Node-CI/badge.svg?branch=main)](https://github.com/Shopify/quilt/actions?query=workflow%3ANode-CI)
[![Build Status](https://github.com/Shopify/quilt/workflows/Ruby-CI/badge.svg?branch=main)](https://github.com/Shopify/quilt/actions?query=workflow%3ARuby-CI)
[![License: MIT](https://img.shields.io/badge/License-MIT-green.svg)](LICENSE.md) [![npm version](https://badge.fury.io/js/graphql-validate-fixtures.svg)](https://badge.fury.io/js/graphql-validate-fixtures.svg)

Validates JSON fixtures for GraphQL responses against the associated operations and schema.

## Installation

```bash
yarn add graphql-validate-fixtures
```

## Usage

In order to associate a fixture with a GraphQL query or mutation in your app, you must follow one of these conventions:

- Your fixtures are in a directory with a name matching that of the associated GraphQL operation
- Your fixtures have a key called `@operation` at the top level, which has a string value that is the name of the associated operation

Once this is done, you can validate your fixtures using the CLI or Node.js API.

### Operation

On startup this tool performs the following actions:

- Loads all schemas
- Discovers all operations belonging to each schema
- Discovers all fixtures and infers operation names as described [above](#Usage)
- Validates fixtures against the operation with a matching name
  - Reports operation not found error if no schema matches
  - Reports ambiguous operation name error if more than one schema matches

### Configuration

This tool reads schema information from a [`.graphqlconfig`](https://github.com/Shopify/graphql-tools-web/tree/main/packages/graphql-tool-utilities#configuration) file in the project root.

### CLI

```sh
# Must provide a list of fixtures as the first argument
yarn run graphql-validate-fixtures 'src/**/fixtures/**/*.graphql.json'
```

### Node

```js
const {evaluateFixtures} = require('graphql-validate-fixtures');
evaluateFixtures({
  fixturePaths: ['test/fixtures/one.json', 'test/fixtures/two.json'],
}).then((results) => {
  // See the TypeScript definition file for more details on the
  // structure of the `results`
  results.forEach((result) => console.log(result));
});
```
npm package: @jmegs/tpl
Description: scaffold projects from github repos
Author: John Meguerian
Latest version: 0.1.0

# TPL

Quickly start up new projects from examples on Github.
![gif of tpl in action](/tpl.gif)

## Installing

install tpl globally so you can access it on the command line

```sh
npm install -g @jmegs/tpl
# or yarn global add @jmegs/tpl
```

## What it does

tpl will shallow clone a repository and re-initialize git, so you have a clean start to your project, without any of the authors commits to worry about.

It basically wraps this squence of commands so you don't have to remember them.

```sh
git clone --depth 1 <repo> <directory> && cd <directory> && rm -rf .git && git init && git add -all && git commit -m 'initial commit'
```

## Usage

tpl accepts two arguments

1.  the repo you want a copy of
2.  the directory you want to put it in (optional)

the repo can either be a full github link or the shorthand `<user>/<repo>`

```sh
# make a fresh copy of static-starter in my-new-site
tpl jmegs/static-starter my-new-site
```

```sh
# make a fresh copy of react-website-starter in a directory of the same name
tpl https://github.com/broccolini/react-website-starter.git
```

## Made With

[ShellJS](https://github.com/shelljs/shelljs)
[Log](https://github.com/c8r/log)
[Meow](https://github.com/sindresorhus/meow)
[Chalk](https://github.com/chalk/chalk)
npm package: @jmellicker/jlogs
Description: Cool colored console logs for Node and browser.
Author: jmellicker
Latest version: 0.0.14

# jlogs

Cool colored console logs for Node and browser.

## Installation

```bash
yarn add @jmellicker/jlogs
```

## Usage

Import the library:

### CommonJS (Node.js)
```javascript
const c = require('@jmellicker/jlogs');
```

### ES Modules (Browser)
```javascript
import c from '@jmellicker/jlogs';
```

For browser projects using bundlers like Vite, Webpack, or Rollup:
```javascript
// In your Vue component or JavaScript file
import c from '@jmellicker/jlogs';

// Now you can use it
c.b('Hello from the browser!');
```

For direct use in HTML:
```html
<script type="module">
  import c from './node_modules/@jmellicker/jlogs/index.mjs';

  c.r('This is a red message in the console');
</script>
```

Use the various color functions:

```javascript
c.p('purple')
c.b('blue')
c.c('cyan')
c.g('green')
c.y('yellow')
c.o('orange')
c.m('magenta')
c.r('red')
```

You can also use multiple arguments, just like console.log:

```javascript
c.b('Hello', 'World')
c.g('Status:', 'Success')
c.r('Error:', 'File not found')
c.y('Warning:', 'Disk space low', '(10% remaining)')

// Works with objects and mixed types too
c.c('User:', { name: 'John', age: 30 })
c.m('Mixed types:', 'string', 123, { key: 'value' }, true)
```

## Demo

Run the included demo to see all available colors:

```bash
node demo
```

## For Contributors

### Release Process

To release a new version of the package:

1. Make sure all your changes are committed and pushed
2. Run the release script:

```bash
yarn release
```

This will:
- Increment the patch version in package.json
- Publish the package to npm
- Commit the version change
- Create a git tag
- Push changes and tags to GitHub

You'll need to be logged in to npm (`npm login`) before running the release script.
npm package: @jmendiara/serverless-plugin-encrypted
Description: A Serverless plugin which encrypts Lambda environment variables using an KMS key which is automatically generated for each stage
Author: Nicholas Albion
Latest version: 1.0.3

# serverless-plugin-encrypted

A [Serverless](https://serverless.com/) [plugin](https://serverless.com/framework/docs/providers/aws/guide/plugins/)
 which encrypts Lambda environment variables using an KMS key which is automatically generated for each stage.

## Installation

    yarn add -D serverless-plugin-encrypted

or 

    npm install --save-dev serverless-plugin-encrypted
    
## Usage
    
```yaml
service: my-service
provider:
  name: aws
  runtime: nodejs6.10
  role: lambda-role
  stage: DEV
  region: ap-southeast-2
  
plugins:
  - serverless-plugin-encrypted
    
custom:
  kmsKeyId: ${self:provider.stage}-my-service
  encrypted:
    SECRET_PASSWORD: ${env:MY_SECRET_PASSWORD}
        
functions:
  my-function:
    handler: index.handler
    environment:
      NOT_SECRET: ${env:NOT_SECRET}
      SECRET_PASSWORD: ${self:custom.encrypted.SECRET_PASSWORD}
```

    $ serverless deploy

The plugin will look for a KMS key with alias `DEV-my-service`, and create it if it does not exist.
Then it will go through all `environment` variables within `provider` and each function.  
If it finds an entry in `custom.encrypted` with a matching name it will use the KMS key to encrypt the value 
(eg: `custom.encrypted.SECRET_PASSWORD`) and update the provider and function values.
 
Note: The original values in the provider and functions will be discarded. 
ie `functions.my-function.environment.SECRET_PASSWORD` has been set to `${self:custom.encrypted.SECRET_PASSWORD}` 
in the example above, but it could be anything really, although it is a recommended convention.

When the plugin creates the KMS key, a policy will be created for it which allows:

 - the account root user to manage the key
 - anybody to encrypt