evolit 0.2.1 → 0.4.0

package/src/deployment-runtime.js

@@ -41,12 +41,19 @@ import {
 } from "./response-cache.js";
 import { createSsrAdapter, renderRouteTreeWithAdapter } from "./ssr-adapter.js";
 import { createNavigationResponseFromDocument } from "./route-segments.js";
-import { appendSsrUrqlData, runWithOptionalSsrUrqlScope } from "./urql-ssr.js";
+import {
+  appendSsrUrqlData,
+  applySsrUrqlRequestContext,
+  createSsrUrqlRequestContext,
+  runWithOptionalSsrUrqlScope,
+} from "./urql-ssr.js";
 import {
   getExtensionClientDescriptors,
   resolveEvolitExtensions,
   runRequestExtensions,
 } from "./extensions.js";
+import { runServerSetup } from "./server-setup.js";
+import { createLitsxPipeline, mergeLitsxAssetsIntoManifest } from "./litsx-pipeline.js";
 
 function isBarePackageModuleId(value) {
   return typeof value === "string"
@@ -253,6 +260,7 @@ export async function createRequestRenderer({
   onDevelopmentEvent,
   managedSourceRoots,
   extensions = [],
+  litsxPipeline = null,
 }) {
   let currentAssetManifest = normalizeClientAssetManifest(assetManifest);
   const extensionClientDescriptors = getExtensionClientDescriptors(extensions);
@@ -319,7 +327,11 @@ export async function createRequestRenderer({
   function getDevelopmentEntryInventory(entryPath) {
     let inventory = devInventoryByEntry.get(entryPath);
     if (!inventory) {
-      inventory = collectClientGraphInventory([entryPath], { projectRoot, managedSourceRoots });
+      inventory = collectClientGraphInventory([entryPath], {
+        projectRoot,
+        managedSourceRoots,
+        litsxPipeline,
+      });
       devInventoryByEntry.set(entryPath, inventory);
       inventory.catch(() => {
         if (devInventoryByEntry.get(entryPath) === inventory) devInventoryByEntry.delete(entryPath);
@@ -331,6 +343,7 @@ export async function createRequestRenderer({
     const resolver = await createRouteResolver(projectRoot, mode, {
       onDevelopmentEvent,
       managedSourceRoots,
+      litsxPipeline,
       segmentRenderCache: sharedSegmentRenderCache,
       getStaticAssetPublicUrls() {
         return createStaticAssetPublicUrlMap(currentAssetManifest);
@@ -353,6 +366,7 @@ export async function createRequestRenderer({
       target: "client",
       onDevelopmentEvent,
       managedSourceRoots,
+      litsxPipeline,
     });
     devPreparedClientModules.add(clientModuleKey);
     devClientModuleDependencies.set(
@@ -381,7 +395,13 @@ export async function createRequestRenderer({
       clientBoundariesByEntry: devClientBoundariesByEntry,
       additionalVendorSpecifiers: [...packageClientSpecifiers],
     });
-    currentAssetManifest = bundledClientAssets.manifest;
+    const integrationOutputs = await litsxPipeline?.finalize({
+      assetManifest: bundledClientAssets.manifest,
+    });
+    currentAssetManifest = mergeLitsxAssetsIntoManifest(
+      bundledClientAssets.manifest,
+      integrationOutputs,
+    );
     devPreviousAssetOutputPaths = new Set();
     currentAssetResolver = createAssetResolver(projectRoot, {
       assetManifest: currentAssetManifest,
@@ -619,6 +639,7 @@ export async function createRequestRenderer({
         : [];
       const styleUrls = currentAssetManifest
         ? [...new Set([
+          ...(currentAssetManifest.documentStyles ?? []),
           ...collectTransitiveStyleUrls(clientImports, currentAssetManifest),
           ...resolveServerStyleUrls(routeResult, projectRoot, currentAssetManifest),
         ])]
@@ -851,6 +872,7 @@ export async function createRequestRenderer({
             target: "client",
             onDevelopmentEvent,
             managedSourceRoots,
+            litsxPipeline,
           });
         }
         return;
@@ -882,7 +904,8 @@ export async function createRequestRenderer({
       return effectiveRouteResolver.resolveRoutePolicy(request, options);
     },
     async renderRoute(request, routePolicyResult = null, options = {}) {
-      return runWithOptionalSsrUrqlScope(async (urqlAdapter) => {
+      const urqlRequestContext = createSsrUrqlRequestContext(request);
+      return runWithOptionalSsrUrqlScope(urqlRequestContext, async (urqlAdapter) => {
         const shouldPrepareBeforeResolve = mode === "development" && !currentAssetManifest;
         let resolvedRoutePolicyResult = routePolicyResult;
         if (shouldPrepareBeforeResolve) {
@@ -895,9 +918,14 @@ export async function createRequestRenderer({
           await this.prepareRouteClientArtifacts(routeResult);
         }
         const renderedResponse = await renderRouteTreeWithAdapter(routeResult, ssrAdapter);
-        const response = urqlAdapter
+        const responseWithData = urqlAdapter
           ? appendSsrUrqlData(renderedResponse, await urqlAdapter.getUrqlSsrData())
           : renderedResponse;
+        const response = applySsrUrqlRequestContext(
+          routeResult,
+          responseWithData,
+          urqlRequestContext,
+        );
         return {
           routeResult,
           response,
@@ -921,8 +949,13 @@ export async function createDeploymentRuntime({
   routeResolver,
   onDevelopmentEvent,
   managedSourceRoots,
+  evolitConfig: configuredEvolitConfig,
 } = {}) {
-  const evolitConfig = await loadEvolitConfig(projectRoot);
+  const evolitConfig = configuredEvolitConfig ?? await loadEvolitConfig(projectRoot);
+  const litsxPipeline = await createLitsxPipeline({ projectRoot, mode, config: evolitConfig });
+  let serverSetupCleanup = null;
+  try {
+  serverSetupCleanup = await runServerSetup({ projectRoot, mode, evolitConfig, litsxPipeline });
   const extensions = resolveEvolitExtensions(evolitConfig);
   const extensionClientSpecifiers = getExtensionClientDescriptors(extensions).map((descriptor) => descriptor.module);
   const effectiveManagedSourceRoots = managedSourceRoots
@@ -980,18 +1013,26 @@ export async function createDeploymentRuntime({
     onDevelopmentEvent,
     managedSourceRoots: effectiveManagedSourceRoots,
     extensions,
+    litsxPipeline,
   });
+  let closed = false;
 
   return {
     assets,
     cache: renderer.responseCacheController,
     renderer,
+    get litsxDependencies() {
+      return litsxPipeline?.dependencies ?? [];
+    },
     async invalidateDevelopmentState(changedPaths = null) {
       if (mode !== "development") {
         return;
       }
 
-      const invalidationResult = await renderer.invalidateDevelopmentState(changedPaths);
+      const litsxInvalidated = await litsxPipeline?.invalidate(changedPaths);
+      const invalidationResult = await renderer.invalidateDevelopmentState(
+        litsxInvalidated ? null : changedPaths,
+      );
       if (typeof effectiveResponseCacheRuntime.store.clear === "function") {
         await effectiveResponseCacheRuntime.store.clear();
       }
@@ -1061,6 +1102,7 @@ export async function createDeploymentRuntime({
       const { routeResult, response } = await renderer.renderRoute(resolvedRequest, routePolicyResult, {
         extensionState: extensionResult,
       });
+      await litsxPipeline?.finalize({ routeResult, assetManifest: renderer.assetManifest });
       runtimeState.assetManifest = normalizeClientAssetManifest(renderer.assetManifest);
       return formatResponseForRequest(
         request,
@@ -1068,12 +1110,39 @@ export async function createDeploymentRuntime({
       );
     },
     async close() {
+      if (closed) return;
+      closed = true;
+      let cleanupError = null;
       const revalidationTasks = this.revalidationTasks;
       if (revalidationTasks) {
-        await Promise.all(revalidationTasks.values());
+        try {
+          await Promise.all(revalidationTasks.values());
+        } catch (error) {
+          cleanupError = error;
+        }
+      }
+      try {
+        await serverSetupCleanup?.();
+      } catch (error) {
+        cleanupError = error;
       }
+      try {
+        await litsxPipeline?.dispose();
+      } catch (error) {
+        cleanupError ??= error;
+      }
+      if (cleanupError) throw cleanupError;
     },
   };
+  } catch (error) {
+    try {
+      await serverSetupCleanup?.();
+    } catch {}
+    try {
+      await litsxPipeline?.dispose();
+    } catch {}
+    throw error;
+  }
 }
 
 function addNavigationVaryHeader(response) {

package/src/index.js

@@ -124,6 +124,9 @@ export { getRequestContext } from "./request-context.js";
 /** Defines an Evolit extension for use in evolit.config.js. */
 export { defineEvolitPlugin } from "./extensions.js";
 
+/** Defines a typed Evolit configuration, including the native LitSX pipeline. */
+export { defineEvolitConfig, defineLitsxIntegration } from "./litsx-pipeline.js";
+
 /**
  * Returns the incoming request URL. Reading it makes the current route dynamic.
  *

package/src/litsx-pipeline.d.ts

@@ -0,0 +1,137 @@
+import type {
+  TransformLitsxOptions,
+  TransformLitsxResult,
+} from "@litsx/compiler";
+
+export type EvolitMode = "development" | "production";
+export type EvolitLitsxTarget = "server" | "client";
+
+export type EvolitLitsxCompilerOptions = Omit<
+  TransformLitsxOptions,
+  "filename" | "ssr" | "reactCompat"
+> & {
+  /** Evolit always uses native LitSX lowering. */
+  reactCompat?: false;
+};
+
+export type EvolitLitsxOutput = {
+  id: string;
+  kind: "asset" | "module" | "style";
+  content: string | Uint8Array;
+  specifier?: string;
+  document?: boolean;
+};
+
+export type EvolitLitsxContribution = Partial<TransformLitsxResult> & {
+  dependencies?: string[];
+  outputs?: EvolitLitsxOutput[];
+};
+
+export type EvolitLitsxIntegrationContext = {
+  readonly projectRoot: string;
+  readonly mode: EvolitMode;
+  readonly identity: Readonly<{ id: string }>;
+};
+
+export type EvolitLitsxModuleContext = {
+  readonly sourcePath: string;
+  readonly source: string;
+  readonly target: EvolitLitsxTarget;
+  readonly ssr: boolean;
+  readonly sourceMaps: boolean;
+  readonly generation: number;
+  readonly result: TransformLitsxResult;
+};
+
+export type EvolitLitsxIntegrationInstance = {
+  compiler?: EvolitLitsxCompilerOptions | ((context: {
+    filename: string;
+    ssr: boolean;
+    sourceMaps: boolean;
+    mode: EvolitMode;
+  }) => EvolitLitsxCompilerOptions);
+  resolveModule?(context: Readonly<{
+    specifier: string;
+    importer: string;
+    target: EvolitLitsxTarget;
+    ssr: boolean;
+    sourceMaps: boolean;
+    generation: number;
+    mode: EvolitMode;
+  }>): null | void | {
+    code: string;
+    map?: unknown;
+    dependencies?: string[];
+  } | Promise<null | void | {
+    code: string;
+    map?: unknown;
+    dependencies?: string[];
+  }>;
+  processModule?(context: EvolitLitsxModuleContext): EvolitLitsxContribution | void | Promise<EvolitLitsxContribution | void>;
+  finalize?(context: Readonly<Record<string, unknown> & {
+    generation: number;
+    mode: EvolitMode;
+  }>): EvolitLitsxContribution | void | Promise<EvolitLitsxContribution | void>;
+  invalidate?(context: Readonly<{
+    paths: string[] | null;
+    affected: boolean;
+    generation: number;
+    mode: EvolitMode;
+  }>): void | Promise<void>;
+  forget?(context: Readonly<{
+    moduleId: string;
+    generation: number;
+    mode: EvolitMode;
+  }>): void | Promise<void>;
+  dispose?(): void | Promise<void>;
+};
+
+export type EvolitLitsxIntegration = {
+  readonly name: string;
+  create(context: EvolitLitsxIntegrationContext): EvolitLitsxIntegrationInstance | Promise<EvolitLitsxIntegrationInstance>;
+};
+
+export type EvolitLitsxConfig = {
+  compiler?: EvolitLitsxCompilerOptions;
+  integrations?: EvolitLitsxIntegration[];
+};
+
+export type EvolitConfig = {
+  litsx?: EvolitLitsxConfig;
+  [key: string]: unknown;
+};
+
+export type EvolitLitsxPipeline = {
+  readonly identity: Readonly<{ id: string }>;
+  readonly generation: number;
+  readonly dependencies: string[];
+  getCompilerOptions(context: { filename: string; ssr: boolean; sourceMaps: boolean }): TransformLitsxOptions;
+  resolveModule(specifier: string, context: {
+    importer: string;
+    target: EvolitLitsxTarget;
+    ssr: boolean;
+    sourceMaps: boolean;
+  }): Promise<string | null>;
+  registerResolvedModule(specifier: string, sourcePath: string, outputPath: string): void;
+  processModule(result: TransformLitsxResult, context: Omit<EvolitLitsxModuleContext, "result" | "generation">): Promise<TransformLitsxResult & { evolitDependencies: string[] }>;
+  finalize(context?: Record<string, unknown>): Promise<null | {
+    assets: Array<{ integration: string; id: string; kind: string; outputPath: string; hash: string; size: number }>;
+    documentStyles: Array<{ integration: string; id: string; kind: string; outputPath: string; hash: string; size: number }>;
+  }>;
+  invalidate(changedPaths?: string[] | null): Promise<boolean>;
+  forget(moduleId: string): Promise<void>;
+  dispose(): Promise<void>;
+};
+
+export function createLitsxPipeline(options: {
+  projectRoot: string;
+  mode: EvolitMode;
+  config?: EvolitConfig;
+}): Promise<EvolitLitsxPipeline | null>;
+
+export function defineEvolitConfig<T extends EvolitConfig>(config: T): T;
+export function defineLitsxIntegration<T extends EvolitLitsxIntegration>(integration: T): T;
+export function mergeLitsxAssetsIntoManifest<T extends Record<string, unknown>>(
+  manifest: T,
+  integrationManifest: Awaited<ReturnType<EvolitLitsxPipeline["finalize"]>>,
+): T;