pastoria 1.0.11 → 1.0.13

package/src/build.ts

@@ -1,206 +1,306 @@
-import tailwindcss from '@tailwindcss/vite';
-import react from '@vitejs/plugin-react';
-import {access} from 'node:fs/promises';
-import * as path from 'node:path';
+import ParcelWatcher, {getEventsSince, writeSnapshot} from '@parcel/watcher';
+import {spawn} from 'node:child_process';
+import {access, readFile} from 'node:fs/promises';
+import path from 'node:path';
+import {IndentationText, Project} from 'ts-morph';
+import {build} from 'vite';
 import {
-  build,
-  InlineConfig,
-  type BuildEnvironmentOptions,
-  type Plugin,
-} from 'vite';
-import {cjsInterop} from 'vite-plugin-cjs-interop';
-
-interface PastoriaCapabilities {
-  hasAppRoot: boolean;
-  hasServerHandler: boolean;
+  generatePastoriaArtifacts,
+  generatePastoriaExports,
+  PASTORIA_TAG_REGEX,
+  PastoriaMetadata,
+} from './generate.js';
+import {logger, logInfo} from './logger.js';
+import {CLIENT_BUILD, createBuildConfig, SERVER_BUILD} from './vite_plugin.js';
+
+enum PastoriaMakePhase {
+  PASTORIA_EXPORTS,
+  PASTORIA_ARTIFACTS,
+  RELAY,
+  GRATS,
 }
 
-function generateClientEntry({hasAppRoot}: PastoriaCapabilities): string {
-  const appImport = hasAppRoot
-    ? `import {App} from '#genfiles/router/app_root';`
-    : '';
-  const appValue = hasAppRoot ? 'App' : 'null';
+const ALL_MAKE_PHASES = new Set([
+  PastoriaMakePhase.PASTORIA_EXPORTS,
+  PastoriaMakePhase.PASTORIA_ARTIFACTS,
+  PastoriaMakePhase.RELAY,
+  PastoriaMakePhase.GRATS,
+]);
+
+const SNAPSHOT_PATH = '.pastoriainfo';
 
-  return `// Generated by Pastoria.
-import {createRouterApp} from '#genfiles/router/router';
-${appImport}
-import {hydrateRoot} from 'react-dom/client';
+async function runCommand(command: string, args: string[]): Promise<void> {
+  return new Promise((resolve, reject) => {
+    const child = spawn(command, args, {
+      cwd: process.cwd(),
+      stdio: 'inherit', // Stream output to terminal
+      shell: true,
+    });
 
-async function main() {
-  const RouterApp = await createRouterApp();
-  hydrateRoot(document, <RouterApp App={${appValue}} />);
+    child.on('exit', (code) => {
+      if (code === 0) {
+        resolve();
+      } else {
+        reject(new Error(`Command failed with exit code ${code}`));
+      }
+    });
+
+    child.on('error', reject);
+  });
 }
 
-main();
-`;
+async function runGratsCompiler(): Promise<void> {
+  const gratsPath = path.join(process.cwd(), 'node_modules', '.bin', 'grats');
+  await runCommand(gratsPath, []);
 }
 
-function generateServerEntry({
-  hasAppRoot,
-  hasServerHandler,
-}: PastoriaCapabilities): string {
-  const appImport = hasAppRoot
-    ? `import {App} from '#genfiles/router/app_root';`
-    : '';
-  const appValue = hasAppRoot ? 'App' : 'null';
-
-  const serverHandlerImport = hasServerHandler
-    ? `import {router as serverHandler} from '#genfiles/router/server_handler';`
-    : '';
-  const serverHandlerUse = hasServerHandler
-    ? '  router.use(serverHandler)'
-    : '';
-
-  return `// Generated by Pastoria.
-import {JSResource} from '#genfiles/router/js_resource';
-import {
-  listRoutes,
-  router__createAppFromEntryPoint,
-  router__loadEntryPoint,
-} from '#genfiles/router/router';
-import {getSchema} from '#genfiles/schema/schema';
-import {Context} from '#genfiles/router/context';
-${appImport}
-${serverHandlerImport}
-import express from 'express';
-import {GraphQLSchema, specifiedDirectives} from 'graphql';
-import {PastoriaConfig} from 'pastoria-config';
-import {createRouterHandler} from 'pastoria-runtime/server';
-import type {Manifest} from 'vite';
-
-const schemaConfig = getSchema().toConfig();
-const schema = new GraphQLSchema({
-  ...schemaConfig,
-  directives: [...specifiedDirectives, ...schemaConfig.directives],
-});
-
-export function createHandler(
-  persistedQueries: Record<string, string>,
-  config: Required<PastoriaConfig>,
-  manifest?: Manifest,
-) {
-  const routeHandler = createRouterHandler(
-    listRoutes(),
-    JSResource.srcOfModuleId,
-    router__loadEntryPoint,
-    router__createAppFromEntryPoint,
-    ${appValue},
-    schema,
-    (req) => Context.createFromRequest(req),
-    persistedQueries,
-    config,
-    manifest,
+async function runRelayCompiler(): Promise<void> {
+  const relayPath = path.join(
+    process.cwd(),
+    'node_modules',
+    '.bin',
+    'relay-compiler',
   );
+  await runCommand(relayPath, []);
+}
 
-  const router = express.Router();
-  router.use(routeHandler);
-  ${serverHandlerUse}
+function fileMatchesPastoriaTags(filePath: string, content: string): boolean {
+  // Skip generated files
+  if (filePath.includes('__generated__')) {
+    return false;
+  }
+  return PASTORIA_TAG_REGEX.test(content);
+}
 
-  return router;
+function fileMatchesGratsTags(filePath: string, content: string): boolean {
+  // Skip generated files
+  if (filePath.includes('__generated__')) {
+    return false;
+  }
+  // Match any Grats JSDoc tag
+  return /@gql\w+/.test(content);
 }
-`;
+
+function fileMatchesRelayImports(filePath: string, content: string): boolean {
+  // Skip generated files
+  if (filePath.includes('__generated__')) {
+    return false;
+  }
+  return (
+    /import\s+.*\s+from\s+['"]react-relay['"]/.test(content) ||
+    /import\s+.*\s+from\s+['"]relay-runtime['"]/.test(content)
+  );
 }
 
-async function determineCapabilities(): Promise<PastoriaCapabilities> {
-  const capabilities: PastoriaCapabilities = {
-    hasAppRoot: false,
-    hasServerHandler: false,
-  };
+async function requiredMakePhasesForChanges(
+  events: Array<{type: string; path: string}>,
+): Promise<Set<PastoriaMakePhase>> {
+  let makePhases = new Set<PastoriaMakePhase>();
 
-  async function hasAppRoot() {
-    try {
-      await access('__generated__/router/app_root.ts');
-      capabilities.hasAppRoot = true;
-    } catch {}
-  }
+  await Promise.all(
+    events.map(async (event) => {
+      const filePath = event.path;
 
-  async function hasServerHandler() {
-    try {
-      await access('__generated__/router/server_handler.ts');
-      capabilities.hasServerHandler = true;
-    } catch {}
+      // Skip non-TypeScript/TSX files
+      if (!filePath.match(/\.(ts|tsx)$/)) {
+        return;
+      }
+
+      // For delete events, we can't read content, so assume it might affect all pipelines
+      if (event.type === 'delete') {
+        makePhases = ALL_MAKE_PHASES;
+        return;
+      }
+
+      // Read file content for create/update events
+      try {
+        const content = await readFile(filePath, 'utf-8');
+
+        if (fileMatchesPastoriaTags(filePath, content)) {
+          makePhases.add(PastoriaMakePhase.PASTORIA_EXPORTS);
+          makePhases.add(PastoriaMakePhase.PASTORIA_ARTIFACTS);
+        }
+
+        if (fileMatchesGratsTags(filePath, content)) {
+          makePhases.add(PastoriaMakePhase.GRATS);
+          makePhases.add(PastoriaMakePhase.RELAY); // Relay depends on Grats schema
+        }
+
+        if (fileMatchesRelayImports(filePath, content)) {
+          makePhases.add(PastoriaMakePhase.RELAY);
+        }
+      } catch {
+        // If we can't read the file, assume it might affect all pipelines
+        makePhases = ALL_MAKE_PHASES;
+      }
+    }),
+  );
+
+  return makePhases;
+}
+
+function requiredMakePhasesForArgs(steps: string[]): Set<PastoriaMakePhase> {
+  const validSteps = new Set(['schema', 'relay', 'router']);
+  const needs = new Set<PastoriaMakePhase>();
+
+  for (const step of steps) {
+    if (!validSteps.has(step)) {
+      throw new Error(
+        `Invalid build step: ${step}. Valid steps are: schema, relay, router`,
+      );
+    }
+
+    switch (step) {
+      case 'schema':
+        needs.add(PastoriaMakePhase.GRATS);
+        break;
+      case 'relay':
+        needs.add(PastoriaMakePhase.RELAY);
+
+        break;
+      case 'router':
+        needs.add(PastoriaMakePhase.PASTORIA_EXPORTS);
+        needs.add(PastoriaMakePhase.PASTORIA_ARTIFACTS);
+        break;
+    }
   }
 
-  await Promise.all([hasAppRoot(), hasServerHandler()]);
-  return capabilities;
+  return needs;
 }
 
-function pastoriaEntryPlugin(): Plugin {
-  const clientEntryModuleId = 'virtual:pastoria-entry-client.tsx';
-  const serverEntryModuleId = 'virtual:pastoria-entry-server.tsx';
-
-  return {
-    name: 'pastoria-entry',
-    resolveId(id) {
-      if (id === clientEntryModuleId) {
-        return clientEntryModuleId; // Return without \0 prefix so React plugin can see .tsx extension
-      } else if (id === serverEntryModuleId) {
-        return serverEntryModuleId;
-      }
-    },
-    async load(id) {
-      const capabilities = await determineCapabilities();
-      if (id === clientEntryModuleId) {
-        return generateClientEntry(capabilities);
-      } else if (id === serverEntryModuleId) {
-        return generateServerEntry(capabilities);
-      }
-    },
-  };
+async function executeBuildSteps(
+  project: Project,
+  needs: Set<PastoriaMakePhase>,
+): Promise<boolean> {
+  let rebuiltAnything = false;
+  let cachedMetadata: PastoriaMetadata | undefined = undefined;
+
+  if (needs.has(PastoriaMakePhase.PASTORIA_EXPORTS)) {
+    logInfo('Running Pastoria exports generation...');
+    cachedMetadata = await generatePastoriaExports(project);
+    rebuiltAnything = true;
+  }
+
+  if (needs.has(PastoriaMakePhase.GRATS)) {
+    logInfo('Running Grats compiler...');
+    await runGratsCompiler();
+    rebuiltAnything = true;
+  }
+
+  if (needs.has(PastoriaMakePhase.RELAY)) {
+    logInfo('Running Relay compiler...');
+    await runRelayCompiler();
+    rebuiltAnything = true;
+  }
+
+  if (needs.has(PastoriaMakePhase.PASTORIA_ARTIFACTS)) {
+    logInfo('Running Pastoria artifacts generation...');
+    await generatePastoriaArtifacts(project, cachedMetadata);
+    rebuiltAnything = true;
+  }
+
+  return rebuiltAnything;
 }
 
-export const CLIENT_BUILD: BuildEnvironmentOptions = {
-  outDir: 'dist/client',
-  rollupOptions: {
-    input: 'virtual:pastoria-entry-client.tsx',
+export async function createBuild(
+  steps: string[],
+  opts: {
+    alwaysMake: boolean;
+    release: boolean;
+    watch?: boolean;
   },
-};
+) {
+  if (opts.watch && opts.release) {
+    throw new Error(
+      'Cannot use --watch and --release together. Watch mode is for development only.',
+    );
+  }
 
-export const SERVER_BUILD: BuildEnvironmentOptions = {
-  outDir: 'dist/server',
-  ssr: true,
-  rollupOptions: {
-    input: 'virtual:pastoria-entry-server.tsx',
-  },
-};
-
-export function createBuildConfig(
-  buildEnv: BuildEnvironmentOptions,
-): InlineConfig {
-  return {
-    appType: 'custom' as const,
-    build: {
-      ...buildEnv,
-      assetsInlineLimit: 0,
-      manifest: true,
-      ssrManifest: true,
-    },
-    plugins: [
-      pastoriaEntryPlugin(),
-      tailwindcss(),
-      react({
-        babel: {
-          plugins: [['babel-plugin-react-compiler', {}], 'relay'],
-        },
-      }),
-      cjsInterop({
-        dependencies: ['react-relay', 'react-relay/hooks', 'relay-runtime'],
-      }),
-    ],
-    ssr: {
-      noExternal: ['pastoria-runtime'],
+  const project = new Project({
+    tsConfigFilePath: path.join(process.cwd(), 'tsconfig.json'),
+    manipulationSettings: {
+      indentationText: IndentationText.TwoSpaces,
     },
-  };
-}
-
-export async function createBuild() {
-  const clientBuild = await build({
-    ...createBuildConfig(CLIENT_BUILD),
-    configFile: false,
   });
 
-  const serverBuild = await build({
-    ...createBuildConfig(SERVER_BUILD),
-    configFile: false,
-  });
+  const cwd = process.cwd();
+  let makePhases = new Set<PastoriaMakePhase>();
+
+  // If specific steps are provided, override automatic inference
+  if (steps.length > 0) {
+    makePhases = makePhases.union(requiredMakePhasesForArgs(steps));
+  } else if (opts.alwaysMake) {
+    makePhases = ALL_MAKE_PHASES;
+  }
+  // Use @parcel/watcher to get changes since last snapshot
+  else {
+    try {
+      // Check if snapshot exists - if not, do a full build
+      await access(SNAPSHOT_PATH);
+
+      // Get events since last snapshot
+      const events = await getEventsSince(cwd, SNAPSHOT_PATH);
+
+      if (events.length > 0) {
+        // Analyze which files changed and determine what needs to be rebuilt
+        makePhases = makePhases.union(
+          await requiredMakePhasesForChanges(events),
+        );
+      }
+    } catch (err) {
+      // No snapshot exists yet, or error reading it - do a full build
+      makePhases = ALL_MAKE_PHASES;
+    }
+  }
+
+  // Execute build pipeline conditionally
+  await executeBuildSteps(project, makePhases);
+
+  // Write snapshot for next incremental build
+  await writeSnapshot(cwd, SNAPSHOT_PATH);
+
+  if (opts.release) {
+    await build({
+      ...createBuildConfig(CLIENT_BUILD),
+      configFile: false,
+    });
+
+    await build({
+      ...createBuildConfig(SERVER_BUILD),
+      configFile: false,
+    });
+  }
+
+  // Start watch mode if requested
+  if (opts.watch) {
+    logInfo('Watching for changes...');
+
+    const subscription = await ParcelWatcher.subscribe(
+      cwd,
+      async (err, events) => {
+        if (err) {
+          logger.error('Watch error!', {error: err});
+          return;
+        }
+
+        // Analyze which files changed and determine what needs to be rebuilt
+        const rebuiltAnything = await executeBuildSteps(
+          project,
+          await requiredMakePhasesForChanges(events),
+        );
+
+        if (rebuiltAnything) {
+          // Write snapshot after successful rebuild
+          await writeSnapshot(cwd, SNAPSHOT_PATH);
+          logInfo('Rebuild complete. Watching for changes...');
+        }
+      },
+    );
+
+    // Keep the process running
+    process.on('SIGINT', async () => {
+      await subscription.unsubscribe();
+      process.exit(0);
+    });
+  }
 }

package/src/devserver.ts

@@ -2,10 +2,11 @@ import cookieParser from 'cookie-parser';
 import dotenv from 'dotenv';
 import express from 'express';
 import {readFile} from 'node:fs/promises';
-import pc from 'picocolors';
 import {loadConfig, PastoriaConfig} from 'pastoria-config';
+import pc from 'picocolors';
 import {createServer as createViteServer, type Manifest} from 'vite';
-import {CLIENT_BUILD, createBuildConfig} from './build.js';
+import {logInfo} from './logger.js';
+import {CLIENT_BUILD, createBuildConfig} from './vite_plugin.js';
 
 interface PersistedQueries {
   [hash: string]: string;
@@ -51,7 +52,7 @@ export async function startDevserver(opts: {port: string}) {
     if (err) {
       console.error(err);
     } else {
-      console.log(pc.cyan(`Listening on port ${opts.port}!`));
+      logInfo(pc.cyan(`Listening on port ${opts.port}!`));
     }
   });
 }