chore: use strict compilation mode

src/source/GitHubBase.ts

@@ -11,7 +11,7 @@ export default abstract class GitHubBase {
   type: "GitHubDownload" | "GitHubStream" | "Zip";
   githubRepository: GitHubRepository;
   branch: Branch;
-  accessToken: string;
+  accessToken: string | undefined;
   repository: Repository;
 
   constructor(
@@ -27,13 +27,17 @@ export default abstract class GitHubBase {
   ) {
     this.type = data.type;
     this.accessToken = data.accessToken;
+    const branches = [];
+    if (data.branch && data.commit) {
+      branches.push({ commit: data.commit, name: data.branch });
+    }
     this.githubRepository = new GitHubRepository({
       name: data.repositoryName,
       externalId: data.repositoryId,
-      branches: [{ commit: data.commit, name: data.branch }],
+      branches,
     });
     this.repository = repository;
-    this.branch = { commit: data.commit, name: data.branch };
+    this.branch = branches[0];
   }
 
   async getFileContent(file: AnonymizedFile): Promise<Readable> {

src/source/GitHubDownload.ts

@@ -1,14 +1,14 @@
 import { Octokit } from "@octokit/rest";
-import config from "../../config";
-import storage from "../storage";
-import Repository from "../Repository";
-
-import GitHubBase from "./GitHubBase";
-import AnonymizedFile from "../AnonymizedFile";
-import { RepositoryStatus, SourceBase } from "../types";
 import got from "got";
 import { Readable } from "stream";
 import { OctokitResponse } from "@octokit/types";
+
+import config from "../../config";
+import storage from "../storage";
+import Repository from "../Repository";
+import GitHubBase from "./GitHubBase";
+import AnonymizedFile from "../AnonymizedFile";
+import { RepositoryStatus, SourceBase } from "../types";
 import AnonymousError from "../AnonymousError";
 
 export default class GitHubDownload extends GitHubBase implements SourceBase {
@@ -56,7 +56,7 @@ export default class GitHubDownload extends GitHubBase implements SourceBase {
       }
       response = await this._getZipUrl(token);
     } catch (error) {
-      if (error.status == 401 && config.GITHUB_TOKEN) {
+      if ((error as any).status == 401 && config.GITHUB_TOKEN) {
         try {
           response = await this._getZipUrl(config.GITHUB_TOKEN);
         } catch (error) {
@@ -66,7 +66,7 @@ export default class GitHubDownload extends GitHubBase implements SourceBase {
           );
           throw new AnonymousError("repo_not_accessible", {
             httpStatus: 404,
-            cause: error,
+            cause: error as Error,
             object: this.repository,
           });
         }
@@ -78,23 +78,23 @@ export default class GitHubDownload extends GitHubBase implements SourceBase {
         throw new AnonymousError("repo_not_accessible", {
           httpStatus: 404,
           object: this.repository,
-          cause: error,
+          cause: error as Error,
         });
       }
     }
     await this.repository.updateStatus(RepositoryStatus.DOWNLOAD);
     const originalPath = this.repository.originalCachePath;
     await storage.mk(originalPath);
-    let progress = null;
+    let progress: { transferred: number } | undefined = undefined;
     let progressTimeout;
     let inDownload = true;
 
     const that = this;
     async function updateProgress() {
-      if (progress) {
+      if (progress && that.repository.status) {
         await that.repository.updateStatus(
           that.repository.status,
-          progress.transferred
+          progress.transferred.toString()
         );
       }
       if (inDownload) {
@@ -106,7 +106,7 @@ export default class GitHubDownload extends GitHubBase implements SourceBase {
     try {
       const downloadStream = got.stream(response.url);
       downloadStream.addListener("downloadProgress", (p) => (progress = p));
-      await storage.extractZip(originalPath, downloadStream, null, this);
+      await storage.extractZip(originalPath, downloadStream, undefined, this);
     } catch (error) {
       await this.repository.updateStatus(
         RepositoryStatus.ERROR,
@@ -114,7 +114,7 @@ export default class GitHubDownload extends GitHubBase implements SourceBase {
       );
       throw new AnonymousError("unable_to_download", {
         httpStatus: 500,
-        cause: error,
+        cause: error as Error,
         object: this.repository,
       });
     } finally {

src/source/GitHubRepository.ts

@@ -31,15 +31,15 @@ export class GitHubRepository {
     return this._data;
   }
 
-  public get fullName(): string {
+  public get fullName(): string | undefined {
     return this._data.name;
   }
 
-  public get id(): string {
+  public get id(): string | undefined {
     return this._data.externalId;
   }
 
-  public get size(): number {
+  public get size(): number | undefined {
     return this._data.size;
   }
 
@@ -76,27 +76,30 @@ export class GitHubRepository {
         { $set: { branches } }
       );
     } else {
-      this._data.branches = (
-        await RepositoryModel.findOne({ externalId: this.id }).select(
-          "branches"
-        )
-      ).branches;
+      const q = await RepositoryModel.findOne({ externalId: this.id }).select(
+        "branches"
+      );
+      this._data.branches = q?.branches;
     }
 
-    return this._data.branches;
+    return this._data.branches || [];
   }
 
   async readme(opt: {
     branch?: string;
     force?: boolean;
     accessToken?: string;
-  }): Promise<string> {
+  }): Promise<string | undefined> {
     if (!opt.branch) opt.branch = this._data.defaultBranch || "master";
 
     const model = await RepositoryModel.findOne({
       externalId: this.id,
     }).select("branches");
 
+    if (!model) {
+      throw new AnonymousError("repo_not_found", { httpStatus: 404 });
+    }
+
     this._data.branches = await this.branches(opt);
     model.branches = this._data.branches;
 
@@ -119,7 +122,7 @@ export class GitHubRepository {
       } catch (error) {
         throw new AnonymousError("readme_not_available", {
           httpStatus: 404,
-          cause: error,
+          cause: error as Error,
           object: this,
         });
       }
@@ -136,6 +139,12 @@ export class GitHubRepository {
   }
 
   public get owner(): string {
+    if (!this.fullName) {
+      throw new AnonymousError("invalid_repo", {
+        httpStatus: 400,
+        object: this,
+      });
+    }
     const repo = gh(this.fullName);
     if (!repo) {
       throw new AnonymousError("invalid_repo", {
@@ -147,6 +156,12 @@ export class GitHubRepository {
   }
 
   public get repo(): string {
+    if (!this.fullName) {
+      throw new AnonymousError("invalid_repo", {
+        httpStatus: 400,
+        object: this,
+      });
+    }
     const repo = gh(this.fullName);
     if (!repo) {
       throw new AnonymousError("invalid_repo", {
@@ -177,12 +192,12 @@ export async function getRepositoryFromGitHub(opt: {
     ).data;
   } catch (error) {
     throw new AnonymousError("repo_not_found", {
-      httpStatus: error.status,
+      httpStatus: (error as any).status,
       object: {
         owner: opt.owner,
         repo: opt.repo,
       },
-      cause: error,
+      cause: error as Error,
     });
   }
   if (!r)

src/source/GitHubStream.ts

@@ -30,11 +30,18 @@ export default class GitHubStream extends GitHubBase implements SourceBase {
       auth: await this.getToken(),
     });
 
+    const file_sha = await file.sha();
+    if (!file_sha) {
+      throw new AnonymousError("file_not_accessible", {
+        httpStatus: 404,
+        object: file,
+      });
+    }
     try {
       const ghRes = await octokit.rest.git.getBlob({
         owner: this.githubRepository.owner,
         repo: this.githubRepository.repo,
-        file_sha: await file.sha(),
+        file_sha,
       });
       if (!ghRes.data.content && ghRes.data.size != 0) {
         throw new AnonymousError("file_not_accessible", {
@@ -57,16 +64,16 @@ export default class GitHubStream extends GitHubBase implements SourceBase {
       await storage.write(file.originalCachePath, content, file, this);
       return stream.Readable.from(content);
     } catch (error) {
-      if (error.status === 404 || error.httpStatus === 404) {
+      if ((error as any).status === 404 || (error as any).httpStatus === 404) {
         throw new AnonymousError("file_not_found", {
-          httpStatus: error.status,
-          cause: error,
+          httpStatus: (error as any).status || (error as any).httpStatus,
+          cause: error as Error,
           object: file,
         });
       }
       throw new AnonymousError("file_too_big", {
-        httpStatus: error.status,
-        cause: error,
+        httpStatus: (error as any).status || (error as any).httpStatus,
+        cause: error as Error,
         object: file,
       });
     }
@@ -92,7 +99,7 @@ export default class GitHubStream extends GitHubBase implements SourceBase {
       count.request++;
       ghRes = await this.getGHTree(sha, { recursive: true });
     } catch (error) {
-      if (error.status == 409) {
+      if ((error as any).status == 409) {
         // empty tree
         if (this.repository.status != RepositoryStatus.READY)
           await this.repository.updateStatus(RepositoryStatus.READY);
@@ -100,15 +107,17 @@ export default class GitHubStream extends GitHubBase implements SourceBase {
         return { __: {} };
       } else {
         console.log(
-          `[ERROR] getTree ${this.repository.repoId}@${sha}: ${error.message}`
+          `[ERROR] getTree ${this.repository.repoId}@${sha}: ${
+            (error as Error).message
+          }`
         );
         await this.repository.resetSate(
           RepositoryStatus.ERROR,
           "repo_not_accessible"
         );
         throw new AnonymousError("repo_not_accessible", {
-          httpStatus: error.status,
-          cause: error,
+          httpStatus: (error as any).status,
+          cause: error as Error,
           object: {
             owner: this.githubRepository.owner,
             repo: this.githubRepository.repo,
@@ -161,8 +170,8 @@ export default class GitHubStream extends GitHubBase implements SourceBase {
     if (data.tree.length < 100 && count.request < 200) {
       const promises: Promise<any>[] = [];
       for (const file of data.tree) {
-        const elementPath = path.join(parentPath, file.path);
-        if (file.type == "tree") {
+        if (file.type == "tree" && file.path && file.sha) {
+          const elementPath = path.join(parentPath, file.path);
           promises.push(
             this.getTruncatedTree(
               file.sha,