@hyperweb/telescope 1.15.0

package/src/parse.ts

@@ -0,0 +1,243 @@
+import { ProtoRef, ProtoType, ServiceInfo, ALLOWED_RPC_SERVICES } from '@cosmology/types'
+import { getObjectName } from '@cosmology/proto-parser';
+import { getKeyTypeEntryName } from '@cosmology/ast';
+import { getRoot } from './utils';
+import { TelescopeParseContext } from './build';
+import { getEnumValues } from '@cosmology/utils';
+
+export const parse = (
+    context: TelescopeParseContext,
+): void => {
+    const root = getRoot(context.ref);
+    parseRecur({
+        context,
+        obj: root.root,
+        scope: [],
+        isNested: false
+    });
+};
+
+export const getParsedObjectName = (
+    ref: ProtoRef,
+    obj: any,
+    scope: string[],
+) => {
+    const _scope = [...scope];
+    const root = getRoot(ref);
+    const allButPackage = _scope.splice(root.package.split('.').length);
+    // pull off "this" name
+    allButPackage.pop();
+    return getObjectName(obj.name, [root.package, ...allButPackage]);
+};
+
+// TODO potentially move this back to ast or proto bc the ast lib references MapEntries...
+// Creating those BindingsEntry interfaces
+const makeKeyTypeObj = (ref: ProtoRef, field: any, scope: string[]) => {
+    const root = getRoot(ref);
+    const scoped = [...scope].splice(root.package.split('.').length);
+    const adhocObj: ProtoType = {
+        type: 'Type',
+        comment: undefined,
+        fields: {
+            key: {
+                id: 1,
+                type: field.keyType,
+                scope: [...scoped],
+                parsedType: {
+                    name: field.keyType,
+                    type: field.keyType
+                },
+                comment: undefined,
+                options: {
+                  "(telescope:map_entry_type_field)": true
+                }
+            },
+            value: {
+                id: 2,
+                type: field.type,
+                scope: [...scoped],
+                parsedType: {
+                    name: field.parsedType.name,
+                    type: field.parsedType.type
+                },
+                comment: undefined,
+                options: {
+                  "(telescope:map_entry_type_field)": true
+                }
+            }
+        }
+    };
+    return adhocObj;
+}
+
+export const parseType = (
+    context: TelescopeParseContext,
+    obj: any,
+    // scope already has the name of "this" field at the end of it
+    scope: string[],
+    isNested: boolean = false
+) => {
+
+    obj.keyTypes.forEach(field => {
+        const keyTypeObject = makeKeyTypeObj(context.ref, field, [...scope]);
+        const name = getParsedObjectName(context.ref, {
+            name: getKeyTypeEntryName(obj.name, field.name)
+        }, [...scope]);
+        context.addType(name, keyTypeObject, true);
+    });
+
+    // parse nested names
+    let name = obj.name;
+    if (isNested) {
+        name = getParsedObjectName(context.ref, obj, [...scope]);
+    }
+
+    context.addType(name, obj, isNested);
+
+    // render nested LAST
+    if (obj.nested) {
+        Object.keys(obj.nested).forEach(key => {
+            // isNested = true;
+            parseRecur({
+                context,
+                obj: obj.nested[key],
+                scope: [...scope, key],
+                isNested: true
+            });
+        });
+    }
+
+};
+
+export const parseEnum = (
+    context: TelescopeParseContext,
+    obj: any,
+    scope: string[],
+    isNested: boolean = false
+) => {
+    let name = obj.name;
+    let enumObj = {
+      ...obj,
+      package: context.ref.proto.package
+    };
+    // parse nested names
+    if (isNested) {
+        name = getParsedObjectName(context.ref, enumObj, scope);
+    }
+    context.addType(name, enumObj, isNested);
+
+};
+
+export const parseService = (
+    context: TelescopeParseContext,
+    obj: any,
+    scope: string[],
+    isNested: boolean = false
+) => {
+
+    const methodHash: Record<string, {
+        requestType: string;
+        responseType: string;
+        comment?: string;
+    }> = obj.methods;
+
+    if (!ALLOWED_RPC_SERVICES.includes(obj.name)) {
+        return;
+    }
+
+    Object.entries(methodHash)
+        .forEach(([key, value]) => {
+            const lookup = context.store.get(context.ref, value.requestType);
+            if (!lookup) {
+                console.warn(`cannot find ${value.requestType}`);
+                throw new Error('undefined symbol for service.');
+            }
+            const lookupResponse = context.store.get(context.ref, value.responseType);
+            if (!lookupResponse) {
+                console.warn(`cannot find ${value.responseType}`);
+                throw new Error('undefined symbol for service.');
+            }
+            const serviceInfo: ServiceInfo = {
+                methodName: key,
+                package: context.ref.proto.package,
+                message: lookup.importedName,
+                messageImport: lookup.import ?? context.ref.filename,
+                response: lookupResponse.importedName,
+                responseImport: lookupResponse.import ?? context.ref.filename,
+                comment: value.comment
+            };
+            switch (obj.name) {
+                case 'Msg':
+                    context.addMutation(serviceInfo);
+                    break;
+                case 'Query':
+                    context.addQuery(serviceInfo);
+                    break;
+                default:
+                    context.addService(serviceInfo);
+                    break;
+            }
+        });
+};
+
+interface ParseRecur {
+    context: TelescopeParseContext,
+    obj: any;
+    scope: string[];
+    isNested: boolean;
+}
+export const parseRecur = ({
+    context,
+    obj,
+    scope,
+    isNested
+}: ParseRecur) => {
+    switch (obj.type) {
+        case 'Type':
+            return parseType(
+                context, obj, scope, isNested
+            );
+        case 'Enum':
+            return parseEnum(
+                context, obj, scope, isNested
+            );
+        case 'Service':
+            return parseService(
+                context, obj, scope, isNested
+            );
+        case 'Field':
+            console.log(obj);
+            return;
+        case 'Root':
+        case 'Namespace':
+            if (obj.nested) {
+                return Object.keys(obj.nested).forEach(key => {
+                    parseRecur({
+                        context,
+                        obj: obj.nested[key],
+                        scope: [...scope, key],
+                        isNested
+                    });
+                });
+            } else {
+                throw new Error('parseRecur() cannot find protobufjs Type')
+            }
+        default:
+        // if (obj.type === 'string') return;
+        // if (obj.type === 'bool') return;
+        // if (obj.type === 'HttpRule') return;
+        // if (obj.type === 'InterfaceDescriptor') return;
+        // if (obj.type === 'ScalarDescriptor') return;
+        // if (obj.type === 'ModuleDescriptor') return;
+        // if (obj.type === 'TableDescriptor') return;
+        // if (obj.type === 'SingletonDescriptor') return;
+        // if (obj.type === 'ModuleSchemaDescriptor') return;
+        // if (obj.type === 'google.api.FieldBehavior') return;
+        // if (obj.type === 'google.api.ResourceReference') return;
+        // if (obj.type === 'google.api.ResourceDescriptor') return;
+        // if (obj.type === 'google.api.RoutingRule') return;
+        // if (obj.type === 'google.api.VisibilityRule') return;
+        // if (obj.type === 'google.longrunning.OperationInfo') return;
+        // throw new Error('parseRecur() cannot find protobufjs Type')
+    }
+};

package/src/prompt.js

@@ -0,0 +1,65 @@
+import { filter } from 'fuzzy';
+import { prompt as inquirerer } from 'inquirerer';
+
+export const getFuzzySearch = (list) => {
+  return (answers, input) => {
+    input = input || '';
+    return new Promise(function (resolve) {
+      setTimeout(function () {
+        const fuzzyResult = filter(input, list);
+        resolve(
+          fuzzyResult.map(function (el) {
+            return el.original;
+          })
+        );
+      }, 25);
+    });
+  };
+};
+
+export const getFuzzySearchNames = (nameValueItemList) => {
+  const list = nameValueItemList.map(({ name, value }) => name);
+  return (answers, input) => {
+    input = input || '';
+    return new Promise(function (resolve) {
+      setTimeout(function () {
+        const fuzzyResult = filter(input, list);
+        resolve(
+          fuzzyResult.map(function (el) {
+            return nameValueItemList.find(
+              ({ name, value }) => el.original == name
+            );
+          })
+        );
+      }, 25);
+    });
+  };
+};
+const transform = (questions) => {
+  return questions.map((q) => {
+    if (q.type === 'fuzzy') {
+      const choices = q.choices;
+      delete q.choices;
+      return {
+        ...q,
+        type: 'autocomplete',
+        source: getFuzzySearch(choices)
+      };
+    } else if (q.type === 'fuzzy:objects') {
+      const choices = q.choices;
+      delete q.choices;
+      return {
+        ...q,
+        type: 'autocomplete',
+        source: getFuzzySearchNames(choices)
+      };
+    } else {
+      return q;
+    }
+  });
+};
+
+export const prompt = async (questions = [], argv = {}) => {
+  questions = transform(questions);
+  return await inquirerer(questions, argv);
+};

package/src/protod/bufbuild.spec.ts

@@ -0,0 +1,80 @@
+import {
+  findAllBufLockFiles,
+  findAllBufYamlFiles,
+  getAllBufDeps,
+  parseBufLockFile,
+  parseBufYamlFile,
+} from "./bufbuild";
+
+import { join } from "path";
+
+const GIT_MOUDLES = "./git-modules";
+let gitModules = join(__dirname, GIT_MOUDLES);
+const TEST_DATA_FOLDER = "test-data";
+let testData = join(__dirname, TEST_DATA_FOLDER);
+
+describe("Test `parseBufLock`", () => {
+  it("should successfully parse `./test-data/buf.lock`", () => {
+    const [cosmosProto, gogoProto, googleapis, wellknowntypes] =
+      parseBufLockFile(join(testData, "buf.lock"));
+    expect(cosmosProto.owner).toBe("cosmos");
+    expect(cosmosProto.repo).toBe("cosmos-proto");
+    expect(gogoProto.owner).toBe("cosmos");
+    expect(gogoProto.repo).toBe("gogo-proto");
+    expect(googleapis.owner).toBe("googleapis");
+    expect(googleapis.repo).toBe("googleapis");
+    expect(wellknowntypes.owner).toBe("protocolbuffers");
+    expect(wellknowntypes.repo).toBe("wellknowntypes");
+  });
+});
+
+describe("Test `parseBufYamlFile`", () => {
+  it("should successfully parse `./test-data/buf.yaml`", () => {
+    const [cosmosProto, gogoProto, googleapis, wellknowntypes] =
+      parseBufYamlFile(join(testData, "buf.yaml"));
+    expect(cosmosProto.owner).toBe("cosmos");
+    expect(cosmosProto.repo).toBe("cosmos-proto");
+    expect(gogoProto.owner).toBe("cosmos");
+    expect(gogoProto.repo).toBe("gogo-proto");
+    expect(googleapis.owner).toBe("googleapis");
+    expect(googleapis.repo).toBe("googleapis");
+    expect(wellknowntypes.owner).toBe("protocolbuffers");
+    expect(wellknowntypes.repo).toBe("wellknowntypes");
+  });
+
+  it("should have no dependency in `./test-data/buf2.yaml`", () => {
+    const result = parseBufYamlFile(join(testData, "buf2.yaml"));
+    expect(result.length).toBe(0);
+  });
+});
+
+describe("Test `findAllBufLockFiles`", () => {
+  it("`./test-data` should contain 2 buf.lock files", () => {
+    const files = findAllBufLockFiles(testData);
+    expect(files.length).toBe(2);
+  });
+
+  it("should print all buf.lock in git-modules", () => {
+    const files = findAllBufLockFiles(gitModules);
+    console.log("All `buf.lock`: ", files);
+  });
+});
+
+describe("Test `findAllBufYamlFiles`", () => {
+  it("`./test-data` should contain only 1 buf.yaml file", () => {
+    const files = findAllBufYamlFiles(testData);
+    expect(files.length).toBe(1);
+  });
+});
+
+describe("Test `getAllBufDeps`", () => {
+  it("should contain 4 buf deps in all buf.lock and buf.yaml files in `./test-data` ", () => {
+    const files = getAllBufDeps(testData);
+    expect(files.length).toBe(4);
+  });
+
+  it("should print all buf.build dependencies in git-modules", () => {
+    const files = getAllBufDeps(gitModules);
+    console.log("All buf.build dependencies: ", files);
+  });
+});

package/src/protod/bufbuild.ts

@@ -0,0 +1,95 @@
+import fs from "fs";
+import { Repo } from "./types";
+import YAML from "yaml";
+import { isPathExist } from "./utils";
+import { crossGlob as glob } from '@cosmology/utils';
+
+export function parseBufLockFile(filePath: string): Repo[] {
+  if (!isPathExist(filePath)) {
+    console.warn(`No such file ${filePath}`);
+    return [];
+  }
+  const bufLock = fs.readFileSync(filePath, "utf8");
+  const deps = bufLock.split(/-\s/);
+  const repos: Repo[] = [];
+  deps.forEach((dep) => {
+    if (!dep.startsWith("remote")) {
+      return;
+    }
+    const bufDep = {
+      owner: /owner:\s(.+)/.exec(dep)?.[1],
+      repo: /repository:\s(.+)/.exec(dep)?.[1],
+    };
+    if (!bufDep.owner || !bufDep.repo) {
+      throw new Error("owner or repository is missing.");
+    }
+    repos.push(bufDep as Repo);
+  });
+  return repos;
+}
+
+export function parseBufYamlFile(filePath: string): Repo[] {
+  if (!isPathExist(filePath)) {
+    console.warn(`No such file ${filePath}`);
+    return [];
+  }
+  const { deps } = YAML.parse(fs.readFileSync(filePath, "utf8"));
+  if (deps) {
+    return deps.map((dep: string) => {
+      const [_, owner, repo] = dep.split("/");
+      return {
+        owner,
+        repo: repo.split(":")[0],
+      };
+    });
+  }
+  return [];
+}
+
+export function findAllBufYamlFiles(dir: string): string[] {
+  return glob(`${dir}/**/buf.yaml`, {
+    ignore: `${dir}/node_modules/**`,
+  });
+}
+
+export function findAllBufLockFiles(dir: string): string[] {
+  return glob(`${dir}/**/buf.lock`, {
+    ignore: `${dir}/node_modules/**`,
+  });
+}
+
+export function getAllBufDeps(dir: string) {
+  const bufDeps: Repo[] = [];
+
+  const bufLockFiles = findAllBufLockFiles(dir);
+
+  bufLockFiles.map(async (filePath) => {
+    const deps = parseBufLockFile(filePath);
+    deps.forEach((dep) => {
+      if (
+        bufDeps.findIndex(
+          (_dep) => _dep.owner == dep.owner && _dep.repo == dep.repo
+        ) == -1
+      ) {
+        bufDeps.push(dep);
+      }
+    });
+  });
+
+  const bufYamlFiles = findAllBufYamlFiles(dir);
+
+  bufYamlFiles.map(async (filePath) => {
+    const deps = await parseBufYamlFile(filePath);
+    deps.forEach((dep) => {
+      if (
+        bufDeps.findIndex(
+          (_dep) => _dep.owner == dep.owner && _dep.repo == dep.repo
+        ) == -1
+      ) {
+        bufDeps.push(dep);
+      }
+    });
+  });
+
+  return bufDeps;
+}

package/src/protod/config.ts

@@ -0,0 +1,30 @@
+import { BufInfo } from "./types";
+
+export const bufInfo: BufInfo[] = [
+  {
+    owner: "protocolbuffers",
+    repo: "wellknowntypes",
+    git: [
+      {
+        owner: "protocolbuffers",
+        repo: "protobuf",
+      },
+    ],
+  },
+  {
+    owner: "cosmos",
+    repo: "gogo-proto",
+    git: [
+      {
+        owner: "cosmos",
+        repo: "gogoproto",
+      },
+    ],
+  },
+];
+
+export const presetProtoDirMapping = {
+  "gogo/protobuf/master": ".",
+  "googleapis/googleapis/master": ".",
+  "protocolbuffers/protobuf/main": "src",
+};

package/src/protod/git-repo.ts

@@ -0,0 +1,74 @@
+import {
+  exec,
+  getMainBranchName,
+  isPathExist,
+  makeDir,
+  removeFolder,
+} from "./utils";
+
+const branchCache: Record<string, string> = {};
+
+export class GitRepo {
+  constructor(
+    public readonly owner: string,
+    public readonly repo: string,
+    public readonly ssh: boolean = false
+  ) {}
+
+  get fullName() {
+    return `${this.owner}/${this.repo}`;
+  }
+
+  get httpsUrl() {
+    return `https://github.com/${this.fullName}.git`;
+  }
+
+  get sshUrl() {
+    return `git@github.com:${this.fullName}.git`;
+  }
+
+  async getMainBranchName() {
+    const url = this.ssh ? this.sshUrl : this.httpsUrl;
+
+    if (branchCache[url]) {
+      return branchCache[url];
+    }
+
+    branchCache[url] = await getMainBranchName(url);
+
+    return branchCache[url];
+  }
+
+  clone(
+    branch: string,
+    depth: number = 1,
+    outDir: string = "./git-modules",
+    isOverride?: boolean
+  ) {
+    const dir = `${outDir}/${this.fullName}/${branch}`;
+    try {
+      if (!isOverride && isPathExist(dir)) {
+        console.log(`Folder ${dir} already exists, skip cloning`);
+        return dir;
+      } else {
+        console.log(`Cloning to ${dir}`);
+      }
+
+      removeFolder(dir);
+      makeDir(dir);
+      exec(
+        `git clone ${
+          this.ssh ? this.sshUrl : this.httpsUrl
+        } --depth ${depth} --branch ${branch} --single-branch ${dir}`
+      );
+      console.log(`Cloned ${this.fullName}/${branch} to ${dir}`);
+      return dir;
+    } catch (error) {
+      if ((error as Error).message.startsWith("Cloning into")) {
+        return dir;
+      } else {
+        throw error;
+      }
+    }
+  }
+}

package/src/protod/index.ts

@@ -0,0 +1 @@
+export * from "./recursive";