TypeScript -> 2.6.2 & strict mode cleanup

Jacob Peddicord · Jacob Peddicord · commit de86fbb86852 · 2017-11-29T14:37:38.000-08:00
diff --git a/package.json b/package.json
@@ -65,7 +65,7 @@
     "selenium-webdriver": "^3.0.1",
     "ts-loader": "^2.3.2",
     "tslint": "^5.5.0",
-    "typescript": "^2.4.1",
+    "typescript": "^2.6.2",
     "url-loader": "^0.5.9",
     "webpack": "^3.6.0",
     "webpack-dev-server": "^2.7.1"
diff --git a/server/api/licenses/index.ts b/server/api/licenses/index.ts
@@ -38,8 +38,8 @@ export async function listLicenses(): Promise<LicenseResponse> {
 function cacheLicenseData() {
     // a little silly, but keep two license lists; one for those that ask to be
     // displayed first and the other for those that don't care
-    const first = [];
-    const rest = [];
+    const first: any[] = [];
+    const rest: any[] = [];
 
     // load each license...
     for (const [id, data] of (licenses as any).entries()) {
diff --git a/server/api/packages/index.ts b/server/api/packages/index.ts
@@ -20,7 +20,7 @@ import * as db from '../../db/packages';
 import { assertCanValidate } from './auth';
 import { WebPackage } from './interfaces';
 
-export async function searchPackages(req: any, query: string): Promise<{results: WebPackage[]}> {
+export async function searchPackages(req: any, query: string): Promise<{results: Array<Partial<WebPackage>>}> {
   const packages = await db.searchPackages(query, 25);
   return {results: packages.map((pkg) => ({
     packageId: pkg.package_id,
@@ -34,7 +34,7 @@ export async function searchPackages(req: any, query: string): Promise<{results:
   }))};
 }
 
-export async function getPackage(req: any, packageId: number, extended = false): Promise<WebPackage> {
+export async function getPackage(req: any, packageId: number, extended = false): Promise<WebPackage | null> {
   const pkg = await db.getPackage(packageId);
   if (pkg == null) {
     return null;
@@ -68,6 +68,7 @@ export async function getPackage(req: any, packageId: number, extended = false):
     license: pkg.license,
     copyright: pkg.copyright,
     licenseText: pkg.license_text,
+    createdBy: pkg.created_by,
     verified: pkg.verified,
     extra,
   };
@@ -113,8 +114,15 @@ export async function storePackage(req: any, packageId: number, info: Pick<WebPa
   let newId: number;
   if (shouldInsert) {
     const createdBy = auth.extractRequestUser(req);
-    newId = await db.createPackageRevision(info.name, info.version, info.website,
-      info.license, info.copyright, info.licenseText, createdBy);
+    newId = await db.createPackageRevision(
+      info.name,
+      info.version,
+      info.website as string,
+      info.license as string,
+      info.copyright as string,
+      info.licenseText as string,
+      createdBy,
+    );
     winston.info('Created a new package revision with ID %s (previous revision at %s) by %s',
       newId, packageId ? packageId : '[none]', createdBy);
   } else {
diff --git a/server/api/packages/interfaces.ts b/server/api/packages/interfaces.ts
@@ -21,7 +21,7 @@ export interface WebPackage {
   licenseText?: string;
   copyright?: string;
   createdBy?: string;
-  verified?: boolean | null;
+  verified: boolean | null;
   extra?: {verification?: PackageVerification, stats?: PackageStats, latest?: number};
 }
 
diff --git a/server/api/projects/auth.ts b/server/api/projects/auth.ts
@@ -50,7 +50,7 @@ export async function assertProjectAccess(req: any, project: ProjectAccess, leve
   throw new AccessError('This project does not exist or you do not have access to it.');
 }
 
-export async function effectivePermission(req: any, project: ProjectAccess): Promise<AccessLevel> {
+export async function effectivePermission(req: any, project: ProjectAccess): Promise<AccessLevel | null> {
   const user = auth.extractRequestUser(req);
   const reqGroups = await auth.getGroups(user);
 
@@ -61,7 +61,7 @@ export async function effectivePermission(req: any, project: ProjectAccess): Pro
   }
 
   // then check the project ACL
-  let effective: AccessLevel = null;
+  let effective: AccessLevel | null = null;
   let effectiveStrength = 0;
   for (const entity of Object.keys(project.acl)) {
     // skip groups that aren't relevant for the requester
diff --git a/server/api/projects/index.spec.ts b/server/api/projects/index.spec.ts
@@ -132,7 +132,7 @@ describe('projects', function () {
           acl: {abc: 'owner'},
           metadata: {open_sourcing: true},
         },
-      };
+      } as any;
     }
 
   });
diff --git a/server/api/projects/index.ts b/server/api/projects/index.ts
@@ -24,21 +24,21 @@ import { AccessError } from '../../errors/index';
 import DocBuilder from '../../licenses/docbuilder';
 import { storePackage } from '../packages';
 import { assertProjectAccess, effectivePermission } from './auth';
-import { AccessLevelStrength, WebProject } from './interfaces';
+import { AccessLevelStrength, WebProject, AccessLevel } from './interfaces';
 
 type ProjectIdPromise = Promise<Pick<WebProject, 'projectId'>>;
 
 export async function getProject(req: Request, projectId: string): Promise<WebProject> {
   const project = await db.getProject(projectId);
   await assertProjectAccess(req, project, 'viewer');
-  const accessLevel = await effectivePermission(req, project);
+  const accessLevel = await effectivePermission(req, project) as AccessLevel;
 
   // map DB types to a public API
   return {
     projectId,
     title: project.title,
     version: project.version,
-    description: project.description,
+    description: project.description || '',
     createdOn: project.created_on,
     plannedRelease: project.planned_release,
     contacts: project.contacts,
@@ -50,7 +50,7 @@ export async function getProject(req: Request, projectId: string): Promise<WebPr
         packageId: usage.package_id,
       };
     }),
-    metadata: project.metadata,
+    metadata: project.metadata || {},
     access: {
       level: accessLevel,
       canEdit: AccessLevelStrength[accessLevel] >= AccessLevelStrength.editor,
@@ -212,6 +212,9 @@ export async function generateAttributionDocument(req: Request, projectId: strin
   const builder = new DocBuilder();
   for (const usage of project.packages_used) {
     const pkg = packages.get(usage.package_id);
+    if (pkg == null) {
+      throw new Error(`Reference to package ${usage.package_id} was not found`);
+    }
     builder.addPackage(pkg, usage);
   }
 
diff --git a/server/api/projects/interfaces.ts b/server/api/projects/interfaces.ts
@@ -33,12 +33,12 @@ export interface PackageUsage {
   packageId: number;
   notes?: string;
   // tag-added properties
-  [key: string]: string | boolean | number;
+  [key: string]: string | boolean | number | undefined;
 }
 
 export const AccessLevelStrength: {[key: string]: number} = {
   viewer: 1,
   editor: 2,
   owner: 3,
 };
-export type AccessLevel = 'owner' | 'editor' | 'viewer' | null;
+export type AccessLevel = 'owner' | 'editor' | 'viewer';
diff --git a/server/auth/base.ts b/server/auth/base.ts
@@ -63,7 +63,7 @@ interface AuthBase {
    * For example, you could look up a user's full name in LDAP/AD.
    * Consider caching this method.
    */
-  getDisplayName(user: string): Promise<string>;
+  getDisplayName(user: string): Promise<string | null>;
 
   /**
    * Given a username, look up the list of groups the user is a member of.
diff --git a/server/auth/impl/nullauth.ts b/server/auth/impl/nullauth.ts
@@ -59,7 +59,7 @@ export default class NullAuth implements AuthBase {
       || request.user.user || process.env.USER || 'unknown';
   }
 
-  async getDisplayName(user: string): Promise<string> {
+  async getDisplayName(user: string): Promise<string | null> {
     // special test case; this user will never "exist"
     if (user === 'nobody') {
       return null;
diff --git a/server/db/index.ts b/server/db/index.ts
@@ -24,7 +24,7 @@ if (process.env.DEBUG_SQL) {
 }
 
 const pgp = pgPromise(options);
-let pg: pgPromise.IDatabase<any> = null;
+let pg: pgPromise.IDatabase<any>;
 
 export function connect(cn: any) {
   pg = pgp(cn);
diff --git a/server/db/packages.ts b/server/db/packages.ts
@@ -23,7 +23,7 @@ export interface Package {
   copyright?: string;
   license_text?: string;
   created_by?: string;
-  verified?: boolean;
+  verified: boolean | null;
 }
 
 export interface PackageVerify {
diff --git a/server/db/projects.ts b/server/db/projects.ts
@@ -29,7 +29,7 @@ export interface DbProject {
   // resource (user/group) name: access level
   acl: {[key: string]: AccessLevel};
   packages_used: any[];
-  metadata?: object;
+  metadata?: {[key: string]: any};
 }
 
 export function getProject(projectId: string): Promise<DbProject> {
@@ -75,7 +75,7 @@ export async function createProject(project: ProjectInput, who: string): Promise
 export async function patchProject(projectId: string, changes: Partial<DbProject>,
                                    who: string): Promise<void> {
   // build a set up update statements
-  const patches = [];
+  const patches: string[] = [];
   for (const change of Object.keys(changes)) {
     // make a named parameter with the same name as the field
     patches.push(`${change} = $(${change})`);
diff --git a/server/licenses/docbuilder.ts b/server/licenses/docbuilder.ts
@@ -15,6 +15,7 @@
 import { createHash } from 'crypto';
 import { Package } from '../db/packages';
 import { licenses, mapTag } from './index';
+import { ValidationResult } from './interfaces';
 
 interface BarePackageUsage {
   package_id: number;
@@ -27,25 +28,30 @@ interface PackagePair {
 }
 
 interface LicenseBucket {
-  name: string;
+  name?: string;
   text: string;
   tags: string[];
   packages: PackagePair[];
 }
 
+interface Annotation {
+  lines: [number, number | null];
+  [key: string]: any;
+}
+
 export default class DocBuilder {
 
   private buckets = new Map<string, LicenseBucket>();
-  private openAnnotations = {};
-  private finalAnnotations = [];
+  private openAnnotations: {[key: string]: Annotation} = {};
+  private finalAnnotations: Annotation[] = [];
   private lineNum = 0;
   private chunks: string[] = [];
-  private finalWarnings = [];
+  private finalWarnings: ValidationResult[] = [];
 
   addPackage(pkg: Package, usage: BarePackageUsage) {
     // see if it's a known license
     const name = pkg.license;
-    const licenseImmutable = licenses.get(name);
+    const licenseImmutable = name ? licenses.get(name) : null;
     const license = licenseImmutable ? licenseImmutable.toJS() : null;
 
     // prefer package's license text
@@ -68,7 +74,7 @@ export default class DocBuilder {
     const tags: string[] = license != null ? license.tags : ['unknown'];
 
     // create or add to a bucket
-    const bucket = this.buckets.get(key) || {name, text, tags, packages: []};
+    const bucket = this.buckets.get(key) || {name, text, tags, packages: [] as PackagePair[]};
 
     bucket.packages.push({pkg, usage});
     this.buckets.set(key, bucket);
@@ -81,7 +87,7 @@ export default class DocBuilder {
     // go through each bucket (packages with same license)
     const sortedBuckets = Array.from(this.buckets.keys()).sort();
     for (const key of sortedBuckets) {
-      const { name, text, tags, packages } = this.buckets.get(key);
+      const { name, text, tags, packages } = this.buckets.get(key) as LicenseBucket;
 
       const mappedTags = tags.map((tagName) => {
         const mod = mapTag(tagName);
@@ -102,13 +108,13 @@ export default class DocBuilder {
           this.addWarnings(mod.validateUsage(pkg, usage), {packageId: pkg.package_id});
 
           // mangle the notice statement
-          if (mod.transformCopyright != null) {
+          if (mod.transformCopyright != null && notice != null) {
             notice = mod.transformCopyright(notice);
           }
         }
 
         let statement = `** ${pkg.name}; version ${pkg.version} -- ${pkg.website}`;
-        if (notice.length > 0) {
+        if (notice != null && notice.length > 0) {
           statement += `\n${notice}`;
         }
 
@@ -143,7 +149,7 @@ export default class DocBuilder {
     this.chunks.push(str);
   }
 
-  private addWarnings(warnings, extra) {
+  private addWarnings(warnings: ValidationResult[], extra: {[key: string]: any}) {
     if (warnings != null) {
       if (!Array.isArray(warnings)) {
         throw new Error('Bug: Validator output should return an array of messages');
diff --git a/server/licenses/interfaces.ts b/server/licenses/interfaces.ts
@@ -13,7 +13,7 @@
  */
 
 export interface TagModule {
-  validateSelf: (name: string, text: string, tags: string[]) => ValidationResult[];
+  validateSelf: (name: string | undefined, text: string, tags: string[]) => ValidationResult[];
   validateUsage: (pkg: any, usage: any) => ValidationResult[];
   transformCopyright?: (original: string) => string;
   transformLicense?: (original: string, packages) => string;
diff --git a/server/licenses/tags/all.ts b/server/licenses/tags/all.ts
@@ -1,3 +1,5 @@
+import { ValidationResult } from '../interfaces';
+
 /* Copyright 2017 Amazon.com, Inc. or its affiliates. All Rights Reserved.
  *
  * Licensed under the Apache License, Version 2.0 (the "License").
@@ -21,7 +23,7 @@
 // tslint:disable:no-empty
 
 export function validateSelf(name, text, tags) {
-  const warnings = [];
+  const warnings: ValidationResult[] = [];
   const nicename = name ? name : 'The provided license';
 
   // look for excessively long lines, but ignore SPDX-tagged licenses.
diff --git a/server/licenses/tags/notice.ts b/server/licenses/tags/notice.ts
@@ -31,7 +31,7 @@ export function transformCopyright(original) {
 
 // ...and place it at the bottom
 export function transformLicense(original, packages) {
-  const notices = [];
+  const notices: string[] = [];
   for (const pkgBundle of packages) {
     const { pkg } = pkgBundle;
 

Original file line number	Diff line number	Diff line change
`@@ -21,7 +21,7 @@ export interface WebPackage {`
`21`	`21`	`licenseText?: string;`
`22`	`22`	`copyright?: string;`
`23`	`23`	`createdBy?: string;`
`24`		`- verified?: boolean \| null;`
	`24`	`+ verified: boolean \| null;`
`25`	`25`	`extra?: {verification?: PackageVerification, stats?: PackageStats, latest?: number};`
`26`	`26`	`}`
`27`	`27`
Original file line number	Diff line number	Diff line change
`@@ -50,7 +50,7 @@ export async function assertProjectAccess(req: any, project: ProjectAccess, leve`
`50`	`50`	`throw new AccessError('This project does not exist or you do not have access to it.');`
`51`	`51`	`}`
`52`	`52`
`53`		`-export async function effectivePermission(req: any, project: ProjectAccess): Promise<AccessLevel> {`
	`53`	`+export async function effectivePermission(req: any, project: ProjectAccess): Promise<AccessLevel \| null> {`
`54`	`54`	`const user = auth.extractRequestUser(req);`
`55`	`55`	`const reqGroups = await auth.getGroups(user);`
`56`	`56`
`@@ -61,7 +61,7 @@ export async function effectivePermission(req: any, project: ProjectAccess): Pro`
`61`	`61`	`}`
`62`	`62`
`63`	`63`	`// then check the project ACL`
`64`		`- let effective: AccessLevel = null;`
	`64`	`+ let effective: AccessLevel \| null = null;`
`65`	`65`	`let effectiveStrength = 0;`
`66`	`66`	`for (const entity of Object.keys(project.acl)) {`
`67`	`67`	`// skip groups that aren't relevant for the requester`
Original file line number	Diff line number	Diff line change
`@@ -132,7 +132,7 @@ describe('projects', function () {`
`132`	`132`	`acl: {abc: 'owner'},`
`133`	`133`	`metadata: {open_sourcing: true},`
`134`	`134`	`},`
`135`		`- };`
	`135`	`+ } as any;`
`136`	`136`	`}`
`137`	`137`
`138`	`138`	`});`
Original file line number	Diff line number	Diff line change
`@@ -59,7 +59,7 @@ export default class NullAuth implements AuthBase {`
`59`	`59`	`\|\| request.user.user \|\| process.env.USER \|\| 'unknown';`
`60`	`60`	`}`
`61`	`61`
`62`		`- async getDisplayName(user: string): Promise<string> {`
	`62`	`+ async getDisplayName(user: string): Promise<string \| null> {`
`63`	`63`	`// special test case; this user will never "exist"`
`64`	`64`	`if (user === 'nobody') {`
`65`	`65`	`return null;`