fix tests & add default type for lang generic to support custom

r4zendev · r4zendev · commit d0817ef28758 · 2025-01-19T00:00:33.000+01:00
diff --git a/crates/napi/__test__/type.spec.ts b/crates/napi/__test__/type.spec.ts
@@ -4,7 +4,7 @@ import type TypeScriptTypes from '../lang/TypeScript'
 import { Lang, parse, parseAsync, type SgNode, type SgRoot } from '../index'
 
 test('test no type annotation', t => {
-  const sg = parse(Lang.TypeScript, 'a + b')
+  const sg = parse('TypeScript', 'a + b')
   // test root kind and field
   const root = sg.root()
   t.is(root.kind(), 'program')
@@ -158,6 +158,53 @@ test('test type argument style', t => {
   })
 })
 
+test('test infer lang node types', t => {
+  const sg = parse(Lang.TypeScript, 'a + b')
+  // test root kind and field
+  const root = sg.root()
+  t.is(root.kind(), 'program')
+  // @ts-expect-error
+  t.is(root.field('body'), null)
+  // test child
+  const child = root.child(0)
+  t.assert(child !== null)
+  const childKind = child!.kind()
+  t.assert(childKind === 'expression_statement')
+  t.assert(childKind !== ',')
+  // test parent method
+  const parent = child!.parent()
+  t.assert(parent!.kind() === root.kind())
+  // test find
+  const sum = root.find({
+    rule: {
+      kind: 'binary_expression',
+    },
+  })!
+  t.is(sum.kind(), 'binary_expression')
+  t.is(sum.field('operator')!.kind(), '+')
+
+  // test type refinement
+  const a = root.find('a')!
+  t.assert(a.is('identifier'))
+  if (a.is('identifier')) {
+    t.assert(a.kind() === 'identifier')
+    // @ts-expect-error: should refine kind
+    t.assert(a.kind() !== 'invalid')
+    // @ts-expect-error: should reject field
+    t.is(a.field('type_annotation'), null)
+  }
+
+  // test rule kind
+  t.throws(() => {
+    root.find({
+      rule: {
+        // @ts-expect-error: reject kind
+        kind: 'notFound',
+      },
+    })
+  })
+})
+
 test('subtype alias', async t => {
   const sg = await parseAsync<TypeScriptTypes>(
     Lang.TypeScript,
@@ -214,4 +261,4 @@ test('subtype alias', async t => {
     },
   })
   t.falsy(wrong)
-})
+})
diff --git a/crates/napi/package.json b/crates/napi/package.json
@@ -46,6 +46,7 @@
     "build:debug": "napi build --no-const-enum --dts ignore.d.ts --platform",
     "prepublishOnly": "napi prepublish -t npm --skip-gh-release",
     "pretest": "ts-node scripts/generateTypes.ts --test-only",
+    "posttest": "ts-node scripts/cleanup.ts",
     "test": "tsc --noEmit && ava",
     "version": "napi version",
     "lint": "biome lint --fix && biome format --write",
diff --git a/crates/napi/scripts/cleanup.ts b/crates/napi/scripts/cleanup.ts
@@ -0,0 +1,45 @@
+import { readdir, readFile, unlink, writeFile } from 'node:fs/promises'
+import path from 'node:path'
+
+const root = path.resolve(__dirname, '..')
+const dirs = {
+  root,
+  types: path.join(root, 'types'),
+  lang: path.join(root, 'lang'),
+}
+
+async function cleanup() {
+  try {
+    const files = await readdir(dirs.lang)
+
+    await Promise.all(
+      files
+        .filter(file => file.endsWith('.d.ts'))
+        .map(async file => {
+          const filePath = path.join(dirs.lang, file)
+          await unlink(filePath)
+          console.log(`Deleted: ${filePath}`)
+        }),
+    )
+
+    const existingTypesSource = await readFile(
+      path.join(dirs.types, 'lang.d.ts'),
+      'utf8',
+    )
+
+    const newSource = existingTypesSource.replace(
+      /export type LanguageNodeTypes = \{[^{}]*\}/,
+      'export type LanguageNodeTypes = Record<never, never>',
+    )
+
+    await writeFile(path.join(dirs.types, 'lang.d.ts'), newSource)
+  } catch (e) {
+    console.error('Error during cleanup:', e)
+    throw e
+  }
+}
+
+cleanup().catch(error => {
+  console.error('Error:', error)
+  process.exit(1)
+})
diff --git a/crates/napi/types/api.d.ts b/crates/napi/types/api.d.ts
@@ -1,14 +1,17 @@
 import type { SgNode, SgRoot } from './sgnode'
 import type { NapiConfig, FindConfig, FileOption } from './config'
-import type { NapiLang, LanguageNodeTypes } from './lang'
+import type { NapiLang, LanguageNodeTypes, CustomLang } from './lang'
 import type { NamedKinds, TypesMap } from './staticTypes'
 
 export declare function parseFiles<M extends TypesMap>(
   paths: Array<string> | FileOption,
   callback: (err: null | Error, result: SgRoot<M>) => void,
 ): Promise<number>
 /** Parse a string to an ast-grep instance */
-export declare function parse<M extends TypesMap, L extends NapiLang>(
+export declare function parse<
+  M extends TypesMap,
+  L extends NapiLang = CustomLang,
+>(
   lang: L,
   src: string,
 ): SgRoot<L extends keyof LanguageNodeTypes ? LanguageNodeTypes[L] : M>
@@ -19,19 +22,28 @@ export declare function parse<M extends TypesMap, L extends NapiLang>(
  * Please refer to libuv doc, nodejs' underlying runtime
  * for its default behavior and performance tuning tricks.
  */
-export declare function parseAsync<M extends TypesMap, L extends NapiLang>(
+export declare function parseAsync<
+  M extends TypesMap,
+  L extends NapiLang = CustomLang,
+>(
   lang: L,
   src: string,
 ): Promise<SgRoot<L extends keyof LanguageNodeTypes ? LanguageNodeTypes[L] : M>>
 /** Get the `kind` number from its string name. */
-export declare function kind<M extends TypesMap, L extends NapiLang>(
+export declare function kind<
+  M extends TypesMap,
+  L extends NapiLang = CustomLang,
+>(
   lang: L,
   kindName: NamedKinds<
     L extends keyof LanguageNodeTypes ? LanguageNodeTypes[L] : M
   >,
 ): number
 /** Compile a string to ast-grep Pattern. */
-export declare function pattern<M extends TypesMap, L extends NapiLang>(
+export declare function pattern<
+  M extends TypesMap,
+  L extends NapiLang = CustomLang,
+>(
   lang: L,
   pattern: string,
 ): Promise<
@@ -43,7 +55,10 @@ export declare function pattern<M extends TypesMap, L extends NapiLang>(
  * `config` specifies the file path and matcher.
  * `callback` will receive matching nodes found in a file.
  */
-export declare function findInFiles<M extends TypesMap, L extends NapiLang>(
+export declare function findInFiles<
+  M extends TypesMap,
+  L extends NapiLang = CustomLang,
+>(
   lang: L,
   config: FindConfig<
     L extends keyof LanguageNodeTypes ? LanguageNodeTypes[L] : M
