graphile-export 0.0.2-beta.3 → 0.0.2-beta.31

package/dist/exportSchema.js

@@ -1,15 +1,23 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.exportSchema = exports.exportSchemaAsString = exports.objectNullPrototype = exports.isNotNullish = exports.canRepresentAsIdentifier = void 0;
+exports.canRepresentAsIdentifier = void 0;
+exports.objectNullPrototype = objectNullPrototype;
+exports.exportSchemaAsString = exportSchemaAsString;
+exports.exportValueAsString = exportValueAsString;
+exports.exportSchema = exportSchema;
 const tslib_1 = require("tslib");
 const promises_1 = require("node:fs/promises");
 const node_util_1 = require("node:util");
 const generator_1 = tslib_1.__importDefault(require("@babel/generator"));
 const parser_1 = require("@babel/parser");
 const template_1 = tslib_1.__importDefault(require("@babel/template"));
+const traverse_1 = tslib_1.__importDefault(require("@babel/traverse"));
 const t = tslib_1.__importStar(require("@babel/types"));
 const graphql_1 = require("grafast/graphql");
+const helpers_js_1 = require("./helpers.js");
 const index_js_1 = require("./optimize/index.js");
+const reservedWords_js_1 = require("./reservedWords.js");
+const utils_js_1 = require("./utils.js");
 const wellKnown_js_1 = require("./wellKnown.js");
 // Cannot import sql because it's optional
 //     import { sql } from "pg-sql2";
@@ -27,7 +35,7 @@ function isSQL(thing) {
     else {
         // An approximation
         if (typeof sql === "object" && sql !== null) {
-            return Object.getOwnPropertySymbols(thing).some((s) => s.description === "pg-sql2-type");
+            return Object.getOwnPropertySymbols(thing).some((s) => s.description?.startsWith("pg-sql2-type"));
         }
         else {
             return false;
@@ -48,6 +56,14 @@ function identifierOrLiteral(key) {
         return t.stringLiteral(key);
     }
 }
+function literal(key) {
+    if (typeof key === "number") {
+        return t.numericLiteral(key);
+    }
+    else {
+        return t.stringLiteral(key);
+    }
+}
 function locationHintToIdentifierName(locationHint) {
     let result = locationHint;
     result = result.replace(/[[.]/g, "__").replace(/\]/g, "");
@@ -59,7 +75,10 @@ function locationHintToIdentifierName(locationHint) {
     return result;
 }
 function getNameForThing(thing, locationHint, baseNameHint) {
-    if (typeof thing === "function") {
+    if (thing.$exporter$name) {
+        return thing.$exporter$name;
+    }
+    else if (typeof thing === "function") {
         if (baseNameHint) {
             return baseNameHint;
         }
@@ -71,14 +90,17 @@ function getNameForThing(thing, locationHint, baseNameHint) {
     }
     else {
         const thingConstructor = thing.constructor;
-        const thingConstructorNameRaw = thingConstructor?.name ?? thingConstructor?.displayName ?? null;
+        const thingConstructorNameRaw = thingConstructor?.$exporter$name ??
+            thingConstructor?.name ??
+            thingConstructor?.displayName ??
+            null;
         const thingConstructorName = ["Array", "Object", "Set", "Map"].includes(thingConstructorNameRaw)
             ? null
             : thingConstructorNameRaw;
         const thingName = thing.name ?? thing.displayName ?? null;
         const name = thingConstructorName && thingName
             ? `${thingName}${thingConstructorName}`
-            : thingName ?? thingConstructorName ?? null;
+            : (thingName ?? thingConstructorName ?? null);
         return baseNameHint || name
             ? (baseNameHint ?? "") + (baseNameHint && name ? "-" : "") + (name ?? "")
             : "value";
@@ -102,15 +124,6 @@ const reallyGenerate = generator_1.default;
 const templateOptions = {
     plugins: ["typescript"],
 };
-function isNotNullish(input) {
-    return input != null;
-}
-exports.isNotNullish = isNotNullish;
-function isImportable(thing) {
-    return ((typeof thing === "object" || typeof thing === "function") &&
-        thing !== null &&
-        "$$export" in thing);
-}
 function isExportedFromFactory(thing) {
     return ((typeof thing === "object" || typeof thing === "function") &&
         thing !== null &&
@@ -120,54 +133,60 @@ const BUILTINS = ["Int", "Float", "Boolean", "ID", "String"];
 function isBuiltinType(type) {
     return type.name.startsWith("__") || BUILTINS.includes(type.name);
 }
+const RESERVED_VARIABLES = {
+    // Reserved variables
+    AbortController: true,
+    Array: true,
+    Buffer: true,
+    DOMException: true,
+    Error: true,
+    Event: true,
+    EventTarget: true,
+    JSON: true,
+    Math: true,
+    MessageChannel: true,
+    MessageEvent: true,
+    MessagePort: true,
+    Object: true,
+    TextDecoder: true,
+    TextEncoder: true,
+    URL: true,
+    URLSearchParams: true,
+    WebAssembly: true,
+    __dirname: true,
+    __filename: true,
+    atob: true,
+    btoa: true,
+    clearImmediate: true,
+    clearInterval: true,
+    clearTimeout: true,
+    console: true,
+    exports: true,
+    global: true,
+    module: true,
+    performance: true,
+    process: true,
+    queueMicrotask: true,
+    require: true,
+    setImmediate: true,
+    setInterval: true,
+    setTimeout: true,
+    structuredClone: true,
+};
+for (const reservedWord of reservedWords_js_1.reservedWords) {
+    RESERVED_VARIABLES[reservedWord] = true;
+}
+Object.freeze(RESERVED_VARIABLES);
 class CodegenFile {
     constructor(options) {
         this.options = options;
-        this._variables = Object.assign(Object.create(null), {
-            // Reserved variables
-            AbortController: true,
-            Array: true,
-            Buffer: true,
-            DOMException: true,
-            Error: true,
-            Event: true,
-            EventTarget: true,
-            JSON: true,
-            Math: true,
-            MessageChannel: true,
-            MessageEvent: true,
-            MessagePort: true,
-            Object: true,
-            TextDecoder: true,
-            TextEncoder: true,
-            URL: true,
-            URLSearchParams: true,
-            WebAssembly: true,
-            __dirname: true,
-            __filename: true,
-            atob: true,
-            btoa: true,
-            clearImmediate: true,
-            clearInterval: true,
-            clearTimeout: true,
-            console: true,
-            exports: true,
-            global: true,
-            module: true,
-            performance: true,
-            process: true,
-            queueMicrotask: true,
-            require: true,
-            setImmediate: true,
-            setInterval: true,
-            setTimeout: true,
-            structuredClone: true,
-        });
+        this._variables = Object.assign(Object.create(null), RESERVED_VARIABLES);
         this._imports = Object.create(null);
         this._types = Object.create(null);
         this._directives = Object.create(null);
         this._statements = [];
         this._values = new Map();
+        this._funcToAstCache = new Map();
     }
     addStatements(statements) {
         if (Array.isArray(statements)) {
@@ -431,6 +450,9 @@ class CodegenFile {
                 name: t.stringLiteral(config.name),
                 description: desc(config.description),
                 extensions: extensions(this, config.extensions, `${config.name}.extensions`, `${config.name}.extensions`),
+                isOneOf: config.isOneOf
+                    ? t.booleanLiteral(true)
+                    : t.identifier("undefined"),
                 fields: t.arrowFunctionExpression([], this.makeInputObjectFields(config.fields, config.name)),
             });
         }
@@ -534,6 +556,9 @@ function canBeRegularObjectKey(key) {
     return key !== "__proto__";
 }
 function _convertToAST(file, thing, locationHint, nameHint, depth, reference) {
+    if ((0, helpers_js_1.isForbidden)(thing)) {
+        throw new Error(`The value at ${locationHint} is forbidden from being exported; please be more specific in your EXPORTABLE factories!`);
+    }
     const handleSubvalue = (value, tKey, key) => {
         const existingIdentifier = getExistingIdentifier(file, value);
         if (existingIdentifier) {
@@ -566,22 +591,25 @@ function _convertToAST(file, thing, locationHint, nameHint, depth, reference) {
         return func(file, thing, locationHint, nameHint);
     }
     else if ((0, graphql_1.isSchema)(thing)) {
-        throw new Error("Attempted to export GraphQLSchema directly from `_convertToAST`; this is currently unsupported.");
+        throw new Error(`Attempted to export GraphQLSchema directly from \`_convertToAST\` (at ${locationHint}); this is currently unsupported.`);
     }
     else if (typeof thing === "object" && thing != null) {
         const prototype = Object.getPrototypeOf(thing);
         if (prototype !== null && prototype !== Object.prototype) {
-            throw new Error(`Attempting to export an instance of a class; you should wrap this definition in EXPORTABLE! (Class: ${thing.constructor})`);
+            if (thing.constructor) {
+                throw new Error(`Attempting to export an instance of a class (at ${locationHint}); you should wrap this definition in EXPORTABLE! (Class: ${thing.constructor})`);
+            }
+            else {
+                throw new Error(`Attempting to export non-POJO object (at ${locationHint}); you should wrap this definition in EXPORTABLE! (Prototype: ${(0, node_util_1.inspect)(prototype)})`);
+            }
         }
         const propertyPairs = [];
-        let hasUnsafeKeys = false;
-        Object.entries(thing).forEach(([key, value]) => {
-            const tKey = identifierOrLiteral(key);
+        const entries = Object.entries(thing);
+        const hasUnsafeKeys = entries.some(([key]) => !canBeRegularObjectKey(key));
+        entries.forEach(([key, value]) => {
+            const tKey = hasUnsafeKeys ? literal(key) : identifierOrLiteral(key);
             const subvalue = handleSubvalue(value, tKey, key);
             propertyPairs.push([tKey, subvalue]);
-            if (!canBeRegularObjectKey(key)) {
-                hasUnsafeKeys = true;
-            }
         });
         if (prototype === null) {
             if (hasUnsafeKeys) {
@@ -590,20 +618,14 @@ function _convertToAST(file, thing, locationHint, nameHint, depth, reference) {
                     t.arrayExpression(propertyPairs.map(([key, val]) => t.arrayExpression([key, val]))),
                 ]);
             }
-            else if (propertyPairs.length === 0) {
-                return t.callExpression(t.memberExpression(t.identifier("Object"), t.identifier("create")), [t.nullLiteral()]);
-            }
             else {
-                const obj = t.objectExpression(propertyPairs.map(([key, val]) => t.objectProperty(key, val)));
-                return t.callExpression(t.memberExpression(t.identifier("Object"), t.identifier("assign")), [
-                    t.callExpression(t.memberExpression(t.identifier("Object"), t.identifier("create")), [t.nullLiteral()]),
-                    obj,
-                ]);
+                const obj = objectNullPrototype(propertyPairs.map(([key, val]) => t.objectProperty(key, val)));
+                return obj;
             }
         }
         else {
             if (hasUnsafeKeys) {
-                throw new Error(`Unexportable key found on non-null-prototype object`);
+                throw new Error(`Unexportable key found on non-null-prototype object (at ${locationHint})`);
             }
             else {
                 const obj = t.objectExpression(propertyPairs.map(([key, val]) => t.objectProperty(key, val)));
@@ -639,7 +661,7 @@ const getExistingIdentifier = (file, thing) => {
         const { moduleName, exportName } = (0, wellKnown_js_1.wellKnown)(file.options, thing);
         return file.import(moduleName, exportName);
     }
-    else if (isImportable(thing)) {
+    else if ((0, utils_js_1.isImportable)(thing)) {
         const { moduleName, exportName } = thing.$$export;
         return file.import(moduleName, exportName);
     }
@@ -650,6 +672,21 @@ const getExistingIdentifier = (file, thing) => {
         return file.declareType(thing);
     }
 };
+function importWellKnownOrFactory(file, value, locationHint, nameHint) {
+    if ((0, utils_js_1.isImportable)(value)) {
+        return file.import(value.$$export.moduleName, value.$$export.exportName);
+    }
+    else if ((0, wellKnown_js_1.wellKnown)(file.options, value)) {
+        const { moduleName, exportName } = (0, wellKnown_js_1.wellKnown)(file.options, value);
+        return file.import(moduleName, exportName);
+    }
+    else if (isExportedFromFactory(value)) {
+        return factoryAst(file, value, locationHint, nameHint);
+    }
+    else {
+        return undefined;
+    }
+}
 function convertToIdentifierViaAST(file, thing, baseNameHint, locationHint, depth = 0) {
     const existingIdentifier = getExistingIdentifier(file, thing);
     if (existingIdentifier) {
@@ -659,9 +696,8 @@ function convertToIdentifierViaAST(file, thing, baseNameHint, locationHint, dept
     const nameHint = getNameForThing(thing, locationHint, baseNameHint);
     const variableIdentifier = file.makeVariable(nameHint || "value");
     file._values.set(thing, variableIdentifier);
-    const ast = isExportedFromFactory(thing)
-        ? factoryAst(file, thing, locationHint, nameHint)
-        : _convertToAST(file, thing, locationHint, nameHint, depth, variableIdentifier);
+    const ast = importWellKnownOrFactory(file, thing, locationHint, nameHint) ??
+        _convertToAST(file, thing, locationHint, nameHint, depth, variableIdentifier);
     if (ast.type === "Identifier") {
         console.warn(`graphile-export error: AST returned an identifier '${ast.name}'; this could cause an infinite loop.`);
     }
@@ -679,20 +715,20 @@ function objectToObjectProperties(o) {
         .map(([key, value]) => t.objectProperty(identifierOrLiteral(key), value));
 }
 function extensions(file, extensions, locationHint, nameHint) {
-    if (extensions == null || Object.keys(extensions).length === 0) {
-        return null;
-    }
-    return convertToIdentifierViaAST(file, extensions, nameHint, locationHint);
+    return isNotEmpty(extensions)
+        ? convertToIdentifierViaAST(file, extensions, nameHint, locationHint)
+        : null;
 }
-/** Maps to `Object.assign(Object.create(null), {...})` */
+/**
+ * Maps to `{__proto__: null, ...}` which is similar to
+ * `Object.assign(Object.create(null), {...})`
+ */
 function objectNullPrototype(properties) {
-    const objectCreateNull = t.callExpression(t.memberExpression(t.identifier("Object"), t.identifier("create")), [t.nullLiteral()]);
-    if (properties.length === 0) {
-        return objectCreateNull;
-    }
-    return t.callExpression(t.memberExpression(t.identifier("Object"), t.identifier("assign")), [objectCreateNull, t.objectExpression(properties)]);
+    return t.objectExpression([
+        t.objectProperty(t.identifier("__proto__"), t.nullLiteral()),
+        ...properties,
+    ]);
 }
-exports.objectNullPrototype = objectNullPrototype;
 /*
 function iife(statements: t.Statement[]): t.Expression {
   return t.callExpression(
@@ -709,24 +745,13 @@ function func(file, fn, locationHint, nameHint) {
     // scope; e.g.:
     //
     // `(() => { const foo = 1, bar = 2; return /*>*/() => {return foo+bar}/*<*/})();`
-    if (isExportedFromFactory(fn)) {
-        return factoryAst(file, fn, locationHint, nameHint);
-    }
-    else if ((0, wellKnown_js_1.wellKnown)(file.options, fn)) {
-        const { moduleName, exportName } = (0, wellKnown_js_1.wellKnown)(file.options, fn);
-        return file.import(moduleName, exportName);
-    }
-    else if (isImportable(fn)) {
-        return file.import(fn.$$export.moduleName, fn.$$export.exportName);
-    }
-    else {
-        return funcToAst(fn, locationHint, nameHint);
-    }
+    return (importWellKnownOrFactory(file, fn, locationHint, nameHint) ??
+        funcToAst(file, fn, locationHint, nameHint).ast);
 }
 const shouldOptimizeFactoryCalls = true;
 function factoryAst(file, fn, locationHint, nameHint) {
     const factory = fn.$exporter$factory;
-    const funcAST = funcToAst(factory, locationHint, nameHint);
+    const { functionWithoutOwnAttributesAST: funcAST } = funcToAst(file, factory, locationHint, nameHint);
     const depArgs = fn.$exporter$args.map((arg, i) => {
         if (typeof arg === "string") {
             return t.stringLiteral(arg);
@@ -778,13 +803,79 @@ function factoryAst(file, fn, locationHint, nameHint) {
         return t.callExpression(funcAST, depArgs);
     }
 }
-function funcToAst(fn, locationHint, _nameHint) {
+function funcToAst(file, fn, locationHint, _nameHint) {
+    if (file._funcToAstCache.has(fn)) {
+        return file._funcToAstCache.get(fn);
+    }
+    const path = _funcToAst(fn, locationHint, _nameHint);
+    const externalReferences = new Set();
+    const localBindings = path.scope.bindings;
+    path.traverse({
+        Identifier(path) {
+            if (t.isReferenced(path.node, path.parent) && // Is a variable reference
+                !path.scope.hasBinding(path.node.name) && // Not defined in local scope
+                !localBindings[path.node.name] // Not a parameter of the function
+            ) {
+                externalReferences.add(path.node.name);
+            }
+        },
+    });
+    // Remove global things they're allowed to reference
+    externalReferences.delete("Buffer");
+    externalReferences.delete("console");
+    externalReferences.delete("process");
+    externalReferences.delete("setTimeout");
+    externalReferences.delete("setInterval");
+    if (externalReferences.size > 0) {
+        throw new Error(`The function being exported as ${locationHint} references external variables: \`${[
+            ...externalReferences,
+        ].join("`, `")}\`. Please ensure this function is wrapped in \`EXPORTABLE(() => ...)\`. Fn:\n${fn}`);
+    }
+    const fnExpression = path.node;
+    const ownProps = Object.entries(fn);
+    const result = (() => {
+        if (ownProps.length > 0) {
+            // Need to assign things to it
+            const properties = ownProps.map(([key, value]) => {
+                return t.objectProperty(identifierOrLiteral(key), convertToIdentifierViaAST(file, value, `${locationHint}.${key}`, `${locationHint}['${key}']`));
+            });
+            return {
+                functionWithoutOwnAttributesAST: fnExpression,
+                ast: t.callExpression(t.memberExpression(t.identifier("Object"), t.identifier("assign")), [fnExpression, t.objectExpression(properties)]),
+            };
+        }
+        else {
+            return {
+                functionWithoutOwnAttributesAST: fnExpression,
+                ast: fnExpression,
+            };
+        }
+    })();
+    file._funcToAstCache.set(fn, result);
+    return result;
+}
+function parseExpressionViaDoc(funcString) {
+    const doc = (0, parser_1.parse)(`const f = ${funcString}`, {
+        sourceType: "module",
+        plugins: ["typescript"],
+    });
+    let result = null;
+    (0, traverse_1.default)(doc, {
+        VariableDeclaration(path) {
+            result = path.get("declarations.0.init");
+            path.stop();
+        },
+    });
+    if (!result) {
+        throw new Error(`graphile-export internal error - failed to find the variable declaration (?!!)`);
+    }
+    return result;
+}
+function _funcToAst(fn, locationHint, _nameHint) {
     const funcString = fn.toString().trim();
     try {
-        const result = (0, parser_1.parseExpression)(funcString, {
-            sourceType: "module",
-            plugins: ["typescript"],
-        });
+        const path = parseExpressionViaDoc(funcString);
+        const result = path.node;
         if (result.type !== "FunctionExpression" &&
             result.type !== "ArrowFunctionExpression") {
             if (result.type === "ClassExpression") {
@@ -793,7 +884,7 @@ Object.defineProperty(${result.id?.name ?? "MyClass"}, '$$export', { value: { mo
             }
             throw new Error(`Expected FunctionExpression or ArrowFunctionExpression but saw ${result.type}`);
         }
-        return result;
+        return path;
     }
     catch (e) {
         if (e.retry === false) {
@@ -811,15 +902,13 @@ Object.defineProperty(${result.id?.name ?? "MyClass"}, '$$export', { value: { mo
             const modifiedDefinition = funcString.startsWith("async ")
                 ? "async function " + funcString.slice(6)
                 : "function " + funcString;
-            const result = (0, parser_1.parseExpression)(modifiedDefinition, {
-                sourceType: "module",
-                plugins: ["typescript"],
-            });
+            const path = parseExpressionViaDoc(modifiedDefinition);
+            const result = path.node;
             if (result.type !== "FunctionExpression" &&
                 result.type !== "ArrowFunctionExpression") {
                 throw new Error(`Expected FunctionExpression or ArrowFunctionExpression but saw ${result.type}`);
             }
-            return result;
+            return path;
         }
         catch {
             throw new Error(`Function export error at ${locationHint} - failed to process function definition '${trimDef(fn.toString())}'\n    ${String(e.stack ?? e)
@@ -836,6 +925,7 @@ function exportSchemaGraphQLJS({ config, customTypes, customDirectives, file, })
     const types = customTypes.map((type) => {
         return file.declareType(type);
     });
+    const specifiedDirectivesAST = file.import("graphql", "specifiedDirectives");
     file.addStatements(declareGraphQLEntity(file, schemaExportName, "GraphQLSchema", {
         description: desc(config.description),
         query: config.query ? file.declareType(config.query) : t.nullLiteral(),
@@ -845,17 +935,19 @@ function exportSchemaGraphQLJS({ config, customTypes, customDirectives, file, })
             : null,
         types: t.arrayExpression(types),
         directives: customDirectives.length > 0
-            ? t.arrayExpression(customDirectives.map((directive) => file.declareDirective(directive)))
+            ? t.arrayExpression([
+                t.spreadElement(specifiedDirectivesAST),
+                ...customDirectives.map((directive) => file.declareDirective(directive)),
+            ])
             : null,
         extensions: extensions(file, config.extensions, "schema.extensions", "schema.extensions"),
-        enableDeferStream: t.booleanLiteral(process.env.ENABLE_DEFER_STREAM === "1"),
-        /*
-        // TODO: use the below once https://github.com/graphql/graphql-js/pull/3450 is fixed:
-        enableDeferStream:
-          config.enableDeferStream != null
-            ? t.booleanLiteral(config.enableDeferStream)
+        // @ts-ignore
+        enableDeferStream: 
+        // @ts-ignore
+        config.enableDeferStream != null
+            ? // @ts-ignore
+                t.booleanLiteral(config.enableDeferStream)
             : null,
-            */
         assumeValid: null, // TODO: t.booleanLiteral(true),
     }));
 }
@@ -866,19 +958,30 @@ function exportSchemaGraphQLJS({ config, customTypes, customDirectives, file, })
  */
 function exportSchemaTypeDefs({ schema, customTypes, file, }) {
     const typeDefsExportName = file.makeVariable("typeDefs");
-    const plansExportName = file.makeVariable("plans");
+    const objectPlansProperties = Object.create(null);
+    const interfacePlansProperties = Object.create(null);
+    const unionPlansProperties = Object.create(null);
+    const inputObjectPlansProperties = Object.create(null);
+    const scalarPlansProperties = Object.create(null);
+    const enumPlansProperties = Object.create(null);
     const schemaExportName = file.makeVariable("schema");
     const typeDefsString = (0, graphql_1.printSchema)(schema);
     const graphqlAST = t.templateLiteral([t.templateElement({ raw: typeDefsString.replace(/[\\`]/g, "\\$&") })], []);
     graphqlAST.leadingComments = [
         { type: "CommentBlock", value: " GraphQL " },
     ];
-    const plansProperties = [];
     customTypes.forEach((type) => {
         if (type instanceof graphql_1.GraphQLObjectType) {
-            const typeProperties = [];
+            const typeProperties = Object.create(null);
+            const plansProperties = Object.create(null);
             if (type.extensions.grafast?.assertStep) {
-                typeProperties.push(t.objectProperty(t.identifier("__assertStep"), convertToIdentifierViaAST(file, type.extensions.grafast.assertStep, `${type.name}AssertStep`, `${type.name}.extensions.assertStep`)));
+                typeProperties.assertStep = convertToIdentifierViaAST(file, type.extensions.grafast.assertStep, `${type.name}AssertStep`, `${type.name}.extensions.assertStep`);
+            }
+            if (type.isTypeOf) {
+                typeProperties.isTypeOf = convertToIdentifierViaAST(file, type.isTypeOf, `${type.name}IsTypeOf`, `${type.name}.extensions.isTypeOf`);
+            }
+            if (type.extensions.grafast?.planType) {
+                typeProperties.planType = convertToIdentifierViaAST(file, type.extensions.grafast.planType, `${type.name}PlanType`, `${type.name}.extensions.planType`);
             }
             for (const [fieldName, field] of Object.entries(type.toConfig().fields)) {
                 // Use shorthand if there's only a `plan` and nothing else
@@ -899,9 +1002,38 @@ function exportSchemaTypeDefs({ schema, customTypes, file, }) {
                 const args = field.args
                     ? Object.entries(field.args)
                         .map(([argName, arg]) => {
-                        return t.objectProperty(identifierOrLiteral(argName), convertToIdentifierViaAST(file, arg.extensions?.grafast, `${type.name}.${fieldName}.${argName}`, `${type.name}.fields[${fieldName}].args[${argName}].extensions.grafast`));
+                        if (arg.extensions) {
+                            const { grafast, ...rest } = arg.extensions;
+                            const extensionsAST = extensions(file, rest, `${type.name}.${fieldName}.${argName}`, `${type.name}.fields[${fieldName}].args[${argName}].extensions`);
+                            if (!extensionsAST) {
+                                if (!grafast)
+                                    return null;
+                                const keys = Object.keys(grafast);
+                                if (keys.length === 1 && keys[0] === "applyPlan") {
+                                    // Shorthand
+                                    return t.objectProperty(identifierOrLiteral(argName), convertToIdentifierViaAST(file, grafast.applyPlan, `${type.name}.${fieldName}${argName}ApplyPlan`, `${type.name}.fields[${fieldName}].args[${argName}].applyPlan`));
+                                }
+                            }
+                            return t.objectProperty(identifierOrLiteral(argName), t.objectExpression([
+                                ...objectToObjectProperties({
+                                    extensions: extensionsAST,
+                                }),
+                                ...(grafast
+                                    ? Object.entries(grafast)
+                                        .map(([k, v]) => {
+                                        if (v == null)
+                                            return null;
+                                        return t.objectProperty(t.identifier(k), convertToIdentifierViaAST(file, grafast.applyPlan, `${type.name}.${fieldName}${argName}${k}`, `${type.name}.fields[${fieldName}].args[${argName}].extensions.grafast[${k}]`));
+                                    })
+                                        .filter(utils_js_1.isNotNullish)
+                                    : []),
+                            ]));
+                        }
+                        else {
+                            return null;
+                        }
                     })
-                        .filter(isNotNullish)
+                        .filter(utils_js_1.isNotNullish)
                     : null;
                 const argsAST = args && args.length ? t.objectExpression(args) : null;
                 if (!planAST && !subscribePlanAST && !resolveAST && !subscribeAST) {
@@ -925,24 +1057,69 @@ function exportSchemaTypeDefs({ schema, customTypes, file, }) {
                         subscribe: subscribeAST,
                         args: argsAST,
                     }));
-                typeProperties.push(t.objectProperty(identifierOrLiteral(fieldName), fieldSpec));
+                plansProperties[fieldName] = fieldSpec;
             }
-            plansProperties.push(t.objectProperty(identifierOrLiteral(type.name), t.objectExpression(typeProperties)));
+            setIfNotEmpty(typeProperties, "plans", plansProperties, true);
+            setIfNotEmpty(objectPlansProperties, type.name, typeProperties, false);
         }
         else if (type instanceof graphql_1.GraphQLInputObjectType) {
-            const typeProperties = [];
+            const typeProperties = Object.create(null);
+            const plansProperties = Object.create(null);
+            if (type.extensions?.grafast?.baked) {
+                typeProperties.baked = convertToIdentifierViaAST(file, type.extensions?.grafast.baked, `${type.name}.inputPlan`, `${type.name}.extensions.grafast.baked`);
+            }
             for (const [fieldName, field] of Object.entries(type.toConfig().fields)) {
-                typeProperties.push(t.objectProperty(identifierOrLiteral(fieldName), convertToIdentifierViaAST(file, field.extensions?.grafast, `${type.name}.${fieldName}`, `${type.name}.fields[${fieldName}].extensions.grafast`)));
+                if (!field.extensions)
+                    continue;
+                const { grafast, ...rest } = field.extensions;
+                const extensionsAST = extensions(file, rest, `${type.name}_${fieldName}Extensions`, `${type.name}.fields[${fieldName}].extensions`);
+                if (!extensionsAST) {
+                    if (!grafast)
+                        continue;
+                    const keys = Object.keys(grafast);
+                    if (keys.length === 1 && keys[0] === "apply") {
+                        plansProperties[fieldName] = convertToIdentifierViaAST(file, grafast.apply, `${type.name}.${fieldName}Apply`, `${type.name}.fields[${fieldName}].extensions.grafast.apply`);
+                        continue;
+                    }
+                }
+                plansProperties[fieldName] = t.objectExpression([
+                    ...objectToObjectProperties({
+                        extensions: extensionsAST,
+                    }),
+                    ...(grafast
+                        ? Object.entries(grafast)
+                            .map(([k, v]) => {
+                            if (v == null)
+                                return null;
+                            return t.objectProperty(t.identifier(k), convertToIdentifierViaAST(file, v, `${type.name}.${fieldName}${k}`, `${type.name}.fields[${fieldName}].extensions.grafast[${k}]`));
+                        })
+                            .filter(utils_js_1.isNotNullish)
+                        : []),
+                ]);
             }
-            plansProperties.push(t.objectProperty(identifierOrLiteral(type.name), t.objectExpression(typeProperties)));
+            setIfNotEmpty(typeProperties, "plans", plansProperties, true);
+            setIfNotEmpty(inputObjectPlansProperties, type.name, typeProperties, false);
         }
         else if (type instanceof graphql_1.GraphQLInterfaceType ||
             type instanceof graphql_1.GraphQLUnionType) {
             const config = type.toConfig();
-            if (config.resolveType) {
-                plansProperties.push(t.objectProperty(identifierOrLiteral(type.name), t.objectExpression(objectToObjectProperties({
-                    __resolveType: convertToIdentifierViaAST(file, type.resolveType, `${type.name}ResolveType`, `${type.name}.resolveType`),
-                }))));
+            if (config.resolveType ||
+                config.extensions.grafast?.toSpecifier ||
+                config.extensions.grafast?.planType) {
+                const target = type instanceof graphql_1.GraphQLInterfaceType
+                    ? interfacePlansProperties
+                    : unionPlansProperties;
+                target[type.name] = t.objectExpression(objectToObjectProperties({
+                    resolveType: type.resolveType
+                        ? convertToIdentifierViaAST(file, type.resolveType, `${type.name}ResolveType`, `${type.name}.resolveType`)
+                        : null,
+                    toSpecifier: type.extensions?.grafast?.toSpecifier
+                        ? convertToIdentifierViaAST(file, type.extensions?.grafast?.toSpecifier, `${type.name}ToSpecifier`, `${type.name}.toSpecifier`)
+                        : null,
+                    planType: type.extensions?.grafast?.planType
+                        ? convertToIdentifierViaAST(file, type.extensions?.grafast?.planType, `${type.name}PlanType`, `${type.name}.planType`)
+                        : null,
+                }));
             }
         }
         else if (type instanceof graphql_1.GraphQLScalarType) {
@@ -950,36 +1127,65 @@ function exportSchemaTypeDefs({ schema, customTypes, file, }) {
             const planAST = config.extensions.grafast?.plan
                 ? convertToIdentifierViaAST(file, config.extensions?.grafast?.plan, `${type.name}Plan`, `${type.name}.extensions.grafast.plan`)
                 : null;
-            if (planAST) {
-                plansProperties.push(t.objectProperty(identifierOrLiteral(type.name), t.objectExpression(objectToObjectProperties({
-                    serialize: convertToIdentifierViaAST(file, type.serialize, `${type.name}Serialize`, `${type.name}.serialize`),
-                    parseValue: convertToIdentifierViaAST(file, type.parseValue, `${type.name}ParseValue`, `${type.name}.parseValue`),
-                    parseLiteral: convertToIdentifierViaAST(file, type.parseLiteral, `${type.name}ParseLiteral`, `${type.name}.parseLiteral`),
+            if (planAST ||
+                type.serialize !== graphql_1.GraphQLScalarType.prototype.serialize ||
+                type.parseValue !== graphql_1.GraphQLScalarType.prototype.parseValue ||
+                type.parseLiteral !== graphql_1.GraphQLScalarType.prototype.parseLiteral) {
+                scalarPlansProperties[type.name] = t.objectExpression(objectToObjectProperties({
+                    serialize: type.serialize !== graphql_1.GraphQLScalarType.prototype.serialize
+                        ? convertToIdentifierViaAST(file, type.serialize, `${type.name}Serialize`, `${type.name}.serialize`)
+                        : null,
+                    parseValue: type.parseValue !== graphql_1.GraphQLScalarType.prototype.parseValue
+                        ? convertToIdentifierViaAST(file, type.parseValue, `${type.name}ParseValue`, `${type.name}.parseValue`)
+                        : null,
+                    parseLiteral: type.parseLiteral !== graphql_1.GraphQLScalarType.prototype.parseLiteral
+                        ? convertToIdentifierViaAST(file, type.parseLiteral, `${type.name}ParseLiteral`, `${type.name}.parseLiteral`)
+                        : null,
                     plan: planAST,
-                }))));
+                }));
             }
         }
         else if (type instanceof graphql_1.GraphQLEnumType) {
             const config = type.toConfig();
-            const enumValues = [];
+            const typeProperties = Object.create(null);
+            const enumValueProperties = Object.create(null);
             for (const [enumValueName, enumValueConfig] of Object.entries(config.values)) {
                 const valueAST = enumValueConfig.value !== undefined &&
                     enumValueConfig.value !== enumValueName
                     ? convertToIdentifierViaAST(file, enumValueConfig.value, `${type.name}_${enumValueName}`, `${type.name}.values[${enumValueName}].value`)
                     : null;
-                const applyPlanAST = enumValueConfig.extensions?.grafast?.applyPlan
-                    ? convertToIdentifierViaAST(file, enumValueConfig.extensions.grafast.applyPlan, `${type.name}_${enumValueName}ApplyPlan`, `${type.name}.values[${enumValueName}].extensions.grafast.applyPlan`)
-                    : null;
-                if (valueAST || applyPlanAST) {
-                    enumValues.push(t.objectProperty(identifierOrLiteral(enumValueName), t.objectExpression(objectToObjectProperties({
-                        value: valueAST,
-                        applyPlan: applyPlanAST,
-                    }))));
+                const { grafast, ...rest } = enumValueConfig.extensions ?? {};
+                const extensionsAST = extensions(file, rest, `${type.name}_${enumValueName}Extensions`, `${type.name}.values[${enumValueName}].extensions`);
+                if (!valueAST && !extensionsAST) {
+                    if (!grafast)
+                        continue;
+                    const keys = Object.keys(grafast);
+                    if (keys.length === 1 && keys[0] === "apply") {
+                        enumValueProperties[enumValueName] = convertToIdentifierViaAST(file, grafast.apply, `${type.name}.${enumValueName}Apply`, `${type.name}.values[${enumValueName}].extensions.grafast.apply`);
+                        continue;
+                    }
+                }
+                const grafastProperties = grafast
+                    ? Object.entries(grafast)
+                        .map(([k, v]) => {
+                        if (v == null)
+                            return null;
+                        return t.objectProperty(t.identifier(k), convertToIdentifierViaAST(file, v, `${type.name}.${enumValueName}${k}`, `${type.name}.values[${enumValueName}].extensions.grafast[${k}]`));
+                    })
+                        .filter(utils_js_1.isNotNullish)
+                    : [];
+                if (valueAST || extensionsAST || grafastProperties.length) {
+                    enumValueProperties[enumValueName] = t.objectExpression([
+                        ...objectToObjectProperties({
+                            value: valueAST,
+                            extensions: extensionsAST,
+                        }),
+                        ...grafastProperties,
+                    ]);
                 }
             }
-            if (enumValues.length > 0) {
-                plansProperties.push(t.objectProperty(identifierOrLiteral(type.name), t.objectExpression(enumValues)));
-            }
+            setIfNotEmpty(typeProperties, "values", enumValueProperties, true);
+            setIfNotEmpty(enumPlansProperties, type.name, typeProperties, false);
         }
         else {
             const never = type;
@@ -989,33 +1195,55 @@ function exportSchemaTypeDefs({ schema, customTypes, file, }) {
     const typeDefs = t.exportNamedDeclaration(t.variableDeclaration("const", [
         t.variableDeclarator(typeDefsExportName, graphqlAST),
     ]));
-    const plans = t.exportNamedDeclaration(t.variableDeclaration("const", [
-        t.variableDeclarator(plansExportName, t.objectExpression(plansProperties)),
-    ]));
     file.addStatements(typeDefs);
-    file.addStatements(plans);
+    const typeDefsEtc = {
+        typeDefs: typeDefsExportName,
+    };
+    const stuff = Object.create(null);
+    setIfNotEmpty(stuff, "objects", objectPlansProperties, [
+        schema.getQueryType()?.name,
+        schema.getMutationType()?.name,
+        schema.getSubscriptionType()?.name,
+    ].filter((n) => n != null));
+    setIfNotEmpty(stuff, "interfaces", interfacePlansProperties, true);
+    setIfNotEmpty(stuff, "unions", unionPlansProperties, true);
+    setIfNotEmpty(stuff, "inputObjects", inputObjectPlansProperties, true);
+    setIfNotEmpty(stuff, "scalars", scalarPlansProperties, true);
+    setIfNotEmpty(stuff, "enums", enumPlansProperties, true);
+    const todos = [];
+    for (const [key, props] of Object.entries(stuff)) {
+        const exportName = file.makeVariable(key);
+        // Do this afterwards so all the variables are reserved first.
+        todos.push(() => {
+            const plans = t.exportNamedDeclaration(t.variableDeclaration("const", [
+                t.variableDeclarator(exportName, props),
+            ]));
+            file.addStatements(plans);
+            typeDefsEtc[key] = exportName;
+        });
+    }
+    // Now all variables are declared, we can populate them
+    for (const todo of todos) {
+        todo();
+    }
     const makeGrafastSchemaAST = file.import("grafast", "makeGrafastSchema");
     const schemaAST = t.callExpression(makeGrafastSchemaAST, [
-        t.objectExpression(objectToObjectProperties({
-            typeDefs: typeDefsExportName,
-            plans: plansExportName,
-        })),
+        t.objectExpression(objectToObjectProperties(typeDefsEtc)),
     ]);
     file.addStatements(t.exportNamedDeclaration(t.variableDeclaration("const", [
         t.variableDeclarator(schemaExportName, schemaAST),
     ])));
 }
+const specifiedDirectiveNames = graphql_1.specifiedDirectives.map((d) => d.name);
 async function exportSchemaAsString(schema, options) {
     const config = schema.toConfig();
     const customTypes = config.types.filter((type) => !isBuiltinType(type));
-    const customDirectives = config.directives.filter((d) => ![
-        "skip",
-        "include",
-        "deprecated",
-        "specifiedBy",
-        "defer",
-        "stream",
-    ].includes(d.name));
+    const customDirectives = config.directives.filter((d) => !specifiedDirectiveNames.includes(d.name));
+    if (config.directives.some((d) => d.name === "defer" || d.name === "skip")) {
+        // Ref: https://github.com/graphql/graphql-js/pull/3450
+        // @ts-ignore
+        config.enableDeferStream = true;
+    }
     const file = new CodegenFile(options);
     const schemaExportDetails = {
         schema,
@@ -1031,16 +1259,79 @@ async function exportSchemaAsString(schema, options) {
     else {
         exportSchemaGraphQLJS(schemaExportDetails);
     }
+    return exportFile(file, options);
+}
+function exportFile(file, { disableOptimize }) {
     const ast = file.toAST();
-    const optimizedAst = (0, index_js_1.optimize)(ast);
+    const optimizedAst = disableOptimize ? ast : (0, index_js_1.optimize)(ast);
     const { code } = reallyGenerate(optimizedAst, {});
     return { code };
 }
-exports.exportSchemaAsString = exportSchemaAsString;
-async function exportSchema(schema, toPath, options = {}) {
-    const { code } = await exportSchemaAsString(schema, options);
-    const HEADER = `/* eslint-disable graphile-export/export-instances, graphile-export/export-methods, graphile-export/exhaustive-deps */\n`;
-    const toFormat = HEADER + code;
+async function exportValueAsString(name, value, options) {
+    const file = new CodegenFile(options);
+    const exportName = file.makeVariable(name);
+    const valueAST = convertToIdentifierViaAST(file, value, name, name);
+    file.addStatements(t.exportNamedDeclaration(t.variableDeclaration("const", [
+        t.variableDeclarator(exportName, valueAST),
+    ])));
+    return exportFile(file, options);
+}
+async function loadESLint() {
+    try {
+        return await import("eslint");
+    }
+    catch (e) {
+        return null;
+    }
+}
+async function lint(code, rawFilePath) {
+    const eslintModule = await loadESLint();
+    if (eslintModule == null) {
+        console.warn(`graphile-export could not find 'eslint' so disabling additional checks`);
+        return;
+    }
+    const filePath = typeof rawFilePath === "string" ? rawFilePath : rawFilePath.pathname;
+    const { ESLint } = eslintModule;
+    const eslint = new ESLint({
+        overrideConfigFile: true, // Don't use external config
+        allowInlineConfig: false, // Ignore `/* eslint-disable ... */` comments
+        overrideConfig: {
+            linterOptions: { reportUnusedDisableDirectives: false },
+            languageOptions: {
+                ecmaVersion: 2022,
+                sourceType: "module",
+            },
+            rules: {
+                "no-use-before-define": [
+                    "error",
+                    {
+                        functions: false,
+                        classes: false,
+                        // We often have cyclic dependencies between types, this is handled via callbacks, so we don't care about that.
+                        variables: false,
+                        allowNamedExports: false,
+                    },
+                ],
+            },
+        },
+    });
+    const results = await eslint.lintText(code, {
+        warnIgnored: true,
+        // DO NOT PASS THE `filePath`; it can result in the file being ignored!
+    });
+    if (results.length !== 1) {
+        console.dir({ filePath, results });
+        throw new Error(`Expected ESLint results to have exactly one entry`);
+    }
+    const [result] = results;
+    if (result.warningCount > 0 || result.errorCount > 0) {
+        console.log(`ESLint found problems in the export; this likely indicates some issue with \`EXPORTABLE\` calls`);
+        const formatter = await eslint.loadFormatter("stylish");
+        const output = formatter.format(results);
+        console.log(output);
+    }
+}
+async function format(toFormat, toPath, options) {
     if (options.prettier) {
         const prettier = await import("prettier");
         const config = await prettier.resolveConfig(toPath.toString());
@@ -1048,11 +1339,65 @@ async function exportSchema(schema, toPath, options = {}) {
             parser: "babel",
             ...(config ?? {}),
         });
-        await (0, promises_1.writeFile)(toPath, formatted);
+        return formatted;
     }
     else {
-        await (0, promises_1.writeFile)(toPath, toFormat);
+        return toFormat;
+    }
+}
+const HEADER = `/* eslint-disable graphile-export/export-instances, graphile-export/export-methods, graphile-export/exhaustive-deps */\n`;
+async function exportSchema(schema, toPath, options = {}) {
+    const { code } = await exportSchemaAsString(schema, options);
+    const toFormat = HEADER + code;
+    const formatted = await format(toFormat, toPath, options);
+    await (0, promises_1.writeFile)(toPath, formatted);
+    await lint(formatted, toPath);
+}
+/**
+ * Returns `false` for nullish values and empty objects, true otherwise.
+ */
+function isNotEmpty(value) {
+    if (value == null)
+        return false;
+    if (typeof value !== "object")
+        return true;
+    const proto = Object.getPrototypeOf(value);
+    if (proto !== null && proto !== Object.prototype)
+        return true;
+    if (Object.getOwnPropertyNames(value).length === 0 &&
+        Object.getOwnPropertySymbols(value).length === 0) {
+        // Empty object!
+        return false;
+    }
+    return true;
+}
+function setIfNotEmpty(target, key, value, sort) {
+    if (Object.keys(value).length > 0) {
+        const entries = Object.entries(value);
+        if (typeof sort === "boolean") {
+            entries.sort((a, z) => a[0].localeCompare(z[0], "und"));
+        }
+        else if (sort) {
+            entries.sort((a, z) => {
+                const ka = a[0];
+                const kz = z[0];
+                // First, compare keys against the specific defined order
+                const sa = sort.indexOf(ka);
+                const sz = sort.indexOf(kz);
+                if (sa >= 0) {
+                    if (sz < 0)
+                        return -1;
+                    return sa - sz;
+                }
+                else if (sz >= 0) {
+                    return 1;
+                }
+                // Failing that, compare them alphabetically
+                return ka.localeCompare(kz, "und");
+            });
+        }
+        const finalProps = entries.map(([k, v]) => t.objectProperty(identifierOrLiteral(k), v));
+        target[key] = t.objectExpression(finalProps);
     }
 }
-exports.exportSchema = exportSchema;
 //# sourceMappingURL=exportSchema.js.map