npm - pastoria - Versions diffs - 0.0.1 - Mend

pastoria 0.0.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (6) hide show

package/package.json +14 -0
package/src/index.mts +297 -0
package/templates/js_resource.ts +55 -0
package/templates/router.tsx +397 -0
package/templates/server_router.ts +112 -0
package/tsconfig.json +18 -0

package/package.json ADDED Viewed

@@ -0,0 +1,14 @@
+{
+  "name": "pastoria",
+  "version": "0.0.1",
+  "type": "module",
+  "bin": "./src/index.mts",
+  "dependencies": {
+    "picocolors": "^1.1.1",
+    "ts-morph": "^26.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "20.3.1",
+    "typescript": "^5.9.2"
+  }
+}

package/src/index.mts ADDED Viewed

@@ -0,0 +1,297 @@
+#!/usr/bin/env node --experimental-strip-types
+/**
+ * @fileoverview Router Code Generator
+ *
+ * This script generates type-safe router configuration files by scanning TypeScript
+ * source code for JSDoc annotations. It's part of the "Pastoria" routing framework.
+ *
+ * How it works:
+ * 1. Scans all TypeScript files in the project for exported functions/classes
+ * 2. Looks for JSDoc tags: @route, @resource, and @param
+ * 3. Generates three files from templates:
+ *    - js_resource.ts: Resource configuration for lazy loading
+ *    - router.tsx: Client-side router with type-safe routes
+ *    - server_router.ts: Server-side router configuration
+ *
+ * Usage:
+ * - Add @route <route-name> to functions to create routes
+ * - Add @param <name> <type> to document route parameters
+ * - Add @resource <resource-name> to exports for lazy loading
+ *
+ * The generator automatically creates Zod schemas for route parameters based on
+ * TypeScript types, enabling runtime validation and type safety.
+ *
+ * Roadmap:
+ * 1. [DONE] Type-safe router APIs - Generate strongly typed navigation functions
+ * 2. Support for useTransition during routing - React 19 concurrent features
+ * 3. Support for metadata management in <head>
+ * 4. HTML manual generator suitable to be read by LLMs - Auto-generated docs
+ */
+import {readFile} from 'node:fs/promises';
+import * as path from 'node:path';
+import {default as pc} from 'picocolors';
+import {Project, SourceFile, Symbol, SyntaxKind, ts, TypeFlags} from 'ts-morph';
+const JS_RESOURCE_FILENAME = '__generated__/router/js_resource.ts';
+const JS_RESOURCE_TEMPLATE = path.join(
+  path.dirname(new URL(import.meta.url).pathname),
+  '../templates/js_resource.ts',
+);
+const ROUTER_FILENAME = '__generated__/router/router.tsx';
+const ROUTER_TEMPLATE = path.join(
+  path.dirname(new URL(import.meta.url).pathname),
+  '../templates/router.tsx',
+);
+const SERVER_ROUTER_FILENAME = '__generated__/router/server_router.ts';
+const SERVER_ROUTER_TEMPLATE = path.join(
+  path.dirname(new URL(import.meta.url).pathname),
+  '../templates/server_router.ts',
+);
+async function loadRouterFiles(project: Project) {
+  async function loadSourceFile(fileName: string, templateFileName: string) {
+    const template = await readFile(templateFileName, 'utf-8');
+    const warningComment = `/*
+ * This file was generated by \`pastoria\`.
+ * Do not modify this file directly. Instead, edit the template at ${path.basename(templateFileName)}.
+ */
+`;
+    return project.createSourceFile(fileName, warningComment + template, {
+      overwrite: true,
+    });
+  }
+  const [jsResource, router, serverRouter] = await Promise.all([
+    loadSourceFile(JS_RESOURCE_FILENAME, JS_RESOURCE_TEMPLATE),
+    loadSourceFile(ROUTER_FILENAME, ROUTER_TEMPLATE),
+    loadSourceFile(SERVER_ROUTER_FILENAME, SERVER_ROUTER_TEMPLATE),
+  ]);
+  return {jsResource, router, serverRouter} as const;
+}
+type RouterResource = {
+  resourceName: string;
+  sourceFile: SourceFile;
+  symbol: Symbol;
+};
+type RouterRoute = {
+  routeName: string;
+  sourceFile: SourceFile;
+  symbol: Symbol;
+  params: Map<string, ts.Type>;
+};
+function collectRouterNodes(project: Project) {
+  const resources: RouterResource[] = [];
+  const routes: RouterRoute[] = [];
+  function visitRouterNodes(sourceFile: SourceFile) {
+    sourceFile.getExportSymbols().forEach((symbol) => {
+      let routerResource = null as RouterResource | null;
+      let routerRoute = null as RouterRoute | null;
+      const routeParams = new Map<string, ts.Type>();
+      function visitJSDocTags(tag: ts.JSDoc | ts.JSDocTag) {
+        if (ts.isJSDoc(tag)) {
+          tag.tags?.forEach(visitJSDocTags);
+        } else if (ts.isJSDocParameterTag(tag)) {
+          const typeNode = tag.typeExpression?.type;
+          const tc = project.getTypeChecker().compilerObject;
+          const type =
+            typeNode == null
+              ? tc.getUnknownType()
+              : tc.getTypeFromTypeNode(typeNode);
+          routeParams.set(tag.name.getText(), type);
+        } else if (typeof tag.comment === 'string') {
+          switch (tag.tagName.getText()) {
+            case 'route': {
+              routerRoute = {
+                routeName: tag.comment,
+                sourceFile,
+                symbol,
+                params: routeParams,
+              };
+              break;
+            }
+            case 'resource': {
+              routerResource = {
+                resourceName: tag.comment,
+                sourceFile,
+                symbol,
+              };
+              break;
+            }
+          }
+        }
+      }
+      symbol
+        .getDeclarations()
+        .flatMap((decl) => ts.getJSDocCommentsAndTags(decl.compilerNode))
+        .forEach(visitJSDocTags);
+      if (routerRoute != null) routes.push(routerRoute);
+      if (routerResource != null) resources.push(routerResource);
+    });
+  }
+  project.getSourceFiles().forEach(visitRouterNodes);
+  return {resources, routes} as const;
+}
+function zodSchemaOfType(tc: ts.TypeChecker, t: ts.Type): string {
+  if (t.getFlags() & TypeFlags.String) {
+    return `z.pipe(z.string(), z.transform(decodeURIComponent))`;
+  } else if (t.getFlags() & TypeFlags.Number) {
+    return `z.coerce.number<number>()`;
+  } else if (t.getFlags() & TypeFlags.Null) {
+    return `z.preprocess(s => s == null ? undefined : s, z.undefined())`;
+  } else if (t.isUnion()) {
+    const isRepresentingOptional =
+      t.types.length === 2 &&
+      t.types.some((s) => s.getFlags() & TypeFlags.Null);
+    if (isRepresentingOptional) {
+      const nonOptionalType = t.types.find(
+        (s) => !(s.getFlags() & TypeFlags.Null),
+      )!;
+      return `z.pipe(z.nullish(${zodSchemaOfType(tc, nonOptionalType)}), z.transform(s => s == null ? undefined : s))`;
+    } else {
+      return `z.union([${t.types.map((it) => zodSchemaOfType(tc, it)).join(', ')}])`;
+    }
+  } else if (tc.isArrayLikeType(t)) {
+    const typeArg = tc.getTypeArguments(t as ts.TypeReference)[0];
+    const argZodSchema =
+      typeArg == null ? `z.any()` : zodSchemaOfType(tc, typeArg);
+    return `z.array(${argZodSchema})`;
+  } else {
+    console.log('Could not handle type:', tc.typeToString(t));
+    return `z.any()`;
+  }
+}
+async function main() {
+  const targetDir = path.resolve(process.argv[2] || process.cwd());
+  process.chdir(targetDir);
+  const project = new Project({
+    tsConfigFilePath: path.join(targetDir, 'tsconfig.json'),
+  });
+  const tc = project.getTypeChecker().compilerObject;
+  const routerFiles = await loadRouterFiles(project);
+  const routerNodes = collectRouterNodes(project);
+  const resourceConf = routerFiles.jsResource
+    .getVariableDeclarationOrThrow('RESOURCE_CONF')
+    .getInitializerIfKindOrThrow(SyntaxKind.AsExpression)
+    .getExpressionIfKindOrThrow(SyntaxKind.ObjectLiteralExpression);
+  resourceConf.getPropertyOrThrow('noop').remove();
+  for (const {resourceName, sourceFile, symbol} of routerNodes.resources) {
+    const filePath = path.relative(process.cwd(), sourceFile.getFilePath());
+    const moduleSpecifier =
+      routerFiles.jsResource.getRelativePathAsModuleSpecifierTo(
+        sourceFile.getFilePath(),
+      );
+    resourceConf.addPropertyAssignment({
+      name: `"${resourceName}"`,
+      initializer: (writer) => {
+        writer.block(() => {
+          writer
+            .writeLine(`src: "${filePath}",`)
+            .writeLine(
+              `loader: () => import("${moduleSpecifier}").then(m => m.${symbol.getName()})`,
+            );
+        });
+      },
+    });
+    console.log(
+      'Created resource',
+      pc.cyan(resourceName),
+      'for',
+      pc.green(symbol.getName()),
+      'exported from',
+      pc.yellow(filePath),
+    );
+  }
+  const routerConf = routerFiles.router
+    .getVariableDeclarationOrThrow('ROUTER_CONF')
+    .getInitializerIfKindOrThrow(SyntaxKind.AsExpression)
+    .getExpressionIfKindOrThrow(SyntaxKind.ObjectLiteralExpression);
+  routerConf.getPropertyOrThrow('noop').remove();
+  let entryPointImportIndex = 0;
+  for (const {routeName, sourceFile, symbol, params} of routerNodes.routes) {
+    const importAlias = `e${entryPointImportIndex++}`;
+    const filePath = path.relative(process.cwd(), sourceFile.getFilePath());
+    const moduleSpecifier =
+      routerFiles.router.getRelativePathAsModuleSpecifierTo(
+        sourceFile.getFilePath(),
+      );
+    routerFiles.router.addImportDeclaration({
+      moduleSpecifier,
+      namedImports: [
+        {
+          name: symbol.getName(),
+          alias: importAlias,
+        },
+      ],
+    });
+    routerConf.addPropertyAssignment({
+      name: `"${routeName}"`,
+      initializer: (writer) => {
+        writer
+          .write('{')
+          .indent(() => {
+            writer.writeLine(`entrypoint: ${importAlias},`);
+            if (params.size === 0) {
+              writer.writeLine(`schema: z.object({})`);
+            } else {
+              writer.writeLine(`schema: z.object({`);
+              for (const [paramName, paramType] of Array.from(params)) {
+                writer.writeLine(
+                  `  ${paramName}: ${zodSchemaOfType(tc, paramType)},`,
+                );
+              }
+              writer.writeLine('})');
+            }
+          })
+          .write('} as const');
+      },
+    });
+    console.log(
+      'Created route',
+      pc.cyan(routeName),
+      'for',
+      pc.green(symbol.getName()),
+      'exported from',
+      pc.yellow(filePath),
+    );
+  }
+  await Promise.all([
+    routerFiles.jsResource.save(),
+    routerFiles.router.save(),
+    routerFiles.serverRouter.save(),
+  ]);
+}
+main().catch(console.error);

package/templates/js_resource.ts ADDED Viewed

@@ -0,0 +1,55 @@
+import type {JSResourceReference} from 'react-relay/hooks';
+type ResourceConf = typeof RESOURCE_CONF;
+const RESOURCE_CONF = {
+  noop: {src: '', loader: () => Promise.reject()},
+} as const;
+type ModuleId = keyof ResourceConf;
+export type ModuleType<M extends ModuleId> = Awaited<
+  ReturnType<ResourceConf[M]['loader']>
+>;
+export class JSResource<M extends ModuleId>
+  implements JSResourceReference<ModuleType<M>>
+{
+  static srcOfModuleId(id: string): string | null {
+    return RESOURCE_CONF[id as ModuleId].src;
+  }
+  private static readonly resourceCache = new Map<ModuleId, JSResource<any>>();
+  static fromModuleId<M extends ModuleId>(moduleId: M) {
+    if (JSResource.resourceCache.has(moduleId)) {
+      return JSResource.resourceCache.get(moduleId)!;
+    }
+    const resource = new JSResource(moduleId);
+    JSResource.resourceCache.set(moduleId, resource);
+    return resource;
+  }
+  private constructor(private readonly moduleId: M) {}
+  private modulePromiseCache: Promise<ModuleType<M>> | null = null;
+  private moduleCache: ModuleType<M> | null = null;
+  getModuleId(): string {
+    return this.moduleId;
+  }
+  getModuleIfRequired(): ModuleType<M> | null {
+    return this.moduleCache;
+  }
+  async load(): Promise<ModuleType<M>> {
+    if (this.modulePromiseCache == null) {
+      this.modulePromiseCache = RESOURCE_CONF[this.moduleId]
+        .loader()
+        .then((m) => {
+          this.moduleCache = m as ModuleType<M>;
+          return this.moduleCache;
+        });
+    }
+    return await this.modulePromiseCache;
+  }
+}

package/templates/router.tsx ADDED Viewed

@@ -0,0 +1,397 @@
+import {createRouter} from 'radix3';
+import {
+  AnchorHTMLAttributes,
+  createContext,
+  PropsWithChildren,
+  Suspense,
+  useCallback,
+  useContext,
+  useEffect,
+  useMemo,
+  useState,
+} from 'react';
+import {
+  EntryPoint,
+  EntryPointContainer,
+  EnvironmentProviderOptions,
+  IEnvironmentProvider,
+  loadEntryPoint,
+  PreloadedEntryPoint,
+  useEntryPointLoader,
+} from 'react-relay/hooks';
+import {OperationDescriptor, PayloadData} from 'relay-runtime';
+import type {Manifest} from 'vite';
+import * as z from 'zod/v4-mini';
+export type AnyPreloadedEntryPoint = PreloadedEntryPoint<any>;
+export type RouterOps = [OperationDescriptor, PayloadData][];
+type RouterConf = typeof ROUTER_CONF;
+const ROUTER_CONF = {
+  noop: {
+    entrypoint: null! as EntryPoint<any>,
+    schema: z.object({}),
+  },
+} as const;
+export type RouteId = keyof RouterConf;
+export type NavigationDirection = string | URL | ((nextUrl: URL) => void);
+export interface EntryPointParams<R extends RouteId> {
+  params: Record<string, any>;
+  schema: RouterConf[R]['schema'];
+}
+const ROUTER = createRouter<RouterConf[keyof RouterConf]>({
+  routes: ROUTER_CONF,
+});
+class RouterLocation {
+  private constructor(
+    readonly pathname: string,
+    readonly searchParams: URLSearchParams,
+    readonly method?: 'push' | 'replace' | 'popstate',
+  ) {}
+  href() {
+    if (this.searchParams.size > 0) {
+      return this.pathname + '?' + this.searchParams.toString();
+    }
+    return this.pathname;
+  }
+  route() {
+    return ROUTER.lookup(this.pathname);
+  }
+  params() {
+    const matchedRoute = this.route();
+    const params = {
+      ...matchedRoute?.params,
+      ...Object.fromEntries(this.searchParams),
+    };
+    if (matchedRoute?.schema) {
+      return matchedRoute.schema.parse(params);
+    } else {
+      return params;
+    }
+  }
+  static parse(path: string, method?: 'push' | 'replace' | 'popstate') {
+    if (path.startsWith('/')) {
+      path = 'router:' + path;
+    }
+    try {
+      const nextUrl = new URL(path);
+      return new RouterLocation(nextUrl.pathname, nextUrl.searchParams, method);
+    } catch (_e) {
+      return new RouterLocation(path, new URLSearchParams(), method);
+    }
+  }
+}
+function useLocation(initialPath?: string) {
+  const [location, setLocation] = useState((): RouterLocation => {
+    return RouterLocation.parse(initialPath ?? window.location.href);
+  });
+  useEffect(() => {
+    function listener(e: PopStateEvent) {
+      setLocation(RouterLocation.parse(window.location.href, 'popstate'));
+    }
+    window.addEventListener('popstate', listener);
+    return () => {
+      window.removeEventListener('popstate', listener);
+    };
+  }, []);
+  useEffect(() => {
+    if (location.method === 'push') {
+      window.history.pushState({}, '', location.href());
+      window.scrollTo(0, 0);
+    } else if (location.method === 'replace') {
+      window.history.replaceState({}, '', location.href());
+    }
+  }, [location]);
+  return [location, setLocation] as const;
+}
+export function router__hydrateStore(
+  provider: IEnvironmentProvider<EnvironmentProviderOptions>,
+) {
+  const env = provider.getEnvironment(null);
+  if ('__router_ops' in window) {
+    const ops = (window as any).__router_ops as RouterOps;
+    for (const [op, payload] of ops) {
+      env.commitPayload(op, payload);
+    }
+  }
+}
+export async function router__loadEntryPoint(
+  provider: IEnvironmentProvider<EnvironmentProviderOptions>,
+  initialPath?: string,
+) {
+  if (!initialPath) initialPath = window.location.href;
+  const initialLocation = RouterLocation.parse(initialPath);
+  const initialRoute = initialLocation.route();
+  if (!initialRoute) return null;
+  await initialRoute.entrypoint?.root.load();
+  return loadEntryPoint(provider, initialRoute.entrypoint, {
+    params: initialLocation.params(),
+    schema: initialRoute.schema,
+  });
+}
+interface RouterContextValue {
+  location: RouterLocation;
+  setLocation: React.Dispatch<React.SetStateAction<RouterLocation>>;
+}
+const RouterContext = createContext<RouterContextValue>({
+  location: RouterLocation.parse('/'),
+  setLocation: () => {},
+});
+export function router__createAppFromEntryPoint(
+  provider: IEnvironmentProvider<EnvironmentProviderOptions>,
+  initialEntryPoint: AnyPreloadedEntryPoint | null,
+  initialPath?: string,
+) {
+  function RouterApp() {
+    const [location, setLocation] = useLocation(initialPath);
+    const routerContextValue = useMemo(
+      (): RouterContextValue => ({
+        location,
+        setLocation,
+      }),
+      [location, setLocation],
+    );
+    const [entryPointRef, loadEntryPointRef, _dispose] = useEntryPointLoader(
+      provider,
+      location.route()?.entrypoint,
+    );
+    useEffect(() => {
+      const schema = location.route()?.schema;
+      if (schema) {
+        loadEntryPointRef({
+          params: location.params(),
+          schema,
+        });
+      }
+      // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [location]);
+    const entryPoint = entryPointRef ?? initialEntryPoint;
+    if (entryPoint == null) return null;
+    return (
+      <RouterContext value={routerContextValue}>
+        {'fallback' in entryPoint.entryPoints ? (
+          <Suspense
+            fallback={
+              <EntryPointContainer
+                entryPointReference={entryPoint.entryPoints.fallback}
+                props={{}}
+              />
+            }
+          >
+            <EntryPointContainer entryPointReference={entryPoint} props={{}} />
+          </Suspense>
+        ) : (
+          <EntryPointContainer entryPointReference={entryPoint} props={{}} />
+        )}
+      </RouterContext>
+    );
+  }
+  RouterApp.bootstrap = (manifest?: Manifest): string | null => null;
+  return RouterApp;
+}
+export async function createRouterApp(
+  provider: IEnvironmentProvider<EnvironmentProviderOptions>,
+) {
+  router__hydrateStore(provider);
+  const ep = await router__loadEntryPoint(provider);
+  return router__createAppFromEntryPoint(provider, ep);
+}
+export function usePath() {
+  const {location} = useContext(RouterContext);
+  return location.pathname;
+}
+export function useRouteParams<R extends RouteId>(
+  routeId: R,
+): z.infer<RouterConf[R]['schema']> {
+  const schema = ROUTER_CONF[routeId].schema;
+  const {location} = useContext(RouterContext);
+  return schema.parse(location.params()) as z.infer<RouterConf[R]['schema']>;
+}
+function router__createPathForRoute(
+  routeId: RouteId,
+  inputParams: Record<string, any>,
+): string {
+  const schema = ROUTER_CONF[routeId].schema;
+  const params = schema.parse(inputParams);
+  let pathname = routeId as string;
+  const searchParams = new URLSearchParams();
+  Object.entries(params).forEach(([key, value]) => {
+    if (value != null) {
+      const paramPattern = `:${key}`;
+      if (pathname.includes(paramPattern)) {
+        pathname = pathname.replace(
+          paramPattern,
+          encodeURIComponent(String(value)),
+        );
+      } else {
+        searchParams.set(key, String(value));
+      }
+    }
+  });
+  if (searchParams.size > 0) {
+    return pathname + '?' + searchParams.toString();
+  } else {
+    return pathname;
+  }
+}
+function router__evaluateNavigationDirection(nav: NavigationDirection) {
+  let nextUrl: URL;
+  if (typeof nav === 'string') {
+    nextUrl = new URL(nav, window.location.origin);
+  } else if (nav instanceof URL) {
+    nextUrl = nav;
+  } else {
+    nextUrl = new URL(window.location.href);
+    nav(nextUrl);
+  }
+  if (window.location.origin !== nextUrl.origin) {
+    throw new Error('Cannot navigate to a different origin.');
+  }
+  if (nextUrl.searchParams.size > 0) {
+    return nextUrl.pathname + '?' + nextUrl.searchParams.toString();
+  } else {
+    return nextUrl.pathname;
+  }
+}
+export function useNavigation() {
+  const {setLocation} = useContext(RouterContext);
+  return useMemo(() => {
+    function push(nav: NavigationDirection) {
+      setLocation(
+        RouterLocation.parse(router__evaluateNavigationDirection(nav), 'push'),
+      );
+    }
+    function replace(nav: NavigationDirection) {
+      setLocation(
+        RouterLocation.parse(
+          router__evaluateNavigationDirection(nav),
+          'replace',
+        ),
+      );
+    }
+    function pushRoute<R extends RouteId>(
+      routeId: R,
+      params: z.input<RouterConf[R]['schema']>,
+    ) {
+      setLocation(
+        RouterLocation.parse(
+          router__createPathForRoute(routeId, params),
+          'push',
+        ),
+      );
+    }
+    function replaceRoute<R extends RouteId>(
+      routeId: R,
+      params: z.input<RouterConf[R]['schema']>,
+    ) {
+      setLocation((prevLoc) =>
+        RouterLocation.parse(
+          router__createPathForRoute(routeId, {...prevLoc.params(), ...params}),
+          'replace',
+        ),
+      );
+    }
+    return {push, replace, pushRoute, replaceRoute} as const;
+  }, [setLocation]);
+}
+export function Link({
+  href,
+  target,
+  onClick,
+  ...props
+}: AnchorHTMLAttributes<HTMLAnchorElement>) {
+  const {push} = useNavigation();
+  const handleClick = useCallback(
+    (e: React.MouseEvent<HTMLAnchorElement, MouseEvent>) => {
+      onClick?.(e);
+      if (e.defaultPrevented || !href) return;
+      // See https://github.com/remix-run/react-router/blob/main/packages/react-router/lib/dom/dom.ts#L34
+      const shouldHandle =
+        e.button === 0 &&
+        (!target || target === '_self') &&
+        !(e.metaKey || e.altKey || e.ctrlKey || e.shiftKey);
+      if (!shouldHandle) return;
+      const destination = new URL(href, window.location.href);
+      if (destination.origin !== window.location.origin) return;
+      e.preventDefault();
+      push(destination);
+    },
+    [push, href, target, onClick],
+  );
+  return <a {...props} href={href} target={target} onClick={handleClick} />;
+}
+export interface LinkProps<R extends RouteId>
+  extends AnchorHTMLAttributes<HTMLAnchorElement> {
+  route: R;
+  params: z.input<RouterConf[R]['schema']>;
+  href?: never;
+}
+export function RouteLink<R extends RouteId>({
+  route,
+  params,
+  ...props
+}: PropsWithChildren<LinkProps<R>>) {
+  const href = useMemo(
+    () => router__createPathForRoute(route, params).toString(),
+    [params, route],
+  );
+  return <Link {...props} href={href} />;
+}
+export function listRoutes() {
+  return Object.keys(ROUTER_CONF);
+}

package/templates/server_router.ts ADDED Viewed

@@ -0,0 +1,112 @@
+import {
+  EnvironmentProviderOptions,
+  IEnvironmentProvider,
+  OperationDescriptor,
+  PreloadedQuery,
+} from 'react-relay/hooks';
+import {
+  createOperationDescriptor,
+  GraphQLResponse,
+  GraphQLSingularResponse,
+  OperationType,
+  PayloadData,
+  PreloadableQueryRegistry,
+} from 'relay-runtime';
+import serialize from 'serialize-javascript';
+import type {Manifest} from 'vite';
+import {JSResource} from './js_resource';
+import {
+  AnyPreloadedEntryPoint,
+  router__createAppFromEntryPoint,
+  router__loadEntryPoint,
+  RouterOps,
+} from './router';
+type AnyPreloadedQuery = PreloadedQuery<OperationType>;
+function router__bootstrapScripts(
+  entryPoint: AnyPreloadedEntryPoint,
+  ops: RouterOps,
+  manifest?: Manifest,
+) {
+  let bootstrap = `
+      <script type="text/javascript">
+        window.__router_ops = ${serialize(ops)};
+      </script>`;
+  const rootModuleSrc = JSResource.srcOfModuleId(entryPoint.rootModuleID);
+  if (rootModuleSrc == null) return bootstrap;
+  function crawlImports(moduleName: string) {
+    const chunk = manifest?.[moduleName];
+    if (!chunk) return;
+    chunk.imports?.forEach(crawlImports);
+    bootstrap =
+      `<link rel="modulepreload" href="${chunk.file}" />\n` + bootstrap;
+  }
+  crawlImports(rootModuleSrc);
+  return bootstrap;
+}
+async function router__ensureQueryFlushed(
+  query: AnyPreloadedQuery,
+): Promise<GraphQLResponse> {
+  return new Promise((resolve, reject) => {
+    if (query.source == null) {
+      resolve({data: {}});
+    } else {
+      query.source.subscribe({
+        next: resolve,
+        error: reject,
+      });
+    }
+  });
+}
+async function router__loadQueries(entryPoint: AnyPreloadedEntryPoint) {
+  const preloadedQueryOps: [OperationDescriptor, PayloadData][] = [];
+  for (const query of Object.values(
+    entryPoint?.queries ?? {},
+  ) as PreloadedQuery<OperationType>[]) {
+    try {
+      const payload = await router__ensureQueryFlushed(query);
+      const concreteRequest =
+        query.id == null ? null : PreloadableQueryRegistry.get(query.id);
+      if (concreteRequest != null) {
+        const desc = createOperationDescriptor(
+          concreteRequest,
+          query.variables,
+        );
+        preloadedQueryOps.push([
+          desc,
+          (payload as GraphQLSingularResponse).data!,
+        ]);
+      }
+    } catch (e) {
+      console.error(e);
+      throw e;
+    }
+  }
+  return preloadedQueryOps;
+}
+export async function createRouterServerApp(
+  provider: IEnvironmentProvider<EnvironmentProviderOptions>,
+  initialPath: string,
+) {
+  const ep = await router__loadEntryPoint(provider, initialPath);
+  const ops = ep != null ? await router__loadQueries(ep) : [];
+  const RouterApp = router__createAppFromEntryPoint(provider, ep, initialPath);
+  if (ep != null) {
+    RouterApp.bootstrap = (manifest) =>
+      router__bootstrapScripts(ep, ops, manifest);
+  }
+  return RouterApp;
+}

package/tsconfig.json ADDED Viewed

@@ -0,0 +1,18 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "allowSyntheticDefaultImports": true,
+    "esModuleInterop": true,
+    "strict": false,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "downlevelIteration": true,
+    "types": ["node"],
+    "lib": ["ES2022"],
+    "noEmit": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}