@nexus-rpc/gen-core 0.1.0-alpha0

package/src/language-python.ts

@@ -0,0 +1,260 @@
+import {
+  ClassType,
+  ConvenienceRenderer,
+  Name,
+  Namer,
+  pythonOptions,
+  PythonRenderer,
+  PythonTargetLanguage,
+  Type,
+  type LanguageName,
+  type OptionValues,
+  type RenderContext,
+  type RendererOptions,
+  type Sourcelike,
+} from "quicktype-core";
+import { RenderAdapter, type RenderAccessible } from "./render-adapter.js";
+import type { PreparedService, PreparedTypeReference } from "./generator.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 {
+  protected override makeRenderer<Lang extends LanguageName = "python">(
+    renderContext: RenderContext,
+    untypedOptionValues: RendererOptions<Lang>,
+  ): PythonRenderer {
+    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();
+      },
+    });
+  }
+}
+
+type PythonRenderAccessible = PythonRenderer &
+  RenderAccessible & {
+    readonly pyOptions: OptionValues<typeof pythonOptions>;
+    declareType<T extends Type>(t: T, emitter: () => void): void;
+    emitBlock(line: Sourcelike, f: () => void): void;
+    emitClass(t: ClassType): void;
+    emitClosingCode(): void;
+    emitImports(): void;
+    emitSourceStructure(givenOutputFilename: string): void;
+    pythonType(t: Type, isRootTypeDef: boolean): Sourcelike;
+    string(s: string): Sourcelike;
+    typeHint(...sl: Sourcelike[]): Sourcelike;
+    withImport(module: string, name: string): Sourcelike;
+  };
+
+const emptyNameMap: ReadonlyMap<Name, string> = new Map();
+
+class PythonRenderAdapter extends RenderAdapter<PythonRenderAccessible> {
+  private readonly typeNamer: Namer;
+  private readonly propertyNamer: Namer;
+
+  constructor(render: ConvenienceRenderer, rendererOptions: 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: string[] = [];
+    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: string, serviceSchema: PreparedService) {
+    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: ClassType) {
+    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: PreparedTypeReference | undefined,
+  ): Sourcelike | undefined {
+    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/src/language-typescript.ts

@@ -0,0 +1,288 @@
+import {
+  ClassType,
+  Name,
+  tsFlowOptions,
+  Type,
+  TypeScriptRenderer,
+  TypeScriptTargetLanguage,
+  type LanguageName,
+  type MultiWord,
+  type RenderContext,
+  type RendererOptions,
+  type Sourcelike,
+} from "quicktype-core";
+import { RenderAdapter, type RenderAccessible } from "./render-adapter.js";
+import type { PreparedService, PreparedTypeReference } from "./generator.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 {
+  protected override get defaultIndentation(): string {
+    // We want two-space indent to be default for TypeScript
+    return "  ";
+  }
+
+  protected override makeRenderer<Lang extends LanguageName = "typescript">(
+    renderContext: RenderContext,
+    untypedOptionValues: RendererOptions<Lang>,
+  ): TypeScriptRenderer {
+    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();
+      },
+    });
+  }
+}
+
+type TypeScriptRenderAccessible = TypeScriptRenderer &
+  RenderAccessible & {
+    emitBlock(source: Sourcelike, end: Sourcelike, emit: () => void): void;
+    emitSourceStructure(): void;
+    emitTypes(): void;
+    nameStyle(original: string, upper: boolean): string;
+    sourceFor(t: Type): MultiWord;
+  };
+
+interface ExistingType {
+  type: string;
+  from?: string;
+  alias?: string;
+}
+
+class TypeScriptRenderAdapter extends RenderAdapter<TypeScriptRenderAccessible> {
+  private _existingTypes?: Record<string, ExistingType>;
+
+  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(): Record<string, ExistingType> {
+    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: 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: Record<string, ExistingType[]> = {};
+    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: string, serviceSchema: PreparedService) {
+    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: ClassType, n: Name) => (this.render as any).emitClass(c, n),
+      (enm, n) => (this.render as any).emitEnum(enm, n),
+      (u, n) => (this.render as any).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: PreparedTypeReference | undefined,
+  ): Sourcelike | undefined {
+    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: string): boolean {
+    // We also want to forbid any Object functions
+    return super.opNameForbidden(name) || name in {};
+  }
+}

package/src/parser.ts

@@ -0,0 +1,47 @@
+import type { DefinitionSchema } from "./definition-schema.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";
+
+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: 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"));
+
+  // Validate. We recreate the validator because it carries state.
+  const valueFunction = await ajv.compileAsync<DefinitionSchema>(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;
+}