@constructive-io/graphql-query 3.15.0 → 3.15.2

package/esm/runtime/index.js

@@ -2,18 +2,21 @@
  * Runtime sub-export for generated ORM code.
  *
  * Generated ORM clients need runtime dependencies at execution time.
- * This module re-exports two of the three so generated code can consolidate imports:
+ * This module re-exports so generated code can consolidate imports:
  *   - @0no-co/graphql.web  — parseType, print
  *   - @constructive-io/graphql-types — GraphQLAdapter, GraphQLError, QueryResult
+ *   - ./localhost-fetch — createFetch (isomorphic *.localhost-aware fetch)
  *
  * gql-ast is intentionally NOT re-exported here because the templates
  * use `import * as t from 'gql-ast'` — mixing it into this namespace
  * would pollute `t` with unrelated symbols like parseType and print.
  *
  * Usage in generated templates:
- *   import { parseType, print } from '@constructive-io/graphql-query/runtime';
+ *   import { parseType, print, createFetch } from '@constructive-io/graphql-query/runtime';
  *   import * as t from 'gql-ast';
  *   import type { GraphQLAdapter } from '@constructive-io/graphql-query/runtime';
  */
 // From @0no-co/graphql.web — GraphQL parsing/printing
 export { parseType, print } from '@0no-co/graphql.web';
+// Isomorphic fetch with *.localhost DNS + Host header fix for Node.js
+export { createFetch } from './localhost-fetch';

package/esm/runtime/localhost-fetch.js

@@ -0,0 +1,108 @@
+/**
+ * Isomorphic fetch that resolves *.localhost subdomains and preserves
+ * Host headers across Node.js and browsers.
+ *
+ * Node.js has two issues with *.localhost subdomains:
+ * 1. DNS — fetch('http://auth.localhost:3000/') throws ENOTFOUND
+ *    because undici doesn't resolve *.localhost to loopback.
+ * 2. Host header — Node's fetch treats Host as forbidden and silently
+ *    drops it, breaking server-side subdomain routing.
+ *
+ * In browsers *.localhost resolves natively, so createFetch() returns
+ * globalThis.fetch as-is.
+ */
+export function isLocalhostSubdomain(hostname) {
+    return hostname.endsWith('.localhost') && hostname !== 'localhost';
+}
+function buildNodeFetch(http, https) {
+    return (input, init) => {
+        const url = new URL(typeof input === 'string'
+            ? input
+            : input instanceof URL
+                ? input.href
+                : input.url);
+        if (!isLocalhostSubdomain(url.hostname)) {
+            return globalThis.fetch(input, init);
+        }
+        const originalHost = url.host;
+        url.hostname = 'localhost';
+        return new Promise((resolve, reject) => {
+            const headers = {
+                Host: originalHost,
+            };
+            if (init?.headers) {
+                const entries = init.headers instanceof Headers
+                    ? Array.from(init.headers.entries())
+                    : Array.isArray(init.headers)
+                        ? init.headers
+                        : Object.entries(init.headers);
+                for (const [key, value] of entries) {
+                    headers[key] = value;
+                }
+            }
+            const protocol = url.protocol === 'https:' ? https : http;
+            const req = protocol.request(url, {
+                method: init?.method ?? 'GET',
+                headers,
+            }, (res) => {
+                const chunks = [];
+                res.on('data', (chunk) => chunks.push(chunk));
+                res.on('end', () => {
+                    const body = Buffer.concat(chunks);
+                    resolve(new Response(body, {
+                        status: res.statusCode ?? 0,
+                        statusText: res.statusMessage ?? '',
+                        headers: res.headers,
+                    }));
+                });
+            });
+            req.on('error', reject);
+            if (init?.signal) {
+                const onAbort = () => {
+                    req.destroy(new Error('The operation was aborted'));
+                };
+                init.signal.addEventListener('abort', onAbort, { once: true });
+                req.on('close', () => {
+                    init.signal.removeEventListener('abort', onAbort);
+                });
+            }
+            if (init?.body != null) {
+                req.write(typeof init.body === 'string' || init.body instanceof Uint8Array
+                    ? init.body
+                    : String(init.body));
+            }
+            req.end();
+        });
+    };
+}
+let _fetch;
+/**
+ * Create an isomorphic fetch function.
+ *
+ * - In browsers (and Deno/Bun/edge): returns globalThis.fetch as-is.
+ * - In Node.js: returns a wrapper that uses node:http/node:https for
+ *   *.localhost URLs (fixing DNS + Host header) and delegates everything
+ *   else to globalThis.fetch.
+ *
+ * The result is cached — calling createFetch() multiple times returns
+ * the same function instance.
+ */
+export function createFetch() {
+    if (_fetch)
+        return _fetch;
+    if (typeof process !== 'undefined' && process.versions?.node) {
+        try {
+            // eslint-disable-next-line @typescript-eslint/no-require-imports
+            const http = require('node:http');
+            // eslint-disable-next-line @typescript-eslint/no-require-imports
+            const https = require('node:https');
+            _fetch = buildNodeFetch(http, https);
+            return _fetch;
+        }
+        catch {
+            // node:http unavailable — fall through
+        }
+    }
+    _fetch = globalThis.fetch;
+    return _fetch;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@constructive-io/graphql-query",
-  "version": "3.15.0",
+  "version": "3.15.2",
   "description": "Constructive GraphQL Query",
   "author": "Constructive <developers@constructive.io>",
   "main": "index.js",
@@ -36,7 +36,7 @@
     "grafast": "1.0.0",
     "graphile-build-pg": "5.0.0",
     "graphile-config": "1.0.0",
-    "graphile-settings": "^4.22.0",
+    "graphile-settings": "^4.22.2",
     "graphql": "16.13.0",
     "inflection": "^3.0.0",
     "inflekt": "^0.7.1",
@@ -53,5 +53,5 @@
   "devDependencies": {
     "makage": "^0.3.0"
   },
-  "gitHead": "434a578648cb04d3ed25e79a75c654f71573292f"
+  "gitHead": "a8ccaed4f3a7c6c82495241ee1581700db9dd2dd"
 }

package/runtime/index.d.ts

@@ -2,18 +2,21 @@
  * Runtime sub-export for generated ORM code.
  *
  * Generated ORM clients need runtime dependencies at execution time.
- * This module re-exports two of the three so generated code can consolidate imports:
+ * This module re-exports so generated code can consolidate imports:
  *   - @0no-co/graphql.web  — parseType, print
  *   - @constructive-io/graphql-types — GraphQLAdapter, GraphQLError, QueryResult
+ *   - ./localhost-fetch — createFetch (isomorphic *.localhost-aware fetch)
  *
  * gql-ast is intentionally NOT re-exported here because the templates
  * use `import * as t from 'gql-ast'` — mixing it into this namespace
  * would pollute `t` with unrelated symbols like parseType and print.
  *
  * Usage in generated templates:
- *   import { parseType, print } from '@constructive-io/graphql-query/runtime';
+ *   import { parseType, print, createFetch } from '@constructive-io/graphql-query/runtime';
  *   import * as t from 'gql-ast';
  *   import type { GraphQLAdapter } from '@constructive-io/graphql-query/runtime';
  */
 export { parseType, print } from '@0no-co/graphql.web';
 export type { GraphQLAdapter, GraphQLError, QueryResult } from '@constructive-io/graphql-types';
+export { createFetch } from './localhost-fetch';
+export type { FetchFunction } from './localhost-fetch';

package/runtime/index.js

@@ -3,22 +3,26 @@
  * Runtime sub-export for generated ORM code.
  *
  * Generated ORM clients need runtime dependencies at execution time.
- * This module re-exports two of the three so generated code can consolidate imports:
+ * This module re-exports so generated code can consolidate imports:
  *   - @0no-co/graphql.web  — parseType, print
  *   - @constructive-io/graphql-types — GraphQLAdapter, GraphQLError, QueryResult
+ *   - ./localhost-fetch — createFetch (isomorphic *.localhost-aware fetch)
  *
  * gql-ast is intentionally NOT re-exported here because the templates
  * use `import * as t from 'gql-ast'` — mixing it into this namespace
  * would pollute `t` with unrelated symbols like parseType and print.
  *
  * Usage in generated templates:
- *   import { parseType, print } from '@constructive-io/graphql-query/runtime';
+ *   import { parseType, print, createFetch } from '@constructive-io/graphql-query/runtime';
  *   import * as t from 'gql-ast';
  *   import type { GraphQLAdapter } from '@constructive-io/graphql-query/runtime';
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseType = void 0;
+exports.createFetch = exports.parseType = void 0;
 // From @0no-co/graphql.web — GraphQL parsing/printing
 var graphql_web_1 = require("@0no-co/graphql.web");
 Object.defineProperty(exports, "parseType", { enumerable: true, get: function () { return graphql_web_1.parseType; } });
 Object.defineProperty(exports, "print", { enumerable: true, get: function () { return graphql_web_1.print; } });
+// Isomorphic fetch with *.localhost DNS + Host header fix for Node.js
+var localhost_fetch_1 = require("./localhost-fetch");
+Object.defineProperty(exports, "createFetch", { enumerable: true, get: function () { return localhost_fetch_1.createFetch; } });

package/runtime/localhost-fetch.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Isomorphic fetch that resolves *.localhost subdomains and preserves
+ * Host headers across Node.js and browsers.
+ *
+ * Node.js has two issues with *.localhost subdomains:
+ * 1. DNS — fetch('http://auth.localhost:3000/') throws ENOTFOUND
+ *    because undici doesn't resolve *.localhost to loopback.
+ * 2. Host header — Node's fetch treats Host as forbidden and silently
+ *    drops it, breaking server-side subdomain routing.
+ *
+ * In browsers *.localhost resolves natively, so createFetch() returns
+ * globalThis.fetch as-is.
+ */
+export type FetchFunction = typeof globalThis.fetch;
+export declare function isLocalhostSubdomain(hostname: string): boolean;
+/**
+ * Create an isomorphic fetch function.
+ *
+ * - In browsers (and Deno/Bun/edge): returns globalThis.fetch as-is.
+ * - In Node.js: returns a wrapper that uses node:http/node:https for
+ *   *.localhost URLs (fixing DNS + Host header) and delegates everything
+ *   else to globalThis.fetch.
+ *
+ * The result is cached — calling createFetch() multiple times returns
+ * the same function instance.
+ */
+export declare function createFetch(): FetchFunction;

package/runtime/localhost-fetch.js

@@ -0,0 +1,112 @@
+"use strict";
+/**
+ * Isomorphic fetch that resolves *.localhost subdomains and preserves
+ * Host headers across Node.js and browsers.
+ *
+ * Node.js has two issues with *.localhost subdomains:
+ * 1. DNS — fetch('http://auth.localhost:3000/') throws ENOTFOUND
+ *    because undici doesn't resolve *.localhost to loopback.
+ * 2. Host header — Node's fetch treats Host as forbidden and silently
+ *    drops it, breaking server-side subdomain routing.
+ *
+ * In browsers *.localhost resolves natively, so createFetch() returns
+ * globalThis.fetch as-is.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isLocalhostSubdomain = isLocalhostSubdomain;
+exports.createFetch = createFetch;
+function isLocalhostSubdomain(hostname) {
+    return hostname.endsWith('.localhost') && hostname !== 'localhost';
+}
+function buildNodeFetch(http, https) {
+    return (input, init) => {
+        const url = new URL(typeof input === 'string'
+            ? input
+            : input instanceof URL
+                ? input.href
+                : input.url);
+        if (!isLocalhostSubdomain(url.hostname)) {
+            return globalThis.fetch(input, init);
+        }
+        const originalHost = url.host;
+        url.hostname = 'localhost';
+        return new Promise((resolve, reject) => {
+            const headers = {
+                Host: originalHost,
+            };
+            if (init?.headers) {
+                const entries = init.headers instanceof Headers
+                    ? Array.from(init.headers.entries())
+                    : Array.isArray(init.headers)
+                        ? init.headers
+                        : Object.entries(init.headers);
+                for (const [key, value] of entries) {
+                    headers[key] = value;
+                }
+            }
+            const protocol = url.protocol === 'https:' ? https : http;
+            const req = protocol.request(url, {
+                method: init?.method ?? 'GET',
+                headers,
+            }, (res) => {
+                const chunks = [];
+                res.on('data', (chunk) => chunks.push(chunk));
+                res.on('end', () => {
+                    const body = Buffer.concat(chunks);
+                    resolve(new Response(body, {
+                        status: res.statusCode ?? 0,
+                        statusText: res.statusMessage ?? '',
+                        headers: res.headers,
+                    }));
+                });
+            });
+            req.on('error', reject);
+            if (init?.signal) {
+                const onAbort = () => {
+                    req.destroy(new Error('The operation was aborted'));
+                };
+                init.signal.addEventListener('abort', onAbort, { once: true });
+                req.on('close', () => {
+                    init.signal.removeEventListener('abort', onAbort);
+                });
+            }
+            if (init?.body != null) {
+                req.write(typeof init.body === 'string' || init.body instanceof Uint8Array
+                    ? init.body
+                    : String(init.body));
+            }
+            req.end();
+        });
+    };
+}
+let _fetch;
+/**
+ * Create an isomorphic fetch function.
+ *
+ * - In browsers (and Deno/Bun/edge): returns globalThis.fetch as-is.
+ * - In Node.js: returns a wrapper that uses node:http/node:https for
+ *   *.localhost URLs (fixing DNS + Host header) and delegates everything
+ *   else to globalThis.fetch.
+ *
+ * The result is cached — calling createFetch() multiple times returns
+ * the same function instance.
+ */
+function createFetch() {
+    if (_fetch)
+        return _fetch;
+    if (typeof process !== 'undefined' && process.versions?.node) {
+        try {
+            // eslint-disable-next-line @typescript-eslint/no-require-imports
+            const http = require('node:http');
+            // eslint-disable-next-line @typescript-eslint/no-require-imports
+            const https = require('node:https');
+            _fetch = buildNodeFetch(http, https);
+            return _fetch;
+        }
+        catch {
+            // node:http unavailable — fall through
+        }
+    }
+    _fetch = globalThis.fetch;
+    return _fetch;
+}