fix: noImplicitAny ts

app/common/FileUtil.ts

@@ -105,13 +105,13 @@ const WHITE_FILENAME_CONTENT_TYPES = {
   '.eslintignore': PLAIN_TEXT,
   '.jshintrc': 'application/json',
   '.eslintrc': 'application/json',
-};
+} as const;
 
 export function mimeLookup(filepath: string) {
   const filename = path.basename(filepath).toLowerCase();
   if (filename.endsWith('.ts')) return PLAIN_TEXT;
   if (filename.endsWith('.lock')) return PLAIN_TEXT;
   return mime.lookup(filename) ||
-    WHITE_FILENAME_CONTENT_TYPES[filename] ||
+    WHITE_FILENAME_CONTENT_TYPES[filename as keyof typeof WHITE_FILENAME_CONTENT_TYPES] ||
     DEFAULT_CONTENT_TYPE;
 }

app/common/UserUtil.ts

@@ -34,7 +34,7 @@ export function integrity(plain: string): string {
 }
 
 export function checkIntegrity(plain: string, expectedIntegrity: string): boolean {
-  return ssri.checkData(plain, expectedIntegrity);
+  return !!ssri.checkData(plain, expectedIntegrity);
 }
 
 export function sha512(plain: string): string {

app/common/adapter/NPMRegistry.ts

@@ -11,6 +11,7 @@ import {
   HttpClientRequestOptions,
   HttpClientResponse,
 } from 'egg';
+import { PackageManifestType } from '../../repository/PackageRepository';
 
 type HttpMethod = HttpClientRequestOptions['method'];
 
@@ -40,7 +41,7 @@ export class NPMRegistry {
     this.registryHost = registryHost;
   }
 
-  public async getFullManifests(fullname: string, optionalConfig?: {retries?:number, remoteAuthToken?:string}): Promise<RegistryResponse> {
+  public async getFullManifests(fullname: string, optionalConfig?: { retries?: number, remoteAuthToken?: string }): Promise<{ method: HttpMethod } & HttpClientResponse<PackageManifestType>> {
     let retries = optionalConfig?.retries || 3;
     // set query t=timestamp, make sure CDN cache disable
     // cache=0 is sync worker request flag

app/common/adapter/binary/AbstractBinary.ts

@@ -17,6 +17,8 @@ export type FetchResult = {
   nextParams?: any;
 };
 
+const platforms = [ 'darwin', 'linux', 'win32' ] as const;
+
 export const BINARY_ADAPTER_ATTRIBUTE = Symbol('BINARY_ADAPTER_ATTRIBUTE');
 
 export abstract class AbstractBinary {
@@ -74,7 +76,7 @@ export abstract class AbstractBinary {
 
   protected listNodePlatforms() {
     // https://nodejs.org/api/os.html#osplatform
-    return [ 'darwin', 'linux', 'win32' ];
+    return platforms;
   }
 
   protected listNodeArchs(binaryConfig?: BinaryTaskConfig) {
@@ -87,11 +89,11 @@ export abstract class AbstractBinary {
     };
   }
 
-  protected listNodeLibcs() {
+  protected listNodeLibcs(): Record<typeof platforms[number], string[]> {
     // https://github.com/lovell/detect-libc/blob/master/lib/detect-libc.js#L42
     return {
-      linux: [ 'glibc', 'musl' ],
       darwin: [ 'unknown' ],
+      linux: [ 'glibc', 'musl' ],
       win32: [ 'unknown' ],
     };
   }

app/common/adapter/binary/PlaywrightBinary.ts

@@ -189,7 +189,7 @@ const DOWNLOAD_PATHS = {
   'android': {
     '<unknown>': 'builds/android/%s/android.zip',
   },
-};
+} as const;
 
 @SingletonProto()
 @BinaryAdapter(BinaryType.Playwright)
@@ -215,7 +215,7 @@ export class PlaywrightBinary extends AbstractBinary {
         .filter(version => version.match(/^(?:\d+\.\d+\.\d+)(?:-beta-\d+)?$/))
         // select recently update 20 items
         .slice(-20);
-      const browsers: { name: string; revision: string; browserVersion: string; revisionOverrides?: Record<string, string> }[] = [];
+      const browsers: { name: keyof typeof DOWNLOAD_PATHS; revision: string; browserVersion: string; revisionOverrides?: Record<string, string> }[] = [];
       await Promise.all(
         packageVersions.map(version =>
           this.requestJSON(

app/common/adapter/changesStream/CnpmjsorgChangesStream.ts

@@ -6,6 +6,16 @@ import { AbstractChangeStream, RegistryChangesStream } from './AbstractChangesSt
 
 const MAX_LIMIT = 10000;
 
+type FetchResults = {
+  results: {
+    seq: number;
+    type: string;
+    id: string;
+    changes: Record<string, string>[];
+    gmt_modified: Date,
+  }[];
+};
+
 @SingletonProto()
 @RegistryChangesStream(RegistryType.Cnpmjsorg)
 export class CnpmjsorgChangesStream extends AbstractChangeStream {
@@ -18,13 +28,13 @@ export class CnpmjsorgChangesStream extends AbstractChangeStream {
     return since;
   }
 
-  private async tryFetch(registry: Registry, since: string, limit = 1000) {
+  private async tryFetch(registry: Registry, since: string, limit = 1000): Promise<{ data: FetchResults }> {
     if (limit > MAX_LIMIT) {
       throw new E500(`limit too large, current since: ${since}, limit: ${limit}`);
     }
     const db = this.getChangesStreamUrl(registry, since, limit);
     // json mode
-    const res = await this.httpclient.request(db, {
+    const res = await this.httpclient.request<FetchResults>(db, {
       followRedirect: true,
       timeout: 30000,
       dataType: 'json',

app/core/entity/BugVersion.ts

@@ -8,7 +8,7 @@ export type BugVersionPackages = Record<string, BugVersionPackage>;
 export class BugVersion {
   private readonly data: BugVersionPackages;
 
-  constructor(data) {
+  constructor(data: BugVersionPackages) {
     this.data = data;
   }
 

app/core/entity/Hook.ts

@@ -48,7 +48,7 @@ export class Hook extends Entity {
   }
 
   // payload 可能会特别大，如果做多次 stringify 浪费太多 cpu
-  signPayload(payload: object): { digest, payloadStr } {
+  signPayload(payload: object) {
     const payloadStr = JSON.stringify(payload);
     const digest = crypto.createHmac('sha256', this.secret)
       .update(JSON.stringify(payload))

app/core/entity/SqlRange.ts

@@ -38,7 +38,7 @@ export class SqlRange {
       };
     }
     const paddingSemver = new PaddingSemVer(comparator.semver);
-    const operator = OPERATOR_MAP[comparator.operator];
+    const operator = OPERATOR_MAP[comparator.operator as keyof typeof OPERATOR_MAP];
     if (!operator) {
       throw new Error(`unknown operator ${comparator.operator}`);
     }

app/core/service/BugVersionService.ts

@@ -40,7 +40,7 @@ export class BugVersionService {
       const packageVersionJson = (await this.distRepository.findPackageVersionManifest(pkg!.packageId, tag!.version)) as PackageJSONType;
       if (!packageVersionJson) return;
       const data = packageVersionJson.config?.['bug-versions'];
-      bugVersion = new BugVersion(data);
+      bugVersion = new BugVersion(data || {});
       this.bugVersionStore.setBugVersion(bugVersion, tag!.version);
     }
     return bugVersion;

app/core/service/PackageManagerService.ts

@@ -425,7 +425,7 @@ export class PackageManagerService extends AbstractService {
 
   public plusPackageVersionCounter(fullname: string, version: string) {
     // set counter + 1, schedule will store them into database
-    const counters = PackageManagerService.downloadCounters;
+    const counters: Record<string, Record<string, number>> = PackageManagerService.downloadCounters;
     if (!counters[fullname]) counters[fullname] = {};
     counters[fullname][version] = (counters[fullname][version] || 0) + 1;
     // Total
@@ -444,7 +444,7 @@ export class PackageManagerService extends AbstractService {
   // will be call by schedule/SavePackageVersionDownloadCounter.ts
   async savePackageVersionCounters() {
     // { [fullname]: { [version]: number } }
-    const counters = PackageManagerService.downloadCounters;
+    const counters: Record<string, Record<string, number>> = PackageManagerService.downloadCounters;
     const fullnames = Object.keys(counters);
     if (fullnames.length === 0) return;
 
@@ -724,13 +724,16 @@ export class PackageManagerService extends AbstractService {
     const fieldsFromLatestManifest = [
       'author', 'bugs', 'contributors', 'description', 'homepage', 'keywords', 'license',
       'readmeFilename', 'repository',
-    ];
+    ] as const;
     // the latest version metas
     for (const field of fieldsFromLatestManifest) {
-      fullManifests[field] = latestManifest[field];
+      if (latestManifest[field]) {
+        (fullManifests as Record<string, unknown>)[field] = latestManifest[field];
+      }
     }
   }
 
+
   private async _setPackageDistTagsAndLatestInfos(pkg: Package, fullManifests: PackageManifestType, abbreviatedManifests: AbbreviatedPackageManifestType) {
     const distTags = await this._listPackageDistTags(pkg);
     if (distTags.latest) {

app/core/service/PackageSyncerService.ts

@@ -18,7 +18,7 @@ import { downloadToTempfile } from '../../common/FileUtil';
 import { TaskState, TaskType } from '../../common/enum/Task';
 import { AbstractService } from '../../common/AbstractService';
 import { TaskRepository } from '../../repository/TaskRepository';
-import { PackageJSONType, PackageRepository } from '../../repository/PackageRepository';
+import { PackageJSONType, PackageManifestType, PackageRepository } from '../../repository/PackageRepository';
 import { PackageVersionDownloadRepository } from '../../repository/PackageVersionDownloadRepository';
 import { UserRepository } from '../../repository/UserRepository';
 import { Task, SyncPackageTaskOptions, CreateSyncPackageTask } from '../entity/Task';
@@ -484,7 +484,7 @@ export class PackageSyncerService extends AbstractService {
     //   { name: 'jasonlaster11', email: 'jason.laster.11@gmail.com' }
     // ],
     let maintainers = data.maintainers;
-    const maintainersMap = {};
+    const maintainersMap: Record<string, PackageManifestType['maintainers']> = {};
     const users: User[] = [];
     let changedUserCount = 0;
     if (!Array.isArray(maintainers) || maintainers.length === 0) {
@@ -619,7 +619,7 @@ export class PackageSyncerService extends AbstractService {
           }
           if (!isEqual(remoteItemValue, existsItem[key])) {
             diffMeta[key] = remoteItemValue;
-          } else if (!ignoreInAbbreviated.includes(key) && existsAbbreviatedItem && !isEqual(remoteItemValue, existsAbbreviatedItem[key])) {
+          } else if (!ignoreInAbbreviated.includes(key) && existsAbbreviatedItem && !isEqual(remoteItemValue, (existsAbbreviatedItem as Record<string, unknown>)[key])) {
             // should diff exists abbreviated item too
             diffMeta[key] = remoteItemValue;
           }

app/core/service/PackageVersionService.ts

@@ -49,7 +49,7 @@ export class PackageVersionService {
     if (isFullManifests) {
       manifest = await this.distRepository.findPackageVersionManifest(pkgId, version);
     } else {
-      manifest = this.distRepository.findPackageAbbreviatedManifest(pkgId, version);
+      manifest = await this.distRepository.findPackageAbbreviatedManifest(pkgId, version);
     }
     if (manifest && bugVersionAdvice) {
       manifest.deprecated = `[WARNING] Use ${bugVersionAdvice.advice.version} instead of ${bugVersionAdvice.version}, reason: ${bugVersionAdvice.advice.reason}`;

app/core/service/UserService.ts

@@ -199,14 +199,14 @@ export class UserService extends AbstractService {
     await this.userRepository.removeToken(token.tokenId);
   }
 
-  async findWebauthnCredential(userId: string, browserType?: string) {
+  async findWebauthnCredential(userId: string, browserType: string | undefined | null) {
     const credential = await this.userRepository.findCredentialByUserIdAndBrowserType(userId, browserType || null);
     return credential;
   }
 
-  async createWebauthnCredential(userId: string, options: CreateWebauthnCredentialOptions) {
+  async createWebauthnCredential(userId: string | undefined, options: CreateWebauthnCredentialOptions) {
     const credentialEntity = WebauthnCredentialEntity.create({
-      userId,
+      userId: userId as string,
       credentialId: options.credentialId,
       publicKey: options.publicKey,
       browserType: options.browserType,
@@ -215,7 +215,7 @@ export class UserService extends AbstractService {
     return credentialEntity;
   }
 
-  async removeWebauthnCredential(userId: string, browserType?: string) {
+  async removeWebauthnCredential(userId?: string, browserType?: string) {
     const credential = await this.userRepository.findCredentialByUserIdAndBrowserType(userId, browserType || null);
     if (credential) {
       await this.userRepository.removeCredential(credential.wancId);

app/port/controller/DownloadController.ts

@@ -28,15 +28,15 @@ export class DownloadController extends AbstractController {
     const pkg = await this.packageRepository.findPackage(scope, name);
     if (!pkg) throw new NotFoundError(`${fullname} not found`);
     const entities = await this.packageVersionDownloadRepository.query(pkg.packageId, startDate.toDate(), endDate.toDate());
-    const days = {};
-    const versions = {};
+    const days: Record<string, number> = {};
+    const versions: Record<string, { day: string, downloads: number }[]> = {};
     for (const entity of entities) {
       const yearMonth = String(entity.yearMonth);
       const prefix = yearMonth.substring(0, 4) + '-' + yearMonth.substring(4, 6);
       for (let i = 1; i <= 31; i++) {
         const day = String(i).padStart(2, '0');
-        const field = `d${day}`;
-        const counter = entity[field];
+        const field = `d${day}` as keyof typeof entity;
+        const counter = entity[field] as number;
         if (!counter) continue;
         const date = `${prefix}-${day}`;
         days[date] = (days[date] || 0) + counter;
@@ -66,14 +66,14 @@ export class DownloadController extends AbstractController {
   async showTotalDownloads(@HTTPParam() scope: string, @HTTPParam() range: string) {
     const [ startDate, endDate ] = this.checkAndGetRange(range);
     const entities = await this.packageVersionDownloadRepository.query(scope, startDate.toDate(), endDate.toDate());
-    const days = {};
+    const days: Record<string, number> = {};
     for (const entity of entities) {
       const yearMonth = String(entity.yearMonth);
       const prefix = yearMonth.substring(0, 4) + '-' + yearMonth.substring(4, 6);
       for (let i = 1; i <= 31; i++) {
         const day = String(i).padStart(2, '0');
-        const field = `d${day}`;
-        const counter = entity[field];
+        const field = `d${day}` as keyof typeof entity;
+        const counter = entity[field] as number;
         if (!counter) continue;
         const date = `${prefix}-${day}`;
         days[date] = (days[date] || 0) + counter;
@@ -115,4 +115,3 @@ export class DownloadController extends AbstractController {
     return [ startDate, endDate ];
   }
 }
-

app/port/controller/PackageTagController.ts

@@ -29,7 +29,7 @@ export class PackageTagController extends AbstractController {
   async showTags(@HTTPParam() fullname: string) {
     const packageEntity = await this.getPackageEntityByFullname(fullname);
     const tagEntities = await this.packageRepository.listPackageTags(packageEntity.packageId);
-    const tags = {};
+    const tags: Record<string, string> = {};
     for (const entity of tagEntities) {
       tags[entity.tag] = entity.version;
     }

app/port/controller/package/SavePackageVersionController.ts

@@ -21,6 +21,7 @@ import { Static, Type } from '@sinclair/typebox';
 import { AbstractController } from '../AbstractController';
 import { getScopeAndName, FULLNAME_REG_STRING, extractPackageJSON } from '../../../common/PackageUtil';
 import { PackageManagerService } from '../../../core/service/PackageManagerService';
+import { PackageVersion as PackageVersionEntity } from '../../../core/entity/PackageVersion';
 import {
   VersionRule,
   TagWithVersionRule,
@@ -103,7 +104,7 @@ export class SavePackageVersionController extends AbstractController {
       const [ scope, name ] = getScopeAndName(fullname);
       const pkg = await this.packageRepository.findPackage(scope, name);
       if (!pkg) {
-        const errors = (validateResult.errors || validateResult.warnings).join(', ');
+        const errors = (validateResult.errors || validateResult.warnings || []).join(', ');
         throw new UnprocessableEntityError(`package.name invalid, errors: ${errors}`);
       }
     }
@@ -185,7 +186,8 @@ export class SavePackageVersionController extends AbstractController {
       const tarballPkg = await extractPackageJSON(tarballBytes);
       const versionManifest = pkg.versions[tarballPkg.version];
       const diffKeys = STRICT_CHECK_TARBALL_FIELDS.filter(key => {
-        return !isEqual(tarballPkg[key], versionManifest[key]);
+        const targetKey = key as unknown as keyof typeof versionManifest;
+        return !isEqual(tarballPkg[key], versionManifest[targetKey]);
       });
       if (diffKeys.length > 0) {
         throw new UnprocessableEntityError(`${diffKeys} mismatch between tarball and manifest`);
@@ -205,7 +207,7 @@ export class SavePackageVersionController extends AbstractController {
 
     const registry = await this.registryManagerService.ensureSelfRegistry();
 
-    let packageVersionEntity;
+    let packageVersionEntity: PackageVersionEntity | undefined;
     const lockRes = await this.cacheAdapter.usingLock(`${pkg.name}:publish`, 60, async () => {
       packageVersionEntity = await this.packageManagerService.publish({
         scope,
@@ -230,12 +232,12 @@ export class SavePackageVersionController extends AbstractController {
     }
 
     this.logger.info('[package:version:add] %s@%s, packageVersionId: %s, tag: %s, userId: %s',
-      packageVersion.name, packageVersion.version, packageVersionEntity.packageVersionId,
-      tagWithVersion.tag, user.userId);
+      packageVersion.name, packageVersion.version, packageVersionEntity?.packageVersionId,
+      tagWithVersion.tag, user?.userId);
     ctx.status = 201;
     return {
       ok: true,
-      rev: `${packageVersionEntity.id}-${packageVersionEntity.packageVersionId}`,
+      rev: `${packageVersionEntity?.id}-${packageVersionEntity?.packageVersionId}`,
     };
   }
 

app/port/schedule/UpdateTotalData.ts

@@ -79,8 +79,8 @@ export class UpdateTotalData {
       for (const row of rows) {
         for (let i = 1; i <= 31; i++) {
           const day = String(i).padStart(2, '0');
-          const field = `d${day}`;
-          const counter = row[field];
+          const field = `d${day}` as keyof typeof row;
+          const counter = row[field] as number;
           if (!counter) continue;
           const dayInt = row.yearMonth * 100 + i;
           if (dayInt === todayInt) download.today += counter;

app/port/typebox.ts

@@ -3,7 +3,7 @@ import { RegistryType } from '../common/enum/Registry';
 import semver from 'semver';
 import npa from 'npm-package-arg';
 import { HookType } from '../common/enum/Hook';
-import binaryConfig from '../../config/binaries';
+import binaryConfig, { BinaryName } from '../../config/binaries';
 
 export const Name = Type.String({
   transform: [ 'trim' ],
@@ -151,8 +151,8 @@ export function patchAjv(ajv: any) {
   });
   ajv.addFormat('binary-name', {
     type: 'string',
-    validate: (binaryName: string) => {
-      return !!binaryConfig[binaryName];
+    validate: (binaryName: BinaryName) => {
+      return binaryConfig[binaryName];
     },
   });
   ajv.addFormat('semver-version-array', {