Skip to content
Source
Sign inSign up
TanStack/router
Open History to see the last commit

analysis.usage.test.ts

366 lines10.8 KB

1import { describe, expect, test } from 'vitest'
2import {
3 findOriginalUnsafeUsagePos,
4 findOriginalUnsafeUsagePosFromResult,
5 findPostCompileUsagePos,
6} from '../../src/import-protection/analysis'
7​
8function pos(code: string, source: string) {
9 return findPostCompileUsagePos(code, source)
11​
12function originalPos(
13 code: string,
14 source: string,
15 envType: 'client' | 'server',
16) {
17 return findOriginalUnsafeUsagePos(code, source, envType)
19​
20describe('findPostCompileUsagePos', () => {
21 test('returns undefined when there is no import from the source', () => {
22 expect(pos(`const x = 1`, 'denied')).toBeUndefined()
23 })
24​
25 test('reports UTF-16 columns after astral characters, tabs and CRLF line endings', () => {
26 const code =
27 "import { secret } from 'denied'\r\n" +
28 '// πŸ‘¨β€πŸ‘©β€πŸ‘§ 𝒳𝒴 ζ—₯本θͺž\r\n' +
29 "\tconst label = 'πŸŽ‰'; const value = secret()\r\n"
30 expect(pos(code, 'denied')).toEqual({
31 line: 3,
32 column0: "\tconst label = 'πŸŽ‰'; const value = ".length,
33 })
34 })
35​
36 test('returns undefined when import is type-only', () => {
37 expect(
38 pos(`import type { Foo } from 'denied';\nconst x = 1`, 'denied'),
39 ).toBeUndefined()
40 })
41​
42 test('finds preferred call usage for named import', () => {
43 const p = pos(
44 `import { getRequest } from 'denied';\nexport function x(){ return getRequest() }`,
45 'denied',
46 )
47 expect(p).toBeDefined()
48 expect(p!.line).toBe(2)
49 })
50​
51 test('prefers call usage over earlier non-preferred identifier usage', () => {
52 const p = pos(
53 `import { getRequest } from 'denied';\nconst a = getRequest;\ngetRequest()`,
54 'denied',
55 )
56 expect(p).toBeDefined()
57 expect(p!.line).toBe(3)
58 })
59​
60 test('falls back to non-binding identifier usage if no preferred usage exists', () => {
61 const p = pos(`import { x } from 'denied';\nconst y = x;`, 'denied')
62 expect(p).toBeDefined()
63 expect(p!.line).toBe(2)
64 })
65​
66 test('ignores binding positions (variable declarator id)', () => {
67 const p = pos(
68 `import { x } from 'denied';\n{ const x = 1;\nconst y = x; }`,
69 'denied',
70 )
71 expect(p).toBeUndefined()
72 })
73​
74 test('ignores object property key (non-shorthand) but still finds later usage', () => {
75 const p = pos(
76 `import { x } from 'denied';\nconst obj = { x: 1 };\nx()`,
77 'denied',
78 )
79 expect(p).toBeDefined()
80 expect(p!.line).toBe(3)
81 })
82​
83 test('ignores shadowed identifiers in nested function scope', () => {
84 const p = pos(
85 `import { x } from 'denied';\nfunction inner(x: any){ return x }\nconst y = x;`,
86 'denied',
87 )
88 expect(p).toBeDefined()
89 expect(p!.line).toBe(3)
90 })
91​
92 test('ignores shadowing via catch clause param', () => {
93 const p = pos(
94 `import { err } from 'denied';\ntry { throw 1 } catch (err) { console.log(err) }\nconsole.log(err)`,
95 'denied',
96 )
97 expect(p).toBeDefined()
98 expect(p!.line).toBe(3)
99 })
100​
101 test('handles namespace member preferred usage (ns.foo)', () => {
102 const p = pos(`import * as ns from 'denied';\nns.getRequest()`, 'denied')
103 expect(p).toBeDefined()
104 expect(p!.line).toBe(2)
105 })
106​
107 test('handles default import preferred usage (call)', () => {
108 const p = pos(`import req from 'denied';\nreq()`, 'denied')
109 expect(p).toBeDefined()
110 expect(p!.line).toBe(2)
111 })
112​
113 test('counts object pattern shorthand as usage (not a binding position)', () => {
114 const p = pos(
115 `import { foo } from 'denied';\nconst obj = { foo };`,
116 'denied',
117 )
118 expect(p).toBeDefined()
119 expect(p!.line).toBe(2)
120 })
121​
122 test('var in block scope shadows import at function level', () => {
123 const p = pos(
124 [
125 `import { x } from 'denied';`,
126 `function f() {`,
127 ` if (true) {`,
128 ` var x = 1;`,
129 ` }`,
130 ` return x;`,
131 `}`,
132 ].join('\n'),
133 'denied',
134 )
135 expect(p).toBeUndefined()
136 })
137​
138 test('var in block scope does NOT shadow import in outer scope', () => {
139 const p = pos(
140 [
141 `import { x } from 'denied';`,
142 `function f() {`,
143 ` if (true) {`,
144 ` var x = 1;`,
145 ` }`,
146 ` return x;`,
147 `}`,
148 `console.log(x);`,
149 ].join('\n'),
150 'denied',
151 )
152 expect(p).toBeDefined()
153 expect(p!.line).toBe(8)
154 })
155​
156 test('let in block scope does NOT shadow import in enclosing function', () => {
157 const p = pos(
158 [
159 `import { x } from 'denied';`,
160 `function f() {`,
161 ` if (true) {`,
162 ` let x = 1;`,
163 ` }`,
164 ` return x;`,
165 `}`,
166 ].join('\n'),
167 'denied',
168 )
169 expect(p).toBeDefined()
170 expect(p!.line).toBe(6)
171 })
172​
173 test('const in block scope does NOT shadow import in enclosing function', () => {
174 const p = pos(
175 [
176 `import { x } from 'denied';`,
177 `function f() {`,
178 ` {`,
179 ` const x = 1;`,
180 ` }`,
181 ` return x;`,
182 `}`,
183 ].join('\n'),
184 'denied',
185 )
186 expect(p).toBeDefined()
187 expect(p!.line).toBe(6)
188 })
189​
190 test('var in nested arrow function does not shadow outer scope', () => {
191 const p = pos(
192 [
193 `import { x } from 'denied';`,
194 `const outer = () => {`,
195 ` const inner = () => {`,
196 ` var x = 1;`,
197 ` };`,
198 ` return x;`,
199 `};`,
200 ].join('\n'),
201 'denied',
202 )
203 expect(p).toBeDefined()
204 expect(p!.line).toBe(6)
205 })
206})
207​
208describe('findOriginalUnsafeUsagePos', () => {
209 test('skips createServerFn handler usage in client env and finds later unsafe usage', () => {
210 const p = originalPos(
211 [
212 `import { createServerFn } from '@tanstack/react-start';`,
213 `import { getSecret } from './secret.server';`,
214 `export const safeServerFn = createServerFn().handler(async () => {`,
215 ` return getSecret();`,
216 `});`,
217 `export function leakyReference() {`,
218 ` return getSecret();`,
219 `}`,
220 ].join('\n'),
221 './secret.server',
222 'client',
223 )
224​
225 expect(p).toBeDefined()
226 expect(p!.line).toBe(7)
227 })
228​
229 test('returns undefined when usage is only inside createServerOnlyFn in client env', () => {
230 const p = originalPos(
231 [
232 `import { createServerOnlyFn } from '@tanstack/react-start';`,
233 `import { getSecret } from './secret.server';`,
234 `export const safeServerOnly = createServerOnlyFn(() => {`,
235 ` return getSecret();`,
236 `});`,
237 ].join('\n'),
238 './secret.server',
239 'client',
240 )
241​
242 expect(p).toBeUndefined()
243 })
244​
245 test('returns undefined when usage is only inside createMiddleware.server in client env', () => {
246 const p = originalPos(
247 [
248 `import { createMiddleware } from '@tanstack/react-start';`,
249 `import { getSecret } from './secret.server';`,
250 `const middleware = createMiddleware({ type: 'function' }).server(({ next }) => {`,
251 ` const secret = getSecret();`,
252 ` return next({ context: { secret } });`,
253 `});`,
254 ].join('\n'),
255 './secret.server',
256 'client',
257 )
258​
259 expect(p).toBeUndefined()
260 })
261​
262 test('returns undefined when usage is only inside createIsomorphicFn.server in client env', () => {
263 const p = originalPos(
264 [
265 `import { createIsomorphicFn } from '@tanstack/react-start';`,
266 `import { getSecret } from './secret.server';`,
267 `export const safeIsomorphic = createIsomorphicFn().server(() => {`,
268 ` return getSecret();`,
269 `});`,
270 ].join('\n'),
271 './secret.server',
272 'client',
273 )
274​
275 expect(p).toBeUndefined()
276 })
277​
278 test('returns undefined when usage is only inside createClientOnlyFn in server env', () => {
279 const p = originalPos(
280 [
281 `import { createClientOnlyFn } from '@tanstack/react-start';`,
282 `import { readWindow } from './browser.client';`,
283 `export const safeClientOnly = createClientOnlyFn(() => {`,
284 ` return readWindow();`,
285 `});`,
286 ].join('\n'),
287 './browser.client',
288 'server',
289 )
290​
291 expect(p).toBeUndefined()
292 })
293})
294​
295test.each([
296 `createServerFn().handler((() => denied()))`,
297 `(createServerFn)().handler(() => denied())`,
298])(
299 'preserves safe-boundary recognition through parentheses: %s',
300 (expression) => {
301 const code = `import { denied } from 'denied';\nexport const result = ${expression}`
302 expect(findOriginalUnsafeUsagePos(code, 'denied', 'client')).toBeUndefined()
303 },
305​
306test.each([
307 `createIsomorphicFn().client((() => denied()))`,
308 `(createClientOnlyFn)((() => denied()))`,
309])('preserves server safe boundaries through parentheses: %s', (expression) => {
310 const code = `import { denied } from 'denied';\nexport const result = ${expression}`
311 expect(findOriginalUnsafeUsagePos(code, 'denied', 'server')).toBeUndefined()
312})
313​
314test('does not treat an immediately invoked function as a safe handler argument', () => {
315 const code = `import { denied } from 'denied';\nexport const result = createServerFn().handler((() => denied())())`
316 expect(findOriginalUnsafeUsagePos(code, 'denied', 'client')).toEqual({
317 line: 2,
318 column0: code.split('\n')[1]!.indexOf('denied'),
319 })
320})
321​
322test('prefers parenthesized call usage over an earlier value reference', () => {
323 const code = `import { denied } from 'denied';\nconst value = denied;\n(denied)()`
324 expect(findPostCompileUsagePos(code, 'denied')).toEqual({
325 line: 3,
326 column0: 1,
327 })
328})
329​
330// On the client, `.handler()` (of createServerFn or a `*ServerFn` builder) and
331// `.server()` (of createMiddleware, a `*Middleware` builder or
332// createIsomorphicFn) are safe boundaries, matched by the root name of the
333// call chain. On the server, the client branches are: createIsomorphicFn()
334// .client() and createClientOnlyFn().
335test.each([
336 [
337 'client',
338 `createServerFn({ method: 'GET' }).validator((d) => d).handler(() => denied())`,
339 true,
340 ],
341 ['client', `myServerFn.handler(() => denied())`, true],
342 ['client', `authMiddleware.server(() => denied())`, true],
343 ['client', `createIsomorphicFn().client(() => denied())`, false],
344 ['server', `createServerFn().handler(() => denied())`, false],
345] as const)('%s: %s is a safe boundary: %s', (env, expression, safe) => {
346 const code = `import { denied } from 'denied';\nexport const result = ${expression}`
347 expect(findOriginalUnsafeUsagePos(code, 'denied', env)).toEqual(
348 safe
349 ? undefined
350 : { line: 2, column0: code.split('\n')[1]!.indexOf('denied()') },
351 )
352})
353​
354test('repeated lookups on one transform result return the cached position', () => {
355 const code = `import { denied } from 'denied';\ndenied()`
356 const result = { code, map: undefined, originalCode: undefined }
357 const position = findOriginalUnsafeUsagePosFromResult(
358 result,
359 'denied',
360 'client',
361 )
362 expect(position).toEqual({ line: 2, column0: 0 })
363 expect(
364 findOriginalUnsafeUsagePosFromResult(result, 'denied', 'client'),
365 ).toEqual(position)
366})