hadars 0.4.1 → 0.4.2

package/src/source/inference.ts

@@ -1,260 +0,0 @@
-/**
- * Schema inference — builds a GraphQL schema from the node store automatically,
- * just like Gatsby does. Uses graphql-js (must be installed in the user's project).
- *
- * Dynamically imports graphql so hadars itself does not depend on it.
- */
-
-import type { NodeStore } from './store';
-import type { GraphQLExecutor } from '../types/hadars';
-
-// ── Primitive inference ────────────────────────────────────────────────────────
-
-type ScalarName = 'String' | 'Int' | 'Float' | 'Boolean' | 'ID';
-
-function inferScalar(value: unknown): ScalarName {
-    if (typeof value === 'boolean') return 'Boolean';
-    if (typeof value === 'number') return Number.isInteger(value) ? 'Int' : 'Float';
-    return 'String';
-}
-
-interface FieldShape {
-    type: string;   // e.g. "String", "Int", "Boolean", "[String]", "InternalType"
-    nullable: boolean;
-}
-
-function inferFieldShape(value: unknown, seenTypes: Set<string>): FieldShape {
-    if (value === null || value === undefined) {
-        return { type: 'String', nullable: true };
-    }
-    if (Array.isArray(value)) {
-        const inner = value.length > 0
-            ? inferFieldShape(value[0], seenTypes)
-            : { type: 'String', nullable: true };
-        return { type: `[${inner.type}]`, nullable: true };
-    }
-    if (typeof value === 'object') {
-        // nested object — we don't recurse deeply for now; use JSON string
-        return { type: 'String', nullable: true };
-    }
-    return { type: inferScalar(value), nullable: true };
-}
-
-// ── Schema string builder ──────────────────────────────────────────────────────
-
-const INTERNAL_FIELDS = new Set(['id', 'internal', '__typename', 'parent', 'children']);
-/** GraphQL spec reserves all names beginning with __ for introspection. */
-const isReservedFieldName = (name: string) => name.startsWith('__');
-
-/** Scalar GraphQL types that are safe to use as lookup filter arguments. */
-const FILTERABLE_SCALARS = new Set(['String', 'Int', 'Float', 'Boolean', 'ID']);
-
-interface InferredField {
-    name: string;
-    type: string;
-    /** True when the base type is a plain scalar (not a list/object). */
-    filterable: boolean;
-}
-
-function buildTypeFields(nodes: readonly Record<string, unknown>[]): InferredField[] {
-    const fieldMap = new Map<string, InferredField>();
-
-    for (const node of nodes) {
-        for (const [key, val] of Object.entries(node)) {
-            if (INTERNAL_FIELDS.has(key) || isReservedFieldName(key)) continue;
-            if (fieldMap.has(key)) continue;
-            const { type } = inferFieldShape(val, new Set());
-            fieldMap.set(key, {
-                name: key,
-                type,
-                filterable: FILTERABLE_SCALARS.has(type),
-            });
-        }
-    }
-
-    return Array.from(fieldMap.values());
-}
-
-function buildTypeSDL(typeName: string, fields: InferredField[]): string {
-    const lines = [
-        '  id: ID!',
-        ...fields.map(f => `  ${f.name}: ${f.type}`),
-    ];
-    return `type ${typeName} {\n${lines.join('\n')}\n}`;
-}
-
-// ── Query builder ──────────────────────────────────────────────────────────────
-
-/** Build allXxx / xxx query names from a type name, matching Gatsby's convention. */
-function queryNames(typeName: string) {
-    const lower = typeName.charAt(0).toLowerCase() + typeName.slice(1);
-    return { single: lower, all: `all${typeName}` };
-}
-
-/**
- * Build the SDL argument list for the single-item query.
- * Includes `id` plus every filterable scalar field so callers can look up
- * nodes by any natural key (e.g. slug, email) without knowing the hashed id.
- * The resolver returns the first node where ALL supplied arguments match.
- */
-function buildSingleArgs(fields: InferredField[]): string {
-    const args = [
-        'id: ID',
-        ...fields.filter(f => f.filterable && f.name !== 'id').map(f => `${f.name}: ${f.type}`),
-    ];
-    return args.join(', ');
-}
-
-// ── Public API ─────────────────────────────────────────────────────────────────
-
-/**
- * Load graphql-js from the user's project and build a schema + SDL from the
- * node store. Returns null if graphql-js is not installed.
- */
-async function loadAndBuildSchema(store: NodeStore): Promise<{
-    schema: any;
-    sdl: string;
-    gql: any;
-} | null> {
-    let gql: any;
-    try {
-        const { createRequire } = await import('node:module');
-        const projectRequire = createRequire(process.cwd() + '/package.json');
-        const graphqlPath = projectRequire.resolve('graphql');
-        gql = await import(graphqlPath);
-    } catch {
-        return null;
-    }
-
-    const { buildSchema, printSchema, print } = gql;
-    const types = store.getTypes();
-
-    if (types.length === 0) {
-        const rawSdl = 'type Query { _empty: String }';
-        return { schema: buildSchema(rawSdl), sdl: rawSdl, gql };
-    }
-
-    // Infer field shapes once per type — reused for SDL, resolvers, and args.
-    const typeFields = new Map(
-        types.map(typeName => {
-            const nodes = store.getNodesByType(typeName) as Record<string, unknown>[];
-            return [typeName, buildTypeFields(nodes)] as const;
-        })
-    );
-
-    const typeSDLs = types.map(typeName =>
-        buildTypeSDL(typeName, typeFields.get(typeName)!)
-    );
-
-    const queryFields = types.map(typeName => {
-        const { single, all } = queryNames(typeName);
-        const args = buildSingleArgs(typeFields.get(typeName)!);
-        return [
-            `  ${single}(${args}): ${typeName}`,
-            `  ${all}: [${typeName}!]!`,
-        ].join('\n');
-    });
-
-    const rawSdl = [
-        ...typeSDLs,
-        `type Query {\n${queryFields.join('\n')}\n}`,
-    ].join('\n\n');
-
-    let schema: any;
-    try {
-        schema = buildSchema(rawSdl);
-    } catch (err) {
-        throw new Error(`[hadars] Failed to build GraphQL schema from node store: ${(err as Error).message}`);
-    }
-
-    return { schema, sdl: printSchema(schema), gql };
-}
-
-/**
- * Build a GraphQL executor backed by the node store.
- *
- * Returns null if graphql-js is not installed — in that case the caller should
- * surface a clear error message asking the user to install `graphql`.
- */
-/**
- * Normalise a query argument to a string.
- * Accepts either a plain query string or a TypedDocumentNode / codegen document object.
- */
-function toQueryString(query: unknown, print: (doc: any) => string): string {
-    return typeof query === 'string' ? query : print(query);
-}
-
-export async function buildSchemaExecutor(
-    store: NodeStore,
-): Promise<GraphQLExecutor | null> {
-    const built = await loadAndBuildSchema(store);
-    if (!built) return null;
-
-    const { schema, gql } = built;
-    const { graphql, print } = gql;
-    const types = store.getTypes();
-
-    if (types.length === 0) {
-        return (query, variables) =>
-            graphql({ schema, source: toQueryString(query, print), variableValues: variables });
-    }
-
-    // Build root resolver map
-    const rootValue: Record<string, unknown> = {};
-    for (const typeName of types) {
-        const { single, all } = queryNames(typeName);
-        rootValue[all] = () => store.getNodesByType(typeName);
-        // Single-item resolver: return the first node matching ALL supplied args.
-        rootValue[single] = (args: Record<string, unknown>) => {
-            const nodes = store.getNodesByType(typeName) as Record<string, unknown>[];
-            return nodes.find(node =>
-                Object.entries(args).every(([k, v]) => v === undefined || node[k] === v)
-            ) ?? null;
-        };
-    }
-
-    return (query, variables) =>
-        graphql({ schema, rootValue, source: toQueryString(query, print), variableValues: variables }) as any;
-}
-
-/**
- * Return the inferred GraphQL schema as a SDL string suitable for writing to a
- * `schema.graphql` file and consuming with graphql-codegen or gql.tada.
- *
- * Returns null if graphql-js is not installed in the user's project.
- */
-export async function buildSchemaSDL(store: NodeStore): Promise<string | null> {
-    const built = await loadAndBuildSchema(store);
-    return built?.sdl ?? null;
-}
-
-/**
- * Introspect a custom GraphQL executor and return its schema as SDL.
- * Uses the standard introspection query so the executor doesn't need to know
- * about hadars internals.
- *
- * Returns null if graphql-js is not installed in the user's project.
- */
-export async function introspectExecutorSDL(
-    executor: GraphQLExecutor,
-): Promise<string | null> {
-    let gql: any;
-    try {
-        const { createRequire } = await import('node:module');
-        const projectRequire = createRequire(process.cwd() + '/package.json');
-        const graphqlPath = projectRequire.resolve('graphql');
-        gql = await import(graphqlPath);
-    } catch {
-        return null;
-    }
-
-    const { getIntrospectionQuery, buildClientSchema, printSchema } = gql;
-    const result = await executor(getIntrospectionQuery());
-    if (result.errors?.length) {
-        throw new Error(`[hadars] Introspection failed: ${result.errors[0].message}`);
-    }
-    if (!result.data) {
-        throw new Error('[hadars] Introspection returned no data');
-    }
-    return printSchema(buildClientSchema(result.data));
-}

package/src/source/runner.ts

@@ -1,138 +0,0 @@
-/**
- * Source plugin runner — calls each plugin's `sourceNodes` with a Gatsby-compatible
- * context object, then returns a populated node store ready for schema inference.
- *
- * Handles async plugins (e.g. gatsby-source-filesystem) that return immediately
- * and create nodes later via file-system events:
- *  1. Wait for nodes to stop arriving ("settle").
- *  2. Emit BOOTSTRAP_FINISHED on the plugin's emitter.
- *  3. Wait for any post-bootstrap nodes to settle.
- */
-
-import { EventEmitter } from 'node:events';
-import { createRequire } from 'node:module';
-import { NodeStore } from './store';
-import { makeGatsbyContext } from './context';
-import type { HadarsSourceEntry } from '../types/hadars';
-
-/** ms without a new createNode call before we consider the plugin settled. */
-const SETTLE_IDLE_MS = 300;
-/** Hard timeout — give up waiting after this many ms. */
-const SETTLE_TIMEOUT_MS = 10_000;
-/** Timeout for a single sourceNodes() call before we give up waiting. */
-const SOURCE_NODES_TIMEOUT_MS = 30_000;
-
-/**
- * Wait until no createNode call has been received for SETTLE_IDLE_MS,
- * or until SETTLE_TIMEOUT_MS elapses, whichever comes first.
- * Timers are unref()ed so they don't keep the process alive artificially.
- */
-function waitForSettle(getLastNodeTime: () => number): Promise<void> {
-    return new Promise(resolve => {
-        const deadline = Date.now() + SETTLE_TIMEOUT_MS;
-        const check = () => {
-            const idle = Date.now() - getLastNodeTime();
-            if (idle >= SETTLE_IDLE_MS || Date.now() >= deadline) {
-                resolve();
-            } else {
-                const t = setTimeout(check, 50);
-                t.unref?.();
-            }
-        };
-        const t = setTimeout(check, SETTLE_IDLE_MS);
-        t.unref?.();
-    });
-}
-
-/**
- * Run a promise with a hard timeout. Rejects with a clear message if the
- * deadline is exceeded, but does not cancel the original promise.
- */
-function withTimeout<T>(promise: Promise<T>, ms: number, label: string): Promise<T> {
-    return new Promise((resolve, reject) => {
-        const t = setTimeout(() => reject(new Error(`[hadars] "${label}" timed out after ${ms}ms`)), ms);
-        t.unref?.();
-        promise.then(resolve, reject).finally(() => clearTimeout(t));
-    });
-}
-
-export async function runSources(
-    sources: HadarsSourceEntry[],
-): Promise<NodeStore> {
-    const store = new NodeStore();
-
-    for (const entry of sources) {
-        const { resolve, options = {} } = entry;
-
-        let mod: { sourceNodes?: (ctx: any, opts?: any) => Promise<void> | void };
-        if (typeof resolve === 'string') {
-            // Resolve from the user's project directory so the package is found
-            // in their node_modules, not in the CLI's own node_modules.
-            const projectRequire = createRequire(process.cwd() + '/package.json');
-
-            // Gatsby plugins export sourceNodes from gatsby-node.js, not their
-            // package main. Try gatsby-node.js first, fall back to main entry.
-            let pkgPath: string;
-            try {
-                pkgPath = projectRequire.resolve(`${resolve}/gatsby-node`);
-            } catch {
-                pkgPath = projectRequire.resolve(resolve);
-            }
-            mod = await import(pkgPath);
-        } else {
-            mod = resolve as any;
-        }
-
-        if (typeof mod.sourceNodes !== 'function') {
-            const name = typeof resolve === 'string' ? resolve : '(module)';
-            console.warn(`[hadars] source plugin ${name} does not export sourceNodes — skipping`);
-            continue;
-        }
-
-        const pluginName = typeof resolve === 'string' ? resolve : 'hadars-source';
-
-        // Track the last time createNode was called so we can detect settling.
-        let lastNodeTime = Date.now();
-        const trackingStore = new Proxy(store, {
-            get(target, prop) {
-                if (prop === 'createNode') {
-                    return (node: any) => {
-                        lastNodeTime = Date.now();
-                        return target.createNode(node);
-                    };
-                }
-                return (target as any)[prop];
-            },
-        });
-
-        // Real EventEmitter — plugins subscribe to BOOTSTRAP_FINISHED on this.
-        const emitter = new EventEmitter();
-        const ctx = makeGatsbyContext(trackingStore, pluginName, options, emitter);
-
-        try {
-            await withTimeout(
-                Promise.resolve(mod.sourceNodes(ctx, options)),
-                SOURCE_NODES_TIMEOUT_MS,
-                `${pluginName} sourceNodes`,
-            );
-        } catch (err) {
-            const cause = err instanceof Error ? err : new Error(String(err));
-            const wrapped = new Error(
-                `[hadars] source plugin "${pluginName}" threw during sourceNodes: ${cause.message}`,
-            );
-            wrapped.cause = cause;
-            throw wrapped;
-        }
-
-        // Phase 1: wait for async initial-scan nodes (e.g. chokidar ready → createFileNode).
-        await waitForSettle(() => lastNodeTime);
-
-        // Signal Gatsby lifecycle end — some plugins create additional nodes here.
-        emitter.emit('BOOTSTRAP_FINISHED');
-
-        // Phase 2: wait for any post-bootstrap nodes to settle.
-        await waitForSettle(() => lastNodeTime);
-    }
-
-    return store;
-}

package/src/source/store.ts

@@ -1,50 +0,0 @@
-/**
- * In-memory node store — the equivalent of Gatsby's internal node database.
- * Source plugins write nodes here via the context shim; the schema inferencer
- * reads them to build the GraphQL schema.
- */
-
-export interface HadarsNode {
-    id: string;
-    /** Gatsby convention: the node type string, e.g. "MarkdownRemark", "ContentfulBlogPost". */
-    internal: {
-        type: string;
-        contentDigest: string;
-        content?: string;
-        mediaType?: string;
-        description?: string;
-    };
-    [key: string]: unknown;
-}
-
-export class NodeStore {
-    private byId   = new Map<string, HadarsNode>();
-    private byType = new Map<string, HadarsNode[]>();
-
-    createNode(node: HadarsNode): void {
-        if (!node.id) throw new Error('[hadars] createNode: node.id must be a non-empty string');
-        if (!node.internal?.type) throw new Error('[hadars] createNode: node.internal.type must be a non-empty string');
-        this.byId.set(node.id, node);
-        const list = this.byType.get(node.internal.type) ?? [];
-        // Replace existing node with same id if present
-        const idx = list.findIndex(n => n.id === node.id);
-        if (idx >= 0) list[idx] = node; else list.push(node);
-        this.byType.set(node.internal.type, list);
-    }
-
-    getNode(id: string): HadarsNode | undefined {
-        return this.byId.get(id);
-    }
-
-    getNodes(): HadarsNode[] {
-        return Array.from(this.byId.values());
-    }
-
-    getNodesByType(type: string): HadarsNode[] {
-        return this.byType.get(type) ?? [];
-    }
-
-    getTypes(): string[] {
-        return Array.from(this.byType.keys());
-    }
-}

package/src/ssr-render-worker.ts

@@ -1,116 +0,0 @@
-/**
- * SSR render worker — runs in a node:worker_threads thread.
- *
- * Uses slim-react (bundled with hadars) for rendering instead of react-dom/server.
- * The SSR bundle is compiled with `react` aliased to slim-react, so both the
- * worker and the bundle share the same slim-react instance (and its globalThis
- * render state) without any extra coordination.
- *
- * Message: { type: 'renderFull', id, request: SerializableRequest }
- * Reply:   { id, html, headHtml, status }  |  { id, error }
- */
-
-import { workerData, parentPort } from 'node:worker_threads';
-import { pathToFileURL } from 'node:url';
-import { renderToString, createElement } from './slim-react/index';
-import { buildHeadHtml } from './utils/response';
-
-const { ssrBundlePath } = workerData as { ssrBundlePath: string };
-
-let _ssrMod: any = null;
-
-async function init() {
-    if (_ssrMod) return;
-    _ssrMod = await import(pathToFileURL(ssrBundlePath).href);
-}
-
-export type SerializableRequest = {
-    url: string;
-    method: string;
-    headers: Record<string, string>;
-    body: Uint8Array | null;
-    pathname: string;
-    search: string;
-    location: string;
-    cookies: Record<string, string>;
-};
-
-function deserializeRequest(s: SerializableRequest): any {
-    const init: RequestInit = { method: s.method, headers: new Headers(s.headers) };
-    if (s.body) init.body = s.body.buffer as ArrayBuffer;
-    const req = new Request(s.url, init);
-    Object.assign(req, { pathname: s.pathname, search: s.search, location: s.location, cookies: s.cookies });
-    return req;
-}
-
-// ── Full lifecycle ─────────────────────────────────────────────────────────
-
-async function runFullLifecycle(serialReq: SerializableRequest) {
-    const Component = _ssrMod.default;
-    const { getInitProps, getFinalProps } = _ssrMod;
-
-    const parsedReq = deserializeRequest(serialReq);
-
-    const context: any = {
-        head: { title: 'Hadars App', meta: {}, link: {}, style: {}, script: {}, status: 200 },
-    };
-
-    let props: any = {
-        ...(getInitProps ? await getInitProps(parsedReq) : {}),
-        location: serialReq.location,
-    };
-
-    // Create per-request cache for useServerData, active for all renders.
-    const unsuspend = { cache: new Map<string, any>() };
-    (globalThis as any).__hadarsUnsuspend = unsuspend;
-    // Expose the head context so HadarsHead can write into it without needing
-    // the user to manually wrap their App with HadarsContext.
-    (globalThis as any).__hadarsContext = context;
-
-    // Single pass — component-level self-retry resolves all useServerData inline.
-    // context.head is fully populated by the time renderToString returns.
-    let appHtml: string;
-    try {
-        appHtml = await renderToString(createElement(Component, props));
-    } finally {
-        (globalThis as any).__hadarsUnsuspend = null;
-        (globalThis as any).__hadarsContext = null;
-    }
-    // Head is captured after the render — all components have run.
-    const headHtml = buildHeadHtml(context.head);
-    const status = context.head.status ?? 200;
-    const { context: _ctx, ...restProps } = getFinalProps ? await getFinalProps(props) : props;
-
-    // Collect fulfilled useServerData values for client-side hydration.
-    const serverData: Record<string, unknown> = {};
-    let hasServerData = false;
-    for (const [key, entry] of unsuspend.cache) {
-        if (entry.status === 'fulfilled') { serverData[key] = entry.value; hasServerData = true; }
-    }
-    const clientProps = {
-        ...restProps,
-        location: serialReq.location,
-        ...(hasServerData ? { __serverData: serverData } : {}),
-    };
-
-    const scriptContent = JSON.stringify({ hadars: { props: clientProps } }).replace(/</g, '\\u003c');
-    const html = `<div id="app">${appHtml}</div><script id="hadars" type="application/json">${scriptContent}</script>`;
-
-    return { html, headHtml, status };
-}
-
-// ── Message handler ────────────────────────────────────────────────────────
-
-parentPort!.on('message', async (msg: any) => {
-    const { id, type, request } = msg;
-    try {
-        await init();
-        if (type !== 'renderFull') return;
-
-        const { html, headHtml, status } = await runFullLifecycle(request as SerializableRequest);
-        parentPort!.postMessage({ id, html, headHtml, status });
-
-    } catch (err: any) {
-        parentPort!.postMessage({ id, error: err?.message ?? String(err) });
-    }
-});

package/src/ssr-watch.ts

@@ -1,62 +0,0 @@
-import pathMod from 'node:path';
-import { compileEntry } from './utils/rspack';
-
-// Simple worker to run an SSR watch in a separate process to avoid multiple
-// rspack instances in the same process.
-
-const args = process.argv.slice(2);
-const argv: Record<string, string> = {};
-for (const a of args) {
-  if (!a.startsWith('--')) continue;
-  const idx = a.indexOf('=');
-  if (idx === -1) continue;
-  const key = a.slice(2, idx);
-  const val = a.slice(idx + 1);
-  argv[key] = val;
-}
-
-const entry = argv['entry'];
-const outDir = argv['outDir'] || '.hadars';
-const outFile = argv['outFile'] || 'index.ssr.js';
-const base = argv['base'] || '';
-const swcPlugins = argv['swcPlugins'] ? JSON.parse(argv['swcPlugins']) : undefined;
-const define = argv['define'] ? JSON.parse(argv['define']) : undefined;
-const moduleRules = argv['moduleRules'] ? JSON.parse(argv['moduleRules'], (_k, v) => (v && typeof v === 'object' && '__re' in v) ? new RegExp(v.__re, v.__flags) : v) : undefined;
-
-if (!entry) {
-  console.error('ssr-watch: missing --entry argument');
-  process.exit(1);
-}
-
-(async () => {
-  try {
-    console.log('ssr-watch: starting SSR watcher for', entry);
-    await compileEntry(entry, {
-      target: 'node',
-      output: {
-        iife: false,
-        filename: outFile,
-        path: pathMod.resolve(process.cwd(), outDir),
-        publicPath: '',
-        library: { type: 'module' }
-      },
-      base,
-      mode: 'development',
-      watch: true,
-      swcPlugins,
-      define,
-      moduleRules,
-      onChange: () => {
-        console.log('ssr-watch: SSR rebuilt');
-      }
-    } as any);
-    // compileEntry with watch resolves after the initial build completes. Keep the
-    // process alive so the watcher remains active, but first emit a clear marker
-    // so the parent process can detect initial build completion.
-    console.log('ssr-watch: initial-build-complete');
-    await new Promise(() => { /* never resolve - keep worker alive */ });
-  } catch (err) {
-    console.error('ssr-watch: error', err);
-    process.exit(1);
-  }
-})();