@snowtop/ent 0.2.8 → 0.2.10

package/scripts/custom_graphql.js

@@ -41,6 +41,7 @@ const glob = __importStar(require("glob"));
 const path = __importStar(require("path"));
 const fs = __importStar(require("fs"));
 const typescript_1 = __importDefault(require("typescript"));
+const url_1 = require("url");
 const graphql_1 = require("../graphql/graphql");
 const readline = __importStar(require("readline"));
 const imports_1 = require("../imports");
@@ -52,6 +53,9 @@ const { parseArgs } = require("./parse_args");
 // we're affecting the local paths as opposed to a different instance
 // life is hard
 const MODULE_PATH = const_1.GRAPHQL_PATH;
+function isBunRuntime() {
+    return process.env.ENT_RUNTIME === "bun" || process.versions.bun;
+}
 function parseJSONC(fileName, text) {
     const { config, error } = typescript_1.default.parseConfigFileTextToJson(fileName, text);
     if (error) {
@@ -171,22 +175,28 @@ async function captureDynamic(filePath, gqlCapture) {
         return;
     }
     return new Promise((resolve, reject) => {
-        let cmd = "";
-        const args = [];
         const env = {
             ...process.env,
         };
-        if (process.env.ENABLE_SWC) {
-            cmd = "node";
-            // we seem to get tsconfig-paths by default because child process but not 100% sure...
-            args.push("-r", "@swc-node/register");
-            env.SWCRC = "true";
+        let cmd = "ts-node";
+        const args = [];
+        const runtime = isBunRuntime() ? "bun" : "node";
+        if (runtime === "bun") {
+            cmd = "bun";
+            args.push(filePath);
         }
         else {
-            cmd = "ts-node";
-            args.push("--transpileOnly");
+            if (process.env.ENABLE_SWC) {
+                cmd = "node";
+                // we seem to get tsconfig-paths by default because child process but not 100% sure...
+                args.push("-r", "@swc-node/register");
+                env.SWCRC = "true";
+            }
+            else {
+                args.push("--transpileOnly");
+            }
+            args.push(filePath);
         }
-        args.push(filePath);
         const r = (0, child_process_1.spawn)(cmd, args, {
             env,
         });
@@ -253,13 +263,6 @@ async function captureCustom(filePath, filesCsv, jsonPath, gqlCapture) {
     // TODO delete all of this eventually
     // TODO configurable paths eventually
     // for now only files that are in the include path of the roots are allowed
-    const rootFiles = [
-        // right now, currently expecting all custom ent stuff to be in the ent object
-        // eventually, create a path we check e.g. ent/custom_gql/ ent/graphql?
-        // for now can just go in graphql/resolvers/ (not generated)
-        path.join(filePath, "ent/index.ts"),
-        path.join(filePath, "/graphql/resolvers/index.ts"),
-    ];
     const ignore = [
         "**/generated/**",
         "**/tests/**",
@@ -268,35 +271,44 @@ async function captureCustom(filePath, filesCsv, jsonPath, gqlCapture) {
         // ignore test files.
         "**/*.test.ts",
     ];
+    const customGraphQLEntFiles = glob.sync(path.join(filePath, "/ent/**/*.ts"), {
+        // not in action files since we can't customize payloads (yet?)
+        ignore: [...ignore, "**/actions/**"],
+    });
     const customGQLResolvers = glob.sync(path.join(filePath, "/graphql/resolvers/**/*.ts"), {
-        // no actions for now to speed things up
-        // no index.ts or internal file.
         ignore: ignore,
     });
     const customGQLMutations = glob.sync(path.join(filePath, "/graphql/mutations/**/*.ts"), {
-        // no actions for now to speed things up
-        // no index.ts or internal file.
         ignore: ignore,
     });
-    const files = rootFiles.concat(customGQLResolvers, customGQLMutations);
+    const files = customGraphQLEntFiles
+        .concat(customGQLResolvers, customGQLMutations)
+        .filter(fileImportsGraphQLDecorators);
     await requireFiles(files);
 }
+function fileImportsGraphQLDecorators(file) {
+    const contents = fs.readFileSync(file, {
+        encoding: "utf8",
+    });
+    return /@snowtop\/ent\/graphql(?:\/graphql)?/.test(contents);
+}
 async function requireFiles(files) {
-    await Promise.all(files.map(async (file) => {
-        if (fs.existsSync(file)) {
-            try {
-                await require(file);
+    for (const file of files) {
+        if (!fs.existsSync(file)) {
+            throw new Error(`file ${file} doesn't exist`);
+        }
+        try {
+            if (isBunRuntime()) {
+                await Promise.resolve(`${(0, url_1.pathToFileURL)(file).href}`).then(s => __importStar(require(s)));
             }
-            catch (e) {
-                throw new Error(`${e.message} loading ${file}`);
+            else {
+                await require(file);
             }
         }
-        else {
-            throw new Error(`file ${file} doesn't exist`);
+        catch (e) {
+            throw new Error(`${e.message} loading ${file}`);
         }
-    })).catch((err) => {
-        throw new Error(err);
-    });
+    }
 }
 // filePath is path-to-src
 async function parseImports(filePath) {
@@ -350,9 +362,10 @@ async function main() {
     // for local dev, get the one from the file system. otherwise, get the one
     // from node_modules
     let gqlCapture;
-    if (process.env.LOCAL_SCRIPT_PATH) {
+    if (process.env.LOCAL_SCRIPT_PATH || isBunRuntime()) {
         const r = require("../graphql/graphql");
         gqlCapture = r.GQLCapture;
+        gqlCapture.enable(true);
     }
     else {
         const r = require(gqlPath);

package/scripts/parse_args.d.ts

@@ -0,0 +1,3 @@
+export function parseArgs(argv: any): {
+    _: never[];
+};

package/scripts/parse_args.js

@@ -0,0 +1,74 @@
+"use strict";
+function coerceValue(value) {
+    if (value === "true") {
+        return true;
+    }
+    if (value === "false") {
+        return false;
+    }
+    return value;
+}
+function normalizeKey(key) {
+    return key.replace(/-/g, "_");
+}
+function setOption(result, key, value) {
+    result[key] = value;
+    const normalized = normalizeKey(key);
+    if (normalized !== key) {
+        result[normalized] = value;
+    }
+}
+function parseArgs(argv) {
+    const result = { _: [] };
+    const args = argv || process.argv.slice(2);
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (arg === "--") {
+            result._.push(...args.slice(i + 1));
+            break;
+        }
+        if (!arg.startsWith("-") || arg === "-") {
+            result._.push(arg);
+            continue;
+        }
+        if (arg.startsWith("--no-")) {
+            setOption(result, normalizeKey(arg.slice(5)), false);
+            continue;
+        }
+        if (arg.startsWith("--")) {
+            const body = arg.slice(2);
+            const idx = body.indexOf("=");
+            if (idx !== -1) {
+                setOption(result, normalizeKey(body.slice(0, idx)), coerceValue(body.slice(idx + 1)));
+                continue;
+            }
+            const key = normalizeKey(body);
+            const next = args[i + 1];
+            if (next !== undefined && !next.startsWith("-")) {
+                setOption(result, key, coerceValue(next));
+                i++;
+            }
+            else {
+                setOption(result, key, true);
+            }
+            continue;
+        }
+        const shorts = arg.slice(1);
+        if (shorts.length === 1) {
+            const next = args[i + 1];
+            if (next !== undefined && !next.startsWith("-")) {
+                setOption(result, shorts, coerceValue(next));
+                i++;
+            }
+            else {
+                setOption(result, shorts, true);
+            }
+            continue;
+        }
+        for (const ch of shorts) {
+            setOption(result, ch, true);
+        }
+    }
+    return result;
+}
+module.exports = { parseArgs };

package/testutils/ent-graphql-tests/index.d.ts

@@ -2,11 +2,17 @@ import { Express, RequestHandler } from "express";
 import { GraphQLSchema } from "graphql";
 import supertest from "supertest";
 import { Viewer } from "../../core/base";
+export declare function cleanupBunGraphQLTestAgent(agent: any): Promise<void>;
+type BunTestTarget = {
+    app: Express;
+    url: string;
+};
 export type Option = [string, any] | [string, any, string];
 interface queryConfig {
     viewer?: Viewer;
     init?: (app: Express) => void;
     test?: supertest.Agent | ((express: Express) => supertest.Agent);
+    bunTest?: (target: BunTestTarget) => supertest.Agent;
     schema: GraphQLSchema;
     headers?: object;
     debugMode?: boolean;

package/testutils/ent-graphql-tests/index.js

@@ -1,52 +1,46 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.cleanupBunGraphQLTestAgent = cleanupBunGraphQLTestAgent;
 exports.expectQueryFromRoot = expectQueryFromRoot;
 exports.expectMutation = expectMutation;
 // NB: this is copied from ent-graphql-tests package until I have time to figure out how to share code here effectively
 // the circular dependencies btw this package and ent-graphql-tests seems to imply something needs to change
 const express_1 = __importDefault(require("express"));
-const fs = __importStar(require("fs"));
-const graphql_1 = require("graphql");
 const graphql_helix_1 = require("graphql-helix");
 const supertest_1 = __importDefault(require("supertest"));
 const util_1 = require("util");
 const auth_1 = require("../../auth");
+const bunAgentServerClose = Symbol("bunAgentServerClose");
+const bunAgentServerCleanups = new Set();
+let bunAgentServerCleanupRegistered = false;
+function registerBunAgentServerCleanup(cleanup) {
+    let cleanupPromise;
+    const cleanupOnce = () => {
+        cleanupPromise = cleanupPromise || cleanup();
+        return cleanupPromise;
+    };
+    bunAgentServerCleanups.add(cleanupOnce);
+    const afterAllFn = globalThis
+        .afterAll;
+    if (!bunAgentServerCleanupRegistered && typeof afterAllFn === "function") {
+        bunAgentServerCleanupRegistered = true;
+        afterAllFn(async () => {
+            const cleanups = [...bunAgentServerCleanups];
+            bunAgentServerCleanups.clear();
+            await Promise.all(cleanups.map((cleanup) => cleanup()));
+        });
+    }
+    return cleanupOnce;
+}
+async function cleanupBunGraphQLTestAgent(agent) {
+    const cleanup = agent?.[bunAgentServerClose];
+    if (cleanup) {
+        await cleanup();
+    }
+}
 function server(config) {
     const viewer = config.viewer;
     if (viewer) {
@@ -83,25 +77,113 @@ function server(config) {
     app.use(config.graphQLPath || "/graphql", ...handlers);
     return app;
 }
+// Bun can load GraphQL types from a different module realm than the schema under test,
+// so constructor identity checks are not reliable here.
+function isWrappingTypeLike(typ) {
+    return !!typ && typeof typ === "object" && "ofType" in typ;
+}
+function isListTypeLike(typ) {
+    return (isWrappingTypeLike(typ) &&
+        (typ.constructor?.name === "GraphQLList" || /^\[.*\]$/.test(String(typ))));
+}
+function isObjectTypeLike(typ) {
+    return (!!typ && typeof typ === "object" && typeof typ.getFields === "function");
+}
+function isScalarTypeLike(typ) {
+    return (!!typ &&
+        typeof typ === "object" &&
+        typeof typ.serialize === "function" &&
+        typeof typ.parseValue === "function" &&
+        typeof typ.parseLiteral === "function");
+}
+function isEnumTypeLike(typ) {
+    return (!!typ &&
+        typeof typ === "object" &&
+        typeof typ.getValues === "function" &&
+        typeof typ.toConfig === "function");
+}
 function getInnerType(typ, list) {
-    if ((0, graphql_1.isWrappingType)(typ)) {
-        if (typ instanceof graphql_1.GraphQLList) {
+    if (isWrappingTypeLike(typ)) {
+        if (isListTypeLike(typ)) {
             return getInnerType(typ.ofType, true);
         }
         return getInnerType(typ.ofType, list);
     }
     return [typ, list];
 }
-function makeGraphQLRequest(config, query, fieldArgs) {
+async function createBunTestHarness(config, persistentAgent, testFactory) {
+    const app = config.server ? config.server : server(config);
+    const httpServer = await new Promise((resolve) => {
+        const srv = app.listen(0, () => resolve(srv));
+    });
+    const address = httpServer.address();
+    if (!address || typeof address === "string") {
+        throw new Error("could not determine test server address");
+    }
+    const url = `http://127.0.0.1:${address.port}`;
+    let closePromise;
+    const close = () => {
+        closePromise =
+            closePromise ||
+                new Promise((resolve, reject) => {
+                    httpServer.close((err) => (err ? reject(err) : resolve()));
+                });
+        return closePromise;
+    };
+    if (persistentAgent) {
+        try {
+            let agent;
+            // Keep the existing Express app factory contract. If bunTest is present,
+            // it owns the URL-backed agent and testFactory still runs against the app.
+            const factoryAgent = testFactory?.(app);
+            if (config.bunTest) {
+                agent = config.bunTest({ app, url });
+            }
+            else if (factoryAgent) {
+                agent = factoryAgent;
+            }
+            else {
+                agent = supertest_1.default.agent(url);
+            }
+            agent[bunAgentServerClose] = registerBunAgentServerCleanup(close);
+            return { agent };
+        }
+        catch (err) {
+            await close();
+            throw err;
+        }
+    }
+    return {
+        agent: (0, supertest_1.default)(url),
+        cleanup: close,
+    };
+}
+async function makeGraphQLRequest(config, query, fieldArgs) {
     let agent;
+    let cleanup;
     if (config.test) {
         if (typeof config.test === "function") {
-            agent = config.test(config.server ? config.server : server(config));
+            if (process.versions.bun) {
+                ({ agent } = await createBunTestHarness(config, true, config.test));
+            }
+            else {
+                const factoryAgent = config.test(config.server ? config.server : server(config));
+                if (!factoryAgent) {
+                    throw new Error("config.test must return a supertest agent");
+                }
+                agent = factoryAgent;
+            }
         }
         else {
             agent = config.test;
         }
     }
+    else if (process.versions.bun && config.bunTest) {
+        ({ agent } = await createBunTestHarness(config, true));
+    }
+    else if (process.versions.bun) {
+        ({ agent, cleanup } = await createBunTestHarness(config, false));
+    }
     else {
         agent = (0, supertest_1.default)(config.server ? config.server : server(config));
     }
@@ -109,7 +191,7 @@ function makeGraphQLRequest(config, query, fieldArgs) {
     // handle files
     fieldArgs.forEach((fieldArg) => {
         let [typ, list] = getInnerType(fieldArg.type, false);
-        if (typ instanceof graphql_1.GraphQLScalarType && typ.name == "Upload") {
+        if (isScalarTypeLike(typ) && typ.name == "Upload") {
             let value = config.args[fieldArg.name];
             if (list) {
                 expect(Array.isArray(value)).toBe(true);
@@ -150,31 +232,29 @@ function makeGraphQLRequest(config, query, fieldArgs) {
         ret.field("map", JSON.stringify(m));
         idx = 0;
         for (let [key, val] of files) {
-            if (typeof val === "string") {
-                val = fs.createReadStream(val);
-            }
             ret.attach(`${idx}`, val, key);
             idx++;
         }
-        return [agent, ret];
+        return { agent, request: ret, cleanup };
     }
     else {
-        return [
+        return {
             agent,
-            agent
+            request: agent
                 .post(config.graphQLPath || "/graphql")
                 .set((config.headers || {}))
                 .send({
                 query: query,
-                variables: JSON.stringify(variables),
+                variables,
             }),
-        ];
+            cleanup,
+        };
     }
 }
 function buildTreeFromQueryPaths(schema, fieldType, ...options) {
     let fields;
     const [typ] = getInnerType(fieldType, false);
-    if (typ instanceof graphql_1.GraphQLObjectType) {
+    if (isObjectTypeLike(typ)) {
         fields = typ.getFields();
     }
     let topLevelTree = {};
@@ -189,7 +269,7 @@ function buildTreeFromQueryPaths(schema, fieldType, ...options) {
             if (!typ) {
                 throw new Error(`can't find type for ${match[1]} in schema`);
             }
-            if (typ instanceof graphql_1.GraphQLObjectType) {
+            if (isObjectTypeLike(typ)) {
                 fields = typ.getFields();
             }
         }
@@ -243,7 +323,7 @@ function buildTreeFromQueryPaths(schema, fieldType, ...options) {
                     subField = root?.[p];
                     if (subField) {
                         [subField] = getInnerType(subField.type, false);
-                        if (subField instanceof graphql_1.GraphQLObjectType) {
+                        if (isObjectTypeLike(subField)) {
                             root = subField.getFields();
                         }
                     }
@@ -251,7 +331,7 @@ function buildTreeFromQueryPaths(schema, fieldType, ...options) {
                 if (!subField) {
                     return false;
                 }
-                return (0, graphql_1.isScalarType)(subField) || (0, graphql_1.isEnumType)(subField);
+                return isScalarTypeLike(subField) || isEnumTypeLike(subField);
             }
             if (i === parts.length - 1 && typeof option[1] === "object") {
                 if (!scalarFieldAtLeaf(parts)) {
@@ -382,8 +462,16 @@ async function expectFromRoot(config, ...options) {
     if (config.debugMode) {
         console.log(q);
     }
-    let [st, temp] = makeGraphQLRequest(config, q, fieldArgs);
-    const res = await temp.expect("Content-Type", /json/);
+    const { agent: st, request, cleanup, } = await makeGraphQLRequest(config, q, fieldArgs);
+    let res;
+    try {
+        res = await request.expect("Content-Type", /json/);
+    }
+    finally {
+        if (cleanup) {
+            await cleanup();
+        }
+    }
     if (config.debugMode) {
         console.log((0, util_1.inspect)(res.body, false, 3));
     }