graphql-buddy 0.0.0

package/.github/workflows/ci.yml

@@ -0,0 +1,32 @@
+name: CI
+
+on:
+  push:
+    branches:
+      - main
+  pull_request:
+
+permissions:
+  actions: read
+  contents: read
+
+jobs:
+  main:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - uses: pnpm/action-setup@v4
+        with:
+          version: 10.13.1
+      - uses: actions/setup-node@v4
+        with:
+          node-version-file: '.nvmrc'
+          cache: 'pnpm'
+
+      - run: pnpm install
+      - run: pnpm run lint
+      - run: pnpm run build
+      - run: pnpm run test

package/.nvmrc

@@ -0,0 +1 @@
+lts/jod

package/.prettierignore

@@ -0,0 +1 @@
+pnpm-lock.yaml

package/.prettierrc

@@ -0,0 +1,7 @@
+{
+  "printWidth": 80,
+  "trailingComma": "all",
+  "tabWidth": 2,
+  "semi": true,
+  "singleQuote": true
+}

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Hunter Larco
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,89 @@
+# graphql-buddy
+
+[![npm version](https://badge.fury.io/js/graphql-buddy.svg)](https://badge.fury.io/js/graphql-buddy)
+[![CI](https://github.com/HunterLarco/graphql-buddy/actions/workflows/ci.yml/badge.svg)](https://github.com/HunterLarco/graphql-buddy/actions/workflows/ci.yml)
+
+> CLI tools for manipulating graphql // designed for build system tooling.
+
+Includes useful tools like:
+
+- `bundle` ~ merge multiple schema's into one (wth tree shaking).
+- `validate` ~ validate GraphQL schema.
+
+Necessary for build tool integrations such as [rules_graphql].
+
+[rules_graphql]: https://github.com/HunterLarco/rules_graphql
+
+## Table of Contents
+
+<!-- TOC start (generated with https://github.com/derlin/bitdowntoc) -->
+
+- [graphql-buddy](#graphql-buddy)
+  - [Quick Start](#quick-start)
+  - [Documentation](#documentation)
+    - [Bundle](#bundle)
+    - [Validate](#validate)
+    - [Programmatic Use](#programmatic-use)
+  - [Contributions](#contributions)
+  <!-- TOC end -->
+
+## Quick Start
+
+```
+npm install graphql-buddy
+
+npx graphql-buddy bundle **/*.graphql
+```
+
+## Documentation
+
+You can always use `graphql-buddy --help` for CLI documentation.
+
+### Bundle
+
+Bundles multiple schema into a single file _and_ prunes any unused types from
+the bundle.
+
+For example:
+
+```sh
+npx graphql-buddy bundle **/*.graphql
+
+# If you want to preserve unused types.
+npx graphql-buddy bundle **/*.graphql --no-shake
+```
+
+### Validate
+
+Validates schema, ensuring valid syntax and that all symbols are found.
+
+For example:
+
+```sh
+npx graphql-buddy validate **/*.graphql
+```
+
+For many build systems (such as BUCK and BAZEL) all build steps _must_ emit a
+file. Validate accomodates this by writing "validation stamps", a file only
+written if validation is successful and documents the exact settings used during
+validation. For example:
+
+```
+npx graphql-buddy validate **/*.graphql --stamp schema.stamp
+```
+
+### Programmatic Use
+
+All commands and most helpers are available programmatically.
+
+```js
+import * as graphqlBuddy from 'graphql-buddy';
+
+await graphqlBuddy.bundle({ ... });
+await graphqlBuddy.validate({ ... });
+```
+
+## Contributions
+
+Contributions, issues and feature requests are very welcome. If you are using
+this package and fixed a bug for yourself, please consider submitting a PR!

package/dist/api.d.ts

@@ -0,0 +1,46 @@
+import * as graphql from 'graphql';
+
+type LoadSchemaOptions = {
+    normalized?: false | null;
+    files: Array<string>;
+    base?: string | null;
+    pathAliases?: Map<string, string> | null;
+};
+declare const loadSchema: (options: LoadSchemaOptions | NormalizedLoadSchemaOptions) => Promise<graphql.GraphQLSchema>;
+type NormalizedLoadSchemaOptions = {
+    normalized: true;
+    files: Array<string>;
+    pathAliases: Map<string, string>;
+};
+declare const normalizeLoadSchemaOptions: (options: LoadSchemaOptions) => Promise<NormalizedLoadSchemaOptions>;
+
+type BundleOptions = {
+    schema: LoadSchemaOptions;
+    shake?: boolean | null;
+};
+/**
+ * Bundles multiple schema together into a single file.
+ *
+ * @param options - Bundle options.
+ *
+ * @returns The merged schema as text.
+ */
+declare const bundle: (options: BundleOptions) => Promise<string>;
+
+type ValidateOptions = {
+    schema: LoadSchemaOptions;
+};
+/**
+ * Validates that the provided GraphQL schema contain valid syntax and have no
+ * unknown symbols.
+ *
+ * @param options - Validate options.
+ *
+ * @returns If validation is successful, returns a validation stamp: a text blob
+ *   describing the successful outcome and options used during validation. This
+ *   is often useful in build systems where a build step *must* emit a file. If
+ *   validation fails, a runtime error will be thrown.
+ */
+declare const validate: (options: ValidateOptions) => Promise<string>;
+
+export { type BundleOptions, type LoadSchemaOptions, type NormalizedLoadSchemaOptions, type ValidateOptions, bundle, loadSchema, normalizeLoadSchemaOptions, validate };

package/dist/api.js

@@ -0,0 +1,13 @@
+import {
+  bundle,
+  loadSchema,
+  normalizeLoadSchemaOptions,
+  validate
+} from "./chunk-Z7B4AQ2U.js";
+export {
+  bundle,
+  loadSchema,
+  normalizeLoadSchemaOptions,
+  validate
+};
+//# sourceMappingURL=api.js.map

package/dist/api.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/chunk-Z7B4AQ2U.js

@@ -0,0 +1,124 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve2, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve2(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+
+// src/api/commands/bundle.ts
+import * as graphqlToolsUtils from "@graphql-tools/utils";
+import * as graphql from "graphql";
+
+// src/api/shared/loadSchema.ts
+import * as nodeFs from "fs/promises";
+import * as nodePath from "path";
+import * as graphqlFileLoader from "@graphql-tools/graphql-file-loader";
+import * as graphqlLoad from "@graphql-tools/load";
+import * as glob from "glob";
+var loadSchema2 = (options) => __async(null, null, function* () {
+  const { files, pathAliases } = options.normalized ? options : yield normalizeLoadSchemaOptions(options);
+  for (const file of files) {
+    try {
+      yield nodeFs.access(file, nodeFs.constants.F_OK);
+    } catch (e) {
+      throw new Error(`File does not exist: ${file}`);
+    }
+  }
+  return graphqlLoad.loadSchema(files, {
+    loaders: [new graphqlFileLoader.GraphQLFileLoader()],
+    pathAliases: {
+      mappings: Object.fromEntries(pathAliases.entries())
+    }
+  });
+});
+var normalizeLoadSchemaOptions = (options) => __async(null, null, function* () {
+  var _a;
+  const base = (_a = options.base) != null ? _a : process.cwd();
+  const files = yield glob.glob(
+    options.files.map((file) => nodePath.resolve(base, file))
+  );
+  const pathAliases = /* @__PURE__ */ new Map();
+  if (options.pathAliases != null) {
+    for (const [alias, source] of options.pathAliases.entries()) {
+      pathAliases.set(alias, nodePath.resolve(base, source));
+    }
+  }
+  return {
+    normalized: true,
+    files,
+    pathAliases
+  };
+});
+
+// src/api/commands/bundle.ts
+var bundle = (options) => __async(null, null, function* () {
+  var _a;
+  const shake = (_a = options.shake) != null ? _a : true;
+  let schema = yield loadSchema2(options.schema);
+  if (shake) {
+    schema = graphqlToolsUtils.pruneSchema(schema);
+  }
+  return graphql.printSchema(schema);
+});
+
+// src/api/commands/validate.ts
+import * as stringifyObject from "stringify-object";
+var validate = (options) => __async(null, null, function* () {
+  const normalizedSchemaOptions = yield normalizeLoadSchemaOptions(
+    options.schema
+  );
+  yield loadSchema2(normalizedSchemaOptions);
+  return createValidationStamp(__spreadProps(__spreadValues({}, options), {
+    schema: normalizedSchemaOptions
+  }));
+});
+var createValidationStamp = (options) => stringifyObject.default(
+  { options, outcome: { valid: true } },
+  {
+    indent: `  `,
+    filter: (container, property) => !(container === options.schema && property === `normalized`)
+  }
+);
+
+export {
+  __spreadValues,
+  __async,
+  loadSchema2 as loadSchema,
+  normalizeLoadSchemaOptions,
+  bundle,
+  validate
+};
+//# sourceMappingURL=chunk-Z7B4AQ2U.js.map

package/dist/chunk-Z7B4AQ2U.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/api/commands/bundle.ts","../src/api/shared/loadSchema.ts","../src/api/commands/validate.ts"],"sourcesContent":["import * as graphqlToolsUtils from '@graphql-tools/utils';\nimport * as graphql from 'graphql';\n\nimport * as shared from '../shared';\n\nexport type BundleOptions = {\n  schema: shared.LoadSchemaOptions;\n\n  // Defaults to true.\n  shake?: boolean | null;\n};\n\n/**\n * Bundles multiple schema together into a single file.\n *\n * @param options - Bundle options.\n *\n * @returns The merged schema as text.\n */\nexport const bundle = async (options: BundleOptions): Promise<string> => {\n  const shake = options.shake ?? true;\n\n  let schema = await shared.loadSchema(options.schema);\n  if (shake) {\n    schema = graphqlToolsUtils.pruneSchema(schema);\n  }\n\n  return graphql.printSchema(schema);\n};\n","import * as nodeFs from 'node:fs/promises';\nimport * as nodePath from 'node:path';\n\nimport * as graphqlFileLoader from '@graphql-tools/graphql-file-loader';\nimport * as graphqlLoad from '@graphql-tools/load';\nimport * as glob from 'glob';\n\nimport type * as graphql from 'graphql';\n\nexport type LoadSchemaOptions = {\n  normalized?: false | null;\n\n  // Relative paths will be resolved using `base`.\n  //\n  // Also accepts glob patterns.\n  files: Array<string>;\n\n  // Directory from which `files` are resolved.\n  //\n  // Defaults to `process.cwd()`.\n  base?: string | null;\n\n  // See @graphql-tools/import#PathAliases\n  //\n  // Note that relative paths will be resolved relative to `base` to maintain\n  // parity with `files`.\n  pathAliases?: Map<string, string> | null;\n};\n\nexport const loadSchema = async (\n  options: LoadSchemaOptions | NormalizedLoadSchemaOptions,\n): Promise<graphql.GraphQLSchema> => {\n  const { files, pathAliases } = options.normalized\n    ? options\n    : await normalizeLoadSchemaOptions(options);\n\n  // @graphql-tools/graphql-file-loader silently skips input files which are not\n  // found. I suspect this is so that it can delegate missing inputs to other\n  // loaders. For our purposes, this is undesirable because we want to inform\n  // clients if expected inputs are missing. For that reason, we manually\n  // validate that the files exist first.\n  for (const file of files) {\n    try {\n      await nodeFs.access(file, nodeFs.constants.F_OK);\n    } catch {\n      throw new Error(`File does not exist: ${file}`);\n    }\n  }\n\n  return graphqlLoad.loadSchema(files, {\n    loaders: [new graphqlFileLoader.GraphQLFileLoader()],\n    pathAliases: {\n      mappings: Object.fromEntries(pathAliases.entries()),\n    },\n  });\n};\n\nexport type NormalizedLoadSchemaOptions = {\n  normalized: true;\n\n  // Absolute paths.\n  files: Array<string>;\n\n  // See @graphql-tools/import#PathAliases\n  pathAliases: Map<string, string>;\n};\n\nexport const normalizeLoadSchemaOptions = async (\n  options: LoadSchemaOptions,\n): Promise<NormalizedLoadSchemaOptions> => {\n  const base = options.base ?? process.cwd();\n  const files = await glob.glob(\n    options.files.map((file) => nodePath.resolve(base, file)),\n  );\n\n  const pathAliases = new Map<string, string>();\n  if (options.pathAliases != null) {\n    for (const [alias, source] of options.pathAliases.entries()) {\n      pathAliases.set(alias, nodePath.resolve(base, source));\n    }\n  }\n\n  return {\n    normalized: true,\n    files,\n    pathAliases,\n  };\n};\n","import * as stringifyObject from 'stringify-object';\n\nimport * as shared from '../shared';\n\nexport type ValidateOptions = {\n  schema: shared.LoadSchemaOptions;\n};\n\n/**\n * Validates that the provided GraphQL schema contain valid syntax and have no\n * unknown symbols.\n *\n * @param options - Validate options.\n *\n * @returns If validation is successful, returns a validation stamp: a text blob\n *   describing the successful outcome and options used during validation. This\n *   is often useful in build systems where a build step *must* emit a file. If\n *   validation fails, a runtime error will be thrown.\n */\nexport const validate = async (options: ValidateOptions): Promise<string> => {\n  // We manually normalize the `LoadSchemaOptions` so that we can write the most\n  // accurate data in our validation stamp. For example, normalization expands\n  // globs and resolves absolute paths. These are critical steps to ensure the\n  // validation stamp describes without ambiguity which schema were loaded.\n  const normalizedSchemaOptions = await shared.normalizeLoadSchemaOptions(\n    options.schema,\n  );\n\n  await shared.loadSchema(normalizedSchemaOptions);\n\n  return createValidationStamp({\n    ...options,\n    schema: normalizedSchemaOptions,\n  });\n};\n\nconst createValidationStamp = (\n  options: Omit<ValidateOptions, `schema`> & {\n    schema: shared.NormalizedLoadSchemaOptions;\n  },\n): string =>\n  stringifyObject.default(\n    { options, outcome: { valid: true } },\n    {\n      indent: `  `,\n      filter: (container, property) =>\n        !(container === options.schema && property === `normalized`),\n    },\n  );\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,YAAY,uBAAuB;AACnC,YAAY,aAAa;;;ACDzB,YAAY,YAAY;AACxB,YAAY,cAAc;AAE1B,YAAY,uBAAuB;AACnC,YAAY,iBAAiB;AAC7B,YAAY,UAAU;AAwBf,IAAMA,cAAa,CACxB,YACmC;AACnC,QAAM,EAAE,OAAO,YAAY,IAAI,QAAQ,aACnC,UACA,MAAM,2BAA2B,OAAO;AAO5C,aAAW,QAAQ,OAAO;AACxB,QAAI;AACF,YAAa,cAAO,MAAa,iBAAU,IAAI;AAAA,IACjD,SAAQ;AACN,YAAM,IAAI,MAAM,wBAAwB,IAAI,EAAE;AAAA,IAChD;AAAA,EACF;AAEA,SAAmB,uBAAW,OAAO;AAAA,IACnC,SAAS,CAAC,IAAsB,oCAAkB,CAAC;AAAA,IACnD,aAAa;AAAA,MACX,UAAU,OAAO,YAAY,YAAY,QAAQ,CAAC;AAAA,IACpD;AAAA,EACF,CAAC;AACH;AAYO,IAAM,6BAA6B,CACxC,YACyC;AArE3C;AAsEE,QAAM,QAAO,aAAQ,SAAR,YAAgB,QAAQ,IAAI;AACzC,QAAM,QAAQ,MAAW;AAAA,IACvB,QAAQ,MAAM,IAAI,CAAC,SAAkB,iBAAQ,MAAM,IAAI,CAAC;AAAA,EAC1D;AAEA,QAAM,cAAc,oBAAI,IAAoB;AAC5C,MAAI,QAAQ,eAAe,MAAM;AAC/B,eAAW,CAAC,OAAO,MAAM,KAAK,QAAQ,YAAY,QAAQ,GAAG;AAC3D,kBAAY,IAAI,OAAgB,iBAAQ,MAAM,MAAM,CAAC;AAAA,IACvD;AAAA,EACF;AAEA,SAAO;AAAA,IACL,YAAY;AAAA,IACZ;AAAA,IACA;AAAA,EACF;AACF;;;ADpEO,IAAM,SAAS,CAAO,YAA4C;AAnBzE;AAoBE,QAAM,SAAQ,aAAQ,UAAR,YAAiB;AAE/B,MAAI,SAAS,MAAaC,YAAW,QAAQ,MAAM;AACnD,MAAI,OAAO;AACT,aAA2B,8BAAY,MAAM;AAAA,EAC/C;AAEA,SAAe,oBAAY,MAAM;AACnC;;;AE5BA,YAAY,qBAAqB;AAmB1B,IAAM,WAAW,CAAO,YAA8C;AAK3E,QAAM,0BAA0B,MAAa;AAAA,IAC3C,QAAQ;AAAA,EACV;AAEA,QAAaC,YAAW,uBAAuB;AAE/C,SAAO,sBAAsB,iCACxB,UADwB;AAAA,IAE3B,QAAQ;AAAA,EACV,EAAC;AACH;AAEA,IAAM,wBAAwB,CAC5B,YAIgB;AAAA,EACd,EAAE,SAAS,SAAS,EAAE,OAAO,KAAK,EAAE;AAAA,EACpC;AAAA,IACE,QAAQ;AAAA,IACR,QAAQ,CAAC,WAAW,aAClB,EAAE,cAAc,QAAQ,UAAU,aAAa;AAAA,EACnD;AACF;","names":["loadSchema","loadSchema","loadSchema"]}

package/dist/cli.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/cli.js

@@ -0,0 +1,122 @@
+#!/usr/bin/env node
+import {
+  __async,
+  __spreadValues,
+  bundle,
+  validate
+} from "./chunk-Z7B4AQ2U.js";
+
+// src/cli/index.ts
+import * as commander3 from "@commander-js/extra-typings";
+import * as graphql from "graphql";
+
+// src/cli/commands/bundle.ts
+import * as nodeFs from "fs/promises";
+import * as nodePath from "path";
+import * as commander from "@commander-js/extra-typings";
+
+// src/cli/shared/parsePathAliases.ts
+var parsePathAliases = (encodedAliases) => {
+  const decodedAliases = /* @__PURE__ */ new Map();
+  for (const encodedAlias of encodedAliases) {
+    const parts = encodedAlias.split(`=`);
+    if (parts.length !== 2) {
+      throw new Error(
+        `Expected an alias in the form "alias=source" but found "${encodedAlias}"`
+      );
+    }
+    const [alias, source] = parts;
+    if (decodedAliases.has(alias)) {
+      throw new Error(`Alias "${alias}" is set multiple times.`);
+    }
+    decodedAliases.set(alias, source);
+  }
+  return decodedAliases;
+};
+
+// src/cli/commands/bundle.ts
+var createBundleCommand = () => new commander.Command().name(`bundle`).description(`Bundles multiple GraphQL inputs into a single file.`).argument(`<schema...>`, `Input GraphQL schema files to bundle.`).option(
+  `-b, --base <directory>`,
+  `Base directory from which paths are resolved.`
+).option(
+  `-a, --alias <pattern...>`,
+  `Path alias options for @graphql-tools/load.`
+).option(
+  `--out <file>`,
+  `Where to write the bundled schema.`,
+  `bundle.graphql`
+).option(`--no-shake`, `Prevents pruning of unused types.`).option(`-s, --silent`, `Only log critical information.`, false).action(
+  (schema, options) => bundle2(__spreadValues({
+    schema
+  }, options))
+);
+var bundle2 = (options) => __async(null, null, function* () {
+  const { schema, base, alias, shake, silent } = options;
+  const out = nodePath.resolve(base != null ? base : process.cwd(), options.out);
+  yield nodeFs.writeFile(
+    out,
+    yield bundle({
+      schema: {
+        files: schema,
+        base,
+        pathAliases: parsePathAliases(alias != null ? alias : [])
+      },
+      shake
+    })
+  );
+  if (!silent) {
+    console.log(`\u2705 bundler encountered no errors.`);
+  }
+});
+
+// src/cli/commands/validate.ts
+import * as nodeFs2 from "fs/promises";
+import * as nodePath2 from "path";
+import * as commander2 from "@commander-js/extra-typings";
+var createValidateCommand = () => new commander2.Command().name(`validate`).description(`Checks that all provided GraphQL files form a valid schema.`).argument(`<schema...>`, `Input GraphQL schema files to validate.`).option(
+  `-b, --base <directory>`,
+  `Base directory from which paths are resolved.`
+).option(
+  `-a, --alias <pattern...>`,
+  `Path alias options for @graphql-tools/load.`
+).option(
+  `--stamp <file>`,
+  `Creates a validation stamp to confirm valid GraphQL schema.`
+).option(`-s, --silent`, `Only log critical information.`, false).action(
+  (schema, options) => validate2(__spreadValues({
+    schema
+  }, options))
+);
+var validate2 = (options) => __async(null, null, function* () {
+  const { schema, base, alias, stamp, silent } = options;
+  const validationStamp = yield validate({
+    schema: {
+      files: schema,
+      base,
+      pathAliases: parsePathAliases(alias != null ? alias : [])
+    }
+  });
+  if (stamp != null) {
+    const destination = nodePath2.resolve(base != null ? base : process.cwd(), stamp);
+    yield nodeFs2.writeFile(destination, validationStamp);
+  }
+  if (!silent) {
+    console.log(`\u2705 validation encountered no errors.`);
+  }
+});
+
+// src/cli/index.ts
+var main = () => {
+  process.setUncaughtExceptionCaptureCallback((error) => {
+    if (error instanceof graphql.GraphQLError) {
+      console.error(error.toString());
+      return;
+    }
+    console.error(error);
+  });
+  commander3.program.name(`graphql-buddy`).description(
+    `CLI tools for manipulating graphql // designed for build system tooling.`
+  ).addCommand(createBundleCommand()).addCommand(createValidateCommand()).parse();
+};
+main();
+//# sourceMappingURL=cli.js.map

package/dist/cli.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/cli/index.ts","../src/cli/commands/bundle.ts","../src/cli/shared/parsePathAliases.ts","../src/cli/commands/validate.ts"],"sourcesContent":["#!/usr/bin/env node\n\nimport * as commander from '@commander-js/extra-typings';\nimport * as graphql from 'graphql';\n\nimport * as commands from './commands';\n\nconst main = () => {\n  process.setUncaughtExceptionCaptureCallback((error) => {\n    // When thrown natively, GraphQLError prints like any other error with\n    // minimal context, however, when logged with `.toString()` it prints\n    // helpful debugging information critical for debugging syntax errors (such\n    // as source file, location, symbol, etc...).\n    //\n    // For example:\n    //\n    // ```\n    // Syntax Error: Expected \":\", found Name \"ID\".\n    //\n    // src/services/api/schema/CurrentUser.graphql:2:6\n    // 1 | type CurrentUser {\n    // 2 |   id ID!\n    //   |      ^\n    // 3 |   dateCreated: DateTime!\n    // ```\n    //\n    // Versus the naive output:\n    //\n    // ```\n    // return new _GraphQLError.GraphQLError(`Syntax Error: ${description}`, {\n    // GraphQLError: Syntax Error: Expected \":\", found Name \"ID\".\n    //     at syntaxError (node_modules/graphql/error/syntaxError.js:15:10)\n    // ```\n    if (error instanceof graphql.GraphQLError) {\n      console.error(error.toString());\n      return;\n    }\n\n    console.error(error);\n  });\n\n  commander.program\n    .name(`graphql-buddy`)\n    .description(\n      `CLI tools for manipulating graphql // designed for build system tooling.`,\n    )\n    .addCommand(commands.createBundleCommand())\n    .addCommand(commands.createValidateCommand())\n    .parse();\n};\n\nmain();\n","import * as nodeFs from 'node:fs/promises';\nimport * as nodePath from 'node:path';\n\nimport * as commander from '@commander-js/extra-typings';\n\nimport * as api from '../../api';\nimport * as shared from '../shared';\n\nexport const createBundleCommand = () =>\n  new commander.Command()\n    .name(`bundle`)\n    .description(`Bundles multiple GraphQL inputs into a single file.`)\n    .argument(`<schema...>`, `Input GraphQL schema files to bundle.`)\n    .option(\n      `-b, --base <directory>`,\n      `Base directory from which paths are resolved.`,\n    )\n    .option(\n      `-a, --alias <pattern...>`,\n      `Path alias options for @graphql-tools/load.`,\n    )\n    .option(\n      `--out <file>`,\n      `Where to write the bundled schema.`,\n      `bundle.graphql`,\n    )\n    .option(`--no-shake`, `Prevents pruning of unused types.`)\n    .option(`-s, --silent`, `Only log critical information.`, false)\n    .action((schema, options) =>\n      bundle({\n        schema,\n        ...options,\n      }),\n    );\n\nconst bundle = async (options: {\n  schema: Array<string>;\n  base?: string;\n  alias?: Array<string>;\n  out: string;\n  shake: boolean;\n  silent: boolean;\n}): Promise<void> => {\n  const { schema, base, alias, shake, silent } = options;\n  const out = nodePath.resolve(base ?? process.cwd(), options.out);\n\n  await nodeFs.writeFile(\n    out,\n    await api.bundle({\n      schema: {\n        files: schema,\n        base,\n        pathAliases: shared.parsePathAliases(alias ?? []),\n      },\n      shake,\n    }),\n  );\n\n  if (!silent) {\n    console.log(`✅ bundler encountered no errors.`);\n  }\n};\n","export type PathAliases = Map<string, string>;\n\nexport const parsePathAliases = (\n  encodedAliases: Array<string>,\n): PathAliases => {\n  const decodedAliases = new Map<string, string>();\n\n  for (const encodedAlias of encodedAliases) {\n    const parts = encodedAlias.split(`=`);\n    if (parts.length !== 2) {\n      throw new Error(\n        `Expected an alias in the form \"alias=source\" but found \"${encodedAlias}\"`,\n      );\n    }\n\n    const [alias, source] = parts;\n    if (decodedAliases.has(alias)) {\n      throw new Error(`Alias \"${alias}\" is set multiple times.`);\n    }\n\n    decodedAliases.set(alias, source);\n  }\n\n  return decodedAliases;\n};\n","import * as nodeFs from 'node:fs/promises';\nimport * as nodePath from 'node:path';\n\nimport * as commander from '@commander-js/extra-typings';\n\nimport * as api from '../../api';\nimport * as shared from '../shared';\n\nexport const createValidateCommand = () =>\n  new commander.Command()\n    .name(`validate`)\n    .description(`Checks that all provided GraphQL files form a valid schema.`)\n    .argument(`<schema...>`, `Input GraphQL schema files to validate.`)\n    .option(\n      `-b, --base <directory>`,\n      `Base directory from which paths are resolved.`,\n    )\n    .option(\n      `-a, --alias <pattern...>`,\n      `Path alias options for @graphql-tools/load.`,\n    )\n    .option(\n      `--stamp <file>`,\n      `Creates a validation stamp to confirm valid GraphQL schema.`,\n    )\n    .option(`-s, --silent`, `Only log critical information.`, false)\n    .action((schema, options) =>\n      validate({\n        schema,\n        ...options,\n      }),\n    );\n\nconst validate = async (options: {\n  schema: Array<string>;\n  base?: string;\n  alias?: Array<string>;\n  stamp?: string;\n  silent: boolean;\n}): Promise<void> => {\n  const { schema, base, alias, stamp, silent } = options;\n\n  const validationStamp = await api.validate({\n    schema: {\n      files: schema,\n      base,\n      pathAliases: shared.parsePathAliases(alias ?? []),\n    },\n  });\n\n  if (stamp != null) {\n    const destination = nodePath.resolve(base ?? process.cwd(), stamp);\n    await nodeFs.writeFile(destination, validationStamp);\n  }\n\n  if (!silent) {\n    console.log(`✅ validation encountered no errors.`);\n  }\n};\n"],"mappings":"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","names":["commander","bundle","nodeFs","nodePath","commander","validate"]}

package/eslint.config.ts

@@ -0,0 +1,168 @@
+import * as nodeUrl from 'node:url';
+
+import * as eslintCompat from '@eslint/compat';
+import * as eslint from '@eslint/js';
+import * as eslintConfig from 'eslint/config';
+import * as eslintImportPlugin from 'eslint-plugin-import';
+import * as tseslint from 'typescript-eslint';
+
+const CONFIG: tseslint.ConfigArray = tseslint.config(
+  eslintConfig.globalIgnores([`pnpm-lock.yaml`]),
+  eslintCompat.includeIgnoreFile(
+    nodeUrl.fileURLToPath(new URL(`.gitignore`, import.meta.url)),
+    `Imported .gitignore patterns`,
+  ),
+  eslint.configs.recommended,
+  ...tseslint.configs.recommended,
+  {
+    files: [`**/*.{ts,cts,mts,js,cjs,mjs}`],
+    extends: [
+      eslintImportPlugin.flatConfigs.recommended,
+      eslintImportPlugin.flatConfigs.typescript,
+    ],
+    settings: {
+      'import/resolver': {
+        typescript: {},
+      },
+    },
+    rules: {
+      // Allow unused variables only when prefixed with '_'.
+      '@typescript-eslint/no-unused-vars': [
+        `warn`,
+        {
+          varsIgnorePattern: `^_`,
+          argsIgnorePattern: `^_`,
+          caughtErrorsIgnorePattern: `^_`,
+        },
+      ],
+
+      // Require a single line of vertical whitespace between imports and file
+      // content.
+      'import/newline-after-import': [`error`, { count: 1 }],
+
+      // Dependency cycles can create hard-to-reason through execution
+      // lifecycles and form unexpected bundling artifacts. To simplify, we
+      // disallow them.
+      'import/no-cycle': [`error`, {}],
+
+      'import/namespace': 0,
+      'import/export': 0,
+      'import/order': [
+        `error`,
+        {
+          groups: [`builtin`, `external`, `internal`, `type`],
+          pathGroups: [
+            {
+              pattern: `//**`,
+              group: `internal`,
+              position: `before`,
+            },
+          ],
+          pathGroupsExcludedImportTypes: [],
+          'newlines-between': `always`,
+          named: true,
+          alphabetize: {
+            order: `asc`,
+            caseInsensitive: true,
+          },
+        },
+      ],
+
+      // When selecting either T[] or Array<T> we've decided to prefer the
+      // latter because it is more consistent in syntax with our other container
+      // types (for example, Map<T>, Set<T>, Custom<T>).
+      '@typescript-eslint/array-type': [
+        `error`,
+        { default: `generic`, readonly: `generic` },
+      ],
+
+      // Interfaces and types are not equivalent. Most notably, interfaces
+      // support recursive structures with fewer constraints however they do not
+      // support "index signature types". The result is that we cannot cast an
+      // interface to something like `Record<string, any>` while types can. This
+      // is because interfaces are considered mutable whereas types are static
+      // by the compiler. For this reason we prefer types for their immutability
+      // treatment.
+      '@typescript-eslint/consistent-type-definitions': [`error`, `type`],
+
+      // TypeScript allows specifying a type keyword on imports to indicate that
+      // the export exists only in the type system, not at runtime. This allows
+      // transpilers to drop imports without knowing the types of the
+      // dependencies. We always prefer using `import type` when importing type
+      // symbols.
+      '@typescript-eslint/consistent-type-imports': [
+        `error`,
+        {
+          prefer: `type-imports`,
+          disallowTypeAnnotations: true,
+        },
+      ],
+
+      // An arbitrary decision to favor consistency, we use function expressions
+      // which are more lightweight rather than function declarations.
+      'func-style': [`error`, `expression`, { allowArrowFunctions: true }],
+
+      // We adhere to the Google style guide which *does* allow inline bodies
+      // for single line statements such as:
+      //
+      // ```ts
+      // if (foo) return foo;
+      // ```
+      //
+      // However, they also share that they only support this style to
+      // historical legacy reasons and that new projects do not support inline
+      // bodies. Here we disable all inline bodies.
+      curly: [`error`, `all`],
+
+      // Prefer `const` instead of `let` when a variable is never modified.
+      'prefer-const': `error`,
+
+      // Always prefer `let` over `var`.
+      'no-var': `error`,
+
+      // Prevents the comma operator from being used to inline multiple
+      // expressions into a single line.
+      //
+      // For example:
+      //
+      // ```ts
+      // a = b += 5, a + b;
+      // ```
+      'no-sequences': `error`,
+
+      // Prevents escaping the multiline character in a file to create multiline
+      // strings. Instead prefer to concatenate multiple strings together like
+      // so:
+      //
+      // ```ts
+      // const longText =
+      //     "this is a really " +
+      //     "really long line";
+      // ```
+      'no-multi-str': `error`,
+
+      // Prevents assigning multiple variables in a single expressions.
+      //
+      // See https://eslint.org/docs/latest/rules/no-multi-assign
+      'no-multi-assign': `error`,
+
+      // Prevents blocks (bodies of code wrapped with curly brackets) which are
+      // not part of control flow.
+      //
+      // See https://eslint.org/docs/latest/rules/no-lone-blocks
+      'no-lone-blocks': `error`,
+
+      // Prevents if statements as the only statement in else blocks.
+      //
+      // See https://eslint.org/docs/latest/rules/no-lonely-if
+      'no-lonely-if': `error`,
+
+      // Enforces that we use single-quotes unless backticks are required.
+      //
+      // See https://eslint.org/docs/latest/rules/quotes
+      quotes: [`error`, `backtick`],
+    },
+  },
+);
+
+export default CONFIG;