feat: Generate Index Files (#821)

* feat: output index files

* chore: add outputIndex to readme

* feat: remove extra index nesting

* chore: update readme

* test: output-index

* fix: lint

* fix: options-test snapshot

README.markdown

@@ -509,6 +509,10 @@ Generated code will be placed in the Gradle build directory.
   Extension encode/decode methods are compliant with the `outputEncodeMethods` option, and if `unknownFields=true`,
   the `setExtension` and `getExtension` methods will be created for extendable messages, also compliant with `outputEncodeMethods` (setExtension = encode, getExtension = decode).
 
+- With `--ts_proto_opt=outputIndex=true`, index files will be generated based on the proto package namespaces.
+
+  This will disable `exportCommonSymbols` to avoid name collisions on the common symbols.
+
 ### NestJS Support
 
 We have a great way of working together with [nestjs](https://docs.nestjs.com/microservices/grpc). `ts-proto` generates `interfaces` and `decorators` for you controller, client. For more information see the [nestjs readme](NESTJS.markdown).

integration/codegen.ts

@@ -4,7 +4,7 @@ import { parse } from "path";
 import { promisify } from "util";
 import { generateFile, makeUtils } from "../src/main";
 import { createTypeMap } from "../src/types";
-import { prefixDisableLinter } from "../src/utils";
+import { generateIndexFiles } from "../src/utils";
 import { getTsPoetOpts, optionsFromParameter } from "../src/options";
 import { Context } from "../src/context";
 import { generateTypeRegistry } from "../src/generate-type-registry";
@@ -56,6 +56,15 @@ async function generate(binFile: string, baseDir: string, parameter: string) {
 
     await promisify(writeFile)(filePath, code.toString({ ...getTsPoetOpts(options), path }));
   }
+
+  if (options.outputIndex) {
+    for (const [path, code] of generateIndexFiles(request.protoFile, options)) {
+      const filePath = `${baseDir}/${path}`;
+      const dirPath = parse(filePath).dir;
+      await promisify(mkdir)(dirPath, { recursive: true }).catch(() => {});
+      await promisify(writeFile)(filePath, code.toString({ ...getTsPoetOpts(options), path }));
+    }
+  }
 }
 
 main().then(() => {

integration/output-index/a-test.ts

@@ -0,0 +1,14 @@
+import * as Index from '.';
+
+describe('output-index', () => {
+  it('generates index files correctly', () => {
+    expect(Index).toMatchObject({
+        base: {
+            A: {
+                encode: expect.any(Function),
+                decode: expect.any(Function),
+            },
+        },
+    });
+  });
+});

integration/output-index/a.proto

@@ -0,0 +1,6 @@
+syntax = "proto3";
+package base;
+
+message A {
+  string a = 1;
+}

integration/output-index/a.ts

@@ -0,0 +1,77 @@
+/* eslint-disable */
+import * as _m0 from "protobufjs/minimal";
+
+export interface A {
+  a: string;
+}
+
+function createBaseA(): A {
+  return { a: "" };
+}
+
+export const A = {
+  encode(message: A, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.a !== "") {
+      writer.uint32(10).string(message.a);
+    }
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): A {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseA();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 10) {
+            break;
+          }
+
+          message.a = reader.string();
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): A {
+    return { a: isSet(object.a) ? String(object.a) : "" };
+  },
+
+  toJSON(message: A): unknown {
+    const obj: any = {};
+    message.a !== undefined && (obj.a = message.a);
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<A>, I>>(base?: I): A {
+    return A.fromPartial(base ?? {});
+  },
+
+  fromPartial<I extends Exact<DeepPartial<A>, I>>(object: I): A {
+    const message = createBaseA();
+    message.a = object.a ?? "";
+    return message;
+  },
+};
+
+type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
+
+type DeepPartial<T> = T extends Builtin ? T
+  : T extends Array<infer U> ? Array<DeepPartial<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>>
+  : T extends {} ? { [K in keyof T]?: DeepPartial<T[K]> }
+  : Partial<T>;
+
+type KeysOfUnion<T> = T extends T ? keyof T : never;
+type Exact<P, I extends P> = P extends Builtin ? P
+  : P & { [K in keyof P]: Exact<P[K], I[K]> } & { [K in Exclude<keyof I, KeysOfUnion<P>>]: never };
+
+function isSet(value: any): boolean {
+  return value !== null && value !== undefined;
+}

integration/output-index/index.base.ts

@@ -0,0 +1,3 @@
+/* eslint-disable */
+
+export * from "./a";

integration/output-index/index.ts

@@ -0,0 +1,3 @@
+/* eslint-disable */
+
+export * as base from "./index.base";

integration/output-index/parameters.txt

@@ -0,0 +1 @@
+outputIndex=true

src/options.ts

@@ -80,6 +80,7 @@ export type Options = {
   useReadonlyTypes: boolean;
   useSnakeTypeName: boolean;
   outputExtensions: boolean;
+  outputIndex: boolean;
   M: { [from: string]: string };
 };
 
@@ -130,6 +131,7 @@ export function defaultOptions(): Options {
     useReadonlyTypes: false,
     useSnakeTypeName: true,
     outputExtensions: false,
+    outputIndex: false,
     M: {},
   };
 }
@@ -218,6 +220,10 @@ export function optionsFromParameter(parameter: string | undefined): Options {
     options.initializeFieldsAsUndefined = false;
   }
 
+  if (options.outputIndex) {
+    options.exportCommonSymbols = false;
+  }
+
   return options;
 }
 

src/plugin.ts

@@ -1,11 +1,6 @@
-import {
-  CodeGeneratorRequest,
-  CodeGeneratorResponse,
-  CodeGeneratorResponse_Feature,
-  FileDescriptorProto,
-} from "ts-proto-descriptors";
+import { CodeGeneratorRequest, CodeGeneratorResponse, CodeGeneratorResponse_Feature } from "ts-proto-descriptors";
 import { promisify } from "util";
-import { prefixDisableLinter, protoFilesToGenerate, readToBuffer } from "./utils";
+import { generateIndexFiles, protoFilesToGenerate, readToBuffer } from "./utils";
 import { generateFile, makeUtils } from "./main";
 import { createTypeMap } from "./types";
 import { Context } from "./context";
@@ -46,6 +41,13 @@ async function main() {
     files.push({ name: path, content });
   }
 
+  if (options.outputIndex) {
+    for (const [path, code] of generateIndexFiles(filesToGenerate, options)) {
+      const content = code.toString({ ...getTsPoetOpts(options), path });
+      files.push({ name: path, content });
+    }
+  }
+
   const response = CodeGeneratorResponse.fromPartial({
     file: files,
     supportedFeatures: CodeGeneratorResponse_Feature.FEATURE_PROTO3_OPTIONAL,

src/utils.ts

@@ -1,4 +1,5 @@
-import { code, Code, imp, Import } from "ts-poet";
+import * as path from "path";
+import { code, Code, imp, Import, joinCode } from "ts-poet";
 import {
   CodeGeneratorRequest,
   FieldDescriptorProto,
@@ -15,6 +16,48 @@ export function protoFilesToGenerate(request: CodeGeneratorRequest): FileDescrip
   return request.protoFile.filter((f) => request.fileToGenerate.includes(f.name));
 }
 
+type PackageTree = {
+  index: string;
+  chunks: Code[];
+  leaves: { [k: string]: PackageTree };
+};
+export function generateIndexFiles(files: FileDescriptorProto[], options: Options): [string, Code][] {
+  const packageTree: PackageTree = {
+    index: "index.ts",
+    leaves: {},
+    chunks: [],
+  };
+  for (const { name, package: pkg } of files) {
+    const moduleName = name.replace(".proto", options.fileSuffix);
+    const pkgParts = pkg.length > 0 ? pkg.split(".") : [];
+
+    const branch = pkgParts.reduce<PackageTree>((branch, part, i): PackageTree => {
+      if (!(part in branch.leaves)) {
+        const prePkgParts = pkgParts.slice(0, i + 1);
+        const index = `index.${prePkgParts.join(".")}.ts`;
+        branch.chunks.push(code`export * as ${part} from "./${path.basename(index, ".ts")}";`);
+        branch.leaves[part] = {
+          index,
+          leaves: {},
+          chunks: [],
+        };
+      }
+      return branch.leaves[part];
+    }, packageTree);
+    branch.chunks.push(code`export * from "./${moduleName}";`);
+  }
+
+  const indexFiles: [string, Code][] = [];
+  let branches: PackageTree[] = [packageTree];
+  let currentBranch;
+  while ((currentBranch = branches.pop())) {
+    indexFiles.push([currentBranch.index, joinCode(currentBranch.chunks)]);
+    branches.push(...Object.values(currentBranch.leaves));
+  }
+
+  return indexFiles;
+}
+
 export function readToBuffer(stream: ReadStream): Promise<Buffer> {
   return new Promise((resolve) => {
     const ret: Array<Buffer | string> = [];

tests/options-test.ts

@@ -26,6 +26,7 @@ describe("options", () => {
         "outputClientImpl": false,
         "outputEncodeMethods": false,
         "outputExtensions": false,
+        "outputIndex": false,
         "outputJsonMethods": true,
         "outputPartialMethods": false,
         "outputSchema": false,