protoc-gen-pothos 0.2.2 → 0.3.0

package/module/dslgen/printers/enumType.js

@@ -1,68 +1,36 @@
-import ts from "typescript";
-import { createBuilderCallExpr, createDeprecationPropertyAssignment, createDescriptionPropertyAssignment, createDslExportConstStmt, onlyNonNull, } from "./util";
+import { compact, protobufGraphQLExtensions } from "@proto-graphql/codegen-core";
+import { code, joinCode, literalOf } from "ts-poet";
+import { pothosBuilder, pothosRef } from "./util";
 /**
  * @example
  * ```ts
- * export cosnt Hello = builder.enumType("Hello", {
+ * export cosnt Hello$Ref = builder.enumType("Hello", {
+ *   values: [
+ *     // ...
+ *   ],
  *   // ...
  * })
  * ```
  */
-export function createEnumTypeDslStmt(type) {
-    return createDslExportConstStmt(type.pothosRefObjectName, createBuilderCallExpr("enumType", [
-        ts.factory.createStringLiteral(type.typeName),
-        ts.factory.createObjectLiteralExpression([
-            createDescriptionPropertyAssignment(type),
-            ts.factory.createPropertyAssignment("values", ts.factory.createAsExpression(ts.factory.createObjectLiteralExpression(type.values
-                .filter((v) => !v.isIgnored() && !v.isUnespecified())
-                .map((ev) => ts.factory.createPropertyAssignment(ev.name, createEnumValueExpr(ev))), true // multiline
-            ), ts.factory.createTypeReferenceNode("const"))),
-            ts.factory.createPropertyAssignment("extensions", createExtensionsObjectLiteralExpr(type)),
-        ].filter(onlyNonNull()), true),
-    ]));
-}
-function createEnumValueExpr(ev) {
-    return ts.factory.createObjectLiteralExpression([
-        createDescriptionPropertyAssignment(ev),
-        createDeprecationPropertyAssignment(ev),
-        ts.factory.createPropertyAssignment("value", ts.factory.createNumericLiteral(ev.number)),
-        ts.factory.createPropertyAssignment("extensions", createExtensionsObjectLiteralExprForEnumValue(ev)),
-    ].filter(onlyNonNull()), true // multiline
-    );
-}
-/**
- * @example
- * ```ts
- * {{
- *   protobufEnum: {
- *     name: "...",
- *     fullName: "...",
- *     package: "...",
- *   },
- * } as ProtobufEnumExtensions)
- * ```
- */
-function createExtensionsObjectLiteralExpr(type) {
-    return ts.factory.createObjectLiteralExpression([
-        ts.factory.createPropertyAssignment("protobufEnum", ts.factory.createObjectLiteralExpression([
-            ts.factory.createPropertyAssignment("name", ts.factory.createStringLiteral(type.proto.name)),
-            ts.factory.createPropertyAssignment("fullName", ts.factory.createStringLiteral(type.proto.fullName.toString())),
-            ts.factory.createPropertyAssignment("package", ts.factory.createStringLiteral(type.proto.file.package)),
-        ], true)),
-    ], true);
-}
-/**
- * @example
- * ```ts
- * ({
- *   protobufEnumValue: {
- *     name: "...",
- *   },
- * } as ProtobufEnumValueExtensions)
- * ```
- */
-function createExtensionsObjectLiteralExprForEnumValue(ev) {
-    return ts.factory.createObjectLiteralExpression([
-        ts.factory.createPropertyAssignment("protobufEnumValue", ts.factory.createObjectLiteralExpression([ts.factory.createPropertyAssignment("name", ts.factory.createStringLiteral(ev.proto.name))], true)),
-    ], true);
+export function createEnumTypeCode(type, opts) {
+    const typeOpts = {
+        description: type.description,
+        values: code `{${joinCode(type.values
+            .filter((v) => !v.isIgnored() && !v.isUnespecified())
+            .map((ev) => code `${ev.name}: ${literalOf(compact({
+            description: ev.description,
+            deprecationReason: ev.deprecationReason,
+            value: ev.number,
+            extensions: {
+                protobufEnumValue: {
+                    name: ev.proto.name,
+                },
+            },
+        }))},`))}} as const`,
+        extensions: protobufGraphQLExtensions(type),
+    };
+    return code `
+    export const ${pothosRef(type)} =
+      ${pothosBuilder(type, opts)}.enumType(${literalOf(type.typeName)}, ${literalOf(compact(typeOpts))});
+  `;
 }

package/module/dslgen/printers/field.js

@@ -1,9 +1,9 @@
-import { EnumType, InputObjectField, ObjectField, ObjectOneofField, ObjectType, ScalarType, SquashedOneofUnionType, } from "@proto-graphql/codegen-core";
-import ts from "typescript";
-import { createEnumResolverStmts } from "./fieldResolver/enumFieldResolver";
-import { createNonNullResolverStmts } from "./fieldResolver/nonNullResolver";
-import { createOneofUnionResolverStmts } from "./fieldResolver/oneofUnionResolver";
-import { createDeprecationPropertyAssignment, createDescriptionPropertyAssignment, onlyNonNull } from "./util";
+import { compact, createGetFieldValueCode, EnumType, InputObjectField, ObjectField, ObjectOneofField, ObjectType, protobufGraphQLExtensions, ScalarType, SquashedOneofUnionType, } from "@proto-graphql/codegen-core";
+import { code, literalOf } from "ts-poet";
+import { createEnumResolverCode } from "./fieldResolver/enumFieldResolver";
+import { createNonNullResolverCode } from "./fieldResolver/nonNullResolver";
+import { createOneofUnionResolverCode } from "./fieldResolver/oneofUnionResolver";
+import { fieldTypeRef } from "./util";
 /**
  * @example
  * ```ts
@@ -24,53 +24,45 @@ import { createDeprecationPropertyAssignment, createDescriptionPropertyAssignmen
  * })
  * ```
  */
-export function createFieldDefinitionExpr(field) {
-    let typeExpr = field.type instanceof ScalarType
-        ? ts.factory.createStringLiteral(field.type.typeName)
-        : ts.factory.createIdentifier(field.type.pothosRefObjectName);
+export function createFieldRefCode(field, opts) {
     const isInput = field instanceof InputObjectField;
-    const nullableToken = ts.factory.createToken(isInput ? ts.SyntaxKind.FalseKeyword : ts.SyntaxKind.TrueKeyword);
-    const nonNullableToken = ts.factory.createToken(isInput ? ts.SyntaxKind.TrueKeyword : ts.SyntaxKind.FalseKeyword);
-    let nullableExpr = field.isNullable() ? nullableToken : nonNullableToken;
-    // let defaultValueExpr: ts.Expression | undefined;
-    if (field.isList()) {
-        typeExpr = ts.factory.createArrayLiteralExpression([typeExpr], false);
-        // if (isInput) {
-        //   defaultValueExpr = ts.factory.createArrayLiteralExpression([], false);
-        // }
-        nullableExpr = ts.factory.createObjectLiteralExpression([
-            ts.factory.createPropertyAssignment("list", nullableExpr),
-            ts.factory.createPropertyAssignment("items", nonNullableToken),
-        ], false);
-    }
-    let createResolveStmts;
+    const baseType = field.type instanceof ScalarType ? literalOf(field.type.typeName) : fieldTypeRef(field, opts);
+    const sourceExpr = code `source`;
+    let resolverCode;
     if (!isInput) {
-        const nullableInProto = field.type instanceof ObjectType ||
-            (field.type instanceof ScalarType && !field.type.isPrimitive() && !field.type.isWrapperType());
-        if (nullableInProto && !field.isNullable()) {
-            createResolveStmts = (sourceExpr) => createNonNullResolverStmts(ts.factory.createPropertyAccessExpression(sourceExpr, field.protoJsName));
-        }
-        if (field.type instanceof EnumType && field instanceof ObjectField) {
-            createResolveStmts = (sourceExpr) => createEnumResolverStmts(ts.factory.createPropertyAccessExpression(sourceExpr, field.protoJsName), field);
-        }
         if (field instanceof ObjectOneofField) {
-            createResolveStmts = (sourceExpr) => createOneofUnionResolverStmts(sourceExpr, field);
+            resolverCode = createOneofUnionResolverCode(sourceExpr, field);
         }
-        if (field.type instanceof SquashedOneofUnionType && field instanceof ObjectField) {
-            createResolveStmts = (sourceExpr) => createOneofUnionResolverStmts(ts.factory.createPropertyAccessExpression(sourceExpr, field.protoJsName), field);
+        else {
+            const valueExpr = createGetFieldValueCode(sourceExpr, field.proto, opts);
+            const nullableInProto = field.type instanceof ObjectType ||
+                (field.type instanceof ScalarType && !field.type.isPrimitive() && !field.type.isWrapperType());
+            if (nullableInProto && !field.isNullable()) {
+                resolverCode = createNonNullResolverCode(valueExpr);
+            }
+            if (field.type instanceof EnumType && field instanceof ObjectField) {
+                resolverCode = createEnumResolverCode(valueExpr, field, opts);
+            }
+            if (field.type instanceof SquashedOneofUnionType && field instanceof ObjectField) {
+                resolverCode = createOneofUnionResolverCode(valueExpr, field);
+            }
         }
     }
-    const fieldOptionsExpr = ts.factory.createObjectLiteralExpression([
-        ts.factory.createPropertyAssignment("type", typeExpr),
-        ts.factory.createPropertyAssignment(isInput ? "required" : "nullable", nullableExpr),
-        createDescriptionPropertyAssignment(field),
-        createDeprecationPropertyAssignment(field),
-        // defaultValueExpr && ts.factory.createPropertyAssignment("defaultValue", defaultValueExpr),
-        createResolveStmts && ts.factory.createPropertyAssignment("resolve", createResolverExpr(createResolveStmts)),
-        ts.factory.createPropertyAssignment("extensions", createExtensionsObjectLiteralExpr(field)),
-    ].filter(onlyNonNull()), true);
-    const shouldUseFieldFunc = field instanceof InputObjectField || createResolveStmts != null;
-    return ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier("t"), ts.factory.createIdentifier(shouldUseFieldFunc ? "field" : "expose")), undefined, shouldUseFieldFunc ? [fieldOptionsExpr] : [ts.factory.createStringLiteral(field.protoJsName), fieldOptionsExpr]);
+    const nullableValue = isInput !== field.isNullable(); /* Logical XOR */
+    const fieldOpts = {
+        type: field.isList() ? code `[${baseType}]` : baseType,
+        [isInput ? "required" : "nullable"]: field.isList()
+            ? { list: nullableValue, items: isInput /* always non-null */ }
+            : nullableValue,
+        description: field.description,
+        deprecationReason: field.deprecationReason,
+        resolve: resolverCode ? code `${sourceExpr} => {${resolverCode}}` : null,
+        extensions: protobufGraphQLExtensions(field),
+    };
+    const shouldUseFieldFunc = isInput || resolverCode != null;
+    return shouldUseFieldFunc
+        ? code `t.field(${literalOf(compact(fieldOpts))})`
+        : code `t.expose(${literalOf(field.proto.jsonName)}, ${literalOf(compact(fieldOpts))})`;
 }
 /**
  * @example
@@ -85,51 +77,13 @@ export function createFieldDefinitionExpr(field) {
  * })
  * ```
  */
-export function createNoopFieldDefinitionExpr(opts) {
-    return ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier("t"), ts.factory.createIdentifier("field")), undefined, [
-        ts.factory.createObjectLiteralExpression([
-            ts.factory.createPropertyAssignment("type", ts.factory.createStringLiteral("Boolean")),
-            opts.input
-                ? ts.factory.createPropertyAssignment("required", ts.factory.createToken(ts.SyntaxKind.FalseKeyword))
-                : ts.factory.createPropertyAssignment("nullable", ts.factory.createToken(ts.SyntaxKind.TrueKeyword)),
-            ts.factory.createPropertyAssignment("description", ts.factory.createStringLiteral("noop field")),
-            opts.input
-                ? null
-                : ts.factory.createMethodDeclaration(undefined, undefined, undefined, "resolve", undefined, undefined, [], undefined, ts.factory.createBlock([
-                    ts.factory.createReturnStatement(ts.factory.createToken(ts.SyntaxKind.TrueKeyword)),
-                ])),
-        ].filter(onlyNonNull()), true),
-    ]);
-}
-function createResolverExpr(createStmts) {
-    return ts.factory.createArrowFunction(undefined, undefined, [ts.factory.createParameterDeclaration(undefined, undefined, undefined, ts.factory.createIdentifier("source"))], undefined, ts.factory.createToken(ts.SyntaxKind.EqualsGreaterThanToken), ts.factory.createBlock(createStmts(ts.factory.createIdentifier("source")), true));
-}
-/**
- * @example
- * ```ts
- * ({
- *   protobufField: {
- *     name: "...",
- *   },
- * } as ProtobufFieldExtensions)
- * ```
- */
-function createExtensionsObjectLiteralExpr(field) {
-    let typeName;
-    if ((field instanceof ObjectField || field instanceof InputObjectField) && field.proto.type !== null) {
-        if (field.proto.type.kind === "Scalar") {
-            typeName = field.proto.type.type;
-        }
-        else {
-            typeName = field.proto.type.fullName.toString();
-        }
-    }
-    return ts.factory.createObjectLiteralExpression([
-        ts.factory.createPropertyAssignment("protobufField", ts.factory.createObjectLiteralExpression([
-            ts.factory.createPropertyAssignment("name", ts.factory.createStringLiteral(field.proto.name)),
-            typeName
-                ? ts.factory.createPropertyAssignment("typeFullName", ts.factory.createStringLiteral(typeName))
-                : undefined,
-        ].filter(onlyNonNull()), true)),
-    ], true);
+export function createNoopFieldRefCode(opts) {
+    return code `
+    t.field({
+      type: "Boolean",
+      ${opts.input ? "required: false" : "nullable: true"},
+      description: "noop field",
+      ${opts.input ? "" : "resolve: () => true,"}
+    })
+  `;
 }

package/module/dslgen/printers/fieldResolver/enumFieldResolver.js

@@ -1,5 +1,5 @@
-import ts from "typescript";
-import { createFullNameExpr, onlyNonNull } from "../util";
+import { protoType } from "@proto-graphql/codegen-core";
+import { code } from "ts-poet";
 /**
  * @example nullable
  * ```ts
@@ -16,46 +16,42 @@ import { createFullNameExpr, onlyNonNull } from "../util";
  * return root.myEnum
  * ```
  */
-export function createEnumResolverStmts(valueExpr, field) {
-    let whenNullStmt = field.isNullable() && !field.isList()
-        ? ts.factory.createReturnStatement(ts.factory.createToken(ts.SyntaxKind.NullKeyword))
-        : ts.factory.createThrowStatement(ts.factory.createNewExpression(ts.factory.createIdentifier("Error"), undefined, [
-            ts.factory.createStringLiteral(`${field.name} is required field. But got unspecified.`),
-        ]));
-    whenNullStmt = ts.factory.createBlock([whenNullStmt], true // multiline
-    );
+export function createEnumResolverCode(valueExpr, field, opts) {
+    const createBlockStmtCodes = (valueExpr) => {
+        const chunks = [];
+        if (field.type.unspecifiedValue != null) {
+            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 (${valueExpr} === ${protoType(field.type.proto, opts)}.${field.type.unspecifiedValue.proto.name}) {
+          ${escapeCode}
+        }
+      `);
+        }
+        for (const ev of field.type.valuesWithIgnored) {
+            if (!ev.isIgnored())
+                continue;
+            chunks.push(code `
+      if (${valueExpr} === ${protoType(field.type.proto, opts)}.${ev.proto.name}) {
+        throw new Error("${ev.name} is ignored in GraphQL schema");
+      }
+    `);
+        }
+        return chunks;
+    };
     if (field.isList()) {
-        const guardStmts = createGuardStmts(ts.factory.createIdentifier("item"), whenNullStmt, field.type.unspecifiedValue, field.type.valuesWithIgnored);
-        if (guardStmts.length === 0) {
-            return [ts.factory.createReturnStatement(valueExpr)];
+        const stmts = createBlockStmtCodes(code `item`);
+        if (stmts.length === 0) {
+            return code `return ${valueExpr}`;
         }
-        return [
-            ts.factory.createReturnStatement(createMapExpr(valueExpr, (itemExpr) => [...guardStmts, ts.factory.createReturnStatement(itemExpr)])),
-        ];
+        return code `return ${valueExpr}.map(item => {
+      ${stmts}
+      return item;
+    })`;
     }
-    return [
-        ...createGuardStmts(valueExpr, whenNullStmt, field.type.unspecifiedValue, field.type.valuesWithIgnored),
-        ts.factory.createReturnStatement(valueExpr),
-    ];
-}
-function createGuardStmts(valueExpr, thenStmt, unspecifiedValue, ignoredValues) {
-    return [
-        unspecifiedValue
-            ? ts.factory.createIfStatement(ts.factory.createBinaryExpression(valueExpr, ts.SyntaxKind.EqualsEqualsEqualsToken, createFullNameExpr(unspecifiedValue.fullName)), thenStmt)
-            : null,
-        ...ignoredValues.map((ev) => ev.isIgnored()
-            ? ts.factory.createIfStatement(ts.factory.createBinaryExpression(valueExpr, ts.SyntaxKind.EqualsEqualsEqualsToken, createFullNameExpr(ev.fullName)), ts.factory.createBlock([
-                ts.factory.createThrowStatement(ts.factory.createNewExpression(ts.factory.createIdentifier("Error"), undefined, [
-                    ts.factory.createStringLiteral(`${ev.name} is ignored in GraphQL schema`),
-                ])),
-            ], true // multiline
-            ))
-            : null),
-    ].filter(onlyNonNull());
-}
-function createMapExpr(listExpr, blockFn) {
-    return ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(listExpr, "map"), undefined, [
-        ts.factory.createArrowFunction(undefined, undefined, [ts.factory.createParameterDeclaration(undefined, undefined, undefined, "item", undefined, undefined, undefined)], undefined, ts.factory.createToken(ts.SyntaxKind.EqualsGreaterThanToken), ts.factory.createBlock(blockFn(ts.factory.createIdentifier("item")), true // multiline
-        )),
-    ]);
+    return code `
+    ${createBlockStmtCodes(valueExpr)}
+    return ${valueExpr};
+  `;
 }

package/module/dslgen/printers/fieldResolver/nonNullResolver.js

@@ -1,4 +1,6 @@
-import ts from "typescript";
-export function createNonNullResolverStmts(valueExpr) {
-    return [ts.factory.createReturnStatement(ts.factory.createNonNullExpression(valueExpr))];
+import { code } from "ts-poet";
+export function createNonNullResolverCode(valueExpr) {
+    return code `
+    return ${valueExpr}!;
+  `;
 }

package/module/dslgen/printers/fieldResolver/oneofUnionResolver.js

@@ -1,6 +1,5 @@
 import { ObjectField, ObjectOneofField } from "@proto-graphql/codegen-core";
-import ts from "typescript";
-import { onlyNonNull } from "../util";
+import { code, joinCode } from "ts-poet";
 /**
  * @example nullable
  * ```ts
@@ -11,44 +10,28 @@ import { onlyNonNull } from "../util";
  * return value
  * ```
  */
-export function createOneofUnionResolverStmts(sourceExpr, field) {
-    const createResolverStmts = (sourceExpr, field, { nullable }) => {
+export function createOneofUnionResolverCode(sourceExpr, field) {
+    const createBlockStmtCode = (sourceExpr, { nullable }) => {
         const createFieldExpr = (memberField) => {
             if (field instanceof ObjectOneofField) {
-                return ts.factory.createPropertyAccessExpression(sourceExpr, memberField.protoJsName);
+                return code `${sourceExpr}.${memberField.proto.jsonName}`;
             }
-            return ts.factory.createPropertyAccessChain(sourceExpr, ts.factory.createToken(ts.SyntaxKind.QuestionDotToken), memberField.protoJsName);
+            return code `${sourceExpr}?.${memberField.proto.jsonName}`;
         };
-        const valueExpr = ts.factory.createIdentifier("value");
-        return [
-            ts.factory.createVariableStatement(undefined, ts.factory.createVariableDeclarationList([
-                ts.factory.createVariableDeclaration("value", undefined, undefined, 
-                // obj.field1 ?? obj.field2 ?? obj.field3 ?? ...
-                field.type.fields.reduceRight((expr, field) => {
-                    if (expr == null) {
-                        return createFieldExpr(field);
-                    }
-                    return ts.factory.createBinaryExpression(createFieldExpr(field), ts.factory.createToken(ts.SyntaxKind.QuestionQuestionToken), expr);
-                }, null)),
-            ], ts.NodeFlags.Const)),
-            nullable
-                ? undefined
-                : ts.factory.createIfStatement(ts.factory.createBinaryExpression(valueExpr, ts.SyntaxKind.EqualsEqualsToken, ts.factory.createToken(ts.SyntaxKind.NullKeyword)), ts.factory.createBlock([
-                    ts.factory.createThrowStatement(ts.factory.createNewExpression(ts.factory.createIdentifier("Error"), undefined, [
-                        ts.factory.createStringLiteral(`${field.name} should not be null`),
-                    ])),
-                ], true)),
-            ts.factory.createReturnStatement(valueExpr),
-        ].filter(onlyNonNull());
+        return code `
+      const value = ${joinCode(field.type.fields.map(createFieldExpr), { on: "??" })};
+      if (value == null) {
+        ${nullable ? "return null" : `throw new Error("${field.name} should not be null")`};
+      }
+      return value;
+    `;
     };
-    if (!(field instanceof ObjectField && field.isList())) {
-        return createResolverStmts(sourceExpr, field, { nullable: field.isNullable() });
+    if (field instanceof ObjectField && field.isList()) {
+        return code `
+      return ${sourceExpr}.map(item => {
+        ${createBlockStmtCode(code `item`, { nullable: false })}
+      })
+    `;
     }
-    return [
-        ts.factory.createReturnStatement(ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(sourceExpr, "map"), undefined, [
-            ts.factory.createArrowFunction(undefined, undefined, [
-                ts.factory.createParameterDeclaration(undefined, undefined, undefined, "item", undefined, undefined, undefined),
-            ], undefined, ts.factory.createToken(ts.SyntaxKind.EqualsGreaterThanToken), ts.factory.createBlock(createResolverStmts(ts.factory.createIdentifier("item"), field, { nullable: false }), true)),
-        ])),
-    ];
+    return createBlockStmtCode(sourceExpr, { nullable: field.isNullable() });
 }

package/module/dslgen/printers/index.js

@@ -1,53 +1,23 @@
 import { EnumType, InputObjectType, ObjectType, OneofUnionType, SquashedOneofUnionType, } from "@proto-graphql/codegen-core";
-import ts from "typescript";
-import { createEnumTypeDslStmt } from "./enumType";
-import { createInputObjectTypeDslStmts } from "./inputObjectType";
-import { createObjectTypeDslStmts } from "./objectType";
-import { createOneofUnionTypeDslStmt } from "./oneofUnionType";
-import { createImportDecl, createQualifiedName, fullNameString, onlyNonNull, onlyUnique } from "./util";
-export function createImportDecls(types) {
-    return types
-        .flatMap((t) => t.importModules)
-        .filter(onlyUnique((m) => JSON.stringify([m.alias, m.module])))
-        .sort(({ module: a }, { module: b }) => {
-        const pat = /^\.+\//;
-        const [aIsRel, bIsRel] = [a.match(pat), b.match(pat)];
-        if (aIsRel && !bIsRel)
-            return 1;
-        if (!aIsRel && bIsRel)
-            return -1;
-        if (a < b)
-            return -1;
-        if (a > b)
-            return 1;
-        return 0;
-    })
-        .map((m) => createImportDecl(m));
-}
-export function createReExportStmts(types) {
-    return types
-        .flatMap((t) => t.exportTypes)
-        .sort()
-        .filter(onlyUnique(({ type }) => fullNameString(type)))
-        .map(({ name, type }) => ts.factory.createTypeAliasDeclaration(undefined, [ts.factory.createToken(ts.SyntaxKind.ExportKeyword)], name, undefined, ts.factory.createTypeReferenceNode(createQualifiedName(type))));
-}
-export function createTypeDslStmts(types) {
-    return types
-        .flatMap((type) => {
+import { createEnumTypeCode } from "./enumType";
+import { createInputObjectTypeCode } from "./inputObjectType";
+import { createObjectTypeCode } from "./objectType";
+import { createOneofUnionTypeCode } from "./oneofUnionType";
+export function createTypeDslCodes(types, opts) {
+    return types.flatMap((type) => {
         if (type instanceof ObjectType) {
-            return createObjectTypeDslStmts(type);
+            return createObjectTypeCode(type, opts);
         }
         if (type instanceof InputObjectType) {
-            return createInputObjectTypeDslStmts(type);
+            return createInputObjectTypeCode(type, opts);
         }
         if (type instanceof EnumType) {
-            return [createEnumTypeDslStmt(type)];
+            return [createEnumTypeCode(type, opts)];
         }
         if (type instanceof OneofUnionType || type instanceof SquashedOneofUnionType) {
-            return [createOneofUnionTypeDslStmt(type)];
+            return [createOneofUnionTypeCode(type, opts)];
         }
         const _exhaustiveCheck = type;
         throw "unreachable";
-    })
-        .filter(onlyNonNull());
+    });
 }

package/module/dslgen/printers/inputObjectType.js

@@ -1,12 +1,14 @@
-import { InputObjectType } from "@proto-graphql/codegen-core";
-import ts from "typescript";
-import { createFieldDefinitionExpr, createNoopFieldDefinitionExpr } from "./field";
-import { createBuilderPropExpr, createDescriptionPropertyAssignment, createDslExportConstStmt, createQualifiedName, onlyNonNull, } from "./util";
+import { compact, InputObjectType, protobufGraphQLExtensions, protoType } from "@proto-graphql/codegen-core";
+import { code, imp, joinCode, literalOf } from "ts-poet";
+import { createFieldRefCode, createNoopFieldRefCode } from "./field";
+import { fieldTypeShape, pothosBuilder, pothosRef, shapeType } from "./util";
 /**
  * @example
  * ```ts
- * export const HelloInput = builder.inputRef<Omit<_$hello$hello_pb.Hello, "$type">>("HelloInput");
- * HelloInput.implement({
+ * export type HelloInput$Shape = {
+ *   // ...
+ * }
+ * export const HelloInput$Ref: pothos.InputObjectRef<Hello$SHape> = builder.inputRef("HelloInput").implement({
  *   description: "...",
  *   fields: (t) => ({
  *     // ...
@@ -14,80 +16,38 @@ import { createBuilderPropExpr, createDescriptionPropertyAssignment, createDslEx
  * })
  * ```
  */
-export function createInputObjectTypeDslStmts(type) {
-    return [
-        createInputObjectTypeShapeDecl(type),
-        createDslExportConstStmt(type.pothosRefObjectName, ts.factory.createCallExpression(createBuilderPropExpr("inputRef"), [ts.factory.createTypeReferenceNode(createInputObjectTypeShapeIdent(type))], [ts.factory.createStringLiteral(type.typeName)])),
-        ts.factory.createExpressionStatement(ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier(type.pothosRefObjectName), "implement"), undefined, [
-            ts.factory.createObjectLiteralExpression([
-                createDescriptionPropertyAssignment(type),
-                ts.factory.createPropertyAssignment("fields", createInputObjectTypeFieldsMethodExpr(type)),
-                ts.factory.createPropertyAssignment("extensions", createExtensionsObjectLiteralExpr(type)),
-            ].filter(onlyNonNull()), true),
-        ])),
-    ];
-}
-/**
- * @example
- * ```ts
- * definition(t) {
- *   // ...
- * }
- * ```
- */
-function createInputObjectTypeFieldsMethodExpr(type) {
-    return ts.factory.createArrowFunction(undefined, undefined, [ts.factory.createParameterDeclaration(undefined, undefined, undefined, "t", undefined, undefined, undefined)], undefined, ts.factory.createToken(ts.SyntaxKind.EqualsGreaterThanToken), ts.factory.createParenthesizedExpression(ts.factory.createObjectLiteralExpression(type.fields.length > 0
-        ? type.fields.map((f) => ts.factory.createPropertyAssignment(f.name, createFieldDefinitionExpr(f)))
-        : [ts.factory.createPropertyAssignment("_", createNoopFieldDefinitionExpr({ input: true }))], true)));
-}
-/**
- * @example
- * ```ts
- * {
- *   message?: _$hello$hello_pb$Hello["message"] | null,
- *   // ...
- * }
- * ```
- */
-function createInputObjectTypeShapeDecl(type) {
-    return ts.factory.createTypeAliasDeclaration(undefined, [ts.factory.createToken(ts.SyntaxKind.ExportKeyword)], createInputObjectTypeShapeIdent(type), undefined, ts.factory.createTypeLiteralNode(type.fields.map((field) => {
-        let typeNode = ts.factory.createIndexedAccessTypeNode(ts.factory.createTypeReferenceNode(createQualifiedName(type.protoTypeFullName)), ts.factory.createLiteralTypeNode(ts.factory.createStringLiteral(field.protoJsName)));
-        if (field.type instanceof InputObjectType) {
-            typeNode = ts.factory.createTypeReferenceNode(createInputObjectTypeShapeIdent(field.type));
-            if (field.isList()) {
-                typeNode = ts.factory.createTypeReferenceNode("Array", [typeNode]);
-            }
+export function createInputObjectTypeCode(type, opts) {
+    const shapeTypeCode = code `
+    export type ${shapeType(type)} = {
+      ${joinCode(type.fields.map((f) => {
+        let typeNode;
+        if (f.type instanceof InputObjectType) {
+            // @ts-expect-error f should be inferred as InputObjectField<InputObjectType>
+            typeNode = code `${fieldTypeShape(f, opts)}`;
+            if (f.isList())
+                typeNode = code `Array<${typeNode}>`;
         }
-        if (field.isNullable()) {
-            typeNode = ts.factory.createUnionTypeNode([
-                typeNode,
-                ts.factory.createLiteralTypeNode(ts.factory.createToken(ts.SyntaxKind.NullKeyword)),
-            ]);
+        else {
+            typeNode = code `${protoType(type.proto, opts)}[${literalOf(f.proto.jsonName)}]`;
         }
-        return ts.factory.createPropertySignature(undefined, field.name, field.isNullable() ? ts.factory.createToken(ts.SyntaxKind.QuestionToken) : undefined, typeNode);
-    })));
-}
-function createInputObjectTypeShapeIdent(type) {
-    return ts.factory.createIdentifier(`${type.typeName}$Shape`);
-}
-/**
- * @example
- * ```ts
- * {
- *   protobufMessage: {
- *     fullName: "...",
- *     name: "...",
- *     package: "...",
- *   },
- * }
- * ```
- */
-function createExtensionsObjectLiteralExpr(type) {
-    return ts.factory.createObjectLiteralExpression([
-        ts.factory.createPropertyAssignment("protobufMessage", ts.factory.createObjectLiteralExpression([
-            ts.factory.createPropertyAssignment("fullName", ts.factory.createStringLiteral(type.proto.fullName.toString())),
-            ts.factory.createPropertyAssignment("name", ts.factory.createStringLiteral(type.proto.name)),
-            ts.factory.createPropertyAssignment("package", ts.factory.createStringLiteral(type.proto.file.package)),
-        ], true)),
-    ], true);
+        return f.isNullable() ? code `${f.name}?: ${typeNode} | null,` : code `${f.name}: ${typeNode},`;
+    }))}
+    };
+  `;
+    const refCode = code `
+    export const ${pothosRef(type)}: ${imp("InputObjectRef@@pothos/core")}<${shapeType(type)}> =
+      ${pothosBuilder(type, opts)}.inputRef<${shapeType(type)}>(${literalOf(type.typeName)}).implement(
+        ${literalOf(compact({
+        description: type.description,
+        fields: code `t => ({${type.fields.length > 0
+            ? type.fields.map((f) => code `${f.name}: ${createFieldRefCode(f, opts)},`)
+            : code `_: ${createNoopFieldRefCode({ input: true })}`}})`,
+        extensions: protobufGraphQLExtensions(type),
+    }))}
+      );
+  `;
+    return code `
+    ${shapeTypeCode}
+    ${refCode}
+  `;
 }