graphile-export 0.0.2-beta.2 → 0.0.2-beta.21

package/dist/exportSchema.js

@@ -1,15 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.exportSchema = exports.exportSchemaAsString = exports.objectNullPrototype = exports.isNotNullish = exports.canRepresentAsIdentifier = void 0;
+exports.exportSchema = exports.exportValueAsString = exports.exportSchemaAsString = exports.objectNullPrototype = exports.isNotNullish = exports.canRepresentAsIdentifier = void 0;
 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 promises_1 = require("node:fs/promises");
-const node_util_1 = require("node:util");
 const index_js_1 = require("./optimize/index.js");
+const reservedWords_js_1 = require("./reservedWords.js");
 const wellKnown_js_1 = require("./wellKnown.js");
 // Cannot import sql because it's optional
 //     import { sql } from "pg-sql2";
@@ -48,6 +50,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 +69,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,7 +84,10 @@ 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;
@@ -120,54 +136,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)) {
@@ -566,22 +588,20 @@ 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})`);
+            throw new Error(`Attempting to export an instance of a class (at ${locationHint}); you should wrap this definition in EXPORTABLE! (Class: ${thing.constructor})`);
         }
         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) {
@@ -603,7 +623,7 @@ function _convertToAST(file, thing, locationHint, nameHint, depth, reference) {
         }
         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)));
@@ -650,6 +670,21 @@ const getExistingIdentifier = (file, thing) => {
         return file.declareType(thing);
     }
 };
+function importWellKnownOrFactory(file, value, locationHint, nameHint) {
+    if (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 +694,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.`);
     }
@@ -709,24 +743,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 +801,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 +882,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 +900,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)
@@ -848,14 +935,9 @@ function exportSchemaGraphQLJS({ config, customTypes, customDirectives, file, })
             ? t.arrayExpression(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
+        enableDeferStream: config.enableDeferStream != null
             ? t.booleanLiteral(config.enableDeferStream)
             : null,
-            */
         assumeValid: null, // TODO: t.booleanLiteral(true),
     }));
 }
@@ -931,6 +1013,9 @@ function exportSchemaTypeDefs({ schema, customTypes, file, }) {
         }
         else if (type instanceof graphql_1.GraphQLInputObjectType) {
             const typeProperties = [];
+            if (type.extensions?.grafast?.inputPlan) {
+                typeProperties.push(t.objectProperty(identifierOrLiteral("__inputPlan"), convertToIdentifierViaAST(file, type.extensions?.grafast.inputPlan, `${type.name}.inputPlan`, `${type.name}.extensions.grafast.inputPlan`)));
+            }
             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`)));
             }
@@ -950,11 +1035,20 @@ 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) {
+            if (planAST ||
+                type.serialize !== graphql_1.GraphQLScalarType.prototype.serialize ||
+                type.parseValue !== graphql_1.GraphQLScalarType.prototype.parseValue ||
+                type.parseLiteral !== graphql_1.GraphQLScalarType.prototype.parseLiteral) {
                 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`),
+                    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,
                 }))));
             }
@@ -1016,6 +1110,11 @@ async function exportSchemaAsString(schema, options) {
         "defer",
         "stream",
     ].includes(d.name));
+    if (process.env.ENABLE_DEFER_STREAM === "1" ||
+        config.directives.some((d) => d.name === "defer" || d.name === "skip")) {
+        // Ref: https://github.com/graphql/graphql-js/pull/3450
+        config.enableDeferStream = true;
+    }
     const file = new CodegenFile(options);
     const schemaExportDetails = {
         schema,
@@ -1031,28 +1130,102 @@ async function exportSchemaAsString(schema, options) {
     else {
         exportSchemaGraphQLJS(schemaExportDetails);
     }
+    return exportFile(file);
+}
+exports.exportSchemaAsString = exportSchemaAsString;
+function exportFile(file) {
     const ast = file.toAST();
     const optimizedAst = (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);
+}
+exports.exportValueAsString = exportValueAsString;
+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({
+        useEslintrc: false,
+        reportUnusedDisableDirectives: "off",
+        allowInlineConfig: false,
+        overrideConfig: {
+            reportUnusedDisableDirectives: false,
+            parserOptions: {
+                ecmaVersion: 2020,
+                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());
-        const formatted = prettier.format(toFormat, {
+        const formatted = await prettier.format(toFormat, {
             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);
+}
 exports.exportSchema = exportSchema;
 //# sourceMappingURL=exportSchema.js.map