graphql-buddy 0.0.0 → 0.1.1

package/README.md

@@ -63,6 +63,29 @@ For example:
 npx graphql-buddy validate **/*.graphql
 ```
 
+You can also validate GraphQL operations (queries, mutations, subscriptions,
+and fragments) against the schema with `--operations` (`-o`). Each operation is
+checked against the schema, ensuring every referenced field, argument, and type
+exists.
+
+```sh
+npx graphql-buddy validate schema/**/*.graphql --operations 'operations/**/*.graphql'
+```
+
+Operations are validated one file at a time. When an operation depends on a
+fragment defined elsewhere, pull it in with an `#import` (the same mechanism the
+schema loader uses); the imported fragment is resolved before validation:
+
+```graphql
+# import "./FooFields.graphql"
+
+query AllFoo {
+  allFoo {
+    ...FooFields
+  }
+}
+```
+
 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

package/dist/api.d.ts

@@ -1,21 +1,53 @@
+import * as graphqlUtils from '@graphql-tools/utils';
 import * as graphql from 'graphql';
 
-type LoadSchemaOptions = {
+type GraphqlFiles = UnsafeGraphqlFiles | NormalizedGraphqlFiles;
+type UnsafeGraphqlFiles = {
     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 = {
+type NormalizedGraphqlFiles = {
     normalized: true;
     files: Array<string>;
     pathAliases: Map<string, string>;
 };
-declare const normalizeLoadSchemaOptions: (options: LoadSchemaOptions) => Promise<NormalizedLoadSchemaOptions>;
+declare const normalizeGraphqlFiles: (graphqlFiles: GraphqlFiles) => Promise<NormalizedGraphqlFiles>;
+
+/**
+ * Loads, validates, and parses graphql documents.
+ *
+ * @param graphqlFiles - Operation or fragment files to process.
+ *
+ * @returns The parsed GraphQL documents (or throws an error if parsing fails).
+ */
+declare const loadDocuments: (graphqlFiles: GraphqlFiles) => Promise<Array<graphqlUtils.Source>>;
+
+/**
+ * Loads, validates, and parses graphql schema.
+ *
+ * @param graphqlFiles - Schema files to process.
+ *
+ * @returns The parsed GraphQL schema (or throws an error if parsing fails).
+ */
+declare const loadSchema: (graphqlFiles: GraphqlFiles) => Promise<graphql.GraphQLSchema>;
+
+type ValidateDocumentsOptions = {
+    schema: graphql.GraphQLSchema;
+    documents: Array<graphqlUtils.Source>;
+};
+/**
+ * Validates GraphQL documents against their target schema.
+ *
+ * @param options - Validation options (schema and documents).
+ *
+ * @throws GraphQLError instances when validation fails.
+ */
+declare const validateDocuments: (options: ValidateDocumentsOptions) => void;
 
 type BundleOptions = {
-    schema: LoadSchemaOptions;
+    schema: GraphqlFiles;
     shake?: boolean | null;
 };
 /**
@@ -28,11 +60,13 @@ type BundleOptions = {
 declare const bundle: (options: BundleOptions) => Promise<string>;
 
 type ValidateOptions = {
-    schema: LoadSchemaOptions;
+    schema: GraphqlFiles;
+    operations?: GraphqlFiles | null;
 };
 /**
  * Validates that the provided GraphQL schema contain valid syntax and have no
- * unknown symbols.
+ * unknown symbols. When operations are provided, additionally validates that
+ * every operation is valid against that schema.
  *
  * @param options - Validate options.
  *
@@ -43,4 +77,4 @@ type ValidateOptions = {
  */
 declare const validate: (options: ValidateOptions) => Promise<string>;
 
-export { type BundleOptions, type LoadSchemaOptions, type NormalizedLoadSchemaOptions, type ValidateOptions, bundle, loadSchema, normalizeLoadSchemaOptions, validate };
+export { type BundleOptions, type GraphqlFiles, type NormalizedGraphqlFiles, type UnsafeGraphqlFiles, type ValidateDocumentsOptions, type ValidateOptions, bundle, loadDocuments, loadSchema, normalizeGraphqlFiles, validate, validateDocuments };

package/dist/api.js

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

package/dist/chunk-ZIUWDMA7.js

@@ -0,0 +1,190 @@
+var __defProp = Object.defineProperty;
+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 __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 graphql2 from "graphql";
+
+// src/api/shared/GraphqlFiles.ts
+import * as nodePath from "path";
+import * as glob from "glob";
+var normalizeGraphqlFiles = (graphqlFiles) => __async(null, null, function* () {
+  var _a;
+  if (graphqlFiles.normalized) {
+    return graphqlFiles;
+  }
+  const base = (_a = graphqlFiles.base) != null ? _a : process.cwd();
+  const files = yield glob.glob(
+    graphqlFiles.files.map((file) => nodePath.resolve(base, file))
+  );
+  const pathAliases = /* @__PURE__ */ new Map();
+  if (graphqlFiles.pathAliases != null) {
+    for (const [alias, source] of graphqlFiles.pathAliases.entries()) {
+      pathAliases.set(alias, nodePath.resolve(base, source));
+    }
+  }
+  return {
+    normalized: true,
+    files,
+    pathAliases
+  };
+});
+
+// src/api/shared/loadDocuments.ts
+import * as nodeFs from "fs/promises";
+import * as graphqlFileLoader from "@graphql-tools/graphql-file-loader";
+import * as graphqlLoad from "@graphql-tools/load";
+var loadDocuments2 = (graphqlFiles) => __async(null, null, function* () {
+  const { files, pathAliases } = yield normalizeGraphqlFiles(graphqlFiles);
+  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 yield graphqlLoad.loadDocuments(files, {
+    loaders: [new graphqlFileLoader.GraphQLFileLoader()],
+    pathAliases: {
+      mappings: Object.fromEntries(pathAliases.entries())
+    }
+  });
+});
+
+// src/api/shared/loadSchema.ts
+import * as nodeFs2 from "fs/promises";
+import * as graphqlFileLoader2 from "@graphql-tools/graphql-file-loader";
+import * as graphqlLoad2 from "@graphql-tools/load";
+var loadSchema2 = (graphqlFiles) => __async(null, null, function* () {
+  const { files, pathAliases } = yield normalizeGraphqlFiles(graphqlFiles);
+  for (const file of files) {
+    try {
+      yield nodeFs2.access(file, nodeFs2.constants.F_OK);
+    } catch (e) {
+      throw new Error(`File does not exist: ${file}`);
+    }
+  }
+  return graphqlLoad2.loadSchema(files, {
+    loaders: [new graphqlFileLoader2.GraphQLFileLoader()],
+    pathAliases: {
+      mappings: Object.fromEntries(pathAliases.entries())
+    }
+  });
+});
+
+// src/api/shared/validateDocuments.ts
+import * as graphql from "graphql";
+var validateDocuments = (options) => {
+  const { schema, documents } = options;
+  for (const source of documents) {
+    if (source.document == null) {
+      continue;
+    }
+    const definesOperation = source.document.definitions.some(
+      (definition) => definition.kind === graphql.Kind.OPERATION_DEFINITION
+    );
+    const errors = graphql.validate(
+      schema,
+      source.document,
+      graphql.specifiedRules.filter(
+        (rule) => definesOperation || rule !== graphql.NoUnusedFragmentsRule
+      )
+    );
+    if (errors.length > 0) {
+      throw errors[0];
+    }
+  }
+};
+
+// 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 graphql2.printSchema(schema);
+});
+
+// src/api/commands/validate.ts
+import * as stringifyObject from "stringify-object";
+var validate2 = (options) => __async(null, null, function* () {
+  const normalizedSchemaOptions = yield normalizeGraphqlFiles(
+    options.schema
+  );
+  const schema = yield loadSchema2(normalizedSchemaOptions);
+  if (options.operations == null) {
+    return createValidationStamp({ schema: normalizedSchemaOptions });
+  }
+  const normalizedOperationsOptions = yield normalizeGraphqlFiles(
+    options.operations
+  );
+  validateDocuments({
+    schema,
+    documents: yield loadDocuments2(normalizedOperationsOptions)
+  });
+  return createValidationStamp({
+    schema: normalizedSchemaOptions,
+    operations: normalizedOperationsOptions
+  });
+});
+var createValidationStamp = (options) => stringifyObject.default(
+  {
+    options: {
+      schema: options.schema,
+      operations: options.operations
+    },
+    outcome: { valid: true }
+  },
+  {
+    indent: `  `,
+    filter: (container, property) => !(container === options.schema && property === `normalized`) && !(container === options.operations && property === `normalized`)
+  }
+);
+
+export {
+  __spreadValues,
+  __async,
+  normalizeGraphqlFiles,
+  loadDocuments2 as loadDocuments,
+  loadSchema2 as loadSchema,
+  validateDocuments,
+  bundle,
+  validate2 as validate
+};
+//# sourceMappingURL=chunk-ZIUWDMA7.js.map

package/dist/chunk-ZIUWDMA7.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/api/commands/bundle.ts","../src/api/shared/GraphqlFiles.ts","../src/api/shared/loadDocuments.ts","../src/api/shared/loadSchema.ts","../src/api/shared/validateDocuments.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.GraphqlFiles;\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 nodePath from 'node:path';\n\nimport * as glob from 'glob';\n\nexport type GraphqlFiles = UnsafeGraphqlFiles | NormalizedGraphqlFiles;\n\nexport type UnsafeGraphqlFiles = {\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 type NormalizedGraphqlFiles = {\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 normalizeGraphqlFiles = async (\n  graphqlFiles: GraphqlFiles,\n): Promise<NormalizedGraphqlFiles> => {\n  if (graphqlFiles.normalized) {\n    return graphqlFiles;\n  }\n\n  const base = graphqlFiles.base ?? process.cwd();\n  const files = await glob.glob(\n    graphqlFiles.files.map((file) => nodePath.resolve(base, file)),\n  );\n\n  const pathAliases = new Map<string, string>();\n  if (graphqlFiles.pathAliases != null) {\n    for (const [alias, source] of graphqlFiles.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 nodeFs from 'node:fs/promises';\n\nimport * as graphqlFileLoader from '@graphql-tools/graphql-file-loader';\nimport * as graphqlLoad from '@graphql-tools/load';\n\nimport type * as graphqlUtils from '@graphql-tools/utils';\n\nimport * as graphqlFilesModule from './GraphqlFiles';\n\n/**\n * Loads, validates, and parses graphql documents.\n *\n * @param graphqlFiles - Operation or fragment files to process.\n *\n * @returns The parsed GraphQL documents (or throws an error if parsing fails).\n */\nexport const loadDocuments = async (\n  graphqlFiles: graphqlFilesModule.GraphqlFiles,\n): Promise<Array<graphqlUtils.Source>> => {\n  const { files, pathAliases } =\n    await graphqlFilesModule.normalizeGraphqlFiles(graphqlFiles);\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 await graphqlLoad.loadDocuments(files, {\n    loaders: [new graphqlFileLoader.GraphQLFileLoader()],\n    pathAliases: {\n      mappings: Object.fromEntries(pathAliases.entries()),\n    },\n  });\n};\n","import * as nodeFs from 'node:fs/promises';\n\nimport * as graphqlFileLoader from '@graphql-tools/graphql-file-loader';\nimport * as graphqlLoad from '@graphql-tools/load';\n\nimport type * as graphql from 'graphql';\n\nimport * as graphqlFilesModule from './GraphqlFiles';\n\n/**\n * Loads, validates, and parses graphql schema.\n *\n * @param graphqlFiles - Schema files to process.\n *\n * @returns The parsed GraphQL schema (or throws an error if parsing fails).\n */\nexport const loadSchema = async (\n  graphqlFiles: graphqlFilesModule.GraphqlFiles,\n): Promise<graphql.GraphQLSchema> => {\n  const { files, pathAliases } =\n    await graphqlFilesModule.normalizeGraphqlFiles(graphqlFiles);\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","import * as graphql from 'graphql';\n\nimport type * as graphqlUtils from '@graphql-tools/utils';\n\nexport type ValidateDocumentsOptions = {\n  schema: graphql.GraphQLSchema;\n  documents: Array<graphqlUtils.Source>;\n};\n\n/**\n * Validates GraphQL documents against their target schema.\n *\n * @param options - Validation options (schema and documents).\n *\n * @throws GraphQLError instances when validation fails.\n */\nexport const validateDocuments = (options: ValidateDocumentsOptions): void => {\n  const { schema, documents } = options;\n\n  for (const source of documents) {\n    if (source.document == null) {\n      continue;\n    }\n\n    // Fragment-only documents are fragment \"libraries\" that operations pull in\n    // via `#import`. Validated in isolation they would trip\n    // `NoUnusedFragmentsRule`, so we drop that single rule for them. Every\n    // other rule, most importantly that each referenced field, argument, and\n    // type actually exists, are still enforced.\n    const definesOperation = source.document.definitions.some(\n      (definition) => definition.kind === graphql.Kind.OPERATION_DEFINITION,\n    );\n\n    const errors = graphql.validate(\n      schema,\n      source.document,\n      graphql.specifiedRules.filter(\n        (rule) => definesOperation || rule !== graphql.NoUnusedFragmentsRule,\n      ),\n    );\n    if (errors.length > 0) {\n      throw errors[0];\n    }\n  }\n};\n","import * as stringifyObject from 'stringify-object';\n\nimport * as shared from '../shared';\n\nexport type ValidateOptions = {\n  schema: shared.GraphqlFiles;\n\n  // Optional GraphQL operation documents (queries, mutations, subscriptions,\n  // and fragments) to validate against the loaded schema. When omitted, only\n  // the schema itself is validated.\n  operations?: shared.GraphqlFiles | null;\n};\n\n/**\n * Validates that the provided GraphQL schema contain valid syntax and have no\n * unknown symbols. When operations are provided, additionally validates that\n * every operation is valid against that schema.\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.normalizeGraphqlFiles(\n    options.schema,\n  );\n\n  const schema = await shared.loadSchema(normalizedSchemaOptions);\n\n  if (options.operations == null) {\n    return createValidationStamp({ schema: normalizedSchemaOptions });\n  }\n\n  const normalizedOperationsOptions = await shared.normalizeGraphqlFiles(\n    options.operations,\n  );\n  shared.validateDocuments({\n    schema,\n    documents: await shared.loadDocuments(normalizedOperationsOptions),\n  });\n\n  return createValidationStamp({\n    schema: normalizedSchemaOptions,\n    operations: normalizedOperationsOptions,\n  });\n};\n\nconst createValidationStamp = (options: {\n  schema: shared.NormalizedGraphqlFiles;\n  operations?: shared.NormalizedGraphqlFiles;\n}): string =>\n  stringifyObject.default(\n    {\n      options: {\n        schema: options.schema,\n        operations: options.operations,\n      },\n      outcome: { valid: true },\n    },\n    {\n      indent: `  `,\n      filter: (container, property) =>\n        !(container === options.schema && property === `normalized`) &&\n        !(container === options.operations && property === `normalized`),\n    },\n  );\n"],"mappings":"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","names":["graphql","loadDocuments","nodeFs","graphqlFileLoader","graphqlLoad","loadSchema","loadSchema","validate","loadSchema","loadDocuments"]}

package/dist/cli.js

@@ -4,7 +4,7 @@ import {
   __spreadValues,
   bundle,
   validate
-} from "./chunk-Z7B4AQ2U.js";
+} from "./chunk-ZIUWDMA7.js";
 
 // src/cli/index.ts
 import * as commander3 from "@commander-js/extra-typings";
@@ -73,12 +73,17 @@ var bundle2 = (options) => __async(null, null, function* () {
 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(
+var createValidateCommand = () => new commander2.Command().name(`validate`).description(
+  `Checks that all provided GraphQL files form a valid schema, and optionally that operations are valid against it.`
+).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(
+  `-o, --operations <operations...>`,
+  `GraphQL operation documents to validate against the schema.`
 ).option(
   `--stamp <file>`,
   `Creates a validation stamp to confirm valid GraphQL schema.`
@@ -88,14 +93,23 @@ var createValidateCommand = () => new commander2.Command().name(`validate`).desc
   }, options))
 );
 var validate2 = (options) => __async(null, null, function* () {
-  const { schema, base, alias, stamp, silent } = options;
-  const validationStamp = yield validate({
+  const { schema, base, alias, operations, stamp, silent } = options;
+  const pathAliases = parsePathAliases(alias != null ? alias : []);
+  const validateOptions = {
     schema: {
       files: schema,
       base,
-      pathAliases: parsePathAliases(alias != null ? alias : [])
+      pathAliases
     }
-  });
+  };
+  if (operations != null) {
+    validateOptions.operations = {
+      files: operations,
+      base,
+      pathAliases
+    };
+  }
+  const validationStamp = yield validate(validateOptions);
   if (stamp != null) {
     const destination = nodePath2.resolve(base != null ? base : process.cwd(), stamp);
     yield nodeFs2.writeFile(destination, validationStamp);
@@ -113,6 +127,7 @@ var main = () => {
       return;
     }
     console.error(error);
+    process.exit(1);
   });
   commander3.program.name(`graphql-buddy`).description(
     `CLI tools for manipulating graphql // designed for build system tooling.`

package/dist/cli.js.map

@@ -1 +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"]}
+{"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    process.exit(1);\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(\n      `Checks that all provided GraphQL files form a valid schema, and optionally that operations are valid against it.`,\n    )\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      `-o, --operations <operations...>`,\n      `GraphQL operation documents to validate against the schema.`,\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  operations?: Array<string>;\n  stamp?: string;\n  silent: boolean;\n}): Promise<void> => {\n  const { schema, base, alias, operations, stamp, silent } = options;\n\n  const pathAliases = shared.parsePathAliases(alias ?? []);\n\n  const validateOptions: api.ValidateOptions = {\n    schema: {\n      files: schema,\n      base,\n      pathAliases,\n    },\n  };\n  if (operations != null) {\n    validateOptions.operations = {\n      files: operations,\n      base,\n      pathAliases,\n    };\n  }\n  const validationStamp = await api.validate(validateOptions);\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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "graphql-buddy",
-  "version": "0.0.0",
+  "version": "0.1.1",
   "type": "module",
   "license": "MIT",
   "author": "Hunter John Larco",

package/pnpm-workspace.yaml

@@ -1,3 +1,6 @@
+allowBuilds:
+  esbuild: true
+  unrs-resolver: true
 onlyBuiltDependencies:
   - esbuild
   - unrs-resolver

package/src/api/commands/bundle.test.ts

@@ -12,7 +12,7 @@ describe(`bundle`, () => {
           files: [`*.graphql`],
           base: nodePath.resolve(
             __dirname,
-            `../../../test_fixtures/single_file`,
+            `../../../test_fixtures/schema/single_file`,
           ),
         },
       }),
@@ -43,7 +43,7 @@ type Bar {
           files: [`*.graphql`],
           base: nodePath.resolve(
             __dirname,
-            `../../../test_fixtures/multiple_files`,
+            `../../../test_fixtures/schema/multiple_files`,
           ),
         },
       }),
@@ -87,7 +87,7 @@ type Query {
           files: [`*.graphql`],
           base: nodePath.resolve(
             __dirname,
-            `../../../test_fixtures/single_file_with_extra_deps`,
+            `../../../test_fixtures/schema/single_file_with_extra_deps`,
           ),
         },
       }),
@@ -129,7 +129,7 @@ type FooEvent {
           files: [`*.graphql`],
           base: nodePath.resolve(
             __dirname,
-            `../../../test_fixtures/missing_scalar`,
+            `../../../test_fixtures/schema/missing_scalar`,
           ),
         },
       }),

package/src/api/commands/bundle.ts

@@ -4,7 +4,7 @@ import * as graphql from 'graphql';
 import * as shared from '../shared';
 
 export type BundleOptions = {
-  schema: shared.LoadSchemaOptions;
+  schema: shared.GraphqlFiles;
 
   // Defaults to true.
   shake?: boolean | null;