Merge pull request #243 from proto-graphql/izumin5210/refactor-core

Remove unused code from codegen-core

Author: izumin5210

.changeset/lovely-rings-approve.md

@@ -0,0 +1,9 @@
+---
+"@proto-graphql/codegen-core": patch
+"@proto-graphql/protoc-plugin-helpers": patch
+"@proto-graphql/proto-descriptors": patch
+"protoc-gen-nexus": patch
+"protoc-gen-pothos": patch
+---
+
+remove unused code from codegen-core

packages/@proto-graphql/codegen-core/src/printer/index.ts

@@ -1,3 +1,4 @@
 export * from "./util";
 export * from "./graphqlExtensions";
 export * from "./print";
+export * from "./options";

packages/@proto-graphql/codegen-core/src/printer/options.ts

@@ -0,0 +1,19 @@
+export const fileLayouts = ["proto_file", "graphql_type"] as const;
+type FileLayout = typeof fileLayouts[number];
+
+type PrinterDSLOptions =
+  | { dsl: "nexus" }
+  | {
+      dsl: "pothos";
+      pothos: { builderPath: string };
+    };
+
+type PrinterProtobufOptions = { protobuf: "google-protobuf" } | { protobuf: "protobufjs" } | { protobuf: "ts-proto" };
+
+export type PrinterCommonOptions = {
+  importPrefix: string | null;
+  fileLayout: FileLayout;
+  filenameSuffix: string;
+};
+
+export type PrinterOptions = PrinterCommonOptions & PrinterDSLOptions & PrinterProtobufOptions;

packages/@proto-graphql/codegen-core/src/printer/util.ts

@@ -1,4 +1,11 @@
-import { ProtoEnum, ProtoField, ProtoMessage, ProtoScalarType } from "@proto-graphql/proto-descriptors";
+import {
+  ProtoEnum,
+  ProtoField,
+  ProtoFile,
+  ProtoMessage,
+  ProtoScalar,
+  ProtoScalarType,
+} from "@proto-graphql/proto-descriptors";
 import { camelCase } from "change-case";
 import * as path from "path";
 import { code, Code, imp } from "ts-poet";
@@ -11,20 +18,19 @@ import {
   ObjectOneofField,
   ObjectType,
   OneofUnionType,
-  PrinterOptions,
-  protoImportPath,
   SquashedOneofUnionType,
 } from "../types";
+import { PrinterOptions } from "./options";
 
 export function filename(
   type: ObjectType | InputObjectType | EnumType | OneofUnionType | SquashedOneofUnionType | InterfaceType,
-  opts: Pick<PrinterOptions, "fileLayout">
+  opts: Pick<PrinterOptions, "dsl" | "fileLayout" | "filenameSuffix">
 ): string {
   switch (opts.fileLayout) {
     case "proto_file":
-      return type.file.filename;
+      return filenameFromProtoFile(type.proto.file, opts);
     case "graphql_type": {
-      return path.join(path.dirname(type.file.filename), `${type.typeName}${type.file.extname}`);
+      return path.join(path.dirname(type.proto.file.name), `${type.typeName}.${opts.dsl}.ts`);
     }
     /* istanbul ignore next */
     default: {
@@ -34,6 +40,18 @@ export function filename(
   }
 }
 
+export function filenameFromProtoFile(file: ProtoFile, opts: Pick<PrinterOptions, "fileLayout" | "filenameSuffix">) {
+  switch (opts.fileLayout) {
+    case "proto_file":
+      return file.name.replace(/\.proto$/, opts.filenameSuffix);
+    /* istanbul ignore next */
+    default: {
+      const _exhaustiveCheck: "graphql_type" = opts.fileLayout;
+      throw "unreachable";
+    }
+  }
+}
+
 export function generatedGraphQLTypeImportPath(
   field:
     | ObjectField<ObjectType | EnumType | InterfaceType | SquashedOneofUnionType>
@@ -171,6 +189,29 @@ export function isProtobufLong(proto: ProtoField): boolean {
   }
 }
 
-export function isWellKnownType(proto: ProtoField["type"]): proto is ProtoMessage {
+export function isProtobufPrimitiveType(proto: ProtoField["type"]): proto is ProtoScalar {
+  return proto.kind === "Scalar";
+}
+
+export function isProtobufWrapperType(proto: ProtoField["type"]): proto is ProtoMessage {
+  return proto.kind === "Message" && proto.file.name === "google/protobuf/wrappers.proto";
+}
+
+export function isProtobufWellKnownType(proto: ProtoField["type"]): proto is ProtoMessage {
   return proto.kind === "Message" && proto.file.name.startsWith("google/protobuf/");
 }
+
+function protoImportPath(t: ProtoMessage | ProtoEnum, o: Pick<PrinterOptions, "protobuf" | "importPrefix">) {
+  const importPath =
+    o.protobuf === "protobufjs"
+      ? path.dirname(t.file.name)
+      : o.protobuf === "ts-proto"
+      ? t.file.name.slice(0, -1 * path.extname(t.file.name).length)
+      : googleProtobufImportPath(t.file);
+  return `${o.importPrefix ? `${o.importPrefix}/` : "./"}${importPath}`.replace(/(?<!:)\/\//, "/");
+}
+
+function googleProtobufImportPath(file: ProtoFile): string {
+  const { dir, name } = path.parse(file.name);
+  return `${dir}/${name}_pb`;
+}

packages/@proto-graphql/codegen-core/src/types/DslFile.ts

@@ -1,21 +1,9 @@
 import { ProtoEnum, ProtoEnumValue } from "@proto-graphql/proto-descriptors";
 import { constantCase } from "change-case";
 import { TypeBase } from "./TypeBase";
-import {
-  createProtoFullName,
-  descriptionFromProto,
-  FullName,
-  GenerationParams,
-  getDeprecationReason,
-  isIgnoredField,
-  protoImportPathOld,
-} from "./util";
+import { descriptionFromProto, getDeprecationReason, isIgnoredField } from "./util";
 
 export class EnumType extends TypeBase<ProtoEnum> {
-  get protoImportPath(): string {
-    return protoImportPathOld(this.proto, this.options);
-  }
-
   get unspecifiedValue(): EnumTypeValue | null {
     return this.valuesWithIgnored.find((v) => v.isUnespecified()) ?? null;
   }
@@ -25,12 +13,12 @@ export class EnumType extends TypeBase<ProtoEnum> {
   }
 
   get valuesWithIgnored(): EnumTypeValue[] {
-    return this.proto.values.map((v) => new EnumTypeValue(v, this.options));
+    return this.proto.values.map((v) => new EnumTypeValue(v));
   }
 }
 
 export class EnumTypeValue {
-  constructor(readonly proto: ProtoEnumValue, private readonly opts: GenerationParams) {}
+  constructor(readonly proto: ProtoEnumValue) {}
 
   get name(): string {
     const prefix = constantCase(this.proto.parent.name);
@@ -49,10 +37,6 @@ export class EnumTypeValue {
     return isIgnoredField(this.proto);
   }
 
-  get fullName(): FullName {
-    return [createProtoFullName(this.proto.parent, this.opts), this.proto.name];
-  }
-
   public isUnespecified(): boolean {
     return this.proto.index === 0 && this.proto.name === `${constantCase(this.proto.parent.name)}_UNSPECIFIED`;
   }

packages/@proto-graphql/codegen-core/src/types/EnumType.ts

@@ -1,12 +1,12 @@
 import { ProtoField, ProtoOneof } from "@proto-graphql/proto-descriptors";
 import * as extensions from "../__generated__/extensions/graphql/schema_pb";
-import { descriptionFromProto, FullName, GenerationParams, getDeprecationReason } from "./util";
+import { descriptionFromProto, getDeprecationReason } from "./util";
 
 export abstract class FieldBase<P extends ProtoField | ProtoOneof> {
-  constructor(readonly proto: P, protected readonly opts: GenerationParams & { dsl: "nexus" | "pothos" }) {}
+  constructor(readonly proto: P) {}
 
   abstract get name(): string;
-  abstract get protoJsName(): string;
+  public abstract isNullable(): boolean;
 
   get description(): string | null {
     return descriptionFromProto(this.proto);
@@ -17,28 +17,11 @@ export abstract class FieldBase<P extends ProtoField | ProtoOneof> {
     return proto.kind === "Field" && proto.list;
   }
 
-  public isNullable(): boolean {
-    throw "unimplemented";
-  }
-
   get deprecationReason(): string | null {
     return getDeprecationReason(this.proto);
   }
 
-  // FIXME: remove
-  public isProtobufjs(): boolean {
-    return this.opts.useProtobufjs;
-  }
-
   public isResolverSkipped(): boolean {
     return this.proto.descriptor.getOptions()?.getExtension(extensions.field)?.getSkipResolver() ?? false;
   }
-
-  public shouldReferenceTypeWithString(): boolean {
-    return this.opts.fileLayout === "proto_file" || this.typeFullName == null;
-  }
-
-  abstract get typeFullName(): FullName | null;
-  abstract get importModules(): { alias: string; module: string }[];
-  abstract shouldNullCheck(): boolean;
 }

packages/@proto-graphql/codegen-core/src/types/FieldBase.ts

@@ -1,138 +1,36 @@
 import { ProtoField } from "@proto-graphql/proto-descriptors";
-import { camelCase } from "change-case";
-import path from "path";
 import * as extensions from "../__generated__/extensions/graphql/schema_pb";
 import { EnumType } from "./EnumType";
 import { FieldBase } from "./FieldBase";
 import { InputObjectType } from "./InputObjectType";
 import { ScalarType } from "./ScalarType";
-import { FullName, GenerationParams, isRequiredField, modulesWithUniqueImportAlias, uniqueImportAlias } from "./util";
+import { isRequiredField } from "./util";
 
 export class InputObjectField<T extends ScalarType | EnumType | InputObjectType> extends FieldBase<ProtoField> {
-  constructor(
-    readonly type: T,
-    readonly parent: InputObjectType,
-    proto: ProtoField,
-    opts: GenerationParams & { dsl: "nexus" | "pothos" }
-  ) {
-    super(proto, opts);
+  constructor(readonly type: T, readonly parent: InputObjectType, proto: ProtoField) {
+    super(proto);
   }
 
   get name(): string {
     return this.proto.descriptor.getOptions()?.getExtension(extensions.field)?.getName() || this.proto.jsonName;
   }
 
-  /**
-   * @override
-   */
-  get protoJsName(): string {
-    if (this.opts.useProtobufjs) return camelCase(this.proto.name);
-    return this.proto.jsonName;
-  }
-
   /**
    * @override
    */
   public override isNullable() {
     return !isRequiredField(this.proto, "input");
   }
 
-  /**
-   * @override
-   */
-  public shouldNullCheck(): boolean {
-    throw "unreachable";
-  }
-
-  get protoSetterType(): "method" | "property" {
-    return this.opts.useProtobufjs ? "property" : "method";
-  }
-
-  get protoSetterNameForGoogleProtobuf(): string {
-    return this.proto.googleProtobufSetterName;
-  }
-
-  get importModules(): { alias: string; module: string; type: "namespace" | "named" }[] {
-    const modulePaths = [];
-    const modules = [];
-    if (this.typeImportPath) {
-      modulePaths.push(this.typeImportPath);
-    }
-    if (
-      this.opts.dsl === "pothos" &&
-      !(this.type instanceof ScalarType) &&
-      this.type.proto.file.name !== this.parent.proto.file.name
-    ) {
-      const file = path.relative(path.dirname(this.parent.filename), this.type.filename);
-      const module = file.slice(0, -path.extname(file).length);
-      modules.push({ alias: this.type.pothosRefObjectName, module, type: "named" as const });
-      if (this.type instanceof InputObjectType) {
-        modules.push({ alias: `${this.type.typeName}$Shape`, module, type: "named" as const });
-      }
-    }
-    return [...modules, ...modulesWithUniqueImportAlias(modulePaths)];
-  }
-
-  get typeFullName(): T extends ScalarType ? FullName | null : FullName {
-    if (this.type instanceof ScalarType) {
-      if (!this.opts.useProtobufjs) return null as any;
-
-      const fn = this.type.protoTypeFullName;
-      if (!fn) return null as any;
-
-      let file: string;
-      {
-        const parentType = this.parent.protoTypeFullName;
-        let parent = parentType[0];
-        for (;;) {
-          if (typeof parent[0] === "string") {
-            file = parent[0];
-            break;
-          }
-          parent = parent[0];
-        }
-      }
-
-      {
-        let parent = fn[0];
-        for (;;) {
-          if (Array.isArray(parent) && typeof parent[0] === "string") {
-            parent.splice(0, 1, file);
-            break;
-          }
-          parent = parent[0];
-        }
-      }
-
-      return fn as any;
-    }
-    if (!this.typeImportPath) {
-      return this.type.typeName as FullName as any;
-    }
-    return [uniqueImportAlias(this.typeImportPath), this.type.typeName] as FullName as any;
-  }
-
-  private get typeImportPath(): string | null {
-    const type: InputObjectType | EnumType | ScalarType = this.type;
-
-    if (type instanceof ScalarType) return type.importPath;
-    if (this.parent.filename === type.filename) return null;
-
-    const [from, to] = [this.parent.filename, type.filename].map((f) => (path.isAbsolute(f) ? `.${path.sep}${f}` : f));
-    const result = path.relative(path.dirname(from), to).replace(/\.ts$/, "");
-    return result.match(/^[\.\/]/) ? result : `./${result}`;
-  }
-
   public toPartialInput(): InputObjectField<T> | PartialInputObjectField<T> {
     if (this.type instanceof InputObjectType) {
       return new PartialInputObjectField(
         (this.type.hasPartialInput() ? this.type.toPartialInput() : this.type) as any,
         this.parent,
-        this.proto,
-        this.opts
+        this.proto
       );
     }
-    return new PartialInputObjectField(this.type, this.parent, this.proto, this.opts);
+    return new PartialInputObjectField(this.type, this.parent, this.proto);
   }
 }