Explore persisting query

Author: captbaritone

examples/yoga/persisted/MyQuery.ts

@@ -0,0 +1,108 @@
+import { getSchema } from "./../schema";
+import { DocumentNode, execute } from "graphql";
+const schema = getSchema();
+const doc: DocumentNode = {
+    kind: "Document",
+    definitions: [
+        {
+            kind: "OperationDefinition",
+            operation: "query",
+            name: {
+                kind: "Name",
+                value: "MyQuery"
+            },
+            variableDefinitions: [],
+            directives: [],
+            selectionSet: {
+                kind: "SelectionSet",
+                selections: [
+                    {
+                        kind: "Field",
+                        alias: undefined,
+                        name: {
+                            kind: "Name",
+                            value: "me"
+                        },
+                        arguments: [],
+                        directives: [],
+                        selectionSet: {
+                            kind: "SelectionSet",
+                            selections: [
+                                {
+                                    kind: "Field",
+                                    alias: undefined,
+                                    name: {
+                                        kind: "Name",
+                                        value: "groups"
+                                    },
+                                    arguments: [],
+                                    directives: [],
+                                    selectionSet: {
+                                        kind: "SelectionSet",
+                                        selections: [
+                                            {
+                                                kind: "Field",
+                                                alias: undefined,
+                                                name: {
+                                                    kind: "Name",
+                                                    value: "name"
+                                                },
+                                                arguments: [],
+                                                directives: [],
+                                                selectionSet: {
+                                                    kind: "SelectionSet",
+                                                    selections: [
+                                                        {
+                                                            kind: "Field",
+                                                            alias: undefined,
+                                                            name: {
+                                                                kind: "Name",
+                                                                value: "description"
+                                                            },
+                                                            arguments: [],
+                                                            directives: [],
+                                                            selectionSet: undefined
+                                                        },
+                                                        {
+                                                            kind: "Field",
+                                                            alias: undefined,
+                                                            name: {
+                                                                kind: "Name",
+                                                                value: "members"
+                                                            },
+                                                            arguments: [],
+                                                            directives: [],
+                                                            selectionSet: {
+                                                                kind: "SelectionSet",
+                                                                selections: [
+                                                                    {
+                                                                        kind: "Field",
+                                                                        alias: undefined,
+                                                                        name: {
+                                                                            kind: "Name",
+                                                                            value: "name"
+                                                                        },
+                                                                        arguments: [],
+                                                                        directives: [],
+                                                                        selectionSet: undefined
+                                                                    }
+                                                                ]
+                                                            }
+                                                        }
+                                                    ]
+                                                }
+                                            }
+                                        ]
+                                    }
+                                }
+                            ]
+                        }
+                    }
+                ]
+            }
+        }
+    ]
+} as DocumentNode;
+export function executeOperation() {
+    return execute({ schema: schema, document: doc });
+}

examples/yoga/query.graphql

@@ -0,0 +1,12 @@
+query MyQuery {
+  me {
+    groups {
+      name {
+        description
+        members {
+          name
+        }
+      }
+    }
+  }
+}

src/cli.ts

@@ -1,6 +1,11 @@
 #!/usr/bin/env node
 
-import { GraphQLSchema, Location, lexicographicSortSchema } from "graphql";
+import {
+  GraphQLSchema,
+  Location,
+  lexicographicSortSchema,
+  parse,
+} from "graphql";
 import { getParsedTsConfig } from "./";
 import {
   ConfigOptions,
@@ -10,12 +15,14 @@ import {
 } from "./lib";
 import { Command } from "commander";
 import { writeFileSync } from "fs";
-import { resolve, dirname } from "path";
+import { resolve, dirname, join } from "path";
 import { version } from "../package.json";
 import { locate } from "./Locate";
 import { printGratsSDL, printExecutableSchema } from "./printSchema";
 import * as ts from "typescript";
 import { ReportableDiagnostics } from "./utils/DiagnosticError";
+import * as fs from "fs";
+import { queryCodegen } from "./queryCodegen";
 
 const program = new Command();
 
@@ -60,6 +67,45 @@ program
     console.log(formatLoc(loc.value));
   });
 
+program
+  .command("persist")
+  .argument("<OPERATION_TEXT>", "Text of the GraphQL operation to persist")
+  .option(
+    "--tsconfig <TSCONFIG>",
+    "Path to tsconfig.json. Defaults to auto-detecting based on the current working directory",
+  )
+  .action((operationText, { tsconfig }) => {
+    const { config, configPath } = getTsConfigOrReportAndExit(tsconfig);
+
+    const schemaResult = buildSchemaResult(config);
+    if (schemaResult.kind === "ERROR") {
+      console.error(schemaResult.err.formatDiagnosticsWithColorAndContext());
+      process.exit(1);
+    }
+
+    if (operationText === "-") {
+      operationText = fs.readFileSync(process.stdin.fd, "utf-8");
+    }
+
+    const doc = parse(operationText, { noLocation: true });
+
+    if (doc.definitions.length !== 1) {
+      throw new Error("Expected exactly one definition in the document");
+    }
+    if (doc.definitions[0].kind !== "OperationDefinition") {
+      throw new Error("Expected the definition to be an operation");
+    }
+    const name = doc.definitions[0].name?.value;
+
+    const destDir = resolve(dirname(configPath), `./persisted`);
+    const dest = join(destDir, `${name}.ts`);
+    const result = queryCodegen(config.raw.grats, configPath, dest, doc);
+
+    fs.mkdirSync(destDir, { recursive: true });
+    writeFileSync(dest, result);
+    console.error(`Grats: Wrote TypeScript operation to \`${dest}\`.`);
+  });
+
 program.parse();
 
 /**