fhirpath-ts 0.2.0 → 0.2.2

package/src/cli/fhirpath-check.ts

@@ -5,32 +5,43 @@
  * exit status. Use `--no-import` for source only and `--dtos` to change the DTO
  * module glob.
  *
- * Usage: fhirpath-check [--dtos <glob>]... [--no-import] <file...>
+ * Usage: fhirpath-check [--dtos <glob>]... [--no-import] [--local-imports] [--strict] <file...>
  */
 /* v8 ignore file -- covered end-to-end as a subprocess in fhirpath-check.test.ts */
 import { readFileSync } from 'node:fs'
+import { dirname, resolve } from 'node:path'
 
 import ts from 'typescript'
 
 import { analyzeSite } from '../analyzer/analyze.ts'
 import { r4Model } from '../r4/index.ts'
-import { createSiteFinder, type ExpressionSite } from '../sites/index.ts'
-import { checkDtoModules, DEFAULT_DTO_GLOB, type DtoFinding } from './dto-check.ts'
-
-const findExpressionSites = createSiteFinder(ts)
+import { createSiteScanner, type ExpressionSite, type SiteScanner, type SiteScanResult } from '../sites/index.ts'
+import {
+  checkDtoModules,
+  DEFAULT_DTO_GLOB,
+  type DtoCheckResult,
+  type DtoFinding,
+  EngineMergeError,
+} from './dto-check.ts'
 
 interface Args {
   files: string[]
   dtoGlobs: string[]
   imports: boolean
+  localImports: boolean
+  strict: boolean
 }
 
 function parseArgs(argv: readonly string[]): Args {
-  const args: Args = { files: [], dtoGlobs: [], imports: true }
+  const args: Args = { files: [], dtoGlobs: [], imports: true, localImports: false, strict: false }
   for (let index = 0; index < argv.length; index++) {
     const arg = argv[index]!
     if (arg === '--no-import') {
       args.imports = false
+    } else if (arg === '--local-imports') {
+      args.localImports = true
+    } else if (arg === '--strict') {
+      args.strict = true
     } else if (arg === '--dtos') {
       const glob = argv[++index]
       if (glob === undefined) {
@@ -47,17 +58,89 @@ function parseArgs(argv: readonly string[]): Args {
 
 const args = parseArgs(process.argv.slice(2))
 if (args.files.length === 0 && !args.imports) {
-  console.error('usage: fhirpath-check [--dtos <glob>]... [--no-import] <file...>')
+  console.error('usage: fhirpath-check [--dtos <glob>]... [--no-import] [--local-imports] [--strict] <file...>')
   process.exit(2)
 }
+const dtoGlobs = args.dtoGlobs.length > 0 ? args.dtoGlobs : [DEFAULT_DTO_GLOB]
+
+/** A type-aware program lets the site finder follow imported and aliased engine receivers. */
+function sourceProgram(files: readonly string[], configPath: string | undefined): ts.Program {
+  const defaults: ts.CompilerOptions = {
+    allowJs: true,
+    skipLibCheck: true,
+    target: ts.ScriptTarget.Latest,
+  }
+  const nodeNext: ts.CompilerOptions = {
+    module: ts.ModuleKind.NodeNext,
+    moduleResolution: ts.ModuleResolutionKind.NodeNext,
+  }
+  let options: ts.CompilerOptions = { ...defaults, ...nodeNext }
+  if (configPath !== undefined) {
+    const config = ts.readConfigFile(configPath, ts.sys.readFile)
+    if (config.error === undefined) {
+      // Resolve `extends`/`paths` from the config's own directory, and layer
+      // the declared options over the defaults instead of replacing them —
+      // a `strict`-only tsconfig must not lose the module resolution the
+      // checker needs to follow package exports. The NodeNext pair applies
+      // only when the config declares neither half, so an explicit
+      // module/moduleResolution keeps TypeScript's own pairing rules.
+      const declared = ts.parseJsonConfigFileContent(
+        config.config,
+        ts.sys,
+        dirname(configPath),
+        undefined,
+        configPath
+      ).options
+      const resolution = declared.module === undefined && declared.moduleResolution === undefined ? nodeNext : {}
+      options = { ...defaults, ...resolution, ...declared }
+    }
+  }
+  return ts.createProgram({ rootNames: files.map(file => resolve(file)), options })
+}
+
+/**
+ * One semantic scanner per tsconfig project. A monorepo command may select
+ * files from packages whose aliases and module settings differ, so each file
+ * starts its config search in its own directory. Files sharing a config share
+ * one Program and TypeChecker.
+ */
+function sourceScanners(files: readonly string[]): ReadonlyMap<string, SiteScanner> {
+  const filesByConfig = new Map<string | undefined, string[]>()
+  for (const file of files) {
+    const absolute = resolve(file)
+    const configPath = ts.findConfigFile(dirname(absolute), ts.sys.fileExists)
+    const grouped = filesByConfig.get(configPath)
+    if (grouped === undefined) {
+      filesByConfig.set(configPath, [absolute])
+    } else {
+      grouped.push(absolute)
+    }
+  }
+
+  const scannersByFile = new Map<string, SiteScanner>()
+  for (const [configPath, groupedFiles] of filesByConfig) {
+    const scanner = createSiteScanner(ts, sourceProgram(groupedFiles, configPath))
+    for (const file of groupedFiles) {
+      scannersByFile.set(file, scanner)
+    }
+  }
+  return scannersByFile
+}
+
+const syntaxScanner = createSiteScanner(ts)
+let semanticScannersByFile: ReadonlyMap<string, SiteScanner> = new Map()
 
 let failures = 0
+let warnings = 0
 
-function report(location: string, diagnostic: { severity: string; code: string; message: string }): void {
-  if (diagnostic.severity === 'error') {
+function report(location: string, diagnostic: { severity: 'error' | 'warning'; code: string; message: string }): void {
+  const severity = args.strict && diagnostic.severity === 'warning' ? 'error' : diagnostic.severity
+  if (severity === 'error') {
     failures += 1
+  } else {
+    warnings += 1
   }
-  const prefix = diagnostic.severity === 'warning' ? 'warning:' : ''
+  const prefix = severity === 'warning' ? 'warning:' : ''
   console.error(`${location} [${prefix}${diagnostic.code}] ${diagnostic.message}`)
 }
 
@@ -73,33 +156,85 @@ function positionIn(site: { line: number; column: number }, span: { line: number
   return `${line}:${column}`
 }
 
-/** Expression sites cached so each source file is read once. */
-const sitesByFile = new Map<string, ExpressionSite[]>()
+/** Source scans cached so each file is read once. */
+const scansByFile = new Map<string, SiteScanResult>()
 
-function sitesOf(file: string): ExpressionSite[] {
-  const cached = sitesByFile.get(file)
+function scanOf(file: string): SiteScanResult {
+  const cached = scansByFile.get(file)
   if (cached !== undefined) {
     return cached
   }
-  const sites = findExpressionSites(readFileSync(file, 'utf8'), file)
-  sitesByFile.set(file, sites)
-  return sites
+  const absolute = resolve(file)
+  const scanner = semanticScannersByFile.get(absolute) ?? syntaxScanner
+  const scan = scanner(readFileSync(file, 'utf8'), absolute, {
+    ...(args.localImports && { localImports: true }),
+  })
+  scansByFile.set(file, scan)
+  return scan
 }
 
-// Check source literals first.
+function sitesOf(file: string): ExpressionSite[] {
+  return scanOf(file).sites
+}
+
+// Extract source sites before executing project modules. Analysis waits until
+// after the import pass so those sites can use the engines' real environment.
 for (const file of args.files) {
-  let sites: ExpressionSite[]
   try {
-    sites = sitesOf(file)
+    scanOf(file)
   } catch (error) {
     console.error(`fhirpath-check: cannot read ${file}: ${error instanceof Error ? error.message : String(error)}`)
     process.exit(2)
   }
+}
+const unresolvedFiles = args.localImports
+  ? []
+  : args.files.filter(file => scanOf(file).skipped.some(skipped => skipped.reason === 'unrecognized-receiver'))
+if (unresolvedFiles.length > 0) {
+  // Pay the Program/TypeChecker cost only when the syntax-only pass found a
+  // receiver it could not prove. Most source files need no compiler graph.
+  semanticScannersByFile = sourceScanners(unresolvedFiles)
+  scansByFile.clear()
+  for (const file of args.files) {
+    scanOf(file)
+  }
+}
+
+let dtoResult: DtoCheckResult | undefined
+if (args.imports) {
+  try {
+    dtoResult = await checkDtoModules(dtoGlobs, process.cwd())
+  } catch (error) {
+    if (error instanceof EngineMergeError) {
+      console.error(`fhirpath-check: ${error.message}`)
+    } else {
+      console.error(
+        `fhirpath-check: cannot import DTO modules (${dtoGlobs.join(', ')}): ${error instanceof Error ? error.message : String(error)}`
+      )
+    }
+    process.exit(2)
+  }
+}
+
+// Check source literals first.
+for (const file of args.files) {
+  const sites = sitesOf(file)
   for (const site of sites) {
-    for (const diagnostic of analyzeSite(site, { model: r4Model })) {
+    for (const diagnostic of analyzeSite(site, {
+      model: r4Model,
+      ...dtoResult?.sourceOptions,
+      reportUnchecked: true,
+    })) {
       report(`${file}:${positionIn(site, diagnostic.span)}`, diagnostic)
     }
   }
+  for (const skipped of scanOf(file).skipped) {
+    report(`${file}:${skipped.line}:${skipped.column}`, {
+      severity: 'warning',
+      code: 'skipped',
+      message: skipped.message,
+    })
+  }
 }
 
 /**
@@ -124,26 +259,35 @@ function locate(finding: DtoFinding): string {
 }
 
 // --- 2. the project's DTO modules, imported ---
-if (args.imports) {
-  const globs = args.dtoGlobs.length > 0 ? args.dtoGlobs : [DEFAULT_DTO_GLOB]
-  let result
-  try {
-    result = await checkDtoModules(globs, process.cwd())
-  } catch (error) {
-    console.error(
-      `fhirpath-check: cannot import DTO modules (${globs.join(', ')}): ${error instanceof Error ? error.message : String(error)}`
-    )
-    process.exit(2)
+if (dtoResult !== undefined) {
+  const result = dtoResult
+  for (const file of result.files) {
+    let scan: SiteScanResult
+    try {
+      scan = scanOf(file)
+    } catch {
+      continue
+    }
+    for (const dto of scan.dtoDeclarations) {
+      if (!dto.loadable) {
+        report(`${file}:${dto.line}:${dto.column}`, {
+          severity: 'warning',
+          code: 'unloaded-dto',
+          message: `DTO ${dto.name} is module-local and was not loaded for full analysis; export it or an extending class`,
+        })
+      }
+    }
   }
   for (const finding of result.findings) {
     // With no engine in reach, an unresolved column call is unresolvable rather
     // than wrong, so it is reported without failing the run.
     const unresolvable = result.engines === 0 && finding.code === 'unknown-function'
-    report(locate(finding), unresolvable ? { ...finding, severity: 'warning' } : finding)
+    const reported = unresolvable ? { ...finding, severity: 'warning' as const } : finding
+    report(locate(finding), reported)
   }
   if (result.files.length === 0) {
     console.error(
-      `fhirpath-check: no DTO modules matched ${globs.join(', ')} — DTOs live in *.dto.ts, or pass --dtos <glob>`
+      `fhirpath-check: no DTO modules matched ${dtoGlobs.join(', ')} — DTOs live in *.dto.ts, or pass --dtos <glob>`
     )
   } else if (result.dtos.length === 0) {
     console.error(`fhirpath-check: ${result.files.length} DTO module(s) matched but export no DTO class`)
@@ -165,4 +309,6 @@ if (failures > 0) {
   console.error(`fhirpath-check: ${failures} problem(s) found`)
   process.exit(1)
 }
-console.log('fhirpath-check: no problems found')
+console.log(
+  warnings > 0 ? `fhirpath-check: ${warnings} warning(s), no errors found` : 'fhirpath-check: no problems found'
+)

package/src/eslint/index.ts

@@ -6,6 +6,7 @@ import type * as ESTree from 'estree'
 import { analyzeSite, type DeclaredFunction, type DeclaredVariable } from '../analyzer/analyze.ts'
 import {
   CALL_SITES,
+  callExpressionCandidates,
   type CallSitePolicy,
   type ClassHeritage,
   columnFunctionDeclaration,
@@ -14,7 +15,6 @@ import {
   DTO_BASE_NAME,
   dtoRootsOf,
   type ExpressionAst,
-  expressionEntries,
   type FileColumnFunction,
   isCheckedCall,
   isCheckedTag,
@@ -22,7 +22,6 @@ import {
   type LocalModuleOptions,
   rootOf,
   type SiteContext,
-  siteContext,
   type SourceBindings,
   TAG_NAME,
 } from '../analyzer/expression-policy.ts'
@@ -32,10 +31,13 @@ function isStringLiteral(node: ESTree.Node): node is ESTree.SimpleLiteral & { va
   return node.type === 'Literal' && typeof node.value === 'string'
 }
 
-/** Statically-known property key (`path` in `{ path: ... }` or `{ 'path': ... }`), undefined when computed. */
+/**
+ * Statically-known property key: `path` in `{ path: ... }`, `{ 'path': ... }`,
+ * or `{ ['path']: ... }`; undefined for other computed keys.
+ */
 function propertyKeyName(property: ESTree.Property): string | undefined {
   if (property.computed) {
-    return undefined
+    return isStringLiteral(property.key) ? property.key.value : undefined
   }
   if (property.key.type === 'Identifier') {
     return property.key.name
@@ -49,8 +51,10 @@ const estreeAst: ExpressionAst<ESTree.Node> = {
   boolean: node => (node.type === 'Literal' && typeof node.value === 'boolean' ? node.value : undefined),
   properties: node =>
     node.type === 'ObjectExpression'
-      ? node.properties.flatMap(property =>
-          property.type === 'Property' ? [{ name: propertyKeyName(property), value: property.value }] : []
+      ? node.properties.map(property =>
+          property.type === 'Property'
+            ? { name: propertyKeyName(property), value: property.value }
+            : { name: undefined, value: property.argument, spread: true as const }
         )
       : undefined,
   elements: node => (node.type === 'ArrayExpression' ? node.elements.filter(element => element !== null) : undefined),
@@ -198,7 +202,6 @@ const noInvalidExpressions: Rule.RuleModule = {
       policy: CallSitePolicy
       name: string
       receiverRoot: string | undefined
-      argument: ESTree.Node
       /** The call itself, for the argument that may name the type it runs against. */
       node: ESTree.CallExpression
       /** The class the call sits in, resolved to a root once the whole file is known. */
@@ -325,7 +328,6 @@ const noInvalidExpressions: Rule.RuleModule = {
           policy,
           name,
           receiverRoot: receiverRoot(callee),
-          argument,
           node,
           enclosing: policy.rootFromClass === true ? enclosingClass(ancestors) : undefined,
         })
@@ -359,14 +361,15 @@ const noInvalidExpressions: Rule.RuleModule = {
           if (!isCheckedCall(call.policy, call.name, call.receiverRoot, bindings)) {
             continue
           }
-          const site = siteContext<ESTree.Node>(
+          for (const candidate of callExpressionCandidates<ESTree.Node>(
             call.policy,
             index => call.node.arguments[index],
             rootOf(call.enclosing, dtoRoots),
             estreeAst
-          )
-          for (const entry of expressionEntries(call.argument, call.policy.shape, estreeAst)) {
-            checkAt(entry.node, entry.expression, site)
+          )) {
+            if (candidate.expression !== undefined) {
+              checkAt(candidate.node, candidate.expression, candidate.context)
+            }
           }
         }
       },