open-index/open-npm huggingface dataset:
npm package: @gpujs/expo-gl
Description: A GPU.js extender for use with React Native's Expo library
Latest version: 0.0.12

# @gpujs/expo-gl - A GPU.js extender for use with React Native's Expo library

This package allows you to use [GPU.js](gpu.rocks) with Expo to get a native GPGPU.

## Installation
1. Setup Expo - https://docs.expo.io/versions/latest/introduction/installation/
2. Add the following to use `@gpujs/expo-gl`:
  ```js
    import { GLView } from 'expo-gl';
    import { GPU } from '@gpujs/expo-gl';
    GLView.createContextAsync()
      .then(context => {
        const gpu = new GPU({ context });
        const kernel = gpu.createKernel(kernelFunctionHere, kernelOptionsHere);
        kernel();
      });
  ```
3. Visit https://github.com/gpujs/gpu.js for documentation on `kernelFunctionHere`, `kernelOptionsHere`, as well as the api.
4. Run your expo from Android or iOS and have native GPGPU support!
5. Have fun!


## Example
```js
import { GLView } from 'expo-gl';
import { GPU } from '@gpujs/expo-gl';
GLView.createContextAsync()
  .then(context => {
    const gpu = new GPU({ context });
    const kernel = gpu.createKernel(function() {
      return 1;
    }, { output: [1], debug: true });
    console.log(kernel());
    gpu.destroy();
  });
```
npm package: @gqfn/cli
Description: The CLI of GQFn
Latest version: 0.7.1

# @gqfn/cli

[![npm version][npm-version-src]][npm-version-href]
[![npm downloads][npm-downloads-src]][npm-downloads-href]

The CLI tool for GQFn - provides commands to initialize, manage, and sync GraphQL schemas for @gqfn/core.

- 📖 [Documentation](https://gqfn.teages.xyz)

## Installation

Install the CLI package globally or locally in your project:

```sh
# ✨ Auto-detect
npx nypm i @gqfn/cli

# npm
npm install @gqfn/cli

# yarn
yarn add @gqfn/cli

# pnpm
pnpm install @gqfn/cli

# bun
bun install @gqfn/cli
```

For global installation:

```sh
npm install -g @gqfn/cli
```

## Usage

### Initialize GQFn in your project

```bash
gqfn init
```

This command creates the necessary configuration files and sets up your project for GQFn usage.

### Add a GraphQL schema

```bash
gqfn add https://your-graphql-endpoint.com/graphql
```

You can add multiple endpoints at once:

```bash
gqfn add https://api.example.com/graphql https://graphql.example.com/v1
```

### Sync schemas

```bash
gqfn sync
```

This command fetches the latest schema definitions from all configured endpoints and updates the generated types.

### Command Options

All commands support the following options:

- `-s, --silent`: Disable all output
- `--ignore-error` (sync only): Ignore errors when syncing the schema

### Configuration

The CLI uses a `gqfn.config.ts` file for configuration. Here's an example:

```ts
import { defineConfig } from '@gqfn/cli'

export default defineConfig({
  clients: [
    {
      name: 'api',
      url: 'https://your-graphql-endpoint.com/graphql',
      headers: {
        Authorization: `Bearer ${process.env.API_TOKEN}`
      }
    }
  ],
  outputDir: './src/gqfn'
})
```

## Development

- Clone this repository
- Install latest LTS version of [Node.js](https://nodejs.org/en/)
- Enable [Corepack](https://github.com/nodejs/corepack) using `corepack enable`
- Install dependencies using `pnpm install`
- Run interactive tests using `pnpm dev`

## License

Published under [MIT License](./LICENSE).

<!-- Badges -->

[npm-version-src]: https://img.shields.io/npm/v/@gqfn/cli?style=flat&color=blue
[npm-version-href]: https://npmjs.com/package/@gqfn/cli
[npm-downloads-src]: https://img.shields.io/npm/dm/@gqfn/cli?style=flat&color=blue
[npm-downloads-href]: https://npmjs.com/package/@gqfn/cli
npm package: @gqfn/core
Description: Writing GraphQL queries with type safety and type hints, power by TypeScript.
Latest version: 0.7.1

# @gqfn/core

[![npm version][npm-version-src]][npm-version-href]
[![npm downloads][npm-downloads-src]][npm-downloads-href]

<!-- [![bundle][bundle-src]][bundle-href] -->
<!-- [![Codecov][codecov-src]][codecov-href] -->

GQFn provides a *typed* way to write GraphQL queries with the help of TypeScript.

<!-- - ✨ [Stackblitz Playground](#) TODO: new playground -->
- 📖 [Documentation](https://gqfn.teages.xyz)

## Usage

Install package:

```sh
# ✨ Auto-detect
npx nypm i @gqfn/core

# npm
npm install @gqfn/core

# yarn
yarn add @gqfn/core

# pnpm
pnpm install @gqfn/core

# bun
bun install @gqfn/core
```

Import:

```js
// ESM
import { useSchema } from '@gqfn/core'
```

```js
// CommonJS
const { useSchema } = require('@gqfn/core')
```

## Development

- Clone this repository
- Install latest LTS version of [Node.js](https://nodejs.org/en/)
- Enable [Corepack](https://github.com/nodejs/corepack) using `corepack enable`
- Install dependencies using `pnpm install`
- Run interactive tests using `pnpm dev`

## License

Published under [MIT License](./LICENSE).

<!-- Badges -->

[npm-version-src]: https://img.shields.io/npm/v/@gqfn/core?style=flat&color=blue
[npm-version-href]: https://npmjs.com/package/@gqfn/core
[npm-downloads-src]: https://img.shields.io/npm/dm/@gqfn/core?style=flat&color=blue
[npm-downloads-href]: https://npmjs.com/package/@gqfn/core

<!-- [codecov-src]: https://img.shields.io/codecov/c/gh/Teages/gqfn/main?style=flat&color=blue
[codecov-href]: https://codecov.io/gh/Teages/gqfn

[bundle-src]: https://img.shields.io/bundlephobia/minzip/@gqfn/core?style=flat&color=blue
[bundle-href]: https://bundlephobia.com/result?p=@gqfn/core -->
npm package: @gql-safeguard/linux-arm64
Description: Platform-specific binary for gql-safeguard
Author: Jan Nicklas
Latest version: 0.12.0

# Platform Binary for gql-safeguard

This package contains the platform-specific binary for [gql-safeguard](https://www.npmjs.com/package/gql-safeguard).

Install the main package instead: `npm install gql-safeguard`
npm package: @gql-safeguard/win32-x64
Description: Platform-specific binary for gql-safeguard
Author: Jan Nicklas
Latest version: 0.12.0

# Platform Binary for gql-safeguard

This package contains the platform-specific binary for [gql-safeguard](https://www.npmjs.com/package/gql-safeguard).

Install the main package instead: `npm install gql-safeguard`
npm package: @gql-tools/hypergraph-express-middleware
Description: Hypergraph Express Middleware
Author: Rajat Sharma
Latest version: 0.1.0-alpha.4

## Hypergraph Express Middleware

_Fastest way to create Graphql Server with Express_

#### Installation

- `yarn add @gql-tools/hypergraph-express-middleware`

#### Usage

##### _middleware_

- Add Middleware

```js
import { middleware } from ' @gql-tools/hypergraph-express-middleware';

const context = { dbConnection, otherGlobals };
app.use('/graphql', middleware(context));
```

- Now place your Resolvers in `graphs/resolvers.js`.

- And your types in `graphs/types`.

- You can change default locations by defining new paths in `.hypergraphrc` in your project root.

```json
{
  "types": "some/other/graphs",
  "resolvers": "src/other/resolvers"
}
```

##### _playground_

```js
import { playground } from ' @gql-tools/hypergraph-express-middleware';

app.use('/graphiql', playground(/* graphql route*/ '/graphql'));
```

##### _merge_

- Merges two graphql resolvers, useful if you want to divide resolver to different files

### Why Hypergraph? or Hot-ish Reloading of Resolvers

- Hypergraph seperates your main node application with the graphql resolvers. You can have separate Dev Servers for your resolvers and Node Server so whenever there are changes in Resolvers only the resolver server is reloaded.

- Hypergraph does cache invalidation during development in order to achieve `hot-ish reloading` for Resolvers, so it relies on `NODE_ENV` environment variable. Server reloading will not work if there's no `NODE_ENV` var present.

- Hot Reloading can be achieved with any server, nodemon or webpack-dev-server or both(Required that only one does reloading).

eg with Nodemon

```js
const resolverReload = nodemon({
  script: 'path to root resolver',
  watch: ['root resolver', 'types dir if you want'],
  nodeArgs: process.argv.slice(2),
}).on('quit', process.exit);

const expressReload = nodemon({
  script: 'path to express app',
  watch: ['express dir'],
  nodeArgs: process.argv.slice(2),
}).on('quit', process.exit);
```
npm package: @gql-vis/exporter
Description: - This is the official [GraphQL Analyzer](https://graphqlanalyzer.com/) exporter.
Latest version: 0.0.0-alpha.10

# @gql-vis/exporter

- This is the official [GraphQL Analyzer](https://graphqlanalyzer.com/) exporter.

You should use the exporter if you want to extend the plugin ecosystem or you want to send custom API calls and responses to your collector.

## Installation

```bash
npm install @gql-vis/exporter
```

## Usage

```js
import { Exporter } from "@gql-vis/exporter";

const exporter = new Exporter({
  apiKey: `YOUR-API-KEY`,
  url: `https://app.graphqlanalyzer.com/api/v1/collector`,
});

const payload = {
  body: {
    query: `query { hello }`,
    params: {},
  },
  headers: {},
  method: "POST",
  type: "GRAPHQL",
  url: "http://127.0.0.1:5000/graphql",
};

const { givenUUID } = exporter.apiCall(payload);

// Do the network call here

exporter.apiResponse({
  body: {
    data: {
      hello: "world",
    },
  },
  givenUUID,
  statusCode: 200,
});
```

## License

MIT - https://graphqlvisualizer.com/
npm package: @gql-vis/plugin-urql
Description: - This is the official [GraphQL Analyzer](https://graphqlanalyzer.com/) exchange for [urql](https://formidable.com/open-source/urql/).
Latest version: 0.0.0-alpha.10

# @gql-vis/plugin-urql

- This is the official [GraphQL Analyzer](https://graphqlanalyzer.com/) exchange for [urql](https://formidable.com/open-source/urql/).

## Installation

```bash
$ npm install @gql-vis/plugin-urql
```

## Usage

```js
import { createClient } from "urql";
import { createExchange } from "@gql-vis/plugin-urql";

const client = createClient({
  url: `http://localhost:3000/graphql`,
  exchanges: [
    createExchange({
      apiKey: `YOUR-API-KEY`,
      url: `https://server.graphqlanalyzer.com/api/v1/collector`,
    }),
  ],
});
```

## License

MIT - https://graphqlvisualizer.com/
npm package: @gql.tada/internal
Description: Internal logic for gql.tada’s CLI tool and GraphQLSP.
Author: 0no.co
Latest version: 1.0.9

# @gql.tada/internal

**`@gql.tada/internal`** is a support package for `gql.tada`
and [`@0no-co/graphqlsp`](https://github.com/0no-co/graphqlsp)
that contains shared logic for both.

_There is no documentation available for this package._

> [!NOTE]
> Use this package at your own risk! This package's exported API
> is only considered stable in the context of it being consumed
> by either `@gql.tada/cli-utils` or `@0no-co/graphqlsp`!
npm package: @gql.tada/svelte-support
Description: Svelte Support package for gql.tada’s CLI tool.
Author: 0no.co
Latest version: 1.0.2

# @gql.tada/svelte-support

**`@gql.tada/svelte-support`** is a support package for the
`gql.tada` CLI (via `@gql.tada/cli-utils`).
It's used to expose transform helpers to the CLI that allow
it to parse and use `.svelte` SFC files.

_There is no documentation available for this package._

> [!NOTE]
> Use this package at your own risk! This package's exported API
> is only considered stable in the context of it being consumed
> by `@gql.tada/cli-utils`!
npm package: @gql.tada/vue-support
Description: Vue Support package for gql.tada’s CLI tool.
Author: 0no.co
Latest version: 1.0.2

# @gql.tada/vue-support

**`@gql.tada/vue-support`** is a support package for the
`gql.tada` CLI (via `@gql.tada/cli-utils`).
It's used to expose transform helpers to the CLI that allow
it to parse and use `.vue` SFC files.

_There is no documentation available for this package._

> [!NOTE]
> Use this package at your own risk! This package's exported API
> is only considered stable in the context of it being consumed
> by `@gql.tada/cli-utils`!
npm package: @gqlbase/core
Description: Core library for gqlbase, providing the GraphQL transformer and plugin system.
Author: sls.dev
Latest version: 0.1.6

# @gqlbase/core

Core library for gqlbase. Provides the GraphQL transformer engine, plugin system, and definition node types.

This is an internal package. Install the main [`gqlbase`](https://www.npmjs.com/package/gqlbase) package instead.

## What this package provides

- `GraphQLTransformer` — schema transformation pipeline
- `createTransformer` — factory function for creating transformer instances
- `TransformerPluginBase` — abstract base class for building plugins
- `createPluginFactory` — type-safe plugin factory generator
- `TransformerContext` — plugin lifecycle and schema state management
- Definition node classes — `DocumentNode`, `ObjectNode`, `FieldNode`, `InputObjectNode`, `EnumNode`, `UnionNode`, `ScalarNode`, `InterfaceNode`, `DirectiveNode`, `TypeNode`

## License

MIT
npm package: @gqlbase/plugins
Description: Collection of plugins and presets for gqlbase, providing common transformations and utilities that can be used in GraphQL schema transformation processes.
Author: sls.dev
Latest version: 0.1.6

# @gqlbase/plugins

Built-in plugins and presets for gqlbase.

This is an internal package. Install the main [`gqlbase`](https://www.npmjs.com/package/gqlbase) package instead.

## What this package provides

**Base preset** (`gqlbase/plugins/base`):

- `ScalarsPlugin` — registers built-in scalar types
- `UtilitiesPlugin` — processes visibility and scope directives
- `ModelPlugin` — generates CRUD operations from `@model` types
- `RelationsPlugin` — resolves `@hasOne` and `@hasMany` relations
- `SchemaGeneratorPlugin` — outputs the transformed schema
- `ModelTypesGeneratorPlugin` — outputs TypeScript type definitions

**Relay preset** (`gqlbase/plugins/relay`):

- `NodeInterfacePlugin` — adds the Relay `Node` interface
- `ConnectionPlugin` — generates connection and edge types

## License

MIT

```ts
declare module "@gqlbase/middy-appsync" {
  interface Definition {
    User: {
      id: { source: User; args: Record<string, never>; result: string };
      name: { source: User; args: Record<string, never>; result: string };
      email: { source: User; args: Record<string, never>; result: string };
    };
    Query: {
      user: { source: null; args: Record<string, never>; result: User | null };
    };
  }
}
```
npm package: @gqless-transport-ws/cli
Description: ## Visit [https://c2atec.com/cli/codegen](https://c2atec.com/cli/codegen)
Author: GQless
Latest version: 2.0.16

# @gqless-transport-ws/cli

## Visit [https://c2atec.com/cli/codegen](https://c2atec.com/cli/codegen)
npm package: @gqless-transport-ws/gqless
Description: gqless client without queries
Author: GQless
Latest version: 2.0.14

# [GQless](https://c2atec.com/getting-started) [![Documentation](https://img.shields.io/badge/documentation-documentation?color=C00B84)](https://c2atec.com) [![Twitter](https://img.shields.io/twitter/follow/gqlessdev?label=%40gqlessdev&style=flat&logo=twitter&color=00acee)](https://twitter.com/gqlessdev)

> GQless is a fully-featured GraphQL client, which lowers the barrier of entry towards using GraphQL.

Data requirements within your application are picked up automatically, freeing you from having to maintain GraphQL queries by-hand. It offers a first-class TypeScript experience. See API documentation at all times within autocomplete.

Make breaking changes to your API, and see type-errors exactly where things are breaking, in realtime. No more running a separate validation step.

**More documentation is available at [gqless.com/getting-started](https://c2atec.com/getting-started).**

<a href="https://c2atec.com">
  <img alt="Example usage" src="https://user-images.githubusercontent.com/13242392/112103674-fddc4980-8ba1-11eb-8c83-b527dcb0243d.PNG" />
</a>
npm package: @gqless/react
Description: ## Visit [https://gqless.com/react/fetching-data](https://gqless.com/react/fetching-data)
Author: GQless
Latest version: 2.0.15

# @gqless/react

## Visit [https://gqless.com/react/fetching-data](https://gqless.com/react/fetching-data)
npm package: @gqloom/drizzle
Description: GQLoom integration with Drizzle ORM
Author: xcfox
Latest version: 0.11.0

![GQLoom Logo](https://github.com/modevol-com/gqloom/blob/main/gqloom.svg?raw=true)

# GQLoom

GQLoom is a **Code-First** GraphQL Schema Loom used to weave **runtime types** in the **TypeScript/JavaScript** ecosystem into GraphQL Schema, helping you build GraphQL server enjoyably and efficiently.

Runtime validation libraries such as [Zod](https://zod.dev/), [Valibot](https://valibot.dev/), and [Yup](https://github.com/jquense/yup) have been widely used in backend application development. Meanwhile, when using ORM libraries like [Prisma](https://www.prisma.io/), [MikroORM](https://mikro-orm.io/), and [Drizzle](https://orm.drizzle.team/), we also pre-define database table structures or entity models that contain runtime types.
The responsibility of GQLoom is to weave these runtime types into a GraphQL Schema.

When developing backend applications with GQLoom, you only need to write types using the Schema libraries you're familiar with. Modern Schema libraries will infer TypeScript types for you, and GQLoom will weave GraphQL types for you.
In addition, the **resolver factory** of GQLoom can create CRUD interfaces for `Prisma`, `MikroORM`, and `Drizzle`, and supports custom input and adding middleware.

## Drizzle

[Drizzle](https://orm.drizzle.team/) is a modern, type-safe TypeScript ORM designed for Node.js. It offers a concise and easy-to-use API, supports databases such as PostgreSQL, MySQL, and SQLite, and has powerful query builders, transaction processing, and database migration capabilities. At the same time, it remains lightweight and has no external dependencies, making it very suitable for database operation scenarios that require high performance and type safety.

## @gqloom/drizzle

This package provides GQLoom integration with [Drizzle](https://orm.drizzle.team/):

- Weave database tables defined by Drizzle into a GraphQL Schema;
- Support quickly creating CRUD interfaces from Drizzle using the resolver factory;

### Installation

```bash
# use npm
npm install @gqloom/core @gqloom/drizzle

# use pnpm
pnpm add @gqloom/core @gqloom/drizzle

# use yarn
yarn add @gqloom/core @gqloom/drizzle
```

Read more at [GQLoom Document](https://gqloom.dev/docs/schema/drizzle).
npm package: @gqloom/federation
Description: Building subGraphs with GQLoom
Author: xcfox
Latest version: 0.12.0

![GQLoom Logo](https://github.com/modevol-com/gqloom/blob/main/gqloom.svg?raw=true)

# GQLoom

GQLoom is a **Code-First** GraphQL Schema Loom used to weave **runtime types** in the **TypeScript/JavaScript** ecosystem into GraphQL Schema, helping you build GraphQL server enjoyably and efficiently.

Runtime validation libraries such as [Zod](https://zod.dev/), [Valibot](https://valibot.dev/), and [Yup](https://github.com/jquense/yup) have been widely used in backend application development. Meanwhile, when using ORM libraries like [Prisma](https://www.prisma.io/), [MikroORM](https://mikro-orm.io/), and [Drizzle](https://orm.drizzle.team/), we also pre-define database table structures or entity models that contain runtime types.
The responsibility of GQLoom is to weave these runtime types into a GraphQL Schema.

When developing backend applications with GQLoom, you only need to write types using the Schema libraries you're familiar with. Modern Schema libraries will infer TypeScript types for you, and GQLoom will weave GraphQL types for you.
In addition, the **resolver factory** of GQLoom can create CRUD interfaces for `Prisma`, `MikroORM`, and `Drizzle`, and supports custom input and adding middleware.

# @gqloom/federation

This package provides GQLoom support for [Apollo Federation](https://www.apollographql.com/docs/federation).

## Installation

```bash
# use npm
npm i graphql @gqloom/core @apollo/subgraph @gqloom/federation

# use pnpm
pnpm add graphql @gqloom/core @apollo/subgraph @gqloom/federation

# use yarn
yarn add graphql @gqloom/core @apollo/subgraph @gqloom/federation
```

Read more at [GQLoom Document](https://gqloom.dev/docs/advanced/federation).
npm package: @gqloom/json
Description: Create GraphQL schema and resolvers easily using using JSON Schema!
Author: xcfox
Latest version: 0.15.0

![GQLoom Logo](https://github.com/modevol-com/gqloom/blob/main/gqloom.svg?raw=true)

# GQLoom

GQLoom is a **Code-First** GraphQL Schema Loom used to weave **runtime types** in the **TypeScript/JavaScript** ecosystem into GraphQL Schema, helping you build GraphQL server enjoyably and efficiently.

Runtime validation libraries such as [Zod](https://zod.dev/), [Valibot](https://valibot.dev/), and [Yup](https://github.com/jquense/yup) have been widely used in backend application development. Meanwhile, when using ORM libraries like [Prisma](https://www.prisma.io/), [MikroORM](https://mikro-orm.io/), and [Drizzle](https://orm.drizzle.team/), we also pre-define database table structures or entity models that contain runtime types.
The responsibility of GQLoom is to weave these runtime types into a GraphQL Schema.

When developing backend applications with GQLoom, you only need to write types using the Schema libraries you're familiar with. Modern Schema libraries will infer TypeScript types for you, and GQLoom will weave GraphQL types for you.
In addition, the **resolver factory** of GQLoom can create CRUD interfaces for `Prisma`, `MikroORM`, and `Drizzle`, and supports custom input and adding middleware.

# @gqloom/json

This package provides GQLoom integration with [JSON Schema](https://json-schema.org/) to weave JSON Schema to GraphQL Schema.

## Installation

```bash
# use npm
npm i @gqloom/core @gqloom/json

# use pnpm
pnpm add @gqloom/core @gqloom/json

# use yarn
yarn add @gqloom/core @gqloom/json
```

## Hello World

```ts
import { query, resolver, weave } from "@gqloom/core"
import { jsonSilk } from "@gqloom/json"

const helloResolver = resolver({
  hello: query(jsonSilk({ type: "string" }))
    .input({ name: jsonSilk({ type: "string" }) })
    .resolve(({ name }) => `Hello, ${name}!`),
})

export const schema = weave(helloResolver)
```

Read more at [GQLoom Document](https://gqloom.dev/docs/schema/json).
npm package: @gqloom/mikro-orm
Description: GQLoom integration with Mikro ORM
Author: xcfox
Latest version: 0.16.1

![GQLoom Logo](https://github.com/modevol-com/gqloom/blob/main/gqloom.svg?raw=true)

# GQLoom

GQLoom is a **Code-First** GraphQL Schema Loom used to weave **runtime types** in the **TypeScript/JavaScript** ecosystem into GraphQL Schema, helping you build GraphQL server enjoyably and efficiently.

Runtime validation libraries such as [Zod](https://zod.dev/), [Valibot](https://valibot.dev/), and [Yup](https://github.com/jquense/yup) have been widely used in backend application development. Meanwhile, when using ORM libraries like [Prisma](https://www.prisma.io/), [MikroORM](https://mikro-orm.io/), and [Drizzle](https://orm.drizzle.team/), we also pre-define database table structures or entity models that contain runtime types.
The responsibility of GQLoom is to weave these runtime types into a GraphQL Schema.

When developing backend applications with GQLoom, you only need to write types using the Schema libraries you're familiar with. Modern Schema libraries will infer TypeScript types for you, and GQLoom will weave GraphQL types for you.
In addition, the **resolver factory** of GQLoom can create CRUD interfaces for `Prisma`, `MikroORM`, and `Drizzle`, and supports custom input and adding middleware.

# @gqloom/mikro-orm

This package provides GQLoom integration with [Mikro ORM](https://mikro-orm.io/):

- Use MikroORM's Entity Schema as the silk;
- Weaving the silk into MikroORM's Entity Schema;
- Generating GraphQL operations from MikroORM's Entity Schema;

## Installation

```bash
# use npm
npm i @gqloom/core @gqloom/mikro-orm @mikro-orm/core

# use pnpm
pnpm add @gqloom/core @gqloom/mikro-orm @mikro-orm/core

# use yarn
yarn add @gqloom/core @gqloom/mikro-orm @mikro-orm/core
```

Read more at [GQLoom Document](https://gqloom.dev/docs/schema/mikro-orm).
npm package: @gqloom/prisma
Description: GQLoom integration with Prisma
Author: xcfox
Latest version: 0.16.0

![GQLoom Logo](https://github.com/modevol-com/gqloom/blob/main/gqloom.svg?raw=true)

# GQLoom

GQLoom is a **Code-First** GraphQL Schema Loom used to weave **runtime types** in the **TypeScript/JavaScript** ecosystem into GraphQL Schema, helping you build GraphQL server enjoyably and efficiently.

Runtime validation libraries such as [Zod](https://zod.dev/), [Valibot](https://valibot.dev/), and [Yup](https://github.com/jquense/yup) have been widely used in backend application development. Meanwhile, when using ORM libraries like [Prisma](https://www.prisma.io/), [MikroORM](https://mikro-orm.io/), and [Drizzle](https://orm.drizzle.team/), we also pre-define database table structures or entity models that contain runtime types.
The responsibility of GQLoom is to weave these runtime types into a GraphQL Schema.

When developing backend applications with GQLoom, you only need to write types using the Schema libraries you're familiar with. Modern Schema libraries will infer TypeScript types for you, and GQLoom will weave GraphQL types for you.
In addition, the **resolver factory** of GQLoom can create CRUD interfaces for `Prisma`, `MikroORM`, and `Drizzle`, and supports custom input and adding middleware.

## Prisma

[Prisma](https://www.prisma.io/) is a next-generation Node.js and TypeScript ORM that unlocks a new level of developer experience when working with databases thanks to its intuitive data model, automated migrations, type-safety & auto-completion.

## @gqloom/prisma

This package provides GQLoom integration with [Prisma](https://www.prisma.io/):

- Weave Prisma model into a GraphQL Schema;
- Support quickly creating CRUD interfaces from Prisma using the resolver factory;

## Installation

```bash
# use npm
npm i @gqloom/core @gqloom/prisma

# use pnpm
pnpm add @gqloom/core @gqloom/prisma

# use yarn
yarn add @gqloom/core @gqloom/prisma
```
Read more at [GQLoom Document](https://gqloom.dev/docs/schema/prisma).
npm package: @gqloom/valibot
Description: Create GraphQL schema and resolvers easily using Valibot!
Author: xcfox
Latest version: 0.15.1

![GQLoom Logo](https://github.com/modevol-com/gqloom/blob/main/gqloom.svg?raw=true)

# GQLoom

GQLoom is a **Code-First** GraphQL Schema Loom used to weave **runtime types** in the **TypeScript/JavaScript** ecosystem into GraphQL Schema, helping you build GraphQL server enjoyably and efficiently.

Runtime validation libraries such as [Zod](https://zod.dev/), [Valibot](https://valibot.dev/), and [Yup](https://github.com/jquense/yup) have been widely used in backend application development. Meanwhile, when using ORM libraries like [Prisma](https://www.prisma.io/), [MikroORM](https://mikro-orm.io/), and [Drizzle](https://orm.drizzle.team/), we also pre-define database table structures or entity models that contain runtime types.
The responsibility of GQLoom is to weave these runtime types into a GraphQL Schema.

When developing backend applications with GQLoom, you only need to write types using the Schema libraries you're familiar with. Modern Schema libraries will infer TypeScript types for you, and GQLoom will weave GraphQL types for you.
In addition, the **resolver factory** of GQLoom can create CRUD interfaces for `Prisma`, `MikroORM`, and `Drizzle`, and supports custom input and adding middleware.

# @gqloom/valibot

This package provides GQLoom integration with [Valibot](https://valibot.dev/) to weave Valibot Schema to GraphQL Schema.

## Installation

```bash
# use npm
npm i @gqloom/core valibot @gqloom/valibot

# use pnpm
pnpm add @gqloom/core valibot @gqloom/valibot

# use yarn
yarn add @gqloom/core valibot @gqloom/valibot
```


## Hello World

```ts
import { resolver, query, weave } from "@gqloom/core"
import { ValibotWeaver } from "@gqloom/valibot"
import * as v from "valibot"

const helloResolver = resolver({
  hello: query(v.string())
    .input({ name: v.nullish(v.string(), "World") })
    .resolve(({ name }) => `Hello, ${name}!`),
})

export const schema = weave(ValibotWeaver, helloResolver)
```

Read more at [GQLoom Document](https://gqloom.dev/docs/schema/valibot).
npm package: @gqloom/yup
Description: Create GraphQL schema and resolvers easily using using Yup!
Author: xcfox
Latest version: 0.13.0

![GQLoom Logo](https://github.com/modevol-com/gqloom/blob/main/gqloom.svg?raw=true)

# GQLoom

GQLoom is a **Code-First** GraphQL Schema Loom used to weave **runtime types** in the **TypeScript/JavaScript** ecosystem into GraphQL Schema, helping you build GraphQL server enjoyably and efficiently.

Runtime validation libraries such as [Zod](https://zod.dev/), [Valibot](https://valibot.dev/), and [Yup](https://github.com/jquense/yup) have been widely used in backend application development. Meanwhile, when using ORM libraries like [Prisma](https://www.prisma.io/), [MikroORM](https://mikro-orm.io/), and [Drizzle](https://orm.drizzle.team/), we also pre-define database table structures or entity models that contain runtime types.
The responsibility of GQLoom is to weave these runtime types into a GraphQL Schema.

When developing backend applications with GQLoom, you only need to write types using the Schema libraries you're familiar with. Modern Schema libraries will infer TypeScript types for you, and GQLoom will weave GraphQL types for you.
In addition, the **resolver factory** of GQLoom can create CRUD interfaces for `Prisma`, `MikroORM`, and `Drizzle`, and supports custom input and adding middleware.

# @gqloom/yup

This package provides GQLoom integration with [Yup](https://github.com/jquense/yup) to weave Yup Schema to GraphQL Schema.

## Installation

```bash
# use npm
npm i @gqloom/core yup @gqloom/yup

# use pnpm
pnpm add @gqloom/core yup @gqloom/yup

# use yarn
yarn add @gqloom/core yup @gqloom/yup
```

## Hello World

```ts
import { query, resolver, weave } from "@gqloom/core"
import { YupWeaver } from "@gqloom/yup"
import { string } from "yup"

const helloResolver = resolver({
  hello: query(string())
    .input({ name: string().default("World") })
    .resolve(({ name }) => `Hello, ${name}!`),
})

export const schema = weave(YupWeaver, helloResolver)
```

Read more at [GQLoom Document](https://gqloom.dev/docs/schema/yup).
npm package: @gqlpt/cli
Description: Leverage AI to generate GraphQL queries from plain text.
Author: rconnect.tech
Latest version: 0.0.0-alpha.33

# @gqlpt/cli

<div align="center" style="text-align: center;">
<img src="https://github.com/rocket-connect/gqlpt/raw/main/apps/docs/static/img/logo.svg" width="20%" alt="GQLPT">
</div>

GQLPT CLI is a powerful command-line tool for generating type definitions for GQLPT (GraphQL Plain Text) queries. It scans your project for GQLPT usage and generates corresponding TypeScript type definitions.

## Installation

```bash
npm install -g @gqlpt/cli
```

## Usage

```bash
npx @gqlpt/cli generate <source> [options]
```

## Docs

[gqlpt.dev/docs/cli](https://www.gqlpt.dev/docs/cli)

## License

MIT - Rocket Connect - https://github.com/rocket-connect
npm package: @gquittet/baltig-label-deployer
Description: Add correct label for deployed issues to board automatically
Author: Guillaume Quittet
Latest version: 0.3.9

# BalTig Automatisation

⚠️ This project is the first part to automate repetitive tasks with a popular Git plateform.

## How to use

See [.env.example](.env.example) for required environement variables


### Add deploy labels
```sh
npx @gquittet/baltig-label-deployer --host https://example.com --token my_token --project my_project --deploy
```

### Start a new milestone
```sh
npx @gquittet/baltig-label-deployer --host https://example.com --token my_token --project my_project --milestone
```
npm package: @gr2m/express-github-stitch
Description: express plugin for stitching GitHub’s GraphQL API
Author: Gregor Martynus
Latest version: 1.0.4

# express-github-stitch

[![Greenkeeper badge](https://badges.greenkeeper.io/gr2m/express-github-stitch.svg)](https://greenkeeper.io/)

> express plugin for stitching GitHub’s GraphQL API

## Install

```bash
npm install @gr2m/express-github-stitch
```

## Usage

```js
const express = require('express')
const app = express()
const stitchGithub = require('@gr2m/express-github-stitch')

const schema = `
  extend type User {
    foo: String
  }
`

const resolvers = mergeInfo => ({
  User: {
    foo: {
      // define requirements for resolver, in this case url + login
      fragment: `fragment UserFragment on User { websiteUrl, login }`,
      // resolve the `twitter` property
      async resolve (parent, args, context, info) {
        return 'bar'
      }
    }
  }
})

app.use(stitchGithub({schema, resolvers}))
app.listen(3000)
```

You can now send a query to localhost:3000

```bash
curl http://localhost:3000/ \
  -XPOST \
  -H"Authorization: bearer <your token here>" \
  -H"Content-Type: application/json" \
  -d '{"query":"{ viewer { foo } }"}'
```

Which returns something like this

```json
{"data":{"viewer":{"foo":"bar"}}}
```

You can use the [GraphiQL app](https://github.com/skevy/graphiql-app) to send
queries. Don’t forget to set the `Authorization` header to `bearer <your token here>`.

## How it works

`express-github-stitch` is based on [Apollo’s GraphQL Tools for Schema Stitching](https://www.apollographql.com/docs/graphql-tools/schema-stitching.html)

## License

[MIT](LICENSE.md)
npm package: @gr2m/github-graphql-schema
Description: GitHub’s GraphQL Schema with validation. Automatically updated.
Author: Gregor Martynus
Latest version: 2.11.0

# github-graphql-schema

> GitHub’s GraphQL Schema with validation. Automatically updated.

[![Build Status](https://travis-ci.org/gr2m/github-graphql-schema.svg?branch=master)](https://travis-ci.org/gr2m/github-graphql-schema)
[![Greenkeeper badge](https://badges.greenkeeper.io/gr2m/github-graphql-schema.svg)](https://greenkeeper.io/)

## Usage

```js
const {validate} = require('@gr2m/github-graphql-schema')
const errors = validate(`
{
  viewer {
    login
  }
}
`)

// errors is array. Contains errors if any
```

You can also load the current Schema directly as JSON or [IDL](https://en.wikipedia.org/wiki/Interface_description_language).

```js
const {schema} = require('@gr2m/github-graphql-schema')
schem.json // JSON version
schem.idl // IDL version
```

## Local setup

```
git clone https://github.com/gr2m/github-graphql-schema.git
cd github-graphql-schema
npm install
npm test
```

Update schema files (`GH_TOKEN` requires no scope)

```
GH_TOKEN=... bin/download.js
```

Create pull request (after schema files changed). This script is run daily on Travis CI. The token requires `public_repo` scope.

```
GH_TOKEN=... TRAVIS_REPO_SLUG=gr2m/github-graphql-schema bin/create-pull-request.js
```

## LICENSE

[MIT](LICENSE.md)