@nexus-rpc/gen-core 0.1.0-alpha.3 → 0.1.0-alpha.4

package/dist/definition-source.d.ts

@@ -0,0 +1,5 @@
+import type { DefinitionSchema } from "./definition-schema.js";
+export interface DefinitionSource {
+    fileURI: URL;
+    schema: DefinitionSchema;
+}

package/dist/definition-source.js

@@ -0,0 +1 @@
+export {};

package/dist/generator.d.ts

@@ -1,12 +1,16 @@
 import { type LanguageName, type RendererOptions, type TargetLanguage } from "quicktype-core";
-import type { DefinitionSchema } from "./definition-schema";
+import type { DefinitionSource } from "./definition-source.js";
 export interface GeneratorOptions<Lang extends LanguageName = LanguageName> {
     lang: TargetLanguage;
-    schema: DefinitionSchema;
+    definitionSources: DefinitionSource[];
     rendererOptions: RendererOptions<Lang>;
     firstFilenameSansExtensions: string;
 }
+export interface PreparedSchemaSources {
+    sources: PreparedSchema[];
+}
 export interface PreparedSchema {
+    sourceURI: string;
     services: {
         [key: string]: PreparedService;
     };
@@ -37,8 +41,16 @@ export interface PreparedTypeReference {
     kind: "jsonSchema" | "existing";
     name: string;
 }
+export interface MergedSources {
+    services: {
+        [key: string]: PreparedService;
+    };
+    topLevelJsonSchemaTypes: {
+        [key: string]: any;
+    };
+}
 export interface NexusRendererOptions {
-    nexusSchema: PreparedSchema;
+    nexusSchema: MergedSources;
     firstFilenameSansExtensions: string;
 }
 export declare function getNexusRendererOptions(rendererOptions: RendererOptions): NexusRendererOptions;
@@ -48,6 +60,6 @@ export declare class Generator {
     generate(): Promise<{
         [fileName: string]: string;
     }>;
-    private prepareSchema;
+    private prepareSchemas;
     private prepareInOutType;
 }

package/dist/generator.js

@@ -1,6 +1,7 @@
 import { InputData, JSONSchemaInput, JSONSchemaStore, quicktypeMultiFile, Ref, } from "quicktype-core";
 import { PathElementKind } from "quicktype-core/dist/input/PathElement.js";
-import { isPrimitiveTypeKind } from "quicktype-core/dist/Type/index.js";
+import { readFile } from "node:fs/promises";
+import yaml from "yaml";
 export function getNexusRendererOptions(rendererOptions) {
     return rendererOptions.nexusOptions;
 }
@@ -11,73 +12,102 @@ export class Generator {
     }
     async generate() {
         // Prepare schema
-        const schema = this.prepareSchema();
-        // Build quicktype input
-        const schemaInput = new JSONSchemaInput(new FetchDisabledSchemaStore());
-        const jsonSchema = {
-            ...schema.sharedJsonSchema,
-            ...schema.topLevelJsonSchemaTypes,
+        const sources = this.prepareSchemas();
+        const mergedSources = {
+            services: {},
+            topLevelJsonSchemaTypes: {},
         };
-        await schemaInput.addSource({
-            // TODO(cretz): Give proper filename name here for proper cross-file referencing
-            name: "__ALL_TYPES__",
-            schema: JSON.stringify(jsonSchema),
-        });
-        // Set the top-level types
-        for (const topLevel of Object.keys(schema.topLevelJsonSchemaTypes)) {
-            schemaInput.addTopLevel(topLevel, Ref.parse(`__ALL_TYPES__#/${topLevel}`));
-        }
-        for (const [name, reference] of Object.entries(schema.topLevelJsonSchemaLocalRefs)) {
-            schemaInput.addTopLevel(name, Ref.parse(`__ALL_TYPES__${reference}`));
+        // Build quicktype input
+        const schemaInput = new JSONSchemaInput(new LocalFetchingSchemaStore());
+        for (const schema of sources.sources) {
+            const jsonSchema = {
+                ...schema.sharedJsonSchema,
+                ...schema.topLevelJsonSchemaTypes,
+            };
+            await schemaInput.addSource({
+                // Append __ALL_TYPES__ to make it easier to filter out top level
+                // while rendering
+                name: schema.sourceURI.toString() + "/__ALL_TYPES__",
+                uris: [schema.sourceURI],
+                schema: JSON.stringify(jsonSchema),
+            });
+            // Set the top-level types
+            for (const topLevel of Object.keys(schema.topLevelJsonSchemaTypes)) {
+                schemaInput.addTopLevel(topLevel, Ref.parse(`${schema.sourceURI}#/${topLevel}`));
+            }
+            for (const [name, reference] of Object.entries(schema.topLevelJsonSchemaLocalRefs)) {
+                schemaInput.addTopLevel(name, Ref.parse(`${schema.sourceURI}${reference}`));
+            }
+            mergeSources(mergedSources, schema);
         }
         const inputData = new InputData();
         inputData.addInput(schemaInput);
         // Update renderer options with the prepared schema
         const rendererOptions = {
             nexusOptions: {
-                nexusSchema: schema,
+                nexusSchema: mergedSources,
                 firstFilenameSansExtensions: this.options.firstFilenameSansExtensions,
             },
             ...this.options.rendererOptions,
         };
         // Run quicktype and return
         const returnValue = {};
-        const results = await quicktypeMultiFile({
-            inputData,
-            lang: this.options.lang,
-            rendererOptions,
-        });
-        results.forEach((contents, fileName) => (returnValue[fileName] = contents.lines.join("\n")));
+        try {
+            const results = await quicktypeMultiFile({
+                inputData,
+                lang: this.options.lang,
+                rendererOptions,
+            });
+            results.forEach((contents, fileName) => (returnValue[fileName] = contents.lines.join("\n")));
+        }
+        catch (error) {
+            if (error instanceof Error &&
+                "properties" in error &&
+                error.messageName === "SchemaFetchError") {
+                // If there is an error with schema fetching, the message
+                // produced by quicktype will use an empty string for the address.
+                const { address, base } = error.properties;
+                throw new Error(`Could not fetch schema "${address}", referred to from ${base}`);
+            }
+            throw error;
+        }
         return returnValue;
     }
-    prepareSchema() {
-        const schema = {
-            services: {},
-            sharedJsonSchema: {
-                types: this.options.schema.types ?? {},
-            },
-            topLevelJsonSchemaTypes: {},
-            topLevelJsonSchemaLocalRefs: {},
+    prepareSchemas() {
+        const prepared = {
+            sources: [],
         };
-        for (const [serviceName, service] of Object.entries(this.options.schema.services || {})) {
-            schema.services[serviceName] = {
-                description: service.description,
-                operations: {},
+        for (const definitionSource of this.options.definitionSources) {
+            const schema = {
+                sourceURI: definitionSource.fileURI.toString(),
+                services: {},
+                sharedJsonSchema: {
+                    types: definitionSource.schema.types ?? {},
+                },
+                topLevelJsonSchemaTypes: {},
+                topLevelJsonSchemaLocalRefs: {},
             };
-            for (const [operationName, operation] of Object.entries(service.operations)) {
-                const schemaOp = {
-                    description: operation.description,
+            for (const [serviceName, service] of Object.entries(definitionSource.schema.services ?? {})) {
+                schema.services[serviceName] = {
+                    description: service.description,
+                    operations: {},
                 };
-                schema.services[serviceName].operations[operationName] = schemaOp;
-                if (operation.input) {
-                    schemaOp.input = this.prepareInOutType(schema, serviceName, operationName, operation.input, "Input");
-                }
-                if (operation.output) {
-                    schemaOp.output = this.prepareInOutType(schema, serviceName, operationName, operation.output, "Output");
+                for (const [operationName, operation] of Object.entries(service.operations)) {
+                    const schemaOp = {
+                        description: operation.description,
+                    };
+                    schema.services[serviceName].operations[operationName] = schemaOp;
+                    if (operation.input) {
+                        schemaOp.input = this.prepareInOutType(schema, serviceName, operationName, operation.input, "Input");
+                    }
+                    if (operation.output) {
+                        schemaOp.output = this.prepareInOutType(schema, serviceName, operationName, operation.output, "Output");
+                    }
                 }
             }
+            prepared.sources.push(schema);
         }
-        return schema;
+        return prepared;
     }
     prepareInOutType(schema, serviceName, operationName, opInOut, suffix) {
         // Check for an existing ref for this specific lang first
@@ -120,9 +150,23 @@ export class Generator {
         return { kind: "jsonSchema", name };
     }
 }
-class FetchDisabledSchemaStore extends JSONSchemaStore {
-    fetch(_address) {
-        // TODO(cretz): Support this?
-        throw new Error("External $ref unsupported");
+function mergeSources(destination, source) {
+    for (const name of Object.keys(source.topLevelJsonSchemaTypes)) {
+        if (name in destination.topLevelJsonSchemaTypes) {
+            throw new Error(`Duplicate type "${name}" defined across multiple definition files`);
+        }
+    }
+    for (const name of Object.keys(source.services)) {
+        if (name in destination.services) {
+            throw new Error(`Duplicate service "${name}" defined across multiple definition files`);
+        }
+    }
+    Object.assign(destination.topLevelJsonSchemaTypes, source.topLevelJsonSchemaTypes);
+    Object.assign(destination.services, source.services);
+}
+class LocalFetchingSchemaStore extends JSONSchemaStore {
+    async fetch(address) {
+        const content = await readFile(new URL(address), "utf8");
+        return yaml.parse(content);
     }
 }

package/dist/index.d.ts

@@ -5,4 +5,5 @@ export { GoLanguageWithNexus } from "./language-go.js";
 export { JavaLanguageWithNexus } from "./language-java.js";
 export { PythonLanguageWithNexus } from "./language-python.js";
 export { TypeScriptLanguageWithNexus } from "./language-typescript.js";
+export type { DefinitionSource } from "./definition-source.js";
 export { parseFiles } from "./parser.js";

package/dist/language-go.js

@@ -28,7 +28,7 @@ export class GoLanguageWithNexus extends GoTargetLanguage {
             },
             emitTopLevel(original, t, name) {
                 // Do not emit __ALL_TYPES__ placeholder
-                if (name.firstProposedName(new Map()) == "__ALL_TYPES__") {
+                if (name.firstProposedName(new Map()).endsWith("/__ALL_TYPES__")) {
                     return;
                 }
                 original(t, name);

package/dist/language-typescript.js

@@ -132,7 +132,7 @@ class TypeScriptRenderAdapter extends RenderAdapter {
         // alterations.
         // Primitives
         this.render.forEachWithBlankLines(this.render.topLevels, "none", (t, name, pos) => {
-            if (!t.isPrimitive() || name == "__ALL_TYPES__") {
+            if (!t.isPrimitive() || name.endsWith("/__ALL_TYPES__")) {
                 return;
             }
             this.render.ensureBlankLine();

package/dist/parser.d.ts

@@ -1,2 +1,2 @@
-import type { DefinitionSchema } from "./definition-schema.js";
-export declare function parseFiles(files: string[]): Promise<DefinitionSchema>;
+import type { DefinitionSource } from "./definition-source.js";
+export declare function parseFiles(files: string[]): Promise<DefinitionSource[]>;

package/dist/parser.js

@@ -3,6 +3,7 @@ import Ajv from "ajv";
 import addFormats from "ajv-formats";
 import yaml from "yaml";
 import { readFile } from "node:fs/promises";
+import { pathToFileURL } from "node:url";
 const ajv = new Ajv({
     allErrors: true,
     strict: false,
@@ -12,13 +13,8 @@ const ajv = new Ajv({
     },
 });
 addFormats(ajv);
-export async function parseFiles(files) {
-    // TODO(cretz): Multi-file
-    if (files.length != 1) {
-        throw new Error("Must have only 1 file at this time");
-    }
-    // Parse YAML
-    const document = yaml.parse(await readFile(files[0], "utf8"));
+async function parseFile(file) {
+    const document = yaml.parse(await readFile(file, "utf8"));
     // Validate. We recreate the validator because it carries state.
     const valueFunction = await ajv.compileAsync(jsonSchema);
     if (!valueFunction(document)) {
@@ -30,5 +26,28 @@ export async function parseFiles(files) {
                 ?.map((error) => `${error.instancePath || "(root)"}: ${error.message} (${JSON.stringify(error.params)})`)
                 .join(", "));
     }
-    return document;
+    return { fileURI: pathToFileURL(file), schema: document };
+}
+export async function parseFiles(files) {
+    if (files.length === 0) {
+        throw new Error("Must have at least 1 file");
+    }
+    const results = await Promise.allSettled(files.map(parseFile));
+    const errors = [];
+    const sources = [];
+    for (let index = 0; index < results.length; index++) {
+        const result = results[index];
+        if (result.status === "rejected") {
+            errors.push(new Error(`${files[index]}: ${result.reason}`, {
+                cause: result.reason,
+            }));
+        }
+        else {
+            sources.push(result.value);
+        }
+    }
+    if (errors.length > 0) {
+        throw new AggregateError(errors, `Failed to parse ${errors.length} file(s)`);
+    }
+    return sources;
 }

package/dist/render-adapter.d.ts

@@ -1,5 +1,5 @@
 import { ConvenienceRenderer, Name, Namer, type RendererOptions, type Sourcelike } from "quicktype-core";
-import { type NexusRendererOptions, type PreparedSchema } from "./generator.js";
+import { type NexusRendererOptions, type MergedSources } from "./generator.js";
 import type { BlankLineConfig, ForEachPosition } from "quicktype-core/dist/Renderer.js";
 import type { ClassProperty, ClassType, EnumType, ObjectType, Type, TypeGraph, UnionType } from "quicktype-core/dist/Type/index.js";
 import type { ForbiddenWordsInfo } from "quicktype-core/dist/ConvenienceRenderer.js";
@@ -9,7 +9,7 @@ export declare abstract class RenderAdapter<AccessibleRenderer> {
     protected readonly nexusRendererOptions: NexusRendererOptions;
     private readonly serviceTypeNamesInUse;
     constructor(render: ConvenienceRenderer, rendererOptions: RendererOptions);
-    get schema(): PreparedSchema;
+    get schema(): MergedSources;
     makeRenderer<T extends ConvenienceRenderer>(overrides: {
         [K in keyof AccessibleRenderer]?: AccessibleRenderer[K] extends AnyFunction ? (this: AccessibleRenderer, original: AccessibleRenderer[K], ...arguments_: Parameters<AccessibleRenderer[K]>) => ReturnType<AccessibleRenderer[K]> : never;
     }): T;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nexus-rpc/gen-core",
-  "version": "0.1.0-alpha.3",
+  "version": "0.1.0-alpha.4",
   "description": "Nexus code generation (core library)",
   "author": "Temporal Technologies Inc. <sdk@temporal.io>",
   "license": "MIT",

package/src/definition-source.ts

@@ -0,0 +1,6 @@
+import type { DefinitionSchema } from "./definition-schema.js";
+
+export interface DefinitionSource {
+  fileURI: URL;
+  schema: DefinitionSchema;
+}

package/src/generator.ts

@@ -9,19 +9,25 @@ import {
   type RendererOptions,
   type TargetLanguage,
 } from "quicktype-core";
-import type { DefinitionSchema } from "./definition-schema";
+import type { DefinitionSource } from "./definition-source.js";
 import { PathElementKind } from "quicktype-core/dist/input/PathElement.js";
-import { isPrimitiveTypeKind } from "quicktype-core/dist/Type/index.js";
+import { readFile } from "node:fs/promises";
+import yaml from "yaml";
 
 export interface GeneratorOptions<Lang extends LanguageName = LanguageName> {
   lang: TargetLanguage;
-  schema: DefinitionSchema;
+  definitionSources: DefinitionSource[];
   rendererOptions: RendererOptions<Lang>;
   // Used to help with ideal output filename
   firstFilenameSansExtensions: string;
 }
 
+export interface PreparedSchemaSources {
+  sources: PreparedSchema[];
+}
+
 export interface PreparedSchema {
+  sourceURI: string;
   services: { [key: string]: PreparedService };
   sharedJsonSchema: { types: { [key: string]: any } };
   topLevelJsonSchemaTypes: { [key: string]: any };
@@ -44,8 +50,13 @@ export interface PreparedTypeReference {
   name: string;
 }
 
+export interface MergedSources {
+  services: { [key: string]: PreparedService };
+  topLevelJsonSchemaTypes: { [key: string]: any };
+}
+
 export interface NexusRendererOptions {
-  nexusSchema: PreparedSchema;
+  nexusSchema: MergedSources;
   firstFilenameSansExtensions: string;
 }
 
@@ -64,30 +75,42 @@ export class Generator {
 
   async generate(): Promise<{ [fileName: string]: string }> {
     // Prepare schema
-    const schema = this.prepareSchema();
+    const sources = this.prepareSchemas();
+    const mergedSources: MergedSources = {
+      services: {},
+      topLevelJsonSchemaTypes: {},
+    };
 
     // Build quicktype input
-    const schemaInput = new JSONSchemaInput(new FetchDisabledSchemaStore());
-    const jsonSchema = {
-      ...schema.sharedJsonSchema,
-      ...schema.topLevelJsonSchemaTypes,
-    };
-    await schemaInput.addSource({
-      // TODO(cretz): Give proper filename name here for proper cross-file referencing
-      name: "__ALL_TYPES__",
-      schema: JSON.stringify(jsonSchema),
-    });
-    // Set the top-level types
-    for (const topLevel of Object.keys(schema.topLevelJsonSchemaTypes)) {
-      schemaInput.addTopLevel(
-        topLevel,
-        Ref.parse(`__ALL_TYPES__#/${topLevel}`),
-      );
-    }
-    for (const [name, reference] of Object.entries(
-      schema.topLevelJsonSchemaLocalRefs,
-    )) {
-      schemaInput.addTopLevel(name, Ref.parse(`__ALL_TYPES__${reference}`));
+    const schemaInput = new JSONSchemaInput(new LocalFetchingSchemaStore());
+    for (const schema of sources.sources) {
+      const jsonSchema = {
+        ...schema.sharedJsonSchema,
+        ...schema.topLevelJsonSchemaTypes,
+      };
+      await schemaInput.addSource({
+        // Append __ALL_TYPES__ to make it easier to filter out top level
+        // while rendering
+        name: schema.sourceURI.toString() + "/__ALL_TYPES__",
+        uris: [schema.sourceURI],
+        schema: JSON.stringify(jsonSchema),
+      });
+      // Set the top-level types
+      for (const topLevel of Object.keys(schema.topLevelJsonSchemaTypes)) {
+        schemaInput.addTopLevel(
+          topLevel,
+          Ref.parse(`${schema.sourceURI}#/${topLevel}`),
+        );
+      }
+      for (const [name, reference] of Object.entries(
+        schema.topLevelJsonSchemaLocalRefs,
+      )) {
+        schemaInput.addTopLevel(
+          name,
+          Ref.parse(`${schema.sourceURI}${reference}`),
+        );
+      }
+      mergeSources(mergedSources, schema);
     }
     const inputData = new InputData();
     inputData.addInput(schemaInput);
@@ -95,7 +118,7 @@ export class Generator {
     // Update renderer options with the prepared schema
     const rendererOptions = {
       nexusOptions: {
-        nexusSchema: schema,
+        nexusSchema: mergedSources,
         firstFilenameSansExtensions: this.options.firstFilenameSansExtensions,
       },
       ...this.options.rendererOptions,
@@ -103,62 +126,86 @@ export class Generator {
 
     // Run quicktype and return
     const returnValue: { [fileName: string]: string } = {};
-    const results = await quicktypeMultiFile({
-      inputData,
-      lang: this.options.lang,
-      rendererOptions,
-    });
-    results.forEach(
-      (contents, fileName) =>
-        (returnValue[fileName] = contents.lines.join("\n")),
-    );
+    try {
+      const results = await quicktypeMultiFile({
+        inputData,
+        lang: this.options.lang,
+        rendererOptions,
+      });
+      results.forEach(
+        (contents, fileName) =>
+          (returnValue[fileName] = contents.lines.join("\n")),
+      );
+    } catch (error: unknown) {
+      if (
+        error instanceof Error &&
+        "properties" in error &&
+        (error as any).messageName === "SchemaFetchError"
+      ) {
+        // If there is an error with schema fetching, the message
+        // produced by quicktype will use an empty string for the address.
+        const { address, base } = (error as any).properties;
+        throw new Error(
+          `Could not fetch schema "${address}", referred to from ${base}`,
+        );
+      }
+      throw error;
+    }
     return returnValue;
   }
 
-  private prepareSchema(): PreparedSchema {
-    const schema: PreparedSchema = {
-      services: {},
-      sharedJsonSchema: {
-        types: this.options.schema.types ?? {},
-      },
-      topLevelJsonSchemaTypes: {},
-      topLevelJsonSchemaLocalRefs: {},
+  private prepareSchemas(): PreparedSchemaSources {
+    const prepared: PreparedSchemaSources = {
+      sources: [],
     };
-    for (const [serviceName, service] of Object.entries(
-      this.options.schema.services || {},
-    )) {
-      schema.services[serviceName] = {
-        description: service.description,
-        operations: {},
+
+    for (const definitionSource of this.options.definitionSources) {
+      const schema: PreparedSchema = {
+        sourceURI: definitionSource.fileURI.toString(),
+        services: {},
+        sharedJsonSchema: {
+          types: definitionSource.schema.types ?? {},
+        },
+        topLevelJsonSchemaTypes: {},
+        topLevelJsonSchemaLocalRefs: {},
       };
-      for (const [operationName, operation] of Object.entries(
-        service.operations,
+      for (const [serviceName, service] of Object.entries(
+        definitionSource.schema.services ?? {},
       )) {
-        const schemaOp: PreparedOperation = {
-          description: operation.description,
+        schema.services[serviceName] = {
+          description: service.description,
+          operations: {},
         };
-        schema.services[serviceName].operations[operationName] = schemaOp;
-        if (operation.input) {
-          schemaOp.input = this.prepareInOutType(
-            schema,
-            serviceName,
-            operationName,
-            operation.input,
-            "Input",
-          );
-        }
-        if (operation.output) {
-          schemaOp.output = this.prepareInOutType(
-            schema,
-            serviceName,
-            operationName,
-            operation.output,
-            "Output",
-          );
+        for (const [operationName, operation] of Object.entries(
+          service.operations,
+        )) {
+          const schemaOp: PreparedOperation = {
+            description: operation.description,
+          };
+          schema.services[serviceName].operations[operationName] = schemaOp;
+          if (operation.input) {
+            schemaOp.input = this.prepareInOutType(
+              schema,
+              serviceName,
+              operationName,
+              operation.input,
+              "Input",
+            );
+          }
+          if (operation.output) {
+            schemaOp.output = this.prepareInOutType(
+              schema,
+              serviceName,
+              operationName,
+              operation.output,
+              "Output",
+            );
+          }
         }
       }
+      prepared.sources.push(schema);
     }
-    return schema;
+    return prepared;
   }
 
   private prepareInOutType(
@@ -214,9 +261,34 @@ export class Generator {
   }
 }
 
-class FetchDisabledSchemaStore extends JSONSchemaStore {
-  fetch(_address: string): Promise<JSONSchema | undefined> {
-    // TODO(cretz): Support this?
-    throw new Error("External $ref unsupported");
+function mergeSources(
+  destination: MergedSources,
+  source: PreparedSchema,
+): void {
+  for (const name of Object.keys(source.topLevelJsonSchemaTypes)) {
+    if (name in destination.topLevelJsonSchemaTypes) {
+      throw new Error(
+        `Duplicate type "${name}" defined across multiple definition files`,
+      );
+    }
+  }
+  for (const name of Object.keys(source.services)) {
+    if (name in destination.services) {
+      throw new Error(
+        `Duplicate service "${name}" defined across multiple definition files`,
+      );
+    }
+  }
+  Object.assign(
+    destination.topLevelJsonSchemaTypes,
+    source.topLevelJsonSchemaTypes,
+  );
+  Object.assign(destination.services, source.services);
+}
+
+class LocalFetchingSchemaStore extends JSONSchemaStore {
+  async fetch(address: string): Promise<JSONSchema | undefined> {
+    const content = await readFile(new URL(address), "utf8");
+    return yaml.parse(content);
   }
 }

package/src/index.ts

@@ -5,4 +5,5 @@ export { GoLanguageWithNexus } from "./language-go.js";
 export { JavaLanguageWithNexus } from "./language-java.js";
 export { PythonLanguageWithNexus } from "./language-python.js";
 export { TypeScriptLanguageWithNexus } from "./language-typescript.js";
+export type { DefinitionSource } from "./definition-source.js";
 export { parseFiles } from "./parser.js";

package/src/language-go.ts

@@ -63,7 +63,7 @@ export class GoLanguageWithNexus extends GoTargetLanguage {
       },
       emitTopLevel(original, t, name) {
         // Do not emit __ALL_TYPES__ placeholder
-        if (name.firstProposedName(new Map()) == "__ALL_TYPES__") {
+        if (name.firstProposedName(new Map()).endsWith("/__ALL_TYPES__")) {
           return;
         }
         original(t, name);

package/src/language-typescript.ts

@@ -220,7 +220,7 @@ class TypeScriptRenderAdapter extends RenderAdapter<TypeScriptRenderAccessible>
       this.render.topLevels,
       "none",
       (t, name, pos) => {
-        if (!t.isPrimitive() || name == "__ALL_TYPES__") {
+        if (!t.isPrimitive() || name.endsWith("/__ALL_TYPES__")) {
           return;
         }
 

package/src/parser.ts

@@ -1,10 +1,12 @@
 import type { DefinitionSchema } from "./definition-schema.js";
+import type { DefinitionSource } from "./definition-source.js";
 
 import jsonSchema from "../schemas/nexus-rpc-gen.json" with { type: "json" };
 import Ajv from "ajv";
 import addFormats from "ajv-formats";
 import yaml from "yaml";
 import { readFile } from "node:fs/promises";
+import { pathToFileURL } from "node:url";
 
 const ajv = new Ajv({
   allErrors: true,
@@ -17,14 +19,8 @@ const ajv = new Ajv({
 
 addFormats(ajv);
 
-export async function parseFiles(files: string[]): Promise<DefinitionSchema> {
-  // TODO(cretz): Multi-file
-  if (files.length != 1) {
-    throw new Error("Must have only 1 file at this time");
-  }
-
-  // Parse YAML
-  const document = yaml.parse(await readFile(files[0], "utf8"));
+async function parseFile(file: string): Promise<DefinitionSource> {
+  const document = yaml.parse(await readFile(file, "utf8"));
 
   // Validate. We recreate the validator because it carries state.
   const valueFunction = await ajv.compileAsync<DefinitionSchema>(jsonSchema);
@@ -42,6 +38,37 @@ export async function parseFiles(files: string[]): Promise<DefinitionSchema> {
           .join(", "),
     );
   }
+  return { fileURI: pathToFileURL(file), schema: document };
+}
+
+export async function parseFiles(files: string[]): Promise<DefinitionSource[]> {
+  if (files.length === 0) {
+    throw new Error("Must have at least 1 file");
+  }
+
+  const results = await Promise.allSettled(files.map(parseFile));
+  const errors: Error[] = [];
+  const sources: DefinitionSource[] = [];
+
+  for (let index = 0; index < results.length; index++) {
+    const result = results[index];
+    if (result.status === "rejected") {
+      errors.push(
+        new Error(`${files[index]}: ${result.reason}`, {
+          cause: result.reason,
+        }),
+      );
+    } else {
+      sources.push(result.value);
+    }
+  }
+
+  if (errors.length > 0) {
+    throw new AggregateError(
+      errors,
+      `Failed to parse ${errors.length} file(s)`,
+    );
+  }
 
-  return document;
+  return sources;
 }

package/src/render-adapter.ts

@@ -8,13 +8,12 @@ import {
 import {
   getNexusRendererOptions,
   type NexusRendererOptions,
-  type PreparedSchema,
+  type MergedSources,
 } from "./generator.js";
 import { proxyWithOverrides } from "./utility.js";
 import type {
   BlankLineConfig,
   ForEachPosition,
-  Renderer,
 } from "quicktype-core/dist/Renderer.js";
 import type {
   ClassProperty,
@@ -42,7 +41,7 @@ export abstract class RenderAdapter<AccessibleRenderer> {
     this.nexusRendererOptions = getNexusRendererOptions(rendererOptions);
   }
 
-  public get schema(): PreparedSchema {
+  public get schema(): MergedSources {
     return this.nexusRendererOptions.nexusSchema;
   }