protoc-gen-pothos 0.6.2 → 0.7.0

package/dist/protoc-gen-pothos.cjs

@@ -24,72 +24,350 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 
 // src/protoc-gen-pothos.ts
-var import_protoplugin2 = require("@bufbuild/protoplugin");
+var import_protoplugin3 = require("@bufbuild/protoplugin");
 
 // src/plugin.ts
-var import_protoplugin = require("@bufbuild/protoplugin");
+var import_protoplugin2 = require("@bufbuild/protoplugin");
 var import_protoc_plugin_helpers = require("@proto-graphql/protoc-plugin-helpers");
 
 // package.json
-var version = "0.6.2";
+var version = "0.7.0";
+
+// src/codegen/stringify.ts
+var import_dprint_node = __toESM(require("dprint-node"), 1);
+function formatCode(code2) {
+  return import_dprint_node.default.format("file.ts", code2, {
+    lineWidth: 80,
+    indentWidth: 2,
+    useTabs: false,
+    semiColons: "always",
+    quoteStyle: "alwaysDouble",
+    quoteProps: "asNeeded",
+    newLineKind: "lf",
+    useBraces: "whenNotSingleLine",
+    bracePosition: "sameLineUnlessHanging",
+    singleBodyPosition: "maintain",
+    nextControlFlowPosition: "sameLine",
+    trailingCommas: "onlyMultiLine",
+    operatorPosition: "nextLine",
+    preferHanging: false,
+    preferSingleLine: true,
+    "arrowFunction.useParentheses": "force"
+  });
+}
+__name(formatCode, "formatCode");
 
 // src/printer.ts
-var import_codegen_core10 = require("@proto-graphql/codegen-core");
+var import_codegen_core9 = require("@proto-graphql/codegen-core");
 
 // src/dslgen/printers/index.ts
-var import_codegen_core9 = require("@proto-graphql/codegen-core");
+var import_codegen_core8 = require("@proto-graphql/codegen-core");
 
 // src/dslgen/printers/enumType.ts
 var import_codegen_core2 = require("@proto-graphql/codegen-core");
-var import_ts_poet2 = require("ts-poet");
+
+// src/codegen/code-builder.ts
+var PRINTABLE_ARRAY_MARKER = /* @__PURE__ */ Symbol.for("proto-graphql:printable-array");
+function isPrintableArray(value) {
+  return Array.isArray(value) && PRINTABLE_ARRAY_MARKER in value;
+}
+__name(isPrintableArray, "isPrintableArray");
+function markAsPrintableArray(arr) {
+  Object.defineProperty(arr, PRINTABLE_ARRAY_MARKER, {
+    value: true,
+    enumerable: false,
+    writable: false,
+    configurable: false
+  });
+  return arr;
+}
+__name(markAsPrintableArray, "markAsPrintableArray");
+function code(strings, ...values) {
+  const result = [];
+  for (let i = 0; i < strings.length; i++) {
+    if (strings[i] !== "") {
+      result.push(strings[i]);
+    }
+    if (i < values.length) {
+      const value = values[i];
+      if (value == null) {
+        result.push(String(value));
+      } else if (typeof value === "string") {
+        if (value !== "") {
+          result.push(value);
+        }
+      } else if (typeof value === "number") {
+        result.push(String(value));
+      } else if (Array.isArray(value)) {
+        result.push(...value);
+      } else {
+        result.push(value);
+      }
+    }
+  }
+  if (result.length === 0) {
+    result.push("");
+  }
+  return markAsPrintableArray(result);
+}
+__name(code, "code");
+
+// src/codegen/types.ts
+var import_protoplugin = require("@bufbuild/protoplugin");
+function isImportSymbol(value) {
+  return typeof value === "object" && value !== null && "kind" in value && value.kind === "es_symbol";
+}
+__name(isImportSymbol, "isImportSymbol");
+
+// src/codegen/helpers.ts
+function joinCode(codes, separator) {
+  if (codes.length === 0) {
+    return [];
+  }
+  const result = [];
+  for (let i = 0; i < codes.length; i++) {
+    result.push(...codes[i]);
+    if (separator !== void 0 && i < codes.length - 1) {
+      result.push(separator);
+    }
+  }
+  return result;
+}
+__name(joinCode, "joinCode");
+function escapeString(str) {
+  return str.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/\t/g, "\\t");
+}
+__name(escapeString, "escapeString");
+function compactForCodegen(v) {
+  if (typeof v !== "object") return v;
+  if (v == null) return v;
+  if (Array.isArray(v)) {
+    if (isPrintableArray(v)) {
+      return v;
+    }
+    return v.map(compactForCodegen);
+  }
+  return compactObjForCodegen(v);
+}
+__name(compactForCodegen, "compactForCodegen");
+function compactObjForCodegen(obj) {
+  const result = {};
+  for (const key of Object.keys(obj)) {
+    const v = obj[key];
+    if (v != null) {
+      result[key] = compactForCodegen(v);
+    }
+  }
+  return result;
+}
+__name(compactObjForCodegen, "compactObjForCodegen");
+function literalOf(value) {
+  if (value === null) {
+    return markAsPrintableArray([
+      "null"
+    ]);
+  }
+  if (value === void 0) {
+    return markAsPrintableArray([
+      "undefined"
+    ]);
+  }
+  if (typeof value === "string") {
+    return markAsPrintableArray([
+      `"${escapeString(value)}"`
+    ]);
+  }
+  if (typeof value === "number") {
+    return markAsPrintableArray([
+      String(value)
+    ]);
+  }
+  if (typeof value === "boolean") {
+    return markAsPrintableArray([
+      String(value)
+    ]);
+  }
+  if (Array.isArray(value)) {
+    if (isPrintableArray(value)) {
+      return value;
+    }
+    if (value.length === 0) {
+      return markAsPrintableArray([
+        "[]"
+      ]);
+    }
+    const elements = [
+      "["
+    ];
+    for (let i = 0; i < value.length; i++) {
+      if (i > 0) {
+        elements.push(", ");
+      }
+      elements.push(...literalOf(value[i]));
+    }
+    elements.push("]");
+    return markAsPrintableArray(elements);
+  }
+  if (typeof value === "object") {
+    if (isImportSymbol(value)) {
+      return markAsPrintableArray([
+        value
+      ]);
+    }
+    const obj = value;
+    const keys = Object.keys(obj);
+    if (keys.length === 0) {
+      return markAsPrintableArray([
+        "{}"
+      ]);
+    }
+    const elements = [
+      "{ "
+    ];
+    for (let i = 0; i < keys.length; i++) {
+      if (i > 0) {
+        elements.push(", ");
+      }
+      const key = keys[i];
+      elements.push(`"${escapeString(key)}": `);
+      elements.push(...literalOf(obj[key]));
+    }
+    elements.push(" }");
+    return markAsPrintableArray(elements);
+  }
+  return markAsPrintableArray([
+    String(value)
+  ]);
+}
+__name(literalOf, "literalOf");
 
 // src/dslgen/printers/util.ts
 var path = __toESM(require("path"), 1);
 var import_codegen_core = require("@proto-graphql/codegen-core");
-var import_ts_poet = require("ts-poet");
-function pothosRef(type) {
-  return import_ts_poet.code`${pothosRefName(type)}`;
-}
-__name(pothosRef, "pothosRef");
 function pothosRefName(type) {
   return `${type.typeName}$Ref`;
 }
 __name(pothosRefName, "pothosRefName");
-function shapeType(type) {
-  return import_ts_poet.code`${shapeTypeName(type)}`;
-}
-__name(shapeType, "shapeType");
 function shapeTypeName(type) {
   return `${type.typeName}$Shape`;
 }
 __name(shapeTypeName, "shapeTypeName");
-function fieldTypeRef(field, opts) {
-  const importPath = (0, import_codegen_core.generatedGraphQLTypeImportPath)(field, opts);
-  if (importPath == null) return pothosRef(field.type);
-  const imported = (0, import_ts_poet.imp)(`IMPORTED_PLACEHOLDER@${importPath}`);
-  imported.symbol = pothosRefName(field.type);
-  return import_ts_poet.code`${imported}`;
-}
-__name(fieldTypeRef, "fieldTypeRef");
-function fieldTypeShape(field, opts) {
-  const importPath = (0, import_codegen_core.generatedGraphQLTypeImportPath)(field, opts);
-  if (importPath == null) return shapeType(field.type);
-  const imported = (0, import_ts_poet.imp)(`IMPORTED_PLACEHOLDER@${importPath}`);
-  imported.symbol = shapeTypeName(field.type);
-  return import_ts_poet.code`${imported}`;
-}
-__name(fieldTypeShape, "fieldTypeShape");
-function pothosBuilder(type, opts) {
-  const importPath = opts.pothos.builderPath.startsWith(".") ? path.relative(path.dirname((0, import_codegen_core.filename)(type, opts)), opts.pothos.builderPath) : opts.pothos.builderPath;
-  return import_ts_poet.code`${(0, import_ts_poet.imp)(`builder@${importPath}`)}`;
-}
-__name(pothosBuilder, "pothosBuilder");
+function resolveImportOrLocal(field, opts, symbolName, localPrintable) {
+  const fromFile = (0, import_codegen_core.filename)(field.parent, opts);
+  const toFile = (0, import_codegen_core.filename)(field.type, opts);
+  if (fromFile === toFile) return localPrintable();
+  const importPath = `./${toFile.replace(/\.ts$/, "")}`;
+  return code`${(0, import_protoplugin.createImportSymbol)(symbolName, importPath)}`;
+}
+__name(resolveImportOrLocal, "resolveImportOrLocal");
+function fieldTypeRefPrintable(field, opts) {
+  if (field instanceof import_codegen_core.ObjectOneofField) return pothosRefPrintable(field.type);
+  return resolveImportOrLocal(field, opts, pothosRefName(field.type), () => pothosRefPrintable(field.type));
+}
+__name(fieldTypeRefPrintable, "fieldTypeRefPrintable");
+function shapeTypePrintable(type) {
+  return code`${shapeTypeName(type)}`;
+}
+__name(shapeTypePrintable, "shapeTypePrintable");
+function fieldTypeShapePrintable(field, opts) {
+  return resolveImportOrLocal(field, opts, shapeTypeName(field.type), () => shapeTypePrintable(field.type));
+}
+__name(fieldTypeShapePrintable, "fieldTypeShapePrintable");
+function toProtoFuncName(type) {
+  return `${type.typeName}$toProto`;
+}
+__name(toProtoFuncName, "toProtoFuncName");
+function toProtoFuncPrintable(field, opts) {
+  return resolveImportOrLocal(field, opts, toProtoFuncName(field.type), () => code`${toProtoFuncName(field.type)}`);
+}
+__name(toProtoFuncPrintable, "toProtoFuncPrintable");
+function pothosRefPrintable(type) {
+  return code`${pothosRefName(type)}`;
+}
+__name(pothosRefPrintable, "pothosRefPrintable");
+function pothosBuilderPrintable(opts) {
+  return code`${(0, import_protoplugin.createImportSymbol)("builder", opts.pothos.builderPath)}`;
+}
+__name(pothosBuilderPrintable, "pothosBuilderPrintable");
+function protoTypeSymbol(proto, opts) {
+  const chunks = [
+    proto.name
+  ];
+  let current = proto;
+  while (current.parent != null) {
+    current = current.parent;
+    chunks.unshift(current.name);
+  }
+  const symbolName = chunks.join("_");
+  const importPath = protoImportPath(proto, opts);
+  return (0, import_protoplugin.createImportSymbol)(symbolName, importPath);
+}
+__name(protoTypeSymbol, "protoTypeSymbol");
+function protoSchemaSymbol(proto, opts) {
+  const chunks = [
+    proto.name
+  ];
+  let current = proto;
+  while (current.parent != null) {
+    current = current.parent;
+    chunks.unshift(current.name);
+  }
+  const symbolName = `${chunks.join("_")}Schema`;
+  const importPath = protoImportPath(proto, opts);
+  return (0, import_protoplugin.createImportSymbol)(symbolName, importPath);
+}
+__name(protoSchemaSymbol, "protoSchemaSymbol");
+function protobufCreateSymbol() {
+  return (0, import_protoplugin.createImportSymbol)("create", "@bufbuild/protobuf");
+}
+__name(protobufCreateSymbol, "protobufCreateSymbol");
+function protobufIsMessageSymbol() {
+  return (0, import_protoplugin.createImportSymbol)("isMessage", "@bufbuild/protobuf");
+}
+__name(protobufIsMessageSymbol, "protobufIsMessageSymbol");
+function protobufMessageShapeSymbol() {
+  return (0, import_protoplugin.createImportSymbol)("MessageShape", "@bufbuild/protobuf");
+}
+__name(protobufMessageShapeSymbol, "protobufMessageShapeSymbol");
+function protoRefTypePrintable(proto, opts) {
+  switch (opts.protobuf) {
+    case "ts-proto":
+    case "protobuf-es-v1": {
+      return code`${protoTypeSymbol(proto, opts)}`;
+    }
+    case "protobuf-es": {
+      return code`${protobufMessageShapeSymbol()}<typeof ${protoSchemaSymbol(proto, opts)}>`;
+    }
+  }
+}
+__name(protoRefTypePrintable, "protoRefTypePrintable");
+function protoImportPath(t, o) {
+  let importPath;
+  switch (o.protobuf) {
+    case "ts-proto": {
+      importPath = t.file.name;
+      break;
+    }
+    case "protobuf-es-v1":
+    case "protobuf-es": {
+      const { dir, name } = path.parse(t.file.name);
+      importPath = `${dir}/${name}_pb`;
+      break;
+    }
+    default: {
+      o.protobuf;
+      throw new Error(`unexpected protobuf option: ${o.protobuf}`);
+    }
+  }
+  return `${o.importPrefix ? `${o.importPrefix}/` : "./"}${importPath}`.replace(/(?<!:)\/\//, "/");
+}
+__name(protoImportPath, "protoImportPath");
 
 // src/dslgen/printers/enumType.ts
 function createEnumTypeCode(type, registry, opts) {
   const typeOpts = {
     description: type.description,
-    values: import_ts_poet2.code`{${(0, import_ts_poet2.joinCode)(type.values.filter((v) => !v.isIgnored() && !v.isUnespecified()).map((ev) => import_ts_poet2.code`${ev.name}: ${(0, import_ts_poet2.literalOf)((0, import_codegen_core2.compact)({
+    values: code`{${joinCode(type.values.filter((v) => !v.isIgnored() && !v.isUnespecified()).map((ev) => code`${ev.name}: ${literalOf(compactForCodegen({
       description: ev.description,
       deprecationReason: ev.deprecationReason,
       value: ev.number,
@@ -97,41 +375,38 @@ function createEnumTypeCode(type, registry, opts) {
     }))},`))}} as const`,
     extensions: (0, import_codegen_core2.protobufGraphQLExtensions)(type, registry)
   };
-  const protoTypeExpr = (0, import_codegen_core2.protoType)(type.proto, opts);
-  const refTypeExpr = import_ts_poet2.code`${(0, import_ts_poet2.imp)("EnumRef@@pothos/core")}<${protoTypeExpr}, ${protoTypeExpr}>`;
-  return import_ts_poet2.code`
-    export const ${pothosRef(type)}: ${refTypeExpr} =
-      ${pothosBuilder(type, opts)}.enumType(${(0, import_ts_poet2.literalOf)(type.typeName)}, ${(0, import_ts_poet2.literalOf)((0, import_codegen_core2.compact)(typeOpts))});
+  const protoTypeExpr = protoTypeSymbol(type.proto, opts);
+  const enumRefSymbol = (0, import_protoplugin.createImportSymbol)("EnumRef", "@pothos/core");
+  const refTypeExpr = code`${enumRefSymbol}<${protoTypeExpr}, ${protoTypeExpr}>`;
+  return code`
+    export const ${pothosRefPrintable(type)}: ${refTypeExpr} =
+      ${pothosBuilderPrintable(opts)}.enumType(${literalOf(type.typeName)}, ${literalOf(compactForCodegen(typeOpts))});
   `;
 }
 __name(createEnumTypeCode, "createEnumTypeCode");
 
 // src/dslgen/printers/inputObjectType.ts
-var import_codegen_core6 = require("@proto-graphql/codegen-core");
-var import_ts_poet7 = require("ts-poet");
+var import_codegen_core5 = require("@proto-graphql/codegen-core");
 
 // src/dslgen/printers/field.ts
-var import_codegen_core5 = require("@proto-graphql/codegen-core");
-var import_ts_poet6 = require("ts-poet");
+var import_codegen_core4 = require("@proto-graphql/codegen-core");
 
 // src/dslgen/printers/fieldResolver/enumFieldResolver.ts
-var import_codegen_core3 = require("@proto-graphql/codegen-core");
-var import_ts_poet3 = require("ts-poet");
 function createEnumResolverCode(valueExpr, field, opts) {
   const createBlockStmtCodes = /* @__PURE__ */ __name((valueExpr2) => {
     const chunks = [];
     if (field.type.unspecifiedValue != null) {
-      const escapeCode = field.isNullable() && !field.isList() ? import_ts_poet3.code`return null;` : import_ts_poet3.code`throw new Error("${field.name} is required field. But got unspecified.");`;
-      chunks.push(import_ts_poet3.code`
-        if (${valueExpr2} === ${(0, import_codegen_core3.protoType)(field.type.proto, opts)}.${enumValueJsName(field.type, field.type.unspecifiedValue, opts)}) {
+      const escapeCode = field.isNullable() && !field.isList() ? code`return null;` : code`throw new Error("${field.name} is required field. But got unspecified.");`;
+      chunks.push(code`
+        if (${valueExpr2} === ${protoTypeSymbol(field.type.proto, opts)}.${enumValueJsName(field.type, field.type.unspecifiedValue, opts)}) {
           ${escapeCode}
         }
       `);
     }
     for (const ev of field.type.valuesWithIgnored) {
       if (!ev.isIgnored()) continue;
-      chunks.push(import_ts_poet3.code`
-      if (${valueExpr2} === ${(0, import_codegen_core3.protoType)(field.type.proto, opts)}.${enumValueJsName(field.type, ev, opts)}) {
+      chunks.push(code`
+      if (${valueExpr2} === ${protoTypeSymbol(field.type.proto, opts)}.${enumValueJsName(field.type, ev, opts)}) {
         throw new Error("${ev.name} is ignored in GraphQL schema");
       }
     `);
@@ -139,51 +414,42 @@ function createEnumResolverCode(valueExpr, field, opts) {
     return chunks;
   }, "createBlockStmtCodes");
   if (field.isList()) {
-    const stmts = createBlockStmtCodes(import_ts_poet3.code`item`);
+    const stmts = createBlockStmtCodes(code`item`);
     if (stmts.length === 0) {
-      return import_ts_poet3.code`return ${valueExpr}`;
+      return code`return ${valueExpr}`;
     }
-    return import_ts_poet3.code`return ${valueExpr}.map(item => {
-      ${stmts}
+    return code`return ${valueExpr}.map(item => {
+      ${joinCode(stmts)}
       return item;
     })`;
   }
-  return import_ts_poet3.code`
-    ${createBlockStmtCodes(valueExpr)}
+  return code`
+    ${joinCode(createBlockStmtCodes(valueExpr))}
     return ${valueExpr};
   `;
 }
 __name(createEnumResolverCode, "createEnumResolverCode");
-function enumValueJsName(et, ev, opts) {
+function enumValueJsName(_et, ev, opts) {
   switch (opts.protobuf) {
     case "ts-proto":
       return ev.proto.name;
-    case "protobuf-es": {
+    case "protobuf-es-v1":
+    case "protobuf-es":
       return ev.proto.localName;
-    }
-    case "protobufjs":
-    case "google-protobuf":
-      throw new Error(`Unsupported protobuf: ${opts.protobuf}`);
-    default: {
-      opts;
-      throw "unreachable";
-    }
   }
 }
 __name(enumValueJsName, "enumValueJsName");
 
 // src/dslgen/printers/fieldResolver/nonNullResolver.ts
-var import_ts_poet4 = require("ts-poet");
 function createNonNullResolverCode(valueExpr) {
-  return import_ts_poet4.code`
+  return code`
     return ${valueExpr}!;
   `;
 }
 __name(createNonNullResolverCode, "createNonNullResolverCode");
 
 // src/dslgen/printers/fieldResolver/oneofUnionResolver.ts
-var import_codegen_core4 = require("@proto-graphql/codegen-core");
-var import_ts_poet5 = require("ts-poet");
+var import_codegen_core3 = require("@proto-graphql/codegen-core");
 function createOneofUnionResolverCode(sourceExpr, field, opts) {
   const createBlockStmtCode = /* @__PURE__ */ __name((sourceExpr2, { nullable, list }) => {
     switch (opts.protobuf) {
@@ -192,26 +458,19 @@ function createOneofUnionResolverCode(sourceExpr, field, opts) {
           nullable
         });
       }
+      case "protobuf-es-v1":
       case "protobuf-es": {
         return createBlockStmtCodeForProtobufEs(sourceExpr2, field, opts, {
           nullable,
           list
         });
       }
-      case "google-protobuf":
-      case "protobufjs": {
-        throw new Error(`Unsupported protobuf: ${opts.protobuf}`);
-      }
-      default: {
-        opts;
-        throw "unreachable";
-      }
     }
   }, "createBlockStmtCode");
-  if (field instanceof import_codegen_core4.ObjectField && field.isList()) {
-    return import_ts_poet5.code`
+  if (field instanceof import_codegen_core3.ObjectField && field.isList()) {
+    return code`
       return ${sourceExpr}.map(item => {
-        ${createBlockStmtCode(import_ts_poet5.code`item`, {
+        ${createBlockStmtCode(code`item`, {
       nullable: false,
       list: true
     })}
@@ -226,15 +485,13 @@ function createOneofUnionResolverCode(sourceExpr, field, opts) {
 __name(createOneofUnionResolverCode, "createOneofUnionResolverCode");
 function createBlockStmtCodeForTsProto(sourceExpr, field, opts, { nullable }) {
   const createFieldExpr = /* @__PURE__ */ __name((memberField) => {
-    if (field instanceof import_codegen_core4.ObjectOneofField) {
-      return import_ts_poet5.code`${sourceExpr}.${(0, import_codegen_core4.tsFieldName)(memberField.proto, opts)}`;
+    if (field instanceof import_codegen_core3.ObjectOneofField) {
+      return code`${sourceExpr}.${(0, import_codegen_core3.tsFieldName)(memberField.proto, opts).toString()}`;
     }
-    return import_ts_poet5.code`${sourceExpr}?.${(0, import_codegen_core4.tsFieldName)(memberField.proto, opts)}`;
+    return code`${sourceExpr}?.${(0, import_codegen_core3.tsFieldName)(memberField.proto, opts).toString()}`;
   }, "createFieldExpr");
-  return import_ts_poet5.code`
-    const value = ${(0, import_ts_poet5.joinCode)(field.type.fields.map(createFieldExpr), {
-    on: "??"
-  })};
+  return code`
+    const value = ${joinCode(field.type.fields.map(createFieldExpr), " ?? ")};
     if (value == null) {
       ${nullable ? "return null" : `throw new Error("${field.name} should not be null")`};
     }
@@ -244,25 +501,21 @@ function createBlockStmtCodeForTsProto(sourceExpr, field, opts, { nullable }) {
 __name(createBlockStmtCodeForTsProto, "createBlockStmtCodeForTsProto");
 function createBlockStmtCodeForProtobufEs(sourceExpr, field, opts, { nullable, list }) {
   let valueExpr;
-  switch (true) {
-    case field instanceof import_codegen_core4.ObjectOneofField: {
-      valueExpr = import_ts_poet5.code`${sourceExpr}.${(0, import_codegen_core4.tsFieldName)(field.proto, opts)}.value`;
-      break;
-    }
-    case field instanceof import_codegen_core4.ObjectField: {
-      valueExpr = import_ts_poet5.code`${sourceExpr}${list ? "" : "?"}.${(0, import_codegen_core4.tsFieldName)(field.type.oneofUnionType.proto, opts)}.value`;
-      break;
-    }
-    default: {
-      field;
-      throw "unreachable";
-    }
+  if (field instanceof import_codegen_core3.ObjectOneofField) {
+    valueExpr = code`${sourceExpr}.${(0, import_codegen_core3.tsFieldName)(field.proto, opts).toString()}.value`;
+  } else if (field instanceof import_codegen_core3.ObjectField) {
+    valueExpr = code`${sourceExpr}${list ? "" : "?"}.${(0, import_codegen_core3.tsFieldName)(field.type.oneofUnionType.proto, opts).toString()}.value`;
+  } else {
+    field;
+    throw new Error("unreachable");
   }
+  const memberTypeSymbols = field.type.fields.map((f) => protoTypeSymbol(f.type.proto, opts));
+  const typeAssertion = memberTypeSymbols.length > 0 ? code`${joinCode(memberTypeSymbols.map((s) => code`${s}`), " | ")} | undefined` : code`undefined`;
   if (nullable) {
-    return import_ts_poet5.code`return ${valueExpr};`;
+    return code`return (${valueExpr} ?? null) as ${typeAssertion} | null;`;
   }
-  return import_ts_poet5.code`
-    const value = ${valueExpr};
+  return code`
+    const value = ${valueExpr} as ${typeAssertion};
     if (value == null) {
       throw new Error("${field.name} should not be null");
     }
@@ -272,40 +525,44 @@ function createBlockStmtCodeForProtobufEs(sourceExpr, field, opts, { nullable, l
 __name(createBlockStmtCodeForProtobufEs, "createBlockStmtCodeForProtobufEs");
 
 // src/dslgen/printers/field.ts
+function createGetFieldValueCodePrintable(source, proto, opts) {
+  return code`${source}.${(0, import_codegen_core4.tsFieldName)(proto, opts)}`;
+}
+__name(createGetFieldValueCodePrintable, "createGetFieldValueCodePrintable");
 function createFieldRefCode(field, registry, opts) {
-  const isInput = field instanceof import_codegen_core5.InputObjectField;
-  const baseType = field.type instanceof import_codegen_core5.ScalarType ? (0, import_ts_poet6.literalOf)(field.type.typeName) : fieldTypeRef(field, opts);
-  const sourceExpr = import_ts_poet6.code`source`;
+  const isInput = field instanceof import_codegen_core4.InputObjectField;
+  const baseType = field.type instanceof import_codegen_core4.ScalarType ? literalOf(field.type.typeName) : fieldTypeRefPrintable(field, opts);
+  const sourceExpr = "source";
   let resolverCode;
   if (!isInput) {
-    if (field instanceof import_codegen_core5.ObjectOneofField) {
-      resolverCode = createOneofUnionResolverCode(sourceExpr, field, opts);
+    if (field instanceof import_codegen_core4.ObjectOneofField) {
+      resolverCode = createOneofUnionResolverCode(code`${sourceExpr}`, field, opts);
     } else {
-      const valueExpr = (0, import_codegen_core5.createGetFieldValueCode)(sourceExpr, field.proto, opts);
-      const nullableInProto = field.type instanceof import_codegen_core5.ObjectType || field.type instanceof import_codegen_core5.ScalarType && !field.type.isPrimitive() && !field.type.isWrapperType();
+      const valueExpr = createGetFieldValueCodePrintable(sourceExpr, field.proto, opts);
+      const nullableInProto = field.type instanceof import_codegen_core4.ObjectType || field.type instanceof import_codegen_core4.ScalarType && !field.type.isPrimitive() && !field.type.isWrapperType();
       if (nullableInProto && !field.isNullable()) {
         resolverCode = createNonNullResolverCode(valueExpr);
       }
-      if (field.type instanceof import_codegen_core5.EnumType && field instanceof import_codegen_core5.ObjectField) {
+      if (field.type instanceof import_codegen_core4.EnumType && field instanceof import_codegen_core4.ObjectField) {
         resolverCode = createEnumResolverCode(valueExpr, field, opts);
       }
-      if (field.type instanceof import_codegen_core5.SquashedOneofUnionType && field instanceof import_codegen_core5.ObjectField) {
+      if (field.type instanceof import_codegen_core4.SquashedOneofUnionType && field instanceof import_codegen_core4.ObjectField) {
         resolverCode = createOneofUnionResolverCode(valueExpr, field, opts);
       }
-      if (field.type instanceof import_codegen_core5.ScalarType && field.type.isBytes()) {
+      if (field.type instanceof import_codegen_core4.ScalarType && field.type.isBytes()) {
         if (field.isList()) {
-          resolverCode = import_ts_poet6.code`return ${valueExpr}.map(v => Buffer.from(v));`;
+          resolverCode = code`return ${valueExpr}.map(v => Buffer.from(v));`;
         } else if (field.isNullable()) {
-          resolverCode = import_ts_poet6.code`return ${valueExpr} == null ? null : Buffer.from(${valueExpr});`;
+          resolverCode = code`return ${valueExpr} == null ? null : Buffer.from(${valueExpr});`;
         } else {
-          resolverCode = import_ts_poet6.code`return Buffer.from(${valueExpr});`;
+          resolverCode = code`return Buffer.from(${valueExpr});`;
         }
       }
     }
   }
   const nullableValue = isInput !== field.isNullable();
   const fieldOpts = {
-    type: field.isList() ? import_ts_poet6.code`[${baseType}]` : baseType,
+    type: field.isList() ? code`[${baseType}]` : baseType,
     [isInput ? "required" : "nullable"]: field.isList() ? {
       list: nullableValue,
       items: isInput
@@ -313,15 +570,15 @@ function createFieldRefCode(field, registry, opts) {
     } : nullableValue,
     description: field.description,
     deprecationReason: field.deprecationReason,
-    resolve: resolverCode ? import_ts_poet6.code`${sourceExpr} => {${resolverCode}}` : null,
-    extensions: (0, import_codegen_core5.protobufGraphQLExtensions)(field, registry)
+    resolve: resolverCode ? code`${sourceExpr} => {${resolverCode}}` : null,
+    extensions: (0, import_codegen_core4.protobufGraphQLExtensions)(field, registry)
   };
   const shouldUseFieldFunc = isInput || resolverCode != null;
-  return shouldUseFieldFunc ? import_ts_poet6.code`t.field(${(0, import_ts_poet6.literalOf)((0, import_codegen_core5.compact)(fieldOpts))})` : import_ts_poet6.code`t.expose(${(0, import_ts_poet6.literalOf)((0, import_codegen_core5.tsFieldName)(field.proto, opts))}, ${(0, import_ts_poet6.literalOf)((0, import_codegen_core5.compact)(fieldOpts))})`;
+  return shouldUseFieldFunc ? code`t.field(${literalOf(compactForCodegen(fieldOpts))})` : code`t.expose(${literalOf((0, import_codegen_core4.tsFieldName)(field.proto, opts))}, ${literalOf(compactForCodegen(fieldOpts))})`;
 }
 __name(createFieldRefCode, "createFieldRefCode");
 function createNoopFieldRefCode(opts) {
-  return import_ts_poet6.code`
+  return code`
     t.field({
       type: "Boolean",
       ${opts.input ? "required: false" : "nullable: true"},
@@ -334,192 +591,195 @@ __name(createNoopFieldRefCode, "createNoopFieldRefCode");
 
 // src/dslgen/printers/inputObjectType.ts
 function createInputObjectTypeCode(type, registry, opts) {
-  const shapeTypeCode = import_ts_poet7.code`
-    export type ${shapeType(type)} = {
-      ${(0, import_ts_poet7.joinCode)(type.fields.map((f) => {
+  const fields = type.fields.filter((f) => !(type.options.ignoreNonMessageOneofFields && f.proto.oneof != null && !(f.type instanceof import_codegen_core5.InputObjectType)));
+  const shapeTypeCode = code`
+    export type ${shapeTypePrintable(type)} = {
+      ${joinCode(fields.map((f) => {
     let typeNode;
-    if (f.type instanceof import_codegen_core6.InputObjectType) {
-      typeNode = import_ts_poet7.code`${fieldTypeShape(f, opts)}`;
-      if (f.isList()) typeNode = import_ts_poet7.code`Array<${typeNode}>`;
+    if (f.type instanceof import_codegen_core5.InputObjectType) {
+      typeNode = fieldTypeShapePrintable(f, opts);
+      if (f.isList()) typeNode = code`Array<${typeNode}>`;
     } else {
-      typeNode = import_ts_poet7.code`${(0, import_codegen_core6.protoType)(type.proto, opts)}[${(0, import_ts_poet7.literalOf)((0, import_codegen_core6.tsFieldName)(f.proto, opts))}]`;
+      typeNode = code`${protoTypeSymbol(type.proto, opts)}[${literalOf((0, import_codegen_core5.tsFieldName)(f.proto, opts).toString())}]`;
     }
-    return f.isNullable() ? import_ts_poet7.code`${f.name}?: ${typeNode} | null,` : import_ts_poet7.code`${f.name}: ${f.type instanceof import_codegen_core6.ScalarType && f.type.isCustomScalar() ? import_ts_poet7.code`NonNullable<${typeNode}>` : typeNode},`;
+    return f.isNullable() ? code`${f.name}?: ${typeNode} | null,` : code`${f.name}: ${f.type instanceof import_codegen_core5.ScalarType && f.type.isCustomScalar() ? code`NonNullable<${typeNode}>` : typeNode},`;
   }))}
     };
   `;
-  const refCode = import_ts_poet7.code`
-    export const ${pothosRef(type)}: ${(0, import_ts_poet7.imp)("InputObjectRef@@pothos/core")}<${shapeType(type)}> =
-      ${pothosBuilder(type, opts)}.inputRef<${shapeType(type)}>(${(0, import_ts_poet7.literalOf)(type.typeName)}).implement(
-        ${(0, import_ts_poet7.literalOf)((0, import_codegen_core6.compact)({
-    description: type.description,
-    fields: import_ts_poet7.code`t => ({${type.fields.length > 0 ? type.fields.map((f) => import_ts_poet7.code`${f.name}: ${createFieldRefCode(f, registry, opts)},`) : import_ts_poet7.code`_: ${createNoopFieldRefCode({
+  const needsTypeAssertion = opts.protobuf === "protobuf-es";
+  const inputObjectRefType = code`${(0, import_protoplugin.createImportSymbol)("InputObjectRef", "@pothos/core")}<${shapeTypePrintable(type)}>`;
+  const refCode = code`
+    export const ${pothosRefPrintable(type)}: ${inputObjectRefType} =
+      ${pothosBuilderPrintable(opts)}.inputRef<${shapeTypePrintable(type)}>(${literalOf(type.typeName)}).implement(
+        ${literalOf(compactForCodegen({
+    fields: code`t => ({${fields.length > 0 ? joinCode(fields.map((f) => code`${f.name}: ${createFieldRefCode(f, registry, opts)}`), ", ") : code`_: ${createNoopFieldRefCode({
       input: true
     })}`}})`,
-    extensions: (0, import_codegen_core6.protobufGraphQLExtensions)(type, registry)
+    extensions: (0, import_codegen_core5.protobufGraphQLExtensions)(type, registry),
+    description: type.description
   }))}
-      );
+      )${needsTypeAssertion ? code` as ${inputObjectRefType}` : ""};
   `;
   const codes = [
     shapeTypeCode,
     refCode
   ];
-  if (opts.protobuf === "protobuf-es") {
-    codes.push(createToProtoFuncCode(type, opts));
+  if (opts.protobuf === "protobuf-es-v1" || opts.protobuf === "protobuf-es") {
+    codes.push(createToProtoFuncCode(type, fields, opts));
   }
-  return import_ts_poet7.code` ${codes} `;
+  return joinCode(codes, "\n\n");
 }
 __name(createInputObjectTypeCode, "createInputObjectTypeCode");
-function createToProtoFuncCode(type, opts) {
+function createToProtoFuncCode(type, fields, opts) {
   const oneofFields = {};
-  for (const f of type.fields) {
+  for (const f of fields) {
     if (f.proto.oneof == null) continue;
-    if (!(f.type instanceof import_codegen_core6.InputObjectType)) {
-      throw new Error("Oneof fields must be of message");
+    if (!(f.type instanceof import_codegen_core5.InputObjectType)) {
+      continue;
     }
     oneofFields[f.proto.oneof.name] = [
       ...oneofFields[f.proto.oneof.name] || [],
       f
     ];
   }
-  return import_ts_poet7.code`
-    export function ${toProtoFuncName(type)} (input: ${shapeType(type)} | null | undefined): ${(0, import_codegen_core6.protoType)(type.proto, opts)} {
-      return new ${(0, import_codegen_core6.protoType)(type.proto, opts)}({
-        ${type.fields.filter((f) => f.proto.oneof == null).map((f) => {
-    switch (true) {
-      case f.type instanceof import_codegen_core6.InputObjectType: {
-        const localName = (0, import_codegen_core6.tsFieldName)(f.proto, opts);
-        const toProtoFunc = fieldToProtoFunc(f, opts);
-        if (f.isList()) {
-          return import_ts_poet7.code`${localName}: input?.${f.name}?.map(v => ${toProtoFunc}(v)),`;
-        }
-        return import_ts_poet7.code`${localName}: input?.${f.name} ? ${toProtoFunc}(input.${f.name}) : undefined,`;
-      }
-      case f.type instanceof import_codegen_core6.ScalarType:
-      case f.type instanceof import_codegen_core6.EnumType: {
-        const localName = (0, import_codegen_core6.tsFieldName)(f.proto, opts);
-        return import_ts_poet7.code`${localName}: input?.${f.name} ?? undefined,`;
-      }
-      default: {
-        f.type;
-        throw "unreachable";
+  const protoTypeSym = protoTypeSymbol(type.proto, opts);
+  const fieldAssignments = joinCode(fields.filter((f) => f.proto.oneof == null).map((f) => {
+    const localName = (0, import_codegen_core5.tsFieldName)(f.proto, opts).toString();
+    if (f.type instanceof import_codegen_core5.InputObjectType) {
+      const toProtoFunc = toProtoFuncPrintable(f, opts);
+      if (f.isList()) {
+        return code`${localName}: input?.${f.name}?.map(v => ${toProtoFunc}(v)),`;
       }
+      return code`${localName}: input?.${f.name} ? ${toProtoFunc}(input.${f.name}) : undefined,`;
     }
-  })}
-        ${Object.values(oneofFields).map((fields) => {
-    return import_ts_poet7.code`${(0, import_codegen_core6.tsFieldName)(
+    if (f.type instanceof import_codegen_core5.ScalarType || f.type instanceof import_codegen_core5.EnumType) {
+      return code`${localName}: input?.${f.name} ?? undefined,`;
+    }
+    f.type;
+    throw new Error("unreachable");
+  }), "\n");
+  const oneofAssignments = joinCode(Object.values(oneofFields).map((fields2) => {
+    const oneofName = (0, import_codegen_core5.tsFieldName)(
       // biome-ignore lint/style/noNonNullAssertion: we know it's not null
-      fields[0].proto.oneof,
+      fields2[0].proto.oneof,
       opts
-    )}:${fields.map((f) => import_ts_poet7.code`input?.${f.name} ? { case: "${(0, import_codegen_core6.tsFieldName)(f.proto, opts)}", value: ${fieldToProtoFunc(f, opts)}(input.${f.name}) } :`)} undefined,`;
-  })}
+    ).toString();
+    const cases = fields2.map((f) => {
+      const caseName = (0, import_codegen_core5.tsFieldName)(f.proto, opts).toString();
+      return code`input?.${f.name} ? { case: "${caseName}", value: ${toProtoFuncPrintable(f, opts)}(input.${f.name}) } :`;
+    });
+    return code`${oneofName}: ${joinCode(cases, " ")} undefined,`;
+  }), "\n");
+  if (opts.protobuf === "protobuf-es") {
+    const protoSchemaSym = protoSchemaSymbol(type.proto, opts);
+    return code`
+      export function ${toProtoFuncName(type)} (input: ${shapeTypePrintable(type)} | null | undefined): ${protoTypeSym} {
+        return ${protobufCreateSymbol()}(${protoSchemaSym}, {
+          ${fieldAssignments}
+          ${oneofAssignments}
+        });
+      }
+    `;
+  }
+  return code`
+    export function ${toProtoFuncName(type)} (input: ${shapeTypePrintable(type)} | null | undefined): ${protoTypeSym} {
+      return new ${protoTypeSym}({
+        ${fieldAssignments}
+        ${oneofAssignments}
       });
     }
   `;
 }
 __name(createToProtoFuncCode, "createToProtoFuncCode");
-function toProtoFuncName(type) {
-  return `${type.typeName}$toProto`;
-}
-__name(toProtoFuncName, "toProtoFuncName");
-function fieldToProtoFunc(field, opts) {
-  const importPath = (0, import_codegen_core6.generatedGraphQLTypeImportPath)(field, opts);
-  if (importPath == null) return import_ts_poet7.code`${toProtoFuncName(field.type)}`;
-  const imported = (0, import_ts_poet7.imp)(`IMPORTED_PLACEHOLDER@${importPath}`);
-  imported.symbol = toProtoFuncName(field.type);
-  return import_ts_poet7.code`${imported}`;
-}
-__name(fieldToProtoFunc, "fieldToProtoFunc");
 
 // src/dslgen/printers/objectType.ts
-var import_codegen_core7 = require("@proto-graphql/codegen-core");
-var import_ts_poet8 = require("ts-poet");
+var import_codegen_core6 = require("@proto-graphql/codegen-core");
 function createObjectTypeCode(type, registry, opts) {
-  const isInterface = type instanceof import_codegen_core7.InterfaceType;
+  const isInterface = type instanceof import_codegen_core6.InterfaceType;
   const typeOpts = {
     name: type.typeName,
-    fields: import_ts_poet8.code`t => ({${type.fields.length > 0 ? (0, import_ts_poet8.joinCode)(type.fields.map((f) => import_ts_poet8.code`${f.name}: ${createFieldRefCode(f, registry, opts)},`)) : import_ts_poet8.code`_: ${createNoopFieldRefCode({
+    fields: code`t => ({${type.fields.length > 0 ? joinCode(type.fields.map((f) => code`${f.name}: ${createFieldRefCode(f, registry, opts)},`)) : code`_: ${createNoopFieldRefCode({
       input: false
     })}`}})`,
     description: type.description,
     isTypeOf: isInterface ? void 0 : createIsTypeOfFuncCode(type, registry, opts),
-    extensions: (0, import_codegen_core7.protobufGraphQLExtensions)(type, registry)
+    extensions: (0, import_codegen_core6.protobufGraphQLExtensions)(type, registry)
   };
-  const buildRefFunc = import_ts_poet8.code`${pothosBuilder(type, opts)}.${isInterface ? "interface" : "object"}Ref`;
-  const buildTypeFunc = import_ts_poet8.code`${pothosBuilder(type, opts)}.${isInterface ? "interface" : "object"}Type`;
-  const refFuncTypeArg = isInterface ? import_ts_poet8.code`
+  const buildRefFunc = code`${pothosBuilderPrintable(opts)}.${isInterface ? "interface" : "object"}Ref`;
+  const buildTypeFunc = code`${pothosBuilderPrintable(opts)}.${isInterface ? "interface" : "object"}Type`;
+  const refFuncTypeArg = isInterface ? code`
         Pick<
-          ${(0, import_codegen_core7.protoType)(type.proto, opts)},
-          ${(0, import_ts_poet8.joinCode)(type.fields.map((f) => import_ts_poet8.code`${(0, import_ts_poet8.literalOf)((0, import_codegen_core7.tsFieldName)(f.proto, opts))}`), {
-    on: "|"
-  })}
-        >` : (0, import_codegen_core7.protoType)(type.proto, opts);
-  return import_ts_poet8.code`
-    export const ${pothosRef(type)} = ${buildRefFunc}<${refFuncTypeArg}>(${(0, import_ts_poet8.literalOf)(type.typeName)});
-    ${buildTypeFunc}(${pothosRef(type)}, ${(0, import_ts_poet8.literalOf)((0, import_codegen_core7.compact)(typeOpts))});
+          ${protoRefTypePrintable(type.proto, opts)},
+          ${joinCode(type.fields.map((f) => literalOf((0, import_codegen_core6.tsFieldName)(f.proto, opts))), "|")}
+        >` : protoRefTypePrintable(type.proto, opts);
+  return code`
+    export const ${pothosRefPrintable(type)} = ${buildRefFunc}<${refFuncTypeArg}>(${literalOf(type.typeName)});
+    ${buildTypeFunc}(${pothosRefPrintable(type)}, ${literalOf(compactForCodegen(typeOpts))});
   `;
 }
 __name(createObjectTypeCode, "createObjectTypeCode");
-function createIsTypeOfFuncCode(type, registry, opts) {
+function createIsTypeOfFuncCode(type, _registry, opts) {
   switch (opts.protobuf) {
     case "ts-proto": {
-      return import_ts_poet8.code`
+      return code`
         (source) => {
-          return (source as ${(0, import_codegen_core7.protoType)(type.proto, opts)} | { $type: string & {} }).$type
-            === ${(0, import_ts_poet8.literalOf)(type.proto.typeName)};
+          return (source as ${protoTypeSymbol(type.proto, opts)} | { $type: string & {} }).$type
+            === ${literalOf(type.proto.typeName)};
         }
       `;
     }
-    case "protobuf-es": {
-      return import_ts_poet8.code`
+    case "protobuf-es-v1": {
+      return code`
         (source) => {
-          return source instanceof ${(0, import_codegen_core7.protoType)(type.proto, opts)}
+          return source instanceof ${protoTypeSymbol(type.proto, opts)}
         }
       `;
     }
-    case "google-protobuf":
-    case "protobufjs": {
-      throw new Error(`Unsupported protobuf lib: ${opts.protobuf}`);
-    }
-    default: {
-      opts;
-      throw "unreachable";
+    case "protobuf-es": {
+      return code`
+        (source) => {
+          return ${protobufIsMessageSymbol()}(source, ${protoSchemaSymbol(type.proto, opts)})
+        }
+      `;
     }
   }
 }
 __name(createIsTypeOfFuncCode, "createIsTypeOfFuncCode");
 
 // src/dslgen/printers/oneofUnionType.ts
-var import_codegen_core8 = require("@proto-graphql/codegen-core");
-var import_ts_poet9 = require("ts-poet");
+var import_codegen_core7 = require("@proto-graphql/codegen-core");
 function createOneofUnionTypeCode(type, registry, opts) {
   const typeOpts = {
-    types: type.fields.map((f) => fieldTypeRef(f, opts)),
+    types: type.fields.map((f) => fieldTypeRefPrintable(f, opts)),
     description: type.description,
-    extensions: (0, import_codegen_core8.protobufGraphQLExtensions)(type, registry)
+    extensions: (0, import_codegen_core7.protobufGraphQLExtensions)(type, registry)
   };
-  return import_ts_poet9.code`
-    export const ${pothosRef(type)} =
-      ${pothosBuilder(type, opts)}.unionType(${(0, import_ts_poet9.literalOf)(type.typeName)}, ${(0, import_ts_poet9.literalOf)((0, import_codegen_core8.compact)(typeOpts))});
+  return code`
+    export const ${pothosRefPrintable(type)} =
+      ${pothosBuilderPrintable(opts)}.unionType(${literalOf(type.typeName)}, ${literalOf(compactForCodegen(typeOpts))});
   `;
 }
 __name(createOneofUnionTypeCode, "createOneofUnionTypeCode");
 
 // src/dslgen/printers/index.ts
-function createTypeDslCodes(types, registry, opts) {
+function createTypeDslPrintables(types, registry, opts) {
   return types.flatMap((type) => {
-    if (type instanceof import_codegen_core9.ObjectType) {
-      return createObjectTypeCode(type, registry, opts);
+    if (type instanceof import_codegen_core8.ObjectType) {
+      return [
+        createObjectTypeCode(type, registry, opts)
+      ];
     }
-    if (type instanceof import_codegen_core9.InputObjectType) {
-      return createInputObjectTypeCode(type, registry, opts);
+    if (type instanceof import_codegen_core8.InputObjectType) {
+      return [
+        createInputObjectTypeCode(type, registry, opts)
+      ];
     }
-    if (type instanceof import_codegen_core9.EnumType) {
+    if (type instanceof import_codegen_core8.EnumType) {
       return [
         createEnumTypeCode(type, registry, opts)
       ];
     }
-    if (type instanceof import_codegen_core9.OneofUnionType || type instanceof import_codegen_core9.SquashedOneofUnionType) {
+    if (type instanceof import_codegen_core8.OneofUnionType || type instanceof import_codegen_core8.SquashedOneofUnionType) {
       return [
         createOneofUnionTypeCode(type, registry, opts)
       ];
@@ -528,11 +788,12 @@ function createTypeDslCodes(types, registry, opts) {
     throw "unreachable";
   });
 }
-__name(createTypeDslCodes, "createTypeDslCodes");
+__name(createTypeDslPrintables, "createTypeDslPrintables");
 
 // src/printer.ts
 var allowedProtobufs = [
   "ts-proto",
+  "protobuf-es-v1",
   "protobuf-es"
 ];
 function generateFiles(schema, file) {
@@ -540,41 +801,26 @@ function generateFiles(schema, file) {
   if (!allowedProtobufs.includes(opts.printer.protobuf)) {
     opts.printer.protobuf = "ts-proto";
   }
-  const registry = (0, import_codegen_core10.createRegistryFromSchema)(schema);
-  const types = (0, import_codegen_core10.collectTypesFromFile)(file, opts.type, schema.allFiles);
-  switch (opts.printer.fileLayout) {
-    case "proto_file": {
-      const f = schema.generateFile((0, import_codegen_core10.filenameFromProtoFile)(file, opts.printer));
-      const code10 = (0, import_codegen_core10.printCodes)(createCodes(types, registry, opts.printer), "protoc-gen-pothos", file);
-      f.print(code10.trimEnd());
-      break;
-    }
-    case "graphql_type": {
-      for (const t of types) {
-        const f = schema.generateFile((0, import_codegen_core10.filename)(t, opts.printer));
-        const code10 = (0, import_codegen_core10.printCodes)(createCodes([
-          t
-        ], registry, opts.printer), "protoc-gen-pothos", file);
-        f.print(code10.trimEnd());
-      }
-      break;
-    }
-    default: {
-      const _exhaustiveCheck = opts.printer.fileLayout;
-      throw "unreachable";
-    }
+  const registry = (0, import_codegen_core9.createRegistryFromSchema)(schema);
+  const types = (0, import_codegen_core9.collectTypesFromFile)(file, opts.type, schema.allFiles);
+  const f = schema.generateFile((0, import_codegen_core9.filenameFromProtoFile)(file, opts.printer));
+  const printables = [
+    ...createTypeDslPrintables(types, registry, opts.printer)
+  ];
+  f.preamble(file);
+  if (printables.length === 0) {
+    f.print("export {};");
+    return;
+  }
+  for (const p of printables) {
+    f.print(...p);
+    f.print();
   }
 }
 __name(generateFiles, "generateFiles");
-function createCodes(types, registry, opts) {
-  return [
-    ...createTypeDslCodes(types, registry, opts)
-  ];
-}
-__name(createCodes, "createCodes");
 
 // src/plugin.ts
-var protocGenPothos = (0, import_protoplugin.createEcmaScriptPlugin)({
+var protocGenPothos = (0, import_protoplugin2.createEcmaScriptPlugin)({
   name: "protoc-gen-pothos",
   version: `v${version}`,
   generateTs: (0, import_protoc_plugin_helpers.createTsGenerator)({
@@ -582,12 +828,15 @@ var protocGenPothos = (0, import_protoplugin.createEcmaScriptPlugin)({
     dsl: "pothos"
   }),
   parseOptions: import_protoc_plugin_helpers.parsePothosOptions,
-  // NOTE: force `target=ts`
+  // NOTE: force `target=ts` and apply formatting
   transpile: /* @__PURE__ */ __name((files) => {
-    return files;
+    return files.map((f) => ({
+      ...f,
+      content: formatCode(f.content)
+    }));
   }, "transpile")
 });
 
 // src/protoc-gen-pothos.ts
-(0, import_protoplugin2.runNodeJs)(protocGenPothos);
+(0, import_protoplugin3.runNodeJs)(protocGenPothos);
 //# sourceMappingURL=protoc-gen-pothos.cjs.map