Infer genType setup from tsconfig

Author: fhammerschmidt

docs/gentype-tsconfig-mapping.md

@@ -144,10 +144,9 @@ Use:
 | React, Next.js, or another JSX framework is detected in package.json dependencies | `.gen.tsx` |
 | No JSX signal | `.gen.ts` |
 
-If we want to minimize behavior differences from ReScript's documented default,
-omit `generatedFileExtension` when no JSX signal is available and accept the
-compiler default of `.gen.tsx`. If we want the least surprising setup for
-non-React TypeScript projects, set `.gen.ts` explicitly.
+Set `.gen.ts` explicitly when no JSX signal is available. That differs from the
+documented genType default of `.gen.tsx`, but it is less surprising for existing
+non-React TypeScript projects.
 
 ## Fallback Rules
 
@@ -158,7 +157,9 @@ Fall back to the current manual module prompt when:
 - `module` is missing or unsupported.
 - `moduleResolution` is `classic`, unknown, or conflicts with the module mode.
 - The project is a mixed Node dual-format project that cannot be represented by
-  one ReScript project-level module setting.
+  one ReScript project-level module setting, such as a CommonJS package with
+  `.mts` inputs, an ESM package with `.cts` inputs, or included source files
+  under nested package.json files with a different `type`.
 - The project uses `module: "preserve"` and package contents suggest meaningful
   CommonJS-style exports that ReScript cannot preserve statement-by-statement.
 

src/ExistingJsProject.res

@@ -2,6 +2,21 @@ open Node
 
 module P = ClackPrompts
 
+type projectModuleConfig = {
+  moduleSystem: string,
+  suffix: string,
+  gentypeConfig: option<TsConfigMapping.inferredConfig>,
+}
+
+let getOrCreateJsonObject = (config: Dict.t<JSON.t>, ~fieldName) =>
+  switch config->Dict.get(fieldName) {
+  | Some(Object(object)) => object
+  | _ =>
+    let object = Dict.make()
+    config->Dict.set(fieldName, Object(object))
+    object
+  }
+
 let updatePackageJson = async (~versions) =>
   await JsonUtils.updateJsonFile("package.json", json =>
     switch json {
@@ -25,7 +40,14 @@ let updatePackageJson = async (~versions) =>
     }
   )
 
-let updateRescriptJson = async (~projectName, ~sourceDir, ~moduleSystem, ~suffix, ~versions) =>
+let updateRescriptJson = async (
+  ~projectName,
+  ~sourceDir,
+  ~moduleSystem,
+  ~suffix,
+  ~gentypeConfig: option<TsConfigMapping.inferredConfig>,
+  ~versions,
+) =>
   await JsonUtils.updateJsonFile("rescript.json", json =>
     switch json {
     | Object(config) =>
@@ -39,6 +61,21 @@ let updateRescriptJson = async (~projectName, ~sourceDir, ~moduleSystem, ~suffix
       | Some(Object(sources)) => sources->Dict.set("module", String(moduleSystem))
       | _ => ()
       }
+      switch gentypeConfig {
+      | Some(gentypeConfig) =>
+        let gentypeConfigJson: Dict.t<JSON.t> = Dict.make()
+        gentypeConfigJson->Dict.set("module", String(gentypeConfig.moduleSystem))
+        gentypeConfigJson->Dict.set(
+          "moduleResolution",
+          String(gentypeConfig.gentypeModuleResolution),
+        )
+        gentypeConfigJson->Dict.set(
+          "generatedFileExtension",
+          String(gentypeConfig.generatedFileExtension),
+        )
+        config->Dict.set("gentypeconfig", Object(gentypeConfigJson))
+      | None => ()
+      }
 
       if Option.isNone(versions.RescriptVersions.rescriptCoreVersion) {
         RescriptJsonUtils.removeRescriptCore(config)
@@ -60,8 +97,183 @@ let getModuleSystemOptions = () => [
   },
 ]
 
+let getPackageJson = async () => await JsonUtils.readJsonFile("package.json")
+
+let getPackageType = (packageJson: JSON.t) =>
+  switch packageJson {
+  | Object(config) =>
+    switch config->Dict.get("type") {
+    | Some(String(packageType)) => Some(packageType->String.toLowerCase)
+    | _ => None
+    }
+  | _ => None
+  }
+
+let packageJsonHasDependency = (packageJson: JSON.t, dependencyNames) => {
+  let dependencyFields = [
+    "dependencies",
+    "devDependencies",
+    "peerDependencies",
+    "optionalDependencies",
+  ]
+
+  switch packageJson {
+  | Object(config) =>
+    dependencyFields->Array.some(fieldName =>
+      switch config->Dict.get(fieldName) {
+      | Some(Object(dependencies)) =>
+        dependencyNames->Array.some(dependencyName =>
+          dependencies->Dict.get(dependencyName)->Option.isSome
+        )
+      | _ => false
+      }
+    )
+  | _ => false
+  }
+}
+
+let hasJsxDependency = (packageJson: JSON.t) =>
+  packageJson->packageJsonHasDependency([
+    "react",
+    "react-dom",
+    "next",
+    "preact",
+    "solid-js",
+    "@vitejs/plugin-react",
+  ])
+
+let getManualModuleConfig = async () => {
+  let moduleSystem = await P.select({
+    message: "What module system will you use?",
+    options: getModuleSystemOptions(),
+  })->P.resultOrRaise
+
+  {
+    moduleSystem,
+    suffix: moduleSystem === "esmodule" ? ".res.mjs" : ".res.js",
+    gentypeConfig: None,
+  }
+}
+
+let getTsConfigModuleConfig = async packageJson => {
+  let projectPath = Process.cwd()
+  let tsConfig = TsConfigMapping.read(projectPath)
+
+  switch tsConfig.status {
+  | "found" =>
+    switch TsConfigMapping.infer(
+      tsConfig,
+      ~packageType=getPackageType(packageJson),
+      ~hasJsxDependency=hasJsxDependency(packageJson),
+    ) {
+    | Ok(gentypeConfig) =>
+      P.Log.info(
+        `Detected tsconfig.json. ReScript will use ${gentypeConfig.moduleSystem} output, ${gentypeConfig.gentypeModuleResolution} genType module resolution, and ${gentypeConfig.suffix} generated JS files.`,
+      )
+
+      gentypeConfig.warnings->Array.forEach(P.Log.warn)
+
+      Some({
+        moduleSystem: gentypeConfig.moduleSystem,
+        suffix: gentypeConfig.suffix,
+        gentypeConfig: Some(gentypeConfig),
+      })
+    | Error(message) =>
+      P.Log.warn(`${message} Falling back to manual ReScript module setup.`)
+      None
+    }
+  | "not_found" => None
+  | "typescript_missing" =>
+    P.Log.warn(
+      "Found tsconfig.json, but could not resolve the project's TypeScript package. Falling back to manual ReScript module setup.",
+    )
+    None
+  | _ =>
+    let message = tsConfig.message->Option.getOr("Could not read the effective tsconfig.json.")
+    P.Log.warn(`${message} Falling back to manual ReScript module setup.`)
+    None
+  }
+}
+
+let getProjectModuleConfig = async packageJson =>
+  switch await getTsConfigModuleConfig(packageJson) {
+  | Some(config) => config
+  | None => await getManualModuleConfig()
+  }
+
+let updateTsConfig = async (~setAllowJs, ~setAllowImportingTsExtensions) =>
+  if setAllowJs || setAllowImportingTsExtensions {
+    await JsonUtils.updateJsonFile("tsconfig.json", json =>
+      switch json {
+      | Object(config) =>
+        let compilerOptions = config->getOrCreateJsonObject(~fieldName="compilerOptions")
+
+        if setAllowJs {
+          compilerOptions->Dict.set("allowJs", Boolean(true))
+        }
+
+        if setAllowImportingTsExtensions {
+          compilerOptions->Dict.set("allowImportingTsExtensions", Boolean(true))
+        }
+      | _ => ()
+      }
+    )
+  }
+
+let promptTsConfigUpdates = async (gentypeConfig: option<TsConfigMapping.inferredConfig>) => {
+  switch gentypeConfig {
+  | None => ()
+  | Some(gentypeConfig) =>
+    let setAllowJs = if gentypeConfig.needsAllowJs {
+      P.Log.warn(
+        "TypeScript allowJs is not enabled. genType imports ReScript's generated JS files, so TypeScript needs allowJs: true to type-check the setup.",
+      )
+
+      await P.confirm({
+        message: "Set compilerOptions.allowJs to true in tsconfig.json?",
+      })->P.resultOrRaise
+    } else {
+      false
+    }
+
+    let setAllowImportingTsExtensions = if gentypeConfig.needsAllowImportingTsExtensions {
+      P.Log.warn(
+        "genType bundler module resolution requires TypeScript allowImportingTsExtensions: true.",
+      )
+
+      await P.confirm({
+        message: "Set compilerOptions.allowImportingTsExtensions to true in tsconfig.json?",
+      })->P.resultOrRaise
+    } else {
+      false
+    }
+
+    if gentypeConfig.cannotSetAllowImportingTsExtensions {
+      P.Log.warn(
+        "genType bundler module resolution requires allowImportingTsExtensions: true, but TypeScript only allows that option when noEmit or emitDeclarationOnly is enabled.",
+      )
+
+      let shouldContinue = await P.confirm({
+        message: "Continue with the inferred genType bundler configuration anyway?",
+      })->P.resultOrRaise
+
+      if !shouldContinue {
+        JsError.throwWithMessage("genType bundler setup requires manual tsconfig changes.")
+      }
+    }
+
+    try await updateTsConfig(~setAllowJs, ~setAllowImportingTsExtensions) catch {
+    | JsExn(error) =>
+      P.Log.warn(
+        `Could not update tsconfig.json automatically: ${error->ErrorUtils.getErrorMessage}`,
+      )
+    }
+  }
+}
+
 let addToExistingProject = async (~projectName) => {
   let versions = await RescriptVersions.promptVersions()
+  let packageJson = await getPackageJson()
 
   let sourceDir = await P.text({
     message: "Where will you put your ReScript source files?",
@@ -70,15 +282,11 @@ let addToExistingProject = async (~projectName) => {
     initialValue: "src",
   })->P.resultOrRaise
 
-  let moduleSystem = await P.select({
-    message: "What module system will you use?",
-    options: getModuleSystemOptions(),
-  })->P.resultOrRaise
-
-  let suffix = moduleSystem === "esmodule" ? ".res.mjs" : ".res.js"
+  let moduleConfig = await getProjectModuleConfig(packageJson)
+  await promptTsConfigUpdates(moduleConfig.gentypeConfig)
 
   let shouldCheckJsFilesIntoGit = await P.confirm({
-    message: `Do you want to check generated ${suffix} files into git?`,
+    message: `Do you want to check generated ${moduleConfig.suffix} files into git?`,
   })->P.resultOrRaise
 
   let templatePath = CraPaths.getTemplatePath(~templateName=Templates.basicTemplateName)
@@ -103,11 +311,18 @@ let addToExistingProject = async (~projectName) => {
   }
 
   if !shouldCheckJsFilesIntoGit {
-    await Fs.Promises.appendFile(gitignorePath, `**/*${suffix}${Os.eol}`)
+    await Fs.Promises.appendFile(gitignorePath, `**/*${moduleConfig.suffix}${Os.eol}`)
   }
 
   await updatePackageJson(~versions)
-  await updateRescriptJson(~projectName, ~sourceDir, ~moduleSystem, ~suffix, ~versions)
+  await updateRescriptJson(
+    ~projectName,
+    ~sourceDir,
+    ~moduleSystem=moduleConfig.moduleSystem,
+    ~suffix=moduleConfig.suffix,
+    ~gentypeConfig=moduleConfig.gentypeConfig,
+    ~versions,
+  )
 
   if !Fs.existsSync(sourceDirPath) {
     await Fs.Promises.mkdir(sourceDirPath)