Test exporting schemas, fix schema exporting

.changeset/five-mangos-walk.md

@@ -0,0 +1,6 @@
+---
+"tamedevil": patch
+---
+
+Add `te.runExportable` method, instead of simply calling the generated factory,
+it exports it in a way that's compatible with `graphile-export`.

.changeset/thick-monkeys-buy.md

@@ -0,0 +1,9 @@
+---
+"graphile-build-pg": patch
+"graphile-build": patch
+"postgraphile": patch
+"graphile-export": patch
+"tamedevil": patch
+---
+
+Fix lots of things related to exporting a schema with `graphile-export`.

.changeset/twelve-windows-shake.md

@@ -0,0 +1,8 @@
+---
+"graphile-build-pg": patch
+"graphile-build": patch
+"postgraphile": patch
+---
+
+Make even more of the schema exportable, including handling scalars with no
+parseLiteral definition.

.eslintignore

@@ -13,6 +13,10 @@ node_modules
 /graphile-build/graphile-build-pg/webpacked
 /graphile-build/graphile-build-pg/exported-schema-for-webpack.mjs
 /graphile-build/graphile-build-pg/schema-export-output.mjs
+**/__tests__/**/*.1.graphql
+**/__tests__/**/*.json5
+**/__tests__/**/*.mermaid
+**/__tests__/**/*.export.mjs
 /wal2json
 dist
 CHANGELOG.md

.gitattributes

@@ -1,4 +1,5 @@
 **/__tests__/**/*.1.graphql linguist-vendored
 **/__tests__/**/*.json5 linguist-vendored
 **/__tests__/**/*.mermaid linguist-vendored
+**/__tests__/**/*.export.mjs linguist-vendored
 */website/** linguist-documentation

.github/workflows/test-base.yml

@@ -43,7 +43,7 @@ jobs:
       fail-fast: false
       matrix:
         postgres-version: [12] #, 11, 13, 14, 15]
-        node-version: [16.14] #, 18.x]
+        node-version: [20.x] #, 18.x]
 
     services:
       postgres:

.nvmrc

@@ -1 +1 @@
-18
+20

grafast/grafast/.mocharc.yml

@@ -4,4 +4,4 @@ check-leaks: true
 extension:
   - ts
 node-option:
-  - "loader=ts-node/esm/transpile-only"
+  - "require=ts-node/register/transpile-only"

grafast/grafast/__tests__/awkward-identifiers-test.ts

@@ -1,11 +1,13 @@
 import { expect } from "chai";
-import { parse } from "graphql";
+import { ExecutionResult, parse } from "graphql";
 import { it } from "mocha";
 
 import {
   access,
   constant,
+  type ExecutableStep,
   execute,
+  type FieldArgs,
   grafastSync,
   makeGrafastSchema,
 } from "../dist/index.js";
@@ -30,19 +32,19 @@ const schema = makeGrafastSchema({
       },
     },
     Obj: {
-      o($o) {
+      o($o: ExecutableStep) {
         return $o;
       },
-      a($o) {
+      a($o: ExecutableStep) {
         return access($o, "a");
       },
-      b($o) {
+      b($o: ExecutableStep) {
         return access($o, "b");
       },
-      echoNumber(_, { $nr }) {
+      echoNumber(_, { $nr }: FieldArgs) {
         return $nr;
       },
-      echoString(_, { $str }) {
+      echoString(_, { $str }: FieldArgs) {
         return $str;
       },
     },
@@ -94,6 +96,6 @@ it("ok", () => {
     },
     {},
     true,
-  );
+  ) as any;
   expect(JSON.stringify(JSON.parse(result2.data), null, 2)).to.equal(expected);
 });

graphile-build/graphile-build-pg/src/plugins/PgEnumTablesPlugin.ts

@@ -219,6 +219,7 @@ Original error: ${e.message}
         }
       },
       async processIntrospection(info, event) {
+        const { EXPORTABLE } = info;
         const { introspection, serviceName } = event;
         for (const pgClass of introspection.classes) {
           const pgNamespace = pgClass.getNamespace();
@@ -331,16 +332,21 @@ Original error: ${e.message}
               };
 
               // Build the codec
-              const codec = enumCodec({
-                name: info.inflection.enumTableCodec({
-                  serviceName,
-                  pgClass,
-                  pgConstraint,
-                }),
-                identifier: originalCodec.sqlType,
-                values,
-                extensions,
+              const name = info.inflection.enumTableCodec({
+                serviceName,
+                pgClass,
+                pgConstraint,
               });
+              const codec = EXPORTABLE(
+                (enumCodec, extensions, name, originalCodec, values) =>
+                  enumCodec({
+                    name,
+                    identifier: originalCodec.sqlType,
+                    values,
+                    extensions,
+                  }),
+                [enumCodec, extensions, name, originalCodec, values],
+              );
 
               // Associate this constraint with our new codec
               info.state.codecByPgConstraint.set(pgConstraint, codec);

graphile-build/graphile-build-pg/src/plugins/PgRelationsPlugin.ts

@@ -1046,7 +1046,6 @@ function addRelations(
             ]);
 
             const functionLines: TE[] = [];
-            const prefixLines: TE[] = [];
             if (isMutationPayload) {
               functionLines.push(
                 te`return function PgRelationsPlugin_mutation_payload_relation($in) {`,
@@ -1136,10 +1135,7 @@ function addRelations(
             }
 
             functionLines.push(te.cache`}`);
-            return te.run`${te.join(prefixLines, "\n")}${te.join(
-              functionLines,
-              "\n",
-            )}`;
+            return te.runExportable`${te.join(functionLines, "\n")}`;
           };
           const singleRecordPlan = makePlanResolver("singleRecord");
           const listPlan = makePlanResolver("list");

graphile-build/graphile-build-pg/src/plugins/PgRowByUniquePlugin.ts

@@ -140,6 +140,7 @@ export const PgRowByUniquePlugin: GraphileConfig.Plugin = {
                        * more performant, but it also makes the code nicer to
                        * read in the exported code.
                        */
+                      // TODO: Use `te.runExportable` instead and give the resource a name!
                       // eslint-disable-next-line graphile-export/exhaustive-deps
                       EXPORTABLE(
                         te.run`\

graphile-build/graphile-build/src/index.ts

@@ -74,6 +74,7 @@ import type { PluginHook } from "graphile-config";
 
 import type { GatherPluginContext } from "./interfaces.js";
 import type { NewWithHooksFunction } from "./newWithHooks/index.js";
+import { EXPORTABLE } from "./utils.js";
 
 // export globals for TypeDoc
 export { GraphileBuild, GraphileConfig };
@@ -209,6 +210,7 @@ const gatherBase = (
         inflection,
         resolvedPreset,
         grafast,
+        EXPORTABLE,
       };
       pluginContext.set(plugin, context);
       if (spec.namespace != null) {

graphile-build/graphile-build/src/interfaces.ts

@@ -1,5 +1,7 @@
 import type { AsyncHooks } from "graphile-config";
 
+import type { EXPORTABLE } from "./utils.js";
+
 /**
  * The details in the 'info' object passed as the first argument to all gather
  * hooks and helpers.
@@ -55,4 +57,6 @@ export interface GatherPluginContext<
    */
   // eslint-disable-next-line @typescript-eslint/consistent-type-imports
   grafast: typeof import("grafast");
+
+  EXPORTABLE: typeof EXPORTABLE;
 }

graphile-build/graphile-build/src/newWithHooks/index.ts

@@ -24,11 +24,13 @@ import {
   GraphQLSchema,
   GraphQLUnionType,
   isNamedType,
+  valueFromASTUntyped,
 } from "grafast/graphql";
 import { inspect } from "util";
 
 import type { ScopeForType, SpecForType } from "../global.js";
 import type SchemaBuilder from "../SchemaBuilder.js";
+import { EXPORTABLE } from "../utils.js";
 
 const isString = (str: unknown): str is string => typeof str === "string";
 
@@ -57,6 +59,14 @@ export type NewWithHooksFunction = <
   scope: ScopeForType<TType>,
 ) => TType;
 
+const identity = EXPORTABLE(
+  () =>
+    function identity<T>(value: T): T {
+      return value;
+    },
+  [],
+);
+
 /**
  * Returns a 'newWithHooks' function suitable for creating GraphQL types with
  * the graphile-build plugin system applied.
@@ -691,6 +701,21 @@ export function makeNewWithHooks({ builder }: MakeNewWithHooksOptions): {
             `|${rawSpec.name}`,
           );
 
+          // parseLiteral in GraphQL defaults to a dynamic function; that's not
+          // exportable... So we must handle this ourselves.
+          if (!finalSpec.parseValue) {
+            finalSpec.parseValue = identity;
+          }
+          if (!finalSpec.parseLiteral) {
+            const parseValue = finalSpec.parseValue!;
+            finalSpec.parseLiteral = EXPORTABLE(
+              (parseValue, valueFromASTUntyped) => (node, variables) => {
+                return parseValue(valueFromASTUntyped(node, variables));
+              },
+              [parseValue, valueFromASTUntyped],
+            );
+          }
+
           const Self = new GraphQLScalarType(finalSpec);
           return Self;
         }

postgraphile/postgraphile/__tests__/schema/v4/core.ts

@@ -1,14 +1,18 @@
+import { writeFile } from "fs/promises";
 import type { PromiseOrDirect } from "grafast";
 import type { GraphQLSchema } from "grafast/graphql";
 import { lexicographicSortSchema, printSchema } from "grafast/graphql";
 import { makeSchema } from "graphile-build";
+import { exportSchemaAsString } from "graphile-export";
 import type { PoolClient } from "pg";
 
 import AmberPreset from "../../../src/presets/amber.js";
 import type { V4Options } from "../../../src/presets/v4.js";
 import { makeV4Preset } from "../../../src/presets/v4.js";
 import { snapshot, withPoolClientTransaction } from "../../helpers.js";
 
+jest.setTimeout(30000);
+
 let countByPath = Object.create(null);
 
 export const test =
@@ -77,4 +81,18 @@ export const test =
       if (finalCheck) {
         await finalCheck(schema);
       }
+      // Now check the schema exports
+      const { code: exportString } = await exportSchemaAsString(schema, {
+        mode: "typeDefs",
+        prettier: true,
+        modules: {
+          jsonwebtoken: await import("jsonwebtoken"),
+        },
+      });
+      const executableSchemaPath = `${testPath.replace(/\.test\.[jt]s$/, "")}${
+        sort || i > 1 ? `.${i}` : ""
+      }.export.mjs`;
+      // Cannot rely on snapshot until this is more stable
+      await writeFile(executableSchemaPath, exportString.trim() + "\n");
+      //await snapshot(exportString.trim() + "\n", executableSchemaPath);
     });