@nexus-rpc/gen-core 0.1.0-alpha0

package/dist/language-java.js

@@ -0,0 +1,111 @@
+import { javaOptions, JavaRenderer, JavaTargetLanguage, Namer, Type, } from "quicktype-core";
+import { RenderAdapter } from "./render-adapter.js";
+import { splitDescription } from "./utility.js";
+import { stringEscape } from "quicktype-core/dist/language/Java/utils.js";
+// Change some defaults globally
+javaOptions.packageName.definition.defaultValue = "com.example.nexusservices";
+export class JavaLanguageWithNexus extends JavaTargetLanguage {
+    get defaultIndentation() {
+        // We want two-space indent to be default for Java
+        return "  ";
+    }
+    makeRenderer(renderContext, untypedOptionValues) {
+        const adapter = new JavaRenderAdapter(super.makeRenderer(renderContext, untypedOptionValues), untypedOptionValues);
+        return adapter.makeRenderer({
+            emitSourceStructure(original) {
+                adapter.emitServices();
+                original();
+            },
+            emitConverterClass(original) {
+                // No converter class wanted
+            },
+            forbiddenNamesForGlobalNamespace(original) {
+                const returnValue = original();
+                // We need to adjust some forbidden names to include Object base class items
+                returnValue.push("clone", "equals", "finalize", "getClass", "hashCode", "notify", "notifyAll", "toString", "wait");
+                return returnValue;
+            },
+            startFile(original, basename) {
+                // Prepend a the package name for Java
+                const prepend = adapter.render._options.packageName.replaceAll(".", "/") + "/";
+                original([prepend, basename]);
+                // // Emit generated note
+                // adapter.render.emitLine("// Generated by nexus-rpc-gen. DO NOT EDIT!");
+                // adapter.render.ensureBlankLine();
+            },
+            emitPackageAndImports(original, imports) {
+                adapter.emitGeneratedComment();
+                original(imports);
+            },
+        });
+    }
+}
+class JavaRenderAdapter extends RenderAdapter {
+    emitServices() {
+        for (const [serviceName, serviceSchema] of Object.entries(this.schema.services)) {
+            this.emitService(serviceName, serviceSchema);
+        }
+    }
+    emitService(serviceName, serviceSchema) {
+        // Collect imports
+        const imports = ["io.nexusrpc.Operation", "io.nexusrpc.Service"];
+        for (const [_, op] of Object.entries(serviceSchema.operations)) {
+            if (op.input?.kind == "jsonSchema") {
+                const type = this.render.topLevels.get(op.input.name);
+                if (type) {
+                    imports.push(...this.render.javaImport(type));
+                }
+            }
+            if (op.output?.kind == "jsonSchema") {
+                const type = this.render.topLevels.get(op.output.name);
+                if (type) {
+                    imports.push(...this.render.javaImport(type));
+                }
+            }
+        }
+        // Create class
+        // TODO(cretz): Research addNameForTopLevel and such to prevent service name clash
+        const className = this.makeServiceTypeName(this.render.makeNamedTypeNamer().nameStyle(serviceName));
+        const packagePrepend = this.render._options.packageName.replaceAll(".", "/") + "/";
+        this.emitGeneratedComment();
+        this.render.emitFileHeader([packagePrepend, className], imports);
+        this.render.emitDescription(splitDescription(serviceSchema.description));
+        this.render.emitLine("@Service", className == serviceName
+            ? []
+            : ['(name="', stringEscape(serviceName), '")']);
+        const methodNamesInUse = {};
+        this.render.emitBlock(["public interface ", className], () => {
+            this.render.forEachWithBlankLines(Object.entries(serviceSchema.operations), "interposing", (op, opName, pos) => {
+                this.render.emitDescription(splitDescription(op.description));
+                const methodName = this.makeOperationFunctionName(this.render.namerForObjectProperty().nameStyle(opName), methodNamesInUse);
+                this.render.emitLine("@Operation", methodName == opName ? [] : ['(name="', stringEscape(opName), '")']);
+                const inType = this.getNexusType(op.input);
+                this.render.emitLine(this.getNexusType(op.output) ?? "void", " ", methodName, "(", inType ? [inType, " input"] : [], ");");
+            });
+        });
+        this.render.finishFile();
+    }
+    emitGeneratedComment() {
+        this.render.emitLine("// Generated by nexus-rpc-gen. DO NOT EDIT!");
+        this.render.ensureBlankLine();
+    }
+    emitPackageAndImports(imports) {
+        this.emitGeneratedComment();
+        this.render.emitPackageAndImports(imports);
+    }
+    getNexusType(reference) {
+        if (!reference) {
+            return undefined;
+        }
+        else if (reference.kind == "existing") {
+            return reference.name;
+        }
+        else {
+            const type = this.render.topLevels.get(reference.name);
+            if (!type) {
+                throw new Error(`Unable to find type for ${reference.name}`);
+            }
+            return this.render.javaType(false, type);
+        }
+    }
+}

package/dist/language-python.d.ts

@@ -0,0 +1,4 @@
+import { PythonRenderer, PythonTargetLanguage, type LanguageName, type RenderContext, type RendererOptions } from "quicktype-core";
+export declare class PythonLanguageWithNexus extends PythonTargetLanguage {
+    protected makeRenderer<Lang extends LanguageName = "python">(renderContext: RenderContext, untypedOptionValues: RendererOptions<Lang>): PythonRenderer;
+}

package/dist/language-python.js

@@ -0,0 +1,181 @@
+import { ClassType, ConvenienceRenderer, Name, Namer, pythonOptions, PythonRenderer, PythonTargetLanguage, Type, } from "quicktype-core";
+import { RenderAdapter } from "./render-adapter.js";
+import { splitDescription } from "./utility.js";
+// Change some defaults globally
+pythonOptions.justTypes.definition.defaultValue = true;
+pythonOptions.features.definition.defaultValue = "3.7";
+pythonOptions.nicePropertyNames.definition.defaultValue = true;
+pythonOptions.pydanticBaseModel.definition.defaultValue = true;
+export class PythonLanguageWithNexus extends PythonTargetLanguage {
+    makeRenderer(renderContext, untypedOptionValues) {
+        const adapter = new PythonRenderAdapter(super.makeRenderer(renderContext, untypedOptionValues), untypedOptionValues);
+        adapter.assertValidOptions();
+        return adapter.makeRenderer({
+            emitSourceStructure(original, givenOutputFilename) {
+                // Generated comment
+                adapter.render.emitLine("# Generated by nexus-rpc-gen. DO NOT EDIT!");
+                adapter.render.ensureBlankLine();
+                // We need to add the future annotation
+                // TODO(cretz): Have option to remove this?
+                adapter.render.emitLine("from __future__ import annotations");
+                adapter.render.ensureBlankLine();
+                original(givenOutputFilename);
+                adapter.render.finishFile(adapter.makeFileName());
+            },
+            emitClosingCode(original) {
+                original();
+                // Emit services _after_ all types are present. We choose to be after
+                // the model types so we don't have any "ForwardRef"s to any models
+                // which is not supported by Nexus Python's handler type-checking.
+                adapter.emitServices();
+            },
+            emitClass(_original, t) {
+                adapter.emitClass(t);
+            },
+            emitImports(original) {
+                original();
+                adapter.emitAdditionalImports();
+            },
+        });
+    }
+}
+const emptyNameMap = new Map();
+class PythonRenderAdapter extends RenderAdapter {
+    typeNamer;
+    propertyNamer;
+    constructor(render, rendererOptions) {
+        super(render, rendererOptions);
+        this.typeNamer = this.render.makeNamedTypeNamer();
+        this.propertyNamer = this.render.namerForObjectProperty();
+    }
+    assertValidOptions() {
+        // Currently, we only support specific Python options
+        if (!this.render.pyOptions.justTypes) {
+            throw new Error("Python option for just-types must be set");
+        }
+        if (!this.render.pyOptions.pydanticBaseModel) {
+            throw new Error("Python option for pydantic-model must be set");
+        }
+        if (!this.render.pyOptions.features.typeHints) {
+            throw new Error("Python option to include type hints must be set");
+        }
+    }
+    makeFileName() {
+        // If there is a single service, use that, otherwise use the
+        // filename sans extensions to build it
+        const services = Object.entries(this.schema.services);
+        const name = services.length == 1
+            ? services[0][0]
+            : this.nexusRendererOptions.firstFilenameSansExtensions;
+        return this.propertyNamer.nameStyle(name) + ".py";
+    }
+    emitAdditionalImports() {
+        // We have to emit imports for existing types with dots. Unlike the existing
+        // withImport/emitImports, we do not want from X import Y, we want just
+        // import and we will fully-qualify the types at the usage site.
+        const toImport = [];
+        for (const svcSchema of Object.values(this.schema.services)) {
+            for (const opSchema of Object.values(svcSchema.operations)) {
+                for (const type of [opSchema.input, opSchema.output]) {
+                    if (type?.kind == "existing") {
+                        const lastDot = type.name.lastIndexOf(".");
+                        if (lastDot >= 0 &&
+                            !toImport.includes(type.name.slice(0, lastDot))) {
+                            toImport.push(type.name.slice(0, lastDot));
+                        }
+                    }
+                }
+            }
+        }
+        toImport.sort();
+        for (const module_ of toImport) {
+            this.render.emitLine("import ", module_);
+        }
+    }
+    emitServices() {
+        for (const [serviceName, serviceSchema] of Object.entries(this.schema.services)) {
+            this.emitService(serviceName, serviceSchema);
+        }
+    }
+    emitService(serviceName, serviceSchema) {
+        this.render.ensureBlankLine(2);
+        const typeName = this.makeServiceTypeName(this.typeNamer.nameStyle(serviceName));
+        // Decorator
+        this.render.emitLine("@", this.render.withImport("nexusrpc", "service"), serviceName == typeName
+            ? []
+            : ["(name=", this.render.string(serviceName), ")"]);
+        // Service class with each property
+        this.render.emitBlock(["class ", typeName, ":"], () => {
+            this.render.emitDescription(splitDescription(serviceSchema.description));
+            if (Object.entries(serviceSchema.operations).length == 0) {
+                this.render.emitLine("pass");
+            }
+            const propertyNamesInUse = {};
+            this.render.forEachWithBlankLines(Object.entries(serviceSchema.operations), "interposing", (op, opName, pos) => {
+                const propertyName = this.makeOperationFunctionName(this.propertyNamer.nameStyle(opName), propertyNamesInUse);
+                this.render.emitLine(propertyName, ": ", this.render.withImport("nexusrpc", "Operation"), "[", this.getNexusType(op.input) ?? "None", ", ", this.getNexusType(op.output) ?? "None", "]", opName == propertyName
+                    ? []
+                    : [
+                        " = ",
+                        this.render.withImport("nexusrpc", "Operation"),
+                        "(name=",
+                        this.render.string(opName),
+                        ")",
+                    ]);
+                this.render.emitDescription(splitDescription(op.description));
+            });
+        });
+    }
+    emitClass(t) {
+        this.render.declareType(t, () => {
+            if (t.getProperties().size === 0) {
+                this.render.emitLine("pass");
+                return;
+            }
+            this.render.forEachClassProperty(t, "none", (name, jsonName, cp) => {
+                // Get the type string and append a pydantic Field to it if the name
+                // doesn't match the JSON name.
+                let typeSource = this.render.pythonType(cp.type, true);
+                // const fieldName = name.namingFunction.nameStyle(name.firstProposedName(emptyNameMap));
+                const fieldName = this.render.sourcelikeToString(name);
+                if (fieldName != jsonName) {
+                    // Ellipsis means no default. In optional situations, typeSource has a
+                    // trailing " = None" which we need to remove and set as default
+                    let fieldDefault = "...";
+                    if (Array.isArray(typeSource) && typeSource.at(-1) == " = None") {
+                        typeSource = typeSource.slice(0, -1);
+                        fieldDefault = "None";
+                    }
+                    typeSource = [
+                        typeSource,
+                        " = ",
+                        this.render.withImport("pydantic", "Field"),
+                        "(",
+                        fieldDefault,
+                        ", serialization_alias=",
+                        this.render.string(jsonName),
+                        ")",
+                    ];
+                }
+                this.render.emitLine(name, ": ", typeSource);
+                this.render.emitDescription(this.render.descriptionForClassProperty(t, jsonName));
+            });
+            this.render.ensureBlankLine();
+        });
+    }
+    getNexusType(reference) {
+        if (!reference) {
+            return undefined;
+        }
+        else if (reference.kind == "existing") {
+            return reference.name;
+        }
+        else {
+            const type = this.render.topLevels.get(reference.name);
+            if (!type) {
+                throw new Error(`Unable to find type for ${reference.name}`);
+            }
+            return this.render.pythonType(type, false);
+        }
+    }
+}

package/dist/language-typescript.d.ts

@@ -0,0 +1,5 @@
+import { TypeScriptRenderer, TypeScriptTargetLanguage, type LanguageName, type RenderContext, type RendererOptions } from "quicktype-core";
+export declare class TypeScriptLanguageWithNexus extends TypeScriptTargetLanguage {
+    protected get defaultIndentation(): string;
+    protected makeRenderer<Lang extends LanguageName = "typescript">(renderContext: RenderContext, untypedOptionValues: RendererOptions<Lang>): TypeScriptRenderer;
+}

package/dist/language-typescript.js

@@ -0,0 +1,179 @@
+import { ClassType, Name, tsFlowOptions, Type, TypeScriptRenderer, TypeScriptTargetLanguage, } from "quicktype-core";
+import { RenderAdapter } from "./render-adapter.js";
+import { splitDescription } from "./utility.js";
+import { utf16StringEscape } from "quicktype-core/dist/support/Strings.js";
+// Change some defaults globally
+tsFlowOptions.justTypes.definition.defaultValue = true;
+export class TypeScriptLanguageWithNexus extends TypeScriptTargetLanguage {
+    get defaultIndentation() {
+        // We want two-space indent to be default for TypeScript
+        return "  ";
+    }
+    makeRenderer(renderContext, untypedOptionValues) {
+        const adapter = new TypeScriptRenderAdapter(super.makeRenderer(renderContext, untypedOptionValues), untypedOptionValues);
+        return adapter.makeRenderer({
+            emitSourceStructure(original) {
+                adapter.emitServices();
+                original();
+                adapter.render.finishFile(adapter.makeFileName());
+            },
+            emitTypes(original) {
+                // We cannot use original emitTypes, see override for reason why
+                adapter.emitTypes();
+            },
+        });
+    }
+}
+class TypeScriptRenderAdapter extends RenderAdapter {
+    _existingTypes;
+    makeFileName() {
+        // If there is a single service, use that, otherwise use the
+        // filename sans extensions to build it
+        const services = Object.entries(this.schema.services);
+        if (services.length == 1) {
+            return `${services[0][0]}.ts`;
+        }
+        return `${this.nexusRendererOptions.firstFilenameSansExtensions}.ts`;
+    }
+    // Key is full string as given in schema
+    get existingTypes() {
+        if (this._existingTypes === undefined) {
+            this._existingTypes = {};
+            const inUse = {};
+            for (const serviceSchema of Object.values(this.schema.services)) {
+                for (const opSchema of Object.values(serviceSchema.operations)) {
+                    for (const type of [opSchema.input, opSchema.output]) {
+                        if (type?.kind == "existing") {
+                            // TODO(cretz): Generics with qualified type args that need to be imported?
+                            const lastHash = type.name.lastIndexOf("#");
+                            const existingType = {
+                                type: type.name.slice(lastHash + 1),
+                                from: lastHash == -1 ? undefined : type.name.slice(0, lastHash),
+                            };
+                            // Alias it while it already exists
+                            let alias = existingType.type;
+                            for (let index = 1; Object.hasOwn(inUse, alias) ||
+                                this.topLevelNameInUse(alias, true); index++) {
+                                alias = `${existingType.type}${index}`;
+                            }
+                            if (alias != existingType.type) {
+                                existingType.alias = alias;
+                            }
+                            this._existingTypes[type.name] = existingType;
+                        }
+                    }
+                }
+            }
+        }
+        return this._existingTypes;
+    }
+    emitServices() {
+        // If there are no services, do nothing
+        if (Object.entries(this.schema.services).length == 0) {
+            return;
+        }
+        // Generated comment
+        this.render.emitLine("// Generated by nexus-rpc-gen. DO NOT EDIT!");
+        this.render.ensureBlankLine();
+        // Import Nexus
+        this.render.emitLine('import * as nexus from "nexus-rpc";');
+        // Import all "existing" types
+        const existingTypesByFrom = {};
+        for (const existingType of Object.values(this.existingTypes)) {
+            if (existingType.from) {
+                if (!Object.hasOwn(existingTypesByFrom, existingType.from)) {
+                    existingTypesByFrom[existingType.from] = [];
+                }
+                existingTypesByFrom[existingType.from].push(existingType);
+            }
+        }
+        // TODO(cretz): Better sorting?
+        for (const [from, existingTypes] of Object.entries(existingTypesByFrom).toSorted((a, b) => a[0].localeCompare(b[0]))) {
+            existingTypes.sort((a, b) => a.type.localeCompare(b.type));
+            const pieces = existingTypes.map((t) => {
+                let piece = `type ${t.type}`;
+                if (t.alias)
+                    piece += ` as ${t.alias}`;
+                return piece;
+            });
+            this.render.emitLine("import { ", pieces.join(", "), ' } from "', utf16StringEscape(from), '";');
+        }
+        // Emit each service
+        for (const [serviceName, serviceSchema] of Object.entries(this.schema.services)) {
+            this.emitService(serviceName, serviceSchema);
+        }
+    }
+    emitService(serviceName, serviceSchema) {
+        this.render.ensureBlankLine();
+        const constName = this.makeServiceTypeName(this.render.nameStyle(serviceName, false));
+        this.render.emitDescription(splitDescription(serviceSchema.description));
+        this.render.emitBlock([
+            "export const ",
+            constName,
+            ' = nexus.service("',
+            utf16StringEscape(serviceName),
+            '", ',
+        ], ");", () => {
+            const propertyNamesInUse = {};
+            this.render.forEachWithBlankLines(Object.entries(serviceSchema.operations), "interposing", (op, opName, pos) => {
+                this.render.emitDescription(splitDescription(op.description));
+                const propertyName = this.makeOperationFunctionName(this.render.nameStyle(opName, false), propertyNamesInUse);
+                const opArguments = opName == propertyName
+                    ? []
+                    : ['{ name: "', utf16StringEscape(opName), '" }'];
+                this.render.emitLine(propertyName, ": nexus.operation<", this.getNexusType(op.input) ?? "void", ", ", this.getNexusType(op.output) ?? "void", ">(", opArguments, "),");
+            });
+        });
+    }
+    emitTypes() {
+        // We cannot use original emitTypes because it renders all top level types
+        // as non-export and includes __ALL_TYPES__, but we want export and don't
+        // want that pseudo type. So we copy what Quicktype did mostly, with some
+        // alterations.
+        // Primitives
+        this.render.forEachWithBlankLines(this.render.topLevels, "none", (t, name, pos) => {
+            if (!t.isPrimitive() || name == "__ALL_TYPES__") {
+                return;
+            }
+            this.render.ensureBlankLine();
+            this.render.emitDescription(this.render.descriptionForType(t));
+            this.render.emitLine("export type ", name, " = ", this.render.sourceFor(t).source, ";");
+        });
+        // Named types
+        this.render.forEachNamedType("leading-and-interposing", (c, n) => this.render.emitClass(c, n), (enm, n) => this.render.emitEnum(enm, n), (u, n) => this.render.emitUnion(u, n));
+    }
+    exportTopLevelPrimitives() {
+        // TypeScript rendered by default does not export primitive type aliases, so
+        // we must. First, collect set to export
+        const toExport = Object.keys(this.schema.topLevelJsonSchemaTypes).filter((name) => this.render.topLevels.get(name)?.isPrimitive());
+        // Render if any
+        if (toExport.length > 0) {
+            this.render.ensureBlankLine();
+            this.render.emitLine("export { ", toExport.join(", "), " };");
+        }
+    }
+    getNexusType(reference) {
+        if (!reference) {
+            return undefined;
+        }
+        else if (reference.kind == "existing") {
+            const type = this.existingTypes[reference.name];
+            return type.alias ?? type.type;
+        }
+        else {
+            const type = this.render.topLevels.get(reference.name);
+            if (!type) {
+                throw new Error(`Unable to find type for ${reference.name}`);
+            }
+            // If the type is primitive, use the alias
+            if (type.isPrimitive()) {
+                return reference.name;
+            }
+            return this.render.sourceFor(type).source;
+        }
+    }
+    opNameForbidden(name) {
+        // We also want to forbid any Object functions
+        return super.opNameForbidden(name) || name in {};
+    }
+}

package/dist/parser.d.ts

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

package/dist/parser.js

@@ -0,0 +1,34 @@
+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";
+const ajv = new Ajv({
+    allErrors: true,
+    strict: false,
+    loadSchema: async (uri) => {
+        // TODO(cretz): This
+        throw new Error(`Unable to load remote schema at ${uri} at this time`);
+    },
+});
+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"));
+    // Validate. We recreate the validator because it carries state.
+    const valueFunction = await ajv.compileAsync(jsonSchema);
+    if (!valueFunction(document)) {
+        for (const error of valueFunction.errors ?? []) {
+            console.log(error);
+        }
+        throw new Error(`Found ${valueFunction.errors?.length} error(s): ` +
+            valueFunction.errors
+                ?.map((error) => `${error.instancePath || "(root)"}: ${error.message} (${JSON.stringify(error.params)})`)
+                .join(", "));
+    }
+    return document;
+}

package/dist/render-adapter.d.ts

@@ -0,0 +1,44 @@
+import { ConvenienceRenderer, Name, Namer, type RendererOptions, type Sourcelike } from "quicktype-core";
+import { type NexusRendererOptions, type PreparedSchema } 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";
+type AnyFunction = (...arguments_: any[]) => any;
+export declare abstract class RenderAdapter<AccessibleRenderer> {
+    readonly render: AccessibleRenderer & RenderAccessible & ConvenienceRenderer;
+    protected readonly nexusRendererOptions: NexusRendererOptions;
+    private readonly serviceTypeNamesInUse;
+    constructor(render: ConvenienceRenderer, rendererOptions: RendererOptions);
+    get schema(): PreparedSchema;
+    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;
+    makeServiceTypeName(idealName: string): string;
+    makeOperationFunctionName(idealName: string, inUse: Record<string, boolean>): string;
+    topLevelNameInUse(name: string, includeServices: boolean): boolean;
+    opNameForbidden(name: string): boolean;
+}
+export interface RenderAccessible {
+    readonly typeGraph: TypeGraph;
+    descriptionForClassProperty(o: ObjectType, name: string): string[] | undefined;
+    descriptionForType(t: Type): string[] | undefined;
+    emitDescription(description: Sourcelike[] | undefined): void;
+    emitGatheredSource(items: Sourcelike[]): void;
+    emitLineOnce(...lineParts: Sourcelike[]): void;
+    emitSourceStructure(givenOutputFilename: string): void;
+    emitTable(tableArray: Sourcelike[][]): void;
+    finishFile(filename: string): void;
+    forbiddenForObjectProperties(_o: ObjectType, _className: Name): ForbiddenWordsInfo;
+    forbiddenNamesForGlobalNamespace(): readonly string[];
+    forEachClassProperty(o: ObjectType, blankLocations: BlankLineConfig, f: (name: Name, jsonName: string, p: ClassProperty, position: ForEachPosition) => void): void;
+    forEachNamedType(blankLocations: BlankLineConfig, objectFunction: ((c: ClassType, className: Name, position: ForEachPosition) => void) | ((o: ObjectType, objectName: Name, position: ForEachPosition) => void), enumFunction: (enm: EnumType, enumName: Name, position: ForEachPosition) => void, unionFunction: (u: UnionType, unionName: Name, position: ForEachPosition) => void): void;
+    forEachTopLevel(blankLocations: BlankLineConfig, f: (t: Type, name: Name, position: ForEachPosition) => void, predicate?: (t: Type) => boolean): boolean;
+    forEachWithBlankLines<K, V>(iterable: Iterable<[K, V]>, blankLineConfig: BlankLineConfig, emitter: (v: V, k: K, position: ForEachPosition) => void): boolean;
+    gatherSource(emitter: () => void): Sourcelike[];
+    makeNamedTypeNamer(): Namer;
+    makeNameForTopLevel(_t: Type, givenName: string, _maybeNamedType: Type | undefined): Name;
+    nameForNamedType(t: Type): Name;
+    namerForObjectProperty(o: ObjectType, p: ClassProperty): Namer | null;
+    sourcelikeToString(source: Sourcelike): string;
+}
+export {};

package/dist/render-adapter.js

@@ -0,0 +1,88 @@
+import { ConvenienceRenderer, Name, Namer, } from "quicktype-core";
+import { getNexusRendererOptions, } from "./generator.js";
+import { proxyWithOverrides } from "./utility.js";
+import { FixedName } from "quicktype-core/dist/Naming.js";
+export class RenderAdapter {
+    render;
+    nexusRendererOptions;
+    serviceTypeNamesInUse = {};
+    constructor(render, rendererOptions) {
+        this.render = render;
+        this.nexusRendererOptions = getNexusRendererOptions(rendererOptions);
+    }
+    get schema() {
+        return this.nexusRendererOptions.nexusSchema;
+    }
+    makeRenderer(overrides) {
+        return proxyWithOverrides(this.render, overrides);
+    }
+    makeServiceTypeName(idealName) {
+        // If name in use but not with services, suffix "Service"
+        if (this.topLevelNameInUse(idealName, false)) {
+            idealName += "Service";
+        }
+        // If name in use, append number, starting with 2
+        if (this.topLevelNameInUse(idealName, true)) {
+            for (let index = 2;; index++) {
+                if (!this.topLevelNameInUse(`${idealName}${index}`, true)) {
+                    idealName += `${index}`;
+                    break;
+                }
+            }
+        }
+        this.serviceTypeNamesInUse[idealName] = true;
+        return idealName;
+    }
+    makeOperationFunctionName(idealName, inUse) {
+        // If forbidden, suffix with "Operation"
+        if (this.opNameForbidden(idealName)) {
+            idealName += "Operation";
+        }
+        // Append numbers starting with 2 if already in use
+        if (Object.hasOwn(inUse, idealName)) {
+            for (let index = 2;; index++) {
+                if (!Object.hasOwn(inUse, `${idealName}${index}`)) {
+                    idealName += `${index}`;
+                    break;
+                }
+            }
+        }
+        inUse[idealName] = true;
+        return idealName;
+    }
+    topLevelNameInUse(name, includeServices) {
+        // Considered in use if forbidden
+        if (this.render.forbiddenNamesForGlobalNamespace().includes(name)) {
+            return true;
+        }
+        // Check services
+        if (includeServices && Object.hasOwn(this.serviceTypeNamesInUse, name)) {
+            return true;
+        }
+        let inNames = false;
+        this.render.names.forEach((value) => {
+            if (value == name) {
+                inNames = true;
+            }
+        });
+        return inNames;
+    }
+    opNameForbidden(name) {
+        // TODO(cretz): hacking undefined in for object type ok?
+        const info = this.render.forbiddenForObjectProperties(undefined, new FixedName(name));
+        if (info.includeGlobalForbidden && this.topLevelNameInUse(name, true)) {
+            return true;
+        }
+        for (const badName of info.names) {
+            if (badName instanceof Name) {
+                if (name == this.render.names.get(badName)) {
+                    return true;
+                }
+            }
+            else if (name == badName) {
+                return true;
+            }
+        }
+        return false;
+    }
+}

package/dist/utility.d.ts

@@ -0,0 +1,10 @@
+type AnyFunction = (...arguments_: any[]) => any;
+/**
+ * A helper that proxies an instance and overrides selected methods.
+ * The overrides receive both the original method and its typed parameters.
+ */
+export declare function proxyWithOverrides<T extends object>(instance: T, overrides: {
+    [K in keyof T]?: T[K] extends AnyFunction ? (this: T, original: T[K], ...arguments_: Parameters<T[K]>) => ReturnType<T[K]> : never;
+}): T;
+export declare function splitDescription(string_: string | undefined): string[] | undefined;
+export {};