pastoria 1.0.11 → 1.0.13

package/src/generate.ts

@@ -31,15 +31,14 @@ import * as path from 'node:path';
 import pc from 'picocolors';
 import {
   CodeBlockWriter,
-  IndentationText,
   Project,
   SourceFile,
   Symbol,
   SyntaxKind,
   ts,
   TypeFlags,
-  WriterFunction,
 } from 'ts-morph';
+import {logInfo, logWarn} from './logger.js';
 
 async function loadRouterTemplates(project: Project, filename: string) {
   async function loadSourceFile(fileName: string, templateFileName: string) {
@@ -78,7 +77,7 @@ type ExportedSymbol = {
   symbol: Symbol;
 };
 
-interface PastoriaMetadata {
+export interface PastoriaMetadata {
   resources: Map<string, RouterResource>;
   routes: Map<string, RouterRoute>;
   serverHandlers: Map<string, ExportedSymbol>;
@@ -87,9 +86,39 @@ interface PastoriaMetadata {
 }
 
 // Regex to quickly check if a file contains any Pastoria JSDoc tags
-const PASTORIA_TAG_REGEX =
+export const PASTORIA_TAG_REGEX =
   /@(route|resource|appRoot|param|gqlContext|serverRoute)\b/;
 
+function collectQueryParameters(
+  project: Project,
+  queries: string[],
+): Map<string, ts.Type> {
+  const vars = new Map<string, ts.Type>();
+
+  for (const query of queries) {
+    const variablesType = project
+      .getSourceFile(`__generated__/queries/${query}.graphql.ts`)
+      ?.getExportedDeclarations()
+      .get(`${query}$variables`)
+      ?.at(0)
+      ?.getType();
+
+    if (variablesType == null) continue;
+
+    for (const property of variablesType.getProperties()) {
+      // TODO: Detect conflicting types among properties declared.
+      const propertyName = property.getName();
+      const propertyType = property.getValueDeclaration()?.getType();
+
+      if (propertyType) {
+        vars.set(propertyName, propertyType.compilerType);
+      }
+    }
+  }
+
+  return vars;
+}
+
 function collectPastoriaMetadata(project: Project): PastoriaMetadata {
   const resources = new Map<string, RouterResource>();
   const routes = new Map<string, RouterRoute>();
@@ -152,36 +181,13 @@ function collectPastoriaMetadata(project: Project): PastoriaMetadata {
               serverHandlers.set(tag.comment, {sourceFile, symbol});
               break;
             }
-            // case 'query': {
-            //   const match = tag.comment.match(
-            //     /^\s*\{\s*(?<query>\w+)\s*\}\s+(?<name>\w+)\s*$/,
-            //   )?.groups;
-
-            //   if (match && match.query && match.name) {
-            //     resourceQueries.set(match.name, match.query);
-            //   }
-            //   break;
-            // }
-            // case 'entrypoint': {
-            //   const match = tag.comment.match(
-            //     /^\s*\{\s*(?<resource>[\w#]+)\s*\}\s+(?<name>\w+)\s*$/,
-            //   )?.groups;
-
-            //   if (match && match.resource && match.name) {
-            //     resourceEntryPoints.set(match.name, match.resource);
-            //   }
-            //   break;
-            // }
           }
         } else {
           // Handle tags without comments (like @ExportedSymbol, @gqlContext)
           switch (tag.tagName.getText()) {
             case 'appRoot': {
               if (appRoot != null) {
-                console.warn(
-                  pc.yellow('Warning:'),
-                  'Multiple @appRoot tags found. Using the first one.',
-                );
+                logWarn('Multiple @appRoot tags found. Using the first one.');
               } else {
                 appRoot = {
                   sourceFile,
@@ -215,8 +221,7 @@ function collectPastoriaMetadata(project: Project): PastoriaMetadata {
 
               if (extendsPastoriaRootContext) {
                 if (gqlContext != null) {
-                  console.warn(
-                    pc.yellow('Warning:'),
+                  logWarn(
                     'Multiple classes with @gqlContext extending PastoriaRootContext found. Using the first one.',
                   );
                 } else {
@@ -328,35 +333,55 @@ function getResourceQueriesAndEntryPoints(symbol: Symbol): {
   return resource;
 }
 
-function zodSchemaOfType(tc: ts.TypeChecker, t: ts.Type): string {
-  if (t.getFlags() & TypeFlags.String) {
+function zodSchemaOfType(
+  sf: SourceFile,
+  tc: ts.TypeChecker,
+  t: ts.Type,
+): string {
+  if (t.aliasSymbol) {
+    const decl = t.aliasSymbol.declarations?.at(0);
+    if (decl == null) {
+      logWarn('Could not handle type:', tc.typeToString(t));
+      return `z.any()`;
+    } else {
+      const importPath = sf.getRelativePathAsModuleSpecifierTo(
+        decl.getSourceFile().fileName,
+      );
+
+      return `z.transform((s: string) => s as import('${importPath}').${t.aliasSymbol.getName()})`;
+    }
+  } else 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),
-      )!;
+    const nullishTypes: ts.Type[] = [];
+    const nonNullishTypes: ts.Type[] = [];
+    for (const s of t.types) {
+      const flags = s.getFlags();
+      if (flags & TypeFlags.Null || flags & TypeFlags.Undefined) {
+        nullishTypes.push(s);
+      } else {
+        nonNullishTypes.push(s);
+      }
+    }
 
-      return `z.pipe(z.nullish(${zodSchemaOfType(tc, nonOptionalType)}), z.transform(s => s == null ? undefined : s))`;
+    if (nullishTypes.length > 0 && nonNullishTypes.length > 0) {
+      const nonOptionalType = t.getNonNullableType();
+      return `z.pipe(z.nullish(${zodSchemaOfType(sf, tc, nonOptionalType)}), z.transform(s => s == null ? undefined : s))`;
     } else {
-      return `z.union([${t.types.map((it) => zodSchemaOfType(tc, it)).join(', ')}])`;
+      return `z.union([${t.types.map((it) => zodSchemaOfType(sf, 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);
+      typeArg == null ? `z.any()` : zodSchemaOfType(sf, tc, typeArg);
 
     return `z.array(${argZodSchema})`;
   } else {
-    console.log('Could not handle type:', tc.typeToString(t));
+    logWarn('Could not handle type:', tc.typeToString(t));
     return `z.any()`;
   }
 }
@@ -435,7 +460,7 @@ async function generateRouter(project: Project, metadata: PastoriaMetadata) {
   routerConf.getPropertyOrThrow('noop').remove();
 
   let entryPointImportIndex = 0;
-  for (const [
+  for (let [
     routeName,
     {sourceFile, symbol, params},
   ] of metadata.routes.entries()) {
@@ -477,6 +502,10 @@ async function generateRouter(project: Project, metadata: PastoriaMetadata) {
         },
       });
 
+      if (params.size === 0 && consumedQueries.size > 0) {
+        params = collectQueryParameters(project, Array.from(consumedQueries));
+      }
+
       for (const query of consumedQueries) {
         routerTemplate.addImportDeclaration({
           moduleSpecifier: `#genfiles/queries/${query}$parameters`,
@@ -517,7 +546,7 @@ async function generateRouter(project: Project, metadata: PastoriaMetadata) {
               writer.writeLine(`schema: z.object({`);
               for (const [paramName, paramType] of Array.from(params)) {
                 writer.writeLine(
-                  `  ${paramName}: ${zodSchemaOfType(tc, paramType)},`,
+                  `  ${paramName}: ${zodSchemaOfType(routerTemplate, tc, paramType)},`,
                 );
               }
 
@@ -528,7 +557,7 @@ async function generateRouter(project: Project, metadata: PastoriaMetadata) {
       },
     });
 
-    console.log(
+    logInfo(
       'Created route',
       pc.cyan(routeName),
       'for',
@@ -579,7 +608,7 @@ async function generateJsResource(
       },
     });
 
-    console.log(
+    logInfo(
       'Created resource',
       pc.cyan(resourceName),
       'for',
@@ -627,7 +656,7 @@ export {${appRootSymbol.getName()} as App} from '${moduleSpecifier}';
 
   await appRootFile.save();
 
-  console.log(
+  logInfo(
     'Created app root for',
     pc.green(appRootSymbol.getName()),
     'exported from',
@@ -663,7 +692,7 @@ async function generateGraphqlContext(
 export {${contextSymbol.getName()} as Context} from '${moduleSpecifier}';
 `);
 
-    console.log(
+    logInfo(
       'Created GraphQL context for',
       pc.green(contextSymbol.getName()),
       'exported from',
@@ -683,10 +712,7 @@ import {PastoriaRootContext} from 'pastoria-runtime/server';
 export class Context extends PastoriaRootContext {}
 `);
 
-    console.log(
-      'No @gqlContext found, generating default',
-      pc.green('Context'),
-    );
+    logInfo('No @gqlContext found, generating default', pc.green('Context'));
   }
 
   await contextFile.save();
@@ -735,7 +761,7 @@ export const router = express.Router();
       `router.use('${routeName}', ${importAlias})`,
     );
 
-    console.log(
+    logInfo(
       'Created server handler',
       pc.cyan(routeName),
       'for',
@@ -748,20 +774,112 @@ export const router = express.Router();
   await serverHandlerTemplate.save();
 }
 
-export async function generatePastoriaArtifacts() {
-  const targetDir = process.cwd();
-  const project = new Project({
-    tsConfigFilePath: path.join(targetDir, 'tsconfig.json'),
-    manipulationSettings: {
-      indentationText: IndentationText.TwoSpaces,
-    },
-  });
-
+export async function generatePastoriaExports(project: Project) {
   const metadata = collectPastoriaMetadata(project);
 
   await generateAppRoot(project, metadata);
   await generateGraphqlContext(project, metadata);
+  return metadata;
+}
+
+export async function generatePastoriaArtifacts(
+  project: Project,
+  metadata = collectPastoriaMetadata(project),
+) {
   await generateRouter(project, metadata);
   await generateJsResource(project, metadata);
   await generateServerHandler(project, metadata);
 }
+
+export interface PastoriaCapabilities {
+  hasAppRoot: boolean;
+  hasServerHandler: boolean;
+}
+
+export function generateClientEntry({
+  hasAppRoot,
+}: PastoriaCapabilities): string {
+  const appImport = hasAppRoot
+    ? `import {App} from '#genfiles/router/app_root';`
+    : '';
+  const appValue = hasAppRoot ? 'App' : 'null';
+
+  return `// Generated by Pastoria.
+import {createRouterApp} from '#genfiles/router/router';
+${appImport}
+import {hydrateRoot} from 'react-dom/client';
+
+async function main() {
+  const RouterApp = await createRouterApp();
+  hydrateRoot(document, <RouterApp App={${appValue}} />);
+}
+
+main();
+`;
+}
+
+export 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,
+  );
+
+  const router = express.Router();
+  router.use(routeHandler);
+  ${serverHandlerUse}
+
+  return router;
+}
+`;
+}

package/src/index.ts

@@ -5,7 +5,6 @@ import {readFile} from 'node:fs/promises';
 import * as path from 'node:path';
 import {createBuild} from './build.js';
 import {startDevserver} from './devserver.js';
-import {generatePastoriaArtifacts} from './generate.js';
 
 async function main() {
   const packageData = JSON.parse(
@@ -17,11 +16,6 @@ async function main() {
     .description(packageData.description)
     .version(packageData.version);
 
-  program
-    .command('gen')
-    .description('Run Pastoria code generation')
-    .action(generatePastoriaArtifacts);
-
   program
     .command('dev')
     .description('Start the pastoria devserver')
@@ -29,8 +23,15 @@ async function main() {
     .action(startDevserver);
 
   program
-    .command('build')
+    .command('make')
     .description('Creates a production build of the project')
+    .argument(
+      '[steps...]',
+      'Specific build steps to run (schema, relay, router). If not provided, will infer from changed files.',
+    )
+    .option('-B, --always-make', 'Always make, never cache')
+    .option('-R, --release', 'Build for production')
+    .option('-w, --watch', 'Watch for changes and rebuild')
     .action(createBuild);
 
   program.parseAsync();

package/src/logger.ts

@@ -0,0 +1,12 @@
+import {createLogger} from 'vite';
+import pc from 'picocolors';
+
+export const logger = createLogger('info', {prefix: pc.greenBright('[MAKE]')});
+
+export function logInfo(...messages: string[]) {
+  logger.info(messages.join(' '), {timestamp: true});
+}
+
+export function logWarn(...messages: string[]) {
+  logger.warn(messages.join(' '), {timestamp: true});
+}

package/src/vite_plugin.ts

@@ -0,0 +1,109 @@
+import tailwindcss from '@tailwindcss/vite';
+import react from '@vitejs/plugin-react';
+import {access} from 'node:fs/promises';
+import {
+  InlineConfig,
+  PluginOption,
+  type BuildEnvironmentOptions,
+  type Plugin,
+} from 'vite';
+import {cjsInterop} from 'vite-plugin-cjs-interop';
+import {
+  generateClientEntry,
+  generateServerEntry,
+  PastoriaCapabilities,
+} from './generate.js';
+import {logger} from './logger.js';
+
+async function determineCapabilities(): Promise<PastoriaCapabilities> {
+  const capabilities: PastoriaCapabilities = {
+    hasAppRoot: false,
+    hasServerHandler: false,
+  };
+
+  async function hasAppRoot() {
+    try {
+      await access('__generated__/router/app_root.ts');
+      capabilities.hasAppRoot = true;
+    } catch {}
+  }
+
+  async function hasServerHandler() {
+    try {
+      await access('__generated__/router/server_handler.ts');
+      capabilities.hasServerHandler = true;
+    } catch {}
+  }
+
+  await Promise.all([hasAppRoot(), hasServerHandler()]);
+  return capabilities;
+}
+
+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);
+      }
+    },
+  };
+}
+
+export const CLIENT_BUILD: BuildEnvironmentOptions = {
+  outDir: 'dist/client',
+  rollupOptions: {
+    input: 'virtual:pastoria-entry-client.tsx',
+  },
+};
+
+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,
+    customLogger: logger,
+    build: {
+      ...buildEnv,
+      assetsInlineLimit: 0,
+      manifest: true,
+      ssrManifest: true,
+    },
+    plugins: [
+      pastoriaEntryPlugin(),
+      tailwindcss() as PluginOption,
+      react({
+        babel: {
+          plugins: [['babel-plugin-react-compiler', {}], 'relay'],
+        },
+      }),
+      cjsInterop({
+        dependencies: ['react-relay', 'react-relay/hooks', 'relay-runtime'],
+      }),
+    ],
+    ssr: {
+      noExternal: ['pastoria-runtime'],
+    },
+  };
+}

package/templates/router.tsx

@@ -245,20 +245,7 @@ export function router__createAppFromEntryPoint(
 
     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={{}} />
-        )}
+        <EntryPointContainer entryPointReference={entryPoint} props={{}} />
       </RouterContext>
     );
   }

package/tsconfig.json

@@ -2,7 +2,7 @@
   "compilerOptions": {
     "target": "ES2022",
     "module": "nodenext",
-    "lib": ["ES2022", "DOM"],
+    "lib": ["ES2022", "DOM", "ESNext.Collection"],
     "moduleResolution": "nodenext",
     "outDir": "./dist",
     "rootDir": "./src",