pastoria 1.0.12 → 1.0.14

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) {
@@ -90,6 +89,36 @@ export interface PastoriaMetadata {
 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>();
@@ -158,10 +187,7 @@ function collectPastoriaMetadata(project: Project): PastoriaMetadata {
           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,
@@ -195,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 {
@@ -284,23 +309,32 @@ function getResourceQueriesAndEntryPoints(symbol: Symbol): {
 
     entryPoints?.getProperties().forEach((prop) => {
       const epRef = prop.getName();
-      const resourceName = prop
+      const entryPointTypeRef = prop
         .getValueDeclaration()
         ?.asKind(SyntaxKind.PropertySignature)
         ?.getTypeNode()
-        ?.asKind(SyntaxKind.TypeReference)
-        ?.getTypeArguments()
-        .at(0)
-        ?.asKind(SyntaxKind.TypeReference)
-        ?.getTypeArguments()
-        .at(0)
-        ?.asKind(SyntaxKind.LiteralType)
-        ?.getLiteral()
-        .asKind(SyntaxKind.StringLiteral)
-        ?.getLiteralText();
-
-      if (resourceName) {
-        resource.entryPoints.set(epRef, resourceName);
+        ?.asKind(SyntaxKind.TypeReference);
+
+      const entryPointTypeName = entryPointTypeRef?.getTypeName().getText();
+      if (entryPointTypeName !== 'EntryPoint') {
+        // TODO: Warn about found types not named EntryPoint
+        return;
+      }
+
+      const entryPointInner = entryPointTypeRef?.getTypeArguments().at(0);
+      const moduleTypeRef = entryPointInner?.asKind(SyntaxKind.TypeReference);
+      if (moduleTypeRef != null) {
+        const resourceName = moduleTypeRef
+          ?.getTypeArguments()
+          .at(0)
+          ?.asKind(SyntaxKind.LiteralType)
+          ?.getLiteral()
+          .asKind(SyntaxKind.StringLiteral)
+          ?.getLiteralText();
+
+        if (resourceName) {
+          resource.entryPoints.set(epRef, resourceName);
+        }
       }
     });
   }
@@ -308,41 +342,62 @@ 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()`;
   }
 }
 
 function writeEntryPoint(
   writer: CodeBlockWriter,
+  project: Project,
   metadata: PastoriaMetadata,
   consumedQueries: Set<string>,
   resourceName: string,
@@ -350,6 +405,7 @@ function writeEntryPoint(
   parseVars = true,
 ) {
   writer.writeLine(`root: JSResource.fromModuleId('${resourceName}'),`);
+
   writer
     .write(`getPreloadProps(${parseVars ? '{params, schema}' : ''})`)
     .block(() => {
@@ -364,11 +420,28 @@ function writeEntryPoint(
             for (const [queryRef, query] of resource.queries.entries()) {
               consumedQueries.add(query);
 
+              // Determine which variables this specific query needs
+              const queryVars = collectQueryParameters(project, [query]);
+              const hasVariables = queryVars.size > 0;
+
               writer
                 .write(`${queryRef}:`)
                 .block(() => {
                   writer.writeLine(`parameters: ${query}Parameters,`);
-                  writer.writeLine(`variables`);
+
+                  if (hasVariables) {
+                    const varNames = Array.from(queryVars.keys());
+                    // Always pick from the variables object
+                    writer.write(`variables: {`);
+                    writer.write(
+                      varNames.map((v) => `${v}: variables.${v}`).join(', '),
+                    );
+                    writer.write(`}`);
+                  } else {
+                    // Query has no variables, pass empty object
+                    writer.write(`variables: {}`);
+                  }
+                  writer.newLine();
                 })
                 .write(',');
             }
@@ -382,19 +455,23 @@ function writeEntryPoint(
           ] of resource.entryPoints.entries()) {
             const subresource = metadata.resources.get(subresourceName);
             if (subresource) {
-              writer.write(`${epRef}:`).block(() => {
-                writer.writeLine(`entryPointParams: {},`);
-                writer.write('entryPoint:').block(() => {
-                  writeEntryPoint(
-                    writer,
-                    metadata,
-                    consumedQueries,
-                    subresourceName,
-                    subresource,
-                    false,
-                  );
-                });
-              });
+              writer
+                .write(`${epRef}:`)
+                .block(() => {
+                  writer.writeLine(`entryPointParams: {},`);
+                  writer.write('entryPoint:').block(() => {
+                    writeEntryPoint(
+                      writer,
+                      project,
+                      metadata,
+                      consumedQueries,
+                      subresourceName,
+                      subresource,
+                      false,
+                    );
+                  });
+                })
+                .writeLine(',');
             }
           }
         });
@@ -415,7 +492,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()) {
@@ -448,6 +525,7 @@ async function generateRouter(project: Project, metadata: PastoriaMetadata) {
           writer.write('return ').block(() => {
             writeEntryPoint(
               writer,
+              project,
               metadata,
               consumedQueries,
               resourceName,
@@ -457,6 +535,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`,
@@ -497,7 +579,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)},`,
                 );
               }
 
@@ -508,7 +590,7 @@ async function generateRouter(project: Project, metadata: PastoriaMetadata) {
       },
     });
 
-    console.log(
+    logInfo(
       'Created route',
       pc.cyan(routeName),
       'for',
@@ -559,7 +641,7 @@ async function generateJsResource(
       },
     });
 
-    console.log(
+    logInfo(
       'Created resource',
       pc.cyan(resourceName),
       'for',
@@ -607,7 +689,7 @@ export {${appRootSymbol.getName()} as App} from '${moduleSpecifier}';
 
   await appRootFile.save();
 
-  console.log(
+  logInfo(
     'Created app root for',
     pc.green(appRootSymbol.getName()),
     'exported from',
@@ -643,7 +725,7 @@ async function generateGraphqlContext(
 export {${contextSymbol.getName()} as Context} from '${moduleSpecifier}';
 `);
 
-    console.log(
+    logInfo(
       'Created GraphQL context for',
       pc.green(contextSymbol.getName()),
       'exported from',
@@ -663,10 +745,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();
@@ -715,7 +794,7 @@ export const router = express.Router();
       `router.use('${routeName}', ${importAlias})`,
     );
 
-    console.log(
+    logInfo(
       'Created server handler',
       pc.cyan(routeName),
       'for',
@@ -744,3 +823,96 @@ export async function generatePastoriaArtifacts(
   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

@@ -30,7 +30,7 @@ async function main() {
       '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('--release', 'Build for production')
+    .option('-R, --release', 'Build for production')
     .option('-w, --watch', 'Watch for changes and rebuild')
     .action(createBuild);
 

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",