improve type safety with regards to config files

src/creation/eslint/createEnv.test.ts

@@ -63,6 +63,20 @@ describe("createEnv", () => {
         });
     });
 
+    it("handles an environment where typescript configuration files are mostly undefined", () => {
+        // Arrange
+        const packages = undefined;
+        const typescript = {};
+
+        // Act
+        const env = createEnv({ packages, typescript });
+
+        // Assert
+        expect(env).not.toContain({
+            browser: expect.any(Boolean),
+        });
+    });
+
     it("returns browser as true if a typescript lib is dom", () => {
         // Arrange
         const packages = undefined;

src/creation/eslint/createEnv.ts

@@ -6,12 +6,12 @@ export const createEnv = ({
 }: Pick<AllOriginalConfigurations, "packages" | "typescript">) => {
     const browser =
         typescript === undefined ||
-        typescript.compilerOptions.lib === undefined ||
+        typescript.compilerOptions?.lib === undefined ||
         typescript.compilerOptions.lib.includes("dom");
 
     const es6 =
         typescript === undefined ||
-        !["es3", "es5"].includes(typescript.compilerOptions.target.toLowerCase());
+        !["es3", "es5"].includes(typescript.compilerOptions?.target?.toLowerCase() ?? "");
 
     const node =
         packages === undefined ||

src/input/findESLintConfiguration.ts

@@ -9,10 +9,10 @@ import { OriginalConfigurations } from "./findOriginalConfigurations";
 import { importer } from "./importer";
 
 export type ESLintConfiguration = {
-    env: Record<string, boolean>;
-    extends: string | string[];
-    globals?: Record<string, boolean>;
-    rules: ESLintConfigurationRules;
+    env?: Record<string, boolean | undefined>;
+    extends?: string | string[];
+    globals?: Record<string, boolean | undefined>;
+    rules?: ESLintConfigurationRules;
 };
 
 export type ESLintConfigurationRules = {
@@ -43,7 +43,7 @@ export const findESLintConfiguration = async (
         findRawConfiguration<ESLintConfiguration>(dependencies.importer, filePath, {
             extends: [],
         }),
-        findReportedConfiguration<Partial<ESLintConfiguration>>(
+        findReportedConfiguration<ESLintConfiguration>(
             dependencies.exec,
             "eslint --print-config",
             filePath,

src/input/findOriginalConfigurations.ts

@@ -14,6 +14,7 @@ import {
 } from "./findTypeScriptConfiguration";
 import { findTSLintConfiguration, TSLintConfiguration } from "./findTSLintConfiguration";
 import { mergeLintConfigurations } from "./mergeLintConfigurations";
+import { DeepPartial } from "./findReportedConfiguration";
 
 export type FindOriginalConfigurationsDependencies = {
     findESLintConfiguration: SansDependencies<typeof findESLintConfiguration>;
@@ -35,7 +36,7 @@ export type OriginalConfigurations<Configuration> = {
     /**
      * Raw import results from `import`ing the configuration file.
      */
-    raw: Partial<Configuration>;
+    raw: DeepPartial<Configuration>;
 };
 
 export type AllOriginalConfigurations = {

src/input/findPackagesConfiguration.ts

@@ -4,8 +4,8 @@ import {
 } from "./findReportedConfiguration";
 
 export type PackagesConfiguration = {
-    dependencies: Record<string, string>;
-    devDependencies: Record<string, string>;
+    dependencies: Record<string, string | undefined>;
+    devDependencies: Record<string, string | undefined>;
 };
 
 export const findPackagesConfiguration = async (

src/input/findReportedConfiguration.ts

@@ -1,7 +1,7 @@
 import { Exec } from "../adapters/exec";
 
 export type DeepPartial<T> = {
-    [P in keyof T]?: T[P] extends Record<P, T[P]> ? DeepPartial<T[P]> : T[P];
+    [P in keyof T]?: T[P] extends Record<string, unknown> ? DeepPartial<T[P]> : T[P];
 };
 
 export type FindReportedConfigurationDependencies = {

src/input/findTSLintConfiguration.ts

@@ -8,7 +8,7 @@ import { importer } from "./importer";
 export type TSLintConfiguration = {
     extends?: string[];
     rulesDirectory?: string[];
-    rules: TSLintConfigurationRules;
+    rules?: TSLintConfigurationRules;
 };
 
 export type TSLintConfigurationRules = Record<string, any>;

src/input/findTypeScriptConfiguration.ts

@@ -4,9 +4,9 @@ import {
 } from "./findReportedConfiguration";
 
 export type TypeScriptConfiguration = {
-    compilerOptions: {
+    compilerOptions?: {
         lib?: string[];
-        target: string;
+        target?: string;
     };
 };
 

src/input/mergeLintConfigurations.ts

@@ -10,7 +10,7 @@ export const mergeLintConfigurations = (
         return tslint;
     }
 
-    const mappedConfig = eslint.full.rules["@typescript-eslint/tslint/config"];
+    const mappedConfig = eslint.full.rules?.["@typescript-eslint/tslint/config"];
     if (!(mappedConfig instanceof Array) || mappedConfig[0] === "off") {
         return tslint;
     }

src/rules/convertRules.test.ts

@@ -5,6 +5,19 @@ import { RuleConverter, ConversionResult } from "./converter";
 import { RuleMerger } from "./merger";
 
 describe("convertRules", () => {
+    it("doesn't crash when passed an undefined configuration", () => {
+        // Arrange
+        const { converters, mergers } = setupConversionEnvironment({
+            ruleSeverity: "off",
+        });
+
+        // Act
+        const { missing } = convertRules({ converters, mergers }, undefined);
+
+        // Assert
+        expect(missing).toEqual([]);
+    });
+
     it("doesn't marks a disabled rule as missing when its converter returns undefined", () => {
         // Arrange
         const { tslintRule, converters, mergers } = setupConversionEnvironment({

src/rules/convertRules.ts

@@ -22,66 +22,67 @@ export type RuleConversionResults = {
 
 export const convertRules = (
     dependencies: ConvertRulesDependencies,
-    rawTslintRules: TSLintConfigurationRules,
+    rawTslintRules?: TSLintConfigurationRules,
 ): RuleConversionResults => {
     const converted = new Map<string, ESLintRuleOptions>();
     const failed: ConversionError[] = [];
     const missing: TSLintRuleOptions[] = [];
     const plugins = new Set<string>();
 
-    for (const [ruleName, value] of Object.entries(rawTslintRules)) {
-        const tslintRule = formatRawTslintRule(ruleName, value);
-        const conversion = convertRule(tslintRule, dependencies.converters);
+    if (rawTslintRules !== undefined) {
+        for (const [ruleName, value] of Object.entries(rawTslintRules)) {
+            const tslintRule = formatRawTslintRule(ruleName, value);
+            const conversion = convertRule(tslintRule, dependencies.converters);
 
-        if (conversion === undefined) {
-            if (tslintRule.ruleSeverity !== "off") {
-                missing.push(tslintRule);
-            }
-
-            continue;
-        }
+            if (conversion === undefined) {
+                if (tslintRule.ruleSeverity !== "off") {
+                    missing.push(tslintRule);
+                }
 
-        if (conversion instanceof ConversionError) {
-            failed.push(conversion);
-            continue;
-        }
-
-        for (const changes of conversion.rules) {
-            const existingConversion = converted.get(changes.ruleName);
-            const newConversion = {
-                ...changes,
-                ruleSeverity: convertTSLintRuleSeverity(tslintRule.ruleSeverity),
-            };
+                continue;
+            }
 
-            if (existingConversion === undefined) {
-                converted.set(changes.ruleName, newConversion);
+            if (conversion instanceof ConversionError) {
+                failed.push(conversion);
                 continue;
             }
 
-            const merger = dependencies.mergers.get(changes.ruleName);
-            if (merger === undefined) {
-                failed.push(ConversionError.forMerger(changes.ruleName));
-            } else {
-                const existingNotices = existingConversion.notices ?? [];
-                const newNotices = newConversion.notices ?? [];
+            for (const changes of conversion.rules) {
+                const existingConversion = converted.get(changes.ruleName);
+                const newConversion = {
+                    ...changes,
+                    ruleSeverity: convertTSLintRuleSeverity(tslintRule.ruleSeverity),
+                };
+
+                if (existingConversion === undefined) {
+                    converted.set(changes.ruleName, newConversion);
+                    continue;
+                }
+
+                const merger = dependencies.mergers.get(changes.ruleName);
+                if (merger === undefined) {
+                    failed.push(ConversionError.forMerger(changes.ruleName));
+                } else {
+                    const existingNotices = existingConversion.notices ?? [];
+                    const newNotices = newConversion.notices ?? [];
 
-                converted.set(changes.ruleName, {
-                    ...existingConversion,
-                    ruleArguments: merger(
-                        existingConversion.ruleArguments,
-                        newConversion.ruleArguments,
-                    ),
-                    notices: Array.from(new Set([...existingNotices, ...newNotices])),
-                });
+                    converted.set(changes.ruleName, {
+                        ...existingConversion,
+                        ruleArguments: merger(
+                            existingConversion.ruleArguments,
+                            newConversion.ruleArguments,
+                        ),
+                        notices: Array.from(new Set([...existingNotices, ...newNotices])),
+                    });
+                }
             }
-        }
 
-        if (conversion.plugins !== undefined) {
-            for (const newPlugin of conversion.plugins) {
-                plugins.add(newPlugin);
+            if (conversion.plugins !== undefined) {
+                for (const newPlugin of conversion.plugins) {
+                    plugins.add(newPlugin);
+                }
             }
         }
     }
-
     return { converted, failed, missing, plugins };
 };