@nexus-rpc/gen-core 0.1.0-alpha0

package/dist/definition-schema.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Definition for Nexus RPC services and operations
+ */
+export interface DefinitionSchema {
+    nexusrpc: string;
+    services?: {
+        [key: string]: ServiceValue;
+    };
+    types?: {
+        [key: string]: {
+            [key: string]: any;
+        };
+    };
+}
+export interface ServiceValue {
+    description?: string;
+    operations: {
+        [key: string]: OperationValue;
+    };
+}
+export interface OperationValue {
+    description?: string;
+    input?: {
+        [key: string]: any;
+    };
+    output?: {
+        [key: string]: any;
+    };
+}

package/dist/definition-schema.js

@@ -0,0 +1,3 @@
+/* eslint-disable */
+// ⚠️ This file is generated. Do not edit manually.
+export {};

package/dist/generator.d.ts

@@ -0,0 +1,53 @@
+import { type LanguageName, type RendererOptions, type TargetLanguage } from "quicktype-core";
+import type { DefinitionSchema } from "./definition-schema";
+export interface GeneratorOptions<Lang extends LanguageName = LanguageName> {
+    lang: TargetLanguage;
+    schema: DefinitionSchema;
+    rendererOptions: RendererOptions<Lang>;
+    firstFilenameSansExtensions: string;
+}
+export interface PreparedSchema {
+    services: {
+        [key: string]: PreparedService;
+    };
+    sharedJsonSchema: {
+        types: {
+            [key: string]: any;
+        };
+    };
+    topLevelJsonSchemaTypes: {
+        [key: string]: any;
+    };
+    topLevelJsonSchemaLocalRefs: {
+        [key: string]: any;
+    };
+}
+export interface PreparedService {
+    description?: string;
+    operations: {
+        [key: string]: PreparedOperation;
+    };
+}
+export interface PreparedOperation {
+    description?: string;
+    input?: PreparedTypeReference;
+    output?: PreparedTypeReference;
+}
+export interface PreparedTypeReference {
+    kind: "jsonSchema" | "existing";
+    name: string;
+}
+export interface NexusRendererOptions {
+    nexusSchema: PreparedSchema;
+    firstFilenameSansExtensions: string;
+}
+export declare function getNexusRendererOptions(rendererOptions: RendererOptions): NexusRendererOptions;
+export declare class Generator {
+    private readonly options;
+    constructor(options: GeneratorOptions);
+    generate(): Promise<{
+        [fileName: string]: string;
+    }>;
+    private prepareSchema;
+    private prepareInOutType;
+}

package/dist/generator.js

@@ -0,0 +1,128 @@
+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";
+export function getNexusRendererOptions(rendererOptions) {
+    return rendererOptions.nexusOptions;
+}
+export class Generator {
+    options;
+    constructor(options) {
+        this.options = options;
+    }
+    async generate() {
+        // Prepare schema
+        const schema = this.prepareSchema();
+        // 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 inputData = new InputData();
+        inputData.addInput(schemaInput);
+        // Update renderer options with the prepared schema
+        const rendererOptions = {
+            nexusOptions: {
+                nexusSchema: schema,
+                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")));
+        return returnValue;
+    }
+    prepareSchema() {
+        const schema = {
+            services: {},
+            sharedJsonSchema: {
+                types: this.options.schema.types ?? {},
+            },
+            topLevelJsonSchemaTypes: {},
+            topLevelJsonSchemaLocalRefs: {},
+        };
+        for (const [serviceName, service] of Object.entries(this.options.schema.services || {})) {
+            schema.services[serviceName] = {
+                description: service.description,
+                operations: {},
+            };
+            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");
+                }
+            }
+        }
+        return schema;
+    }
+    prepareInOutType(schema, serviceName, operationName, opInOut, suffix) {
+        // Check for an existing ref for this specific lang first
+        for (const langName of this.options.lang.names) {
+            if (Object.hasOwn(opInOut, `$${langName.toLowerCase()}Ref`)) {
+                return {
+                    kind: "existing",
+                    name: opInOut[`$${langName.toLowerCase()}Ref`],
+                };
+            }
+        }
+        // If it's a single ref of a local "#" type, just set as reference
+        if (Object.hasOwn(opInOut, "$ref") && opInOut["$ref"].startsWith("#")) {
+            const reference = Ref.parse(opInOut["$ref"]);
+            const other = reference.lookupRef(schema.sharedJsonSchema);
+            if (other) {
+                // Default to the title, otherwise last element in path if it's a string key
+                let name = other.title;
+                if (!name) {
+                    const lastReferenceElement = reference.path.at(-1);
+                    if (lastReferenceElement?.kind == PathElementKind.KeyOrIndex) {
+                        name = lastReferenceElement.key;
+                    }
+                }
+                // Only ref it if there is a name
+                if (name) {
+                    // TODO(cretz): Check that this doesn't clash with something already there
+                    schema.topLevelJsonSchemaLocalRefs[name] = opInOut["$ref"];
+                    return { kind: "jsonSchema", name };
+                }
+            }
+        }
+        // TODO(cretz): Customization of generated names
+        // TODO(cretz): Remove the service name prefix by default
+        const name = `${serviceName}${operationName[0].toUpperCase()}${operationName.slice(1)}${suffix}`;
+        if (Object.hasOwn(schema.topLevelJsonSchemaTypes, name)) {
+            throw new Error(`Input/output for ${serviceName}.${operationName} would be named ${name} which clashes`);
+        }
+        schema.topLevelJsonSchemaTypes[name] = opInOut;
+        return { kind: "jsonSchema", name };
+    }
+}
+class FetchDisabledSchemaStore extends JSONSchemaStore {
+    fetch(_address) {
+        // TODO(cretz): Support this?
+        throw new Error("External $ref unsupported");
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+export * from "./definition-schema.js";
+export { Generator, type GeneratorOptions } from "./generator.js";
+export { CSharpLanguageWithNexus } from "./language-csharp.js";
+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 { parseFiles } from "./parser.js";

package/dist/index.js

@@ -0,0 +1,8 @@
+export * from "./definition-schema.js";
+export { Generator } from "./generator.js";
+export { CSharpLanguageWithNexus } from "./language-csharp.js";
+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 { parseFiles } from "./parser.js";

package/dist/language-csharp.d.ts

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

package/dist/language-csharp.js

@@ -0,0 +1,107 @@
+import { ConvenienceRenderer, cSharpOptions, CSharpRenderer, CSharpTargetLanguage, systemTextJsonCSharpOptions, SystemTextJsonCSharpRenderer, Type, } from "quicktype-core";
+import { splitDescription } from "./utility.js";
+import {} from "./generator.js";
+import { namingFunction } from "quicktype-core/dist/language/CSharp/utils.js";
+import { utf16StringEscape } from "quicktype-core/dist/support/Strings.js";
+import { RenderAdapter } from "./render-adapter.js";
+// Change some defaults globally
+cSharpOptions.features.definition.defaultValue = "attributes-only";
+cSharpOptions.framework.definition.defaultValue = "SystemTextJson";
+cSharpOptions.namespace.definition.defaultValue = "NexusServices";
+export class CSharpLanguageWithNexus extends CSharpTargetLanguage {
+    makeRenderer(renderContext, untypedOptionValues) {
+        const adapter = new CSharpRenderAdapter(super.makeRenderer(renderContext, untypedOptionValues), untypedOptionValues);
+        return adapter.makeRenderer({
+            emitSourceStructure(original, givenOutputFilename) {
+                original(givenOutputFilename);
+                adapter.render.finishFile(adapter.makeFileName());
+            },
+            emitTypesAndSupport(original) {
+                adapter.emitServices();
+                original();
+            },
+            emitUsings(original) {
+                adapter.emitUsings();
+                original();
+            },
+            emitDefaultLeadingComments(original) {
+                adapter.emitDefaultLeadingComments();
+                original();
+            },
+        });
+    }
+}
+class CSharpRenderAdapter extends RenderAdapter {
+    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 "I" + namingFunction.nameStyle(services[0][0]) + ".cs";
+        }
+        return (namingFunction.nameStyle(this.nexusRendererOptions.firstFilenameSansExtensions) + ".cs");
+    }
+    emitDefaultLeadingComments() {
+        // If it's System.Text.Json and not using helpers, we need to emit things
+        if (this.render instanceof SystemTextJsonCSharpRenderer &&
+            !this.render._csOptions.features.helpers) {
+            this.render.emitLine("// <auto-generated />");
+            this.render.emitLine("#pragma warning disable CS8618");
+        }
+    }
+    emitUsings() {
+        this.render.emitLine("using NexusRpc;");
+    }
+    emitServices() {
+        for (const [serviceName, serviceSchema] of Object.entries(this.schema.services)) {
+            this.emitService(serviceName, serviceSchema);
+        }
+    }
+    emitService(serviceName, serviceSchema) {
+        // TODO(cretz): Support force-set type name here
+        // TODO(cretz): Support a gen option to not add the "I"
+        // TODO(cretz): Put these I-prefixed names in the forbidden-top-level-names list
+        this.render.ensureBlankLine();
+        // Doc
+        this.render.emitDescription(splitDescription(serviceSchema.description));
+        const typeName = this.makeServiceTypeName("I" + namingFunction.nameStyle(serviceName));
+        this.render.emitLine("[NexusService", 
+        // If the sans-I form doesn't match, set the name explicitly
+        serviceName == typeName.substring(1)
+            ? []
+            : ['("', utf16StringEscape(serviceName), '")'], "]");
+        // Create interface itself
+        this.render.emitLine("public interface ", typeName);
+        const methodNamesInUse = {};
+        this.render.emitBlock(() => {
+            this.render.forEachWithBlankLines(Object.entries(serviceSchema.operations), "interposing", (op, opName, pos) => {
+                // TODO(cretz): Param and return tags
+                this.render.emitDescription(splitDescription(op.description));
+                // Convert the opName to C# style
+                // TODO(cretz): What about reserved words?
+                const methodName = this.makeOperationFunctionName(namingFunction.nameStyle(opName), methodNamesInUse);
+                // Create the attribute
+                this.render.emitLine("[NexusOperation", 
+                // If the method name doesn't match op name, set explicitly
+                methodName == opName ? [] : ['("', utf16StringEscape(opName), '")'], "]");
+                const inType = this.getNexusType(op.input);
+                this.render.emitLine(this.getNexusType(op.output) ?? "void", " ", methodName, "(", inType ? [inType, " input"] : [], ");");
+            });
+        });
+    }
+    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.csType(type);
+        }
+    }
+}

package/dist/language-go.d.ts

@@ -0,0 +1,15 @@
+import { GoRenderer, GoTargetLanguage, type LanguageName, type RenderContext, type RendererOptions } from "quicktype-core";
+import { BooleanOption } from "quicktype-core/dist/RendererOptions/index.js";
+export declare const goWithNexusOptions: {
+    justTypes: BooleanOption<"just-types">;
+    justTypesAndPackage: BooleanOption<"just-types-and-package">;
+    packageName: import("quicktype-core/dist/RendererOptions/index.js").StringOption<"package">;
+    multiFileOutput: BooleanOption<"multi-file-output">;
+    fieldTags: import("quicktype-core/dist/RendererOptions/index.js").StringOption<"field-tags">;
+    omitEmpty: BooleanOption<"omit-empty">;
+    primitivePointers: BooleanOption<"primitive-pointers">;
+};
+export declare class GoLanguageWithNexus extends GoTargetLanguage {
+    getOptions(): typeof goWithNexusOptions;
+    protected makeRenderer<Lang extends LanguageName = "go">(renderContext: RenderContext, untypedOptionValues: RendererOptions<Lang>): GoRenderer;
+}

package/dist/language-go.js

@@ -0,0 +1,213 @@
+import { ConvenienceRenderer, goOptions, GoRenderer, GoTargetLanguage, Name, Namer, Type, } from "quicktype-core";
+import { splitDescription } from "./utility.js";
+import {} from "./generator.js";
+import { RenderAdapter } from "./render-adapter.js";
+import { stringEscape } from "quicktype-core/dist/support/Strings.js";
+import { BooleanOption, getOptionValues, } from "quicktype-core/dist/RendererOptions/index.js";
+import { primitiveValueTypeKinds } from "quicktype-core/dist/language/Golang/utils.js";
+// Add options
+export const goWithNexusOptions = {
+    primitivePointers: new BooleanOption("primitive-pointers", "Use pointers for nullable primitives", false),
+    ...goOptions,
+};
+// Change some defaults globally
+goWithNexusOptions.justTypesAndPackage.definition.defaultValue = true;
+export class GoLanguageWithNexus extends GoTargetLanguage {
+    getOptions() {
+        return goWithNexusOptions;
+    }
+    makeRenderer(renderContext, untypedOptionValues) {
+        const adapter = new GoRenderAdapter(super.makeRenderer(renderContext, untypedOptionValues), untypedOptionValues);
+        adapter.assertValidOptions();
+        const options = getOptionValues(goWithNexusOptions, untypedOptionValues);
+        return adapter.makeRenderer({
+            emitSourceStructure(original) {
+                adapter.emitServices();
+                original();
+                adapter.render.finishFile(adapter.makeFileName());
+            },
+            emitTopLevel(original, t, name) {
+                // Do not emit __ALL_TYPES__ placeholder
+                if (name.firstProposedName(new Map()) == "__ALL_TYPES__") {
+                    return;
+                }
+                original(t, name);
+            },
+            nullableGoType(original, t, withIssues) {
+                // If the kind is a primitive and primitive pointers disabled, just return goType
+                if (!options.primitivePointers &&
+                    primitiveValueTypeKinds.includes(t.kind)) {
+                    return adapter.render.goType(t, withIssues);
+                }
+                return original(t, withIssues);
+            },
+        });
+    }
+}
+class GoRenderAdapter extends RenderAdapter {
+    _imports;
+    assertValidOptions() {
+        // Currently, we only support single-file in Go
+        if (this.render._options.multiFileOutput) {
+            throw new Error("Multi-file output for Go not supported at this time");
+        }
+    }
+    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]}.go`
+            : `${this.nexusRendererOptions.firstFilenameSansExtensions}.go`;
+        return name.toLowerCase();
+    }
+    // Key is qualified import, value is alias
+    get imports() {
+        if (this._imports === undefined) {
+            this._imports = {};
+            // Quicktype does not have a sophisticated import+alias construct for its
+            // renderer because they only ever needed one import. However, since we allow
+            // external types, we must support proper aliasing.
+            const origImports = this.render.collectAllImports();
+            if (!this.render._options.justTypes &&
+                !this.render._options.justTypesAndPackage) {
+                if (this.render.haveNamedUnions &&
+                    !this.render._options.multiFileOutput) {
+                    origImports.add("bytes");
+                    origImports.add("errors");
+                }
+                origImports.add("encoding/json");
+            }
+            origImports.add("github.com/nexus-rpc/sdk-go/nexus");
+            for (const mport of origImports) {
+                this._imports[mport] = mport.split("/").pop();
+            }
+            // Add any external type reference pre-last-dots as imports
+            // TODO(cretz): Generics with qualified type args that need to be imported?
+            const externalTypes = Object.values(this.schema.services).flatMap((svc) => Object.values(svc.operations).flatMap((op) => [
+                op?.input?.kind == "existing" ? op.input.name : null,
+                op?.output?.kind == "existing" ? op.output.name : null,
+            ]));
+            for (const externalType of externalTypes) {
+                const lastDot = externalType?.lastIndexOf(".") ?? -1;
+                if (externalType && lastDot > 0) {
+                    const mport = externalType.slice(0, lastDot);
+                    if (!Object.hasOwn(this._imports, mport)) {
+                        // Append number until an unused alias is found
+                        const origAlias = mport.split("/").pop();
+                        let alias = origAlias;
+                        let number_ = 0;
+                        while (Object.values(this._imports).includes(alias)) {
+                            alias = `${origAlias}${++number_}`;
+                        }
+                        this._imports[mport] = alias;
+                    }
+                }
+            }
+        }
+        return this._imports;
+    }
+    emitServices() {
+        // Package decl
+        if (!this.render._options.justTypes ||
+            this.render._options.justTypesAndPackage) {
+            this.render.emitLineOnce("// Code generated by nexus-rpc-gen. DO NOT EDIT.");
+            this.render.ensureBlankLine();
+            const packageDeclaration = `package ${this.render._options.packageName}`;
+            this.render.emitLineOnce(packageDeclaration);
+            this.render.ensureBlankLine();
+        }
+        // Emit imports. To match goimports, we do all non-dot sorted, followed by blank line,
+        // then all dotted, sorted
+        const imports = Object.entries(this.imports).toSorted(([mportA, _a], [mportB, _b]) => mportA.localeCompare(mportB));
+        for (const [mport, alias] of imports.filter(([mport, _]) => !mport.includes("."))) {
+            const aliasPiece = alias != mport.split("/").pop() ? `${alias} ` : "";
+            // Must be a single string so it caches the full line for "once" so the
+            // Quicktype renderer doesn't render its own forms
+            this.render.emitLineOnce(`import ${aliasPiece}"${mport}"`);
+        }
+        this.render.ensureBlankLine();
+        for (const [mport, alias] of imports.filter(([mport, _]) => mport.includes("."))) {
+            const aliasPiece = alias != mport.split("/").pop() ? `${alias} ` : "";
+            this.render.emitLineOnce(`import ${aliasPiece}"${mport}"`);
+        }
+        // Emit each service
+        for (const [serviceName, serviceSchema] of Object.entries(this.schema.services)) {
+            this.emitService(serviceName, serviceSchema);
+        }
+    }
+    emitService(serviceName, serviceSchema) {
+        this.render.ensureBlankLine();
+        const variableName = this.makeServiceTypeName(this.render.makeNamedTypeNamer().nameStyle(serviceName));
+        // Collect operations
+        const fieldNamesInUse = {};
+        const operations = Object.entries(serviceSchema.operations).flatMap(([opName, opSchema]) => ({
+            descPieces: splitDescription(opSchema.description) ?? [],
+            opName,
+            fieldName: this.makeOperationFunctionName(this.render.namerForObjectProperty().nameStyle(opName), fieldNamesInUse),
+            inType: this.getNexusType(opSchema.input) ?? "nexus.NoValue",
+            outType: this.getNexusType(opSchema.output) ?? "nexus.NoValue",
+        }));
+        // Create var with anonymous struct
+        this.render.emitDescription(splitDescription(serviceSchema.description));
+        this.render.emitLine("var ", variableName, " = struct {");
+        this.render.indent(() => {
+            this.render.emitTable([
+                [["ServiceName", " "], ["string"]],
+                ...operations.flatMap((op) => {
+                    const pieces = [];
+                    if (op.descPieces.length > 0) {
+                        pieces.push([op.descPieces.map((d) => `// ${d}`)]);
+                    }
+                    pieces.push([
+                        [op.fieldName, " "],
+                        ["nexus.OperationReference[", op.inType, ", ", op.outType, "]"],
+                    ]);
+                    return pieces;
+                }),
+            ]);
+        });
+        this.render.emitLine("}{");
+        this.render.indent(() => {
+            this.render.emitTable([
+                [["ServiceName:", " "], [`"${stringEscape(serviceName)}",`]],
+                ...operations.map((op) => [
+                    [op.fieldName + ":", " "],
+                    [
+                        "nexus.NewOperationReference[",
+                        op.inType,
+                        ", ",
+                        op.outType,
+                        `]("${stringEscape(op.opName)}"),`,
+                    ],
+                ]),
+            ]);
+        });
+        this.render.emitLine("}");
+    }
+    getNexusType(reference) {
+        if (!reference) {
+            return undefined;
+        }
+        else if (reference.kind == "existing") {
+            // If there is a dot, need to take qualified package and get alias
+            const lastDot = reference.name.lastIndexOf(".");
+            if (lastDot > 0) {
+                const mport = reference.name.slice(0, lastDot);
+                return `${this.imports[mport]}.${reference.name.slice(lastDot + 1)}`;
+            }
+            return reference.name;
+        }
+        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.goType(type);
+        }
+    }
+}

package/dist/language-java.d.ts

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