@hyperweb/telescope 2.0.4 → 2.2.0

package/src/parse.ts

@@ -1,243 +0,0 @@
-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

@@ -1,65 +0,0 @@
-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

@@ -1,80 +0,0 @@
-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

@@ -1,95 +0,0 @@
-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

@@ -1,30 +0,0 @@
-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

@@ -1,74 +0,0 @@
-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;
-      }
-    }
-  }
-}