protoc-gen-pothos 0.2.2 → 0.3.0

package/module/dslgen/printers/objectType.js

@@ -1,96 +1,46 @@
-import { InterfaceType } from "@proto-graphql/codegen-core";
-import ts from "typescript";
-import { createFieldDefinitionExpr, createNoopFieldDefinitionExpr } from "./field";
-import { createBuilderCallExpr, createBuilderPropExpr, createDescriptionPropertyAssignment, createDslExportConstStmt, createQualifiedName, onlyNonNull, } from "./util";
+import { compact, InterfaceType, protobufGraphQLExtensions, protoType } from "@proto-graphql/codegen-core";
+import { code, joinCode, literalOf } from "ts-poet";
+import { createFieldRefCode, createNoopFieldRefCode } from "./field";
+import { pothosBuilder, pothosRef } from "./util";
 /**
  * @example
  * ```ts
- * export const Hello = builder.objectRef<_$hello$hello_pb.Hello>("Hello")
- * builder.objectType(Hello, {
+ * export const Hello$Ref = builder.objectRef<_$hello$hello_pb.Hello>("Hello")
+ * builder.objectType(Hello$Ref, {
  *   name: "Hello",
  *   // ...
  * })
  * ```
  */
-export function createObjectTypeDslStmts(objType) {
-    const isInterface = objType instanceof InterfaceType;
-    return [
-        createDslExportConstStmt(objType.pothosRefObjectName, ts.factory.createCallExpression(createBuilderPropExpr(isInterface ? "interfaceRef" : "objectRef"), [
-            isInterface
-                ? ts.factory.createTypeReferenceNode("Pick", [
-                    ts.factory.createTypeReferenceNode(createQualifiedName(objType.protoTypeFullName)),
-                    ts.factory.createUnionTypeNode(objType.fields.map((f) => ts.factory.createLiteralTypeNode(ts.factory.createStringLiteral(f.protoJsName)))),
-                ])
-                : ts.factory.createTypeReferenceNode(createQualifiedName(objType.protoTypeFullName)),
-        ], [ts.factory.createStringLiteral(objType.typeName)])),
-        ts.factory.createExpressionStatement(createBuilderCallExpr(isInterface ? "interfaceType" : "objectType", [
-            ts.factory.createIdentifier(objType.pothosRefObjectName),
-            ts.factory.createObjectLiteralExpression([
-                ts.factory.createPropertyAssignment("name", ts.factory.createStringLiteral(objType.typeName)),
-                createDescriptionPropertyAssignment(objType),
-                ts.factory.createPropertyAssignment("fields", createObjectTypeFieldsFuncExpr(objType)),
-                isInterface ? null : ts.factory.createPropertyAssignment("isTypeOf", createIsTypeOfMethodExpr(objType)),
-                ts.factory.createPropertyAssignment("extensions", createExtensionsObjectLiteralExpr(objType)),
-            ].filter(onlyNonNull()), true),
-        ])),
-    ];
-}
-/**
- * @example
- * ```ts
- * fields: (t) => ({
- *   // ...
- * })
- * ```
- */
-function createObjectTypeFieldsFuncExpr(objType) {
-    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(objType.fields.length > 0
-        ? objType.fields.map((f) => ts.factory.createPropertyAssignment(f.name, createFieldDefinitionExpr(f)))
-        : [ts.factory.createPropertyAssignment("_", createNoopFieldDefinitionExpr({ input: false }))], true)));
-}
-/**
- * @example
- * ```ts
- * isTypeOf(data) {
- *   return data instanceof _$hello$hello_pb.Hello;
- *
- * (source) =>
- *   // eslint-disable-next-line @typescript-eslint/ban-types
- *   (source as _$hello$hello_pb.Hello | { $type: string & {} }).$type === "hello.Hello",
- * }
- * ```
- */
-function createIsTypeOfMethodExpr(objType) {
-    return ts.factory.createArrowFunction(undefined, undefined, [ts.factory.createParameterDeclaration(undefined, undefined, undefined, "source", undefined, undefined, undefined)], undefined, ts.factory.createToken(ts.SyntaxKind.EqualsGreaterThanToken), ts.factory.createBlock([
-        ts.factory.createReturnStatement(ts.factory.createBinaryExpression(ts.factory.createPropertyAccessExpression(ts.factory.createParenthesizedExpression(ts.factory.createAsExpression(ts.factory.createIdentifier("source"), ts.factory.createUnionTypeNode([
-            ts.factory.createTypeReferenceNode(createQualifiedName(objType.protoTypeFullName)),
-            ts.factory.createTypeLiteralNode([
-                ts.factory.createPropertySignature(undefined, "$type", undefined, ts.factory.createIntersectionTypeNode([
-                    ts.factory.createToken(ts.SyntaxKind.StringKeyword),
-                    ts.factory.createTypeLiteralNode([]),
-                ])),
-            ]),
-        ]))), "$type"), ts.SyntaxKind.EqualsEqualsEqualsToken, ts.factory.createStringLiteral(objType.proto.fullName.toString()))),
-    ], true));
-}
-/**
- * @example
- * ```ts
- * {
- *   protobufMessage: {
- *     fullName: "...",
- *     name: "...",
- *     package: "...",
- *   },
- * }
- * ```
- */
-function createExtensionsObjectLiteralExpr(objType) {
-    return ts.factory.createObjectLiteralExpression([
-        ts.factory.createPropertyAssignment("protobufMessage", ts.factory.createObjectLiteralExpression([
-            ts.factory.createPropertyAssignment("fullName", ts.factory.createStringLiteral(objType.proto.fullName.toString())),
-            ts.factory.createPropertyAssignment("name", ts.factory.createStringLiteral(objType.proto.name)),
-            ts.factory.createPropertyAssignment("package", ts.factory.createStringLiteral(objType.proto.file.package)),
-        ], true)),
-    ], true);
+export function createObjectTypeCode(type, opts) {
+    const isInterface = type instanceof InterfaceType;
+    const typeOpts = {
+        name: type.typeName,
+        fields: code `t => ({${type.fields.length > 0
+            ? joinCode(type.fields.map((f) => code `${f.name}: ${createFieldRefCode(f, opts)},`))
+            : code `_: ${createNoopFieldRefCode({ input: false })}`}})`,
+        description: type.description,
+        isTypeOf: isInterface
+            ? undefined
+            : code `
+        (source) => {
+          return (source as ${protoType(type.proto, opts)} | { $type: string & {} }).$type
+            === ${literalOf(type.proto.fullName.toString())};
+        }
+      `,
+        extensions: protobufGraphQLExtensions(type),
+    };
+    const buildRefFunc = code `${pothosBuilder(type, opts)}.${isInterface ? "interface" : "object"}Ref`;
+    const buildTypeFunc = code `${pothosBuilder(type, opts)}.${isInterface ? "interface" : "object"}Type`;
+    const refFuncTypeArg = isInterface
+        ? code `
+        Pick<
+          ${protoType(type.proto, opts)},
+          ${joinCode(type.fields.map((f) => code `${literalOf(f.proto.jsonName)}`), { on: "|" })}
+        >`
+        : protoType(type.proto, opts);
+    return code `
+    export const ${pothosRef(type)} = ${buildRefFunc}<${refFuncTypeArg}>(${literalOf(type.typeName)});
+    ${buildTypeFunc}(${pothosRef(type)}, ${literalOf(compact(typeOpts))});
+  `;
 }

package/module/dslgen/printers/oneofUnionType.js

@@ -1,6 +1,6 @@
-import { SquashedOneofUnionType } from "@proto-graphql/codegen-core";
-import ts from "typescript";
-import { createBuilderCallExpr, createDescriptionPropertyAssignment, createDslExportConstStmt, onlyNonNull, } from "./util";
+import { compact, protobufGraphQLExtensions, } from "@proto-graphql/codegen-core";
+import { code, literalOf } from "ts-poet";
+import { pothosBuilder, pothosRef } from "./util";
 /**
  * @example
  * ```ts
@@ -10,60 +10,14 @@ import { createBuilderCallExpr, createDescriptionPropertyAssignment, createDslEx
  * })
  * ```
  */
-export function createOneofUnionTypeDslStmt(type) {
-    return createDslExportConstStmt(type.pothosRefObjectName, createBuilderCallExpr("unionType", [
-        ts.factory.createStringLiteral(type.typeName),
-        ts.factory.createObjectLiteralExpression([
-            createDescriptionPropertyAssignment(type),
-            ts.factory.createPropertyAssignment("types", ts.factory.createArrayLiteralExpression(type.fields.map((f) => ts.factory.createIdentifier(f.type.pothosRefObjectName)), true)),
-            ts.factory.createPropertyAssignment("extensions", createExtensionsObjectLiteralExpr(type)),
-        ].filter(onlyNonNull()), true),
-    ]));
-}
-/**
- * @example
- * ```ts
- * {
- *   protobufMessage: {
- *     fullName: "...",
- *     name: "...",
- *     package: "...",
- *   },
- * }
- * ```
- */
-function createExtensionsObjectLiteralExpr(type) {
-    if (type instanceof SquashedOneofUnionType) {
-        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)),
-                ts.factory.createPropertyAssignment("fields", ts.factory.createArrayLiteralExpression(type.proto.oneofs[0].fields.map((f) => ts.factory.createObjectLiteralExpression([
-                    ts.factory.createPropertyAssignment("name", ts.factory.createStringLiteral(f.name)),
-                    ...(f.type && f.type.kind !== "Scalar"
-                        ? [
-                            ts.factory.createPropertyAssignment("type", ts.factory.createStringLiteral(f.type.fullName.toString())),
-                        ]
-                        : []),
-                ], true)), true)),
-            ], true)),
-        ], true);
-    }
-    return ts.factory.createObjectLiteralExpression([
-        ts.factory.createPropertyAssignment("protobufOneof", 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("messageName", ts.factory.createStringLiteral(type.proto.parent.name)),
-            ts.factory.createPropertyAssignment("package", ts.factory.createStringLiteral(type.proto.parent.file.package)),
-            ts.factory.createPropertyAssignment("fields", ts.factory.createArrayLiteralExpression(type.proto.fields.map((f) => ts.factory.createObjectLiteralExpression([
-                ts.factory.createPropertyAssignment("name", ts.factory.createStringLiteral(f.name)),
-                ...(f.type && f.type.kind !== "Scalar"
-                    ? [
-                        ts.factory.createPropertyAssignment("type", ts.factory.createStringLiteral(f.type.fullName.toString())),
-                    ]
-                    : []),
-            ], true)), true)),
-        ], true)),
-    ], true);
+export function createOneofUnionTypeCode(type, opts) {
+    const typeOpts = {
+        types: type.fields.map((f) => pothosRef(f.type)),
+        description: type.description,
+        extensions: protobufGraphQLExtensions(type),
+    };
+    return code `
+    export const ${pothosRef(type)} =
+      ${pothosBuilder(type, opts)}.unionType(${literalOf(type.typeName)}, ${literalOf(compact(typeOpts))});
+  `;
 }

package/module/dslgen/printers/util.js

@@ -1,79 +1,37 @@
-import ts from "typescript";
-/**
- * @example
- * ```
- * nexus.objectType(...)
- * ```
- */
-export function createBuilderCallExpr(name, args) {
-    return ts.factory.createCallExpression(createBuilderPropExpr(name), undefined, args);
-}
-/**
- * @example
- * ```
- * builder.objectRef
- * ```
- */
-export function createBuilderPropExpr(name) {
-    return ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier("builder"), name);
-}
-export function createDescriptionPropertyAssignment(gql) {
-    if (!gql.description)
-        return null;
-    return ts.factory.createPropertyAssignment("description", ts.factory.createStringLiteral(gql.description));
-}
-export function createDeprecationPropertyAssignment(gql) {
-    const reason = gql.deprecationReason;
-    if (!reason)
-        return null;
-    return ts.factory.createPropertyAssignment("deprecationReason", ts.factory.createStringLiteral(reason));
-}
-export function fullNameString(fn) {
-    if (typeof fn === "string") {
-        return fn;
-    }
-    return `${typeof fn[0] === "string" ? fn[0] : fullNameString(fn[0])}.${fn[1]}`;
-}
-export function createFullNameExpr(fn) {
-    if (typeof fn === "string") {
-        return ts.factory.createIdentifier(fn);
-    }
-    return ts.factory.createPropertyAccessExpression(typeof fn[0] === "string" ? ts.factory.createIdentifier(fn[0]) : createFullNameExpr(fn[0]), fn[1]);
-}
-export function createQualifiedName(fn) {
-    if (typeof fn === "string") {
-        return ts.factory.createIdentifier(fn);
-    }
-    return ts.factory.createQualifiedName(typeof fn[0] === "string" ? ts.factory.createIdentifier(fn[0]) : createQualifiedName(fn[0]), fn[1]);
-}
-/**
- * @example
- * ```
- * import * as foo$bar$baz from "foo/bar/baz";
- * ```
- */
-export function createImportDecl({ alias, module, type, }) {
-    return ts.factory.createImportDeclaration(undefined, undefined, ts.factory.createImportClause(false, undefined, type === "namespace"
-        ? ts.factory.createNamespaceImport(ts.factory.createIdentifier(alias))
-        : type === "named"
-            ? ts.factory.createNamedImports([
-                ts.factory.createImportSpecifier(false, undefined, ts.factory.createIdentifier(alias)),
-            ])
-            : undefined), ts.factory.createStringLiteral(module));
-}
-export function createDslExportConstStmt(name, exp) {
-    return ts.factory.createVariableStatement([ts.factory.createToken(ts.SyntaxKind.ExportKeyword)], ts.factory.createVariableDeclarationList([ts.factory.createVariableDeclaration(name, undefined, undefined, exp)], ts.NodeFlags.Const));
-}
-export function onlyNonNull() {
-    return (t) => t != null;
-}
-export function onlyUnique(f) {
-    const set = new Set();
-    return (t) => {
-        const key = f ? f(t) : t;
-        if (set.has(key))
-            return false;
-        set.add(key);
-        return true;
-    };
+import { filename, generatedGraphQLTypeImportPath, } from "@proto-graphql/codegen-core";
+import * as path from "path";
+import { code, imp } from "ts-poet";
+export function pothosRef(type) {
+    return code `${pothosRefName(type)}`;
+}
+function pothosRefName(type) {
+    return `${type.typeName}$Ref`;
+}
+export function shapeType(type) {
+    return code `${shapeTypeName(type)}`;
+}
+export function shapeTypeName(type) {
+    return `${type.typeName}$Shape`;
+}
+export function fieldTypeRef(field, opts) {
+    const importPath = generatedGraphQLTypeImportPath(field, opts);
+    if (importPath == null)
+        return pothosRef(field.type);
+    const imported = imp(`IMPORTED_PLACEHOLDER@${importPath}`);
+    imported.symbol = pothosRefName(field.type); // NOTE: Workaround for ts-poet not recognizing "$" as an identifier
+    return code `${imported}`;
+}
+export function fieldTypeShape(field, opts) {
+    const importPath = generatedGraphQLTypeImportPath(field, opts);
+    if (importPath == null)
+        return shapeType(field.type);
+    const imported = imp(`IMPORTED_PLACEHOLDER@${importPath}`);
+    imported.symbol = shapeTypeName(field.type); // NOTE: Workaround for ts-poet not recognizing "$" as an identifier
+    return code `${imported}`;
+}
+export function pothosBuilder(type, opts) {
+    const importPath = opts.pothos.builderPath.startsWith(".")
+        ? path.relative(path.dirname(filename(type, opts)), opts.pothos.builderPath)
+        : opts.pothos.builderPath;
+    return code `${imp(`builder@${importPath}`)}`;
 }

package/module/printer.js

@@ -1,57 +1,30 @@
-import ts from "typescript";
-import { collectTypesFromFile, DslFile } from "@proto-graphql/codegen-core";
-import { createImportDecls, createTypeDslStmts } from "./dslgen";
+import { collectTypesFromFile, filename, filenameFromProtoFile, printCodes, } from "@proto-graphql/codegen-core";
+import { createTypeDslCodes } from "./dslgen";
 export function generateFiles(registry, file, opts) {
-    const dslFile = new DslFile(file, { ...opts, dsl: "pothos", useTsProto: true });
-    const types = collectTypesFromFile(dslFile, registry);
-    switch (opts.fileLayout) {
+    opts.printer.protobuf = "ts-proto"; // default
+    const types = collectTypesFromFile(file, opts.type, registry);
+    switch (opts.printer.fileLayout) {
         case "proto_file": {
             return [
                 {
-                    filename: dslFile.filename,
-                    content: printSource(types, file),
+                    filename: filenameFromProtoFile(file, opts.printer),
+                    content: printCodes(createCodes(types, opts.printer), "protoc-gen-pothos", file),
                 },
             ];
         }
         case "graphql_type": {
             return types.map((t) => ({
-                filename: t.filename,
-                content: printSource([t], file),
+                filename: filename(t, opts.printer),
+                content: printCodes(createCodes([t], opts.printer), "protoc-gen-pothos", file),
             }));
         }
         /* istanbul ignore next */
         default: {
-            const _exhaustiveCheck = opts.fileLayout;
+            const _exhaustiveCheck = opts.printer.fileLayout;
             throw "unreachable";
         }
     }
 }
-function printSource(types, file) {
-    const ast = [
-        // `import builder from "../../builder";`
-        // `import * as _$hello$hello_pb from "./hello/hello_pb";`
-        ...createImportDecls(types),
-        // `export cosnt Hello = objectType({ ... });`
-        // `export cosnt HelloInput = inputObjectType({ ... });`
-        // `export cosnt Oneof = unionType({ ... });`
-        // `export const Role = enumType({ ... });`
-        ...createTypeDslStmts(types),
-    ];
-    if (ast.length === 0) {
-        ast.push(
-        // `export {}`
-        ts.factory.createExportDeclaration(undefined, undefined, false, ts.factory.createNamedExports([]), undefined));
-    }
-    const nexusFile = ts.factory.updateSourceFile(ts.createSourceFile("generated.ts", "", ts.ScriptTarget.Latest, false, ts.ScriptKind.TS), ast, false);
-    const printer = ts.createPrinter({ newLine: ts.NewLineKind.LineFeed });
-    const result = printer.printFile(nexusFile);
-    const content = [
-        "// Code generated by protoc-gen-pothos. DO NOT EDIT.",
-        `// source: ${file.descriptor.getName()}`,
-        "",
-        "/* eslint-disable */",
-        "",
-        result,
-    ].join("\n");
-    return content;
+function createCodes(types, opts) {
+    return [...createTypeDslCodes(types, opts)];
 }

package/module/process.js

@@ -1,3 +1,3 @@
 import { createProcessor } from "@proto-graphql/protoc-plugin-helpers";
 import { generateFiles } from "./printer";
-export const processRequest = createProcessor({ generateFiles });
+export const processRequest = createProcessor({ generateFiles, dsl: "pothos" });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "protoc-gen-pothos",
-  "version": "0.2.2",
+  "version": "0.3.0",
   "description": "Generate DSL for Pothos GraphQL from Protocol Buffers IDL",
   "keywords": [
     "graphql",
@@ -23,10 +23,11 @@
     "node": ">= 14.0.0"
   },
   "dependencies": {
-    "@proto-graphql/codegen-core": "^0.2.2",
-    "@proto-graphql/proto-descriptors": "^0.2.0",
-    "@proto-graphql/protoc-plugin-helpers": "^0.2.1",
-    "google-protobuf": "^3.20.1"
+    "@proto-graphql/codegen-core": "^0.3.0",
+    "@proto-graphql/proto-descriptors": "^0.3.0",
+    "@proto-graphql/protoc-plugin-helpers": "^0.2.2",
+    "google-protobuf": "^3.20.1",
+    "ts-poet": "^6.3.0"
   },
   "devDependencies": {
     "@pothos/core": "^3.22.7",