mikoshi-construct 0.1.3 → 0.3.0

package/templates/presets/monorepo/sample/scripts/tests/lint/syntax-policy.test.ts.eta

@@ -2,35 +2,109 @@ import { ESLint } from 'eslint'
 import { describe, expect, it } from 'vitest'
 import { REPO_ROOT } from '../../composition/files.js'
 
-const PROCESS = 'MemberExpression[object.name="process"]'
-const PROCESS_ENV = 'MemberExpression[object.name="process"][property.name="env"]'
-const RAW_REQUEST_DATA = 'MemberExpression[object.name="req"][property.name=/^(body|query|params)$/]'
-const RAW_SQL = 'CallExpression[callee.object.name="sql"][callee.property.name="raw"]'
-const SHARED_IMPORT = ':matches(ImportDeclaration, ExportNamedDeclaration, ExportAllDeclaration)[source.value=/^{{scope}}\\/shared(\\/|$)/]'
-
-const eslint = new ESLint({ cwd: REPO_ROOT })
-
-async function restrictedSelectors(file: string): Promise<string[]> {
-  const config = await eslint.calculateConfigForFile(file)
-  const [, ...restrictions] = config.rules['no-restricted-syntax'] as [unknown, ...Array<{ selector: string }>]
-  return restrictions.map(restriction => restriction.selector).sort()
-}
+const SAMPLES = {
+  plainModule: 'export function label(name: string): string {\n  return name.trim()\n}\n',
+  processMember: 'export const level = process.env.LOG_LEVEL\n',
+  processDestructured: 'const { env } = process\n\nexport const level = env.LOG_LEVEL\n',
+  processViaGlobalThis: 'export const level = globalThis.process.env.LOG_LEVEL\n',
+  processAliased: 'const runtime = process\n\nexport const level = runtime.env.LOG_LEVEL\n',
+  processArgv: 'export const args = process.argv.slice(2)\n',
+  rawRequestMember: 'export function name(req: { body: { name: string } }): string {\n  return req.body.name\n}\n',
+  rawRequestDestructured: 'export function name(req: { body: { name: string } }): string {\n  const { body } = req\n  return body.name\n}\n',
+  rawRequestAliased: 'export function name(req: { body: { name: string } }): string {\n  const request = req\n  return request.body.name\n}\n',
+  rawSqlCall: 'export const rows = sql.raw(\'select 1\')\n',
+  rawSqlTagged: 'export const rows = sql.raw`select 1`\n',
+  rawSqlComputed: 'export const rows = sql[\'raw\'](\'select 1\')\n',
+  sharedStaticImport: 'import type { components } from \'{{scope}}/shared\'\n\nexport type Contract = components\n',
+  sharedDynamicImport: 'export async function load(): Promise<unknown> {\n  return import(\'{{scope}}/shared\')\n}\n',
+  sharedRequire: 'export const shared: unknown = require(\'{{scope}}/shared\')\n',
+} as const
+
+type SampleName = keyof typeof SAMPLES
+
+const PROCESS_FORMS: SampleName[] = ['processMember', 'processDestructured', 'processViaGlobalThis', 'processAliased', 'processArgv']
+const PROCESS_ENV_FORMS: SampleName[] = ['processMember', 'processDestructured', 'processViaGlobalThis']
+const RAW_REQUEST_FORMS: SampleName[] = ['rawRequestMember', 'rawRequestDestructured', 'rawRequestAliased']
+const RAW_SQL_FORMS: SampleName[] = ['rawSqlCall', 'rawSqlTagged', 'rawSqlComputed']
+const SHARED_FORMS: SampleName[] = ['sharedStaticImport', 'sharedDynamicImport', 'sharedRequire']
 
-const ROLES: Array<{ role: string, file: string, selectors: string[] }> = [
-  { role: 'a service', file: 'apps/api/src/things/things.service.ts', selectors: [PROCESS, RAW_REQUEST_DATA, RAW_SQL, SHARED_IMPORT] },
-  { role: 'a controller', file: 'apps/api/src/things/things.controller.ts', selectors: [PROCESS, RAW_SQL, SHARED_IMPORT] },
-  { role: 'a middleware', file: 'apps/api/src/http/error-handler.middleware.ts', selectors: [PROCESS, RAW_SQL, SHARED_IMPORT] },
-  { role: 'the contract types gateway', file: 'apps/api/src/contracts/types.ts', selectors: [PROCESS, RAW_REQUEST_DATA, RAW_SQL] },
-  { role: 'the app config', file: 'apps/api/src/config.ts', selectors: [RAW_SQL, SHARED_IMPORT] },
-  { role: 'the process entry', file: 'apps/api/src/server.ts', selectors: [RAW_SQL, SHARED_IMPORT] },
-  { role: 'a package module', file: 'packages/shared/src/index.ts', selectors: [PROCESS_ENV, RAW_SQL] },
-  { role: 'a package config', file: 'packages/shared/src/shared.config.ts', selectors: [RAW_SQL] },
+const ROLES: Array<{ role: string, file: string, reported: SampleName[], exempt: SampleName[] }> = [
+  {
+    role: 'a service',
+    file: 'apps/api/src/things/things.service.ts',
+    reported: [...RAW_SQL_FORMS, ...PROCESS_FORMS, ...RAW_REQUEST_FORMS, ...SHARED_FORMS],
+    exempt: [],
+  },
+  {
+    role: 'a controller',
+    file: 'apps/api/src/things/things.controller.ts',
+    reported: [...RAW_SQL_FORMS, ...PROCESS_FORMS, ...SHARED_FORMS],
+    exempt: RAW_REQUEST_FORMS,
+  },
+  {
+    role: 'a middleware',
+    file: 'apps/api/src/http/error-handler.middleware.ts',
+    reported: [...RAW_SQL_FORMS, ...PROCESS_FORMS, ...SHARED_FORMS],
+    exempt: RAW_REQUEST_FORMS,
+  },
+  {
+    role: 'the contract types gateway',
+    file: 'apps/api/src/contracts/types.ts',
+    reported: [...RAW_SQL_FORMS, ...PROCESS_FORMS, ...RAW_REQUEST_FORMS],
+    exempt: SHARED_FORMS,
+  },
+  {
+    role: 'the app config',
+    file: 'apps/api/src/config.ts',
+    reported: [...RAW_SQL_FORMS, ...SHARED_FORMS],
+    exempt: [...PROCESS_FORMS, ...RAW_REQUEST_FORMS],
+  },
+  {
+    role: 'the process entry',
+    file: 'apps/api/src/server.ts',
+    reported: [...RAW_SQL_FORMS, ...SHARED_FORMS],
+    exempt: [...PROCESS_FORMS, ...RAW_REQUEST_FORMS],
+  },
+  {
+    role: 'a package module',
+    file: 'packages/shared/src/index.ts',
+    reported: [...RAW_SQL_FORMS, ...PROCESS_ENV_FORMS],
+    exempt: ['processArgv', ...RAW_REQUEST_FORMS, ...SHARED_FORMS],
+  },
+  {
+    role: 'a package config',
+    file: 'packages/shared/src/shared.config.ts',
+    reported: RAW_SQL_FORMS,
+    exempt: [...PROCESS_FORMS, ...RAW_REQUEST_FORMS, ...SHARED_FORMS],
+  },
 ]
 
+const eslint = new ESLint({
+  cwd: REPO_ROOT,
+  ruleFilter: ({ ruleId }) => ruleId === 'no-restricted-syntax',
+  overrideConfig: { languageOptions: { parserOptions: { projectService: false } } },
+})
+
+async function restrictionReports(file: string, sample: SampleName): Promise<string[]> {
+  const [result] = await eslint.lintText(SAMPLES[sample], { filePath: file })
+  const fatal = result.messages.find(message => message.fatal)
+  if (fatal)
+    throw new Error(`${file} (${sample}): ${fatal.message}`)
+  return result.messages
+    .filter(message => message.ruleId === 'no-restricted-syntax')
+    .map(message => message.message)
+}
+
 describe('syntax policy by file role', () => {
-  for (const { role, file, selectors } of ROLES) {
-    it(`keeps every restriction that applies to ${role}`, async () => {
-      expect(await restrictedSelectors(file)).toEqual([...selectors].sort())
+  for (const { role, file, reported, exempt } of ROLES) {
+    it(`reports every restricted form in ${role}`, async () => {
+      for (const sample of reported)
+        expect(await restrictionReports(file, sample), sample).not.toEqual([])
+    })
+
+    it(`reports nothing ${role} may legitimately write`, async () => {
+      for (const sample of ['plainModule' as SampleName, ...exempt])
+        expect(await restrictionReports(file, sample), sample).toEqual([])
     })
   }
 })

package/templates/presets/node-backend/baseline/eslint.config.mjs

@@ -1,11 +1,19 @@
 import antfu from '@antfu/eslint-config'
 
 const PROCESS_MEMBER = 'MemberExpression[object.name="process"]'
-const RAW_REQUEST_DATA = 'MemberExpression[object.name="req"][property.name=/^(body|query|params)$/]'
-const RAW_SQL = 'CallExpression[callee.object.name="sql"][callee.property.name="raw"]'
+const PROCESS_VIA_GLOBAL_THIS = 'MemberExpression[object.name="globalThis"]:matches([property.name="process"], [property.value="process"])'
+const PROCESS_BINDING = 'VariableDeclarator[init.name="process"]'
+const PROCESS = `:matches(${PROCESS_MEMBER}, ${PROCESS_VIA_GLOBAL_THIS}, ${PROCESS_BINDING})`
+
+const RAW_REQUEST_MEMBER = 'MemberExpression[object.name="req"][property.name=/^(body|query|params)$/]'
+const RAW_REQUEST_DESTRUCTURED = 'VariableDeclarator[init.name="req"] > ObjectPattern > Property[key.name=/^(body|query|params)$/]'
+const RAW_REQUEST_ALIASED = 'VariableDeclarator[id.type="Identifier"][init.name="req"]'
+const RAW_REQUEST_DATA = `:matches(${RAW_REQUEST_MEMBER}, ${RAW_REQUEST_DESTRUCTURED}, ${RAW_REQUEST_ALIASED})`
+
+const RAW_SQL = 'MemberExpression[object.name="sql"]:matches([property.name="raw"], [property.value="raw"])'
 
 const NO_PROCESS_OUTSIDE_CONFIG = {
-  selector: PROCESS_MEMBER,
+  selector: PROCESS,
   message: 'src touches process only in config.ts: read configuration through readConfig() and pass the value on',
 }
 const NO_RAW_REQUEST_DATA = {

package/templates/presets/node-backend/sample/scripts/tests/lint/syntax-policy.test.ts

@@ -2,30 +2,85 @@ import { ESLint } from 'eslint'
 import { describe, expect, it } from 'vitest'
 import { REPO_ROOT } from '../../composition/files.js'
 
-const PROCESS = 'MemberExpression[object.name="process"]'
-const RAW_REQUEST_DATA = 'MemberExpression[object.name="req"][property.name=/^(body|query|params)$/]'
-const RAW_SQL = 'CallExpression[callee.object.name="sql"][callee.property.name="raw"]'
+const SAMPLES = {
+  plainModule: 'export function label(name: string): string {\n  return name.trim()\n}\n',
+  processMember: 'export const level = process.env.LOG_LEVEL\n',
+  processDestructured: 'const { env } = process\n\nexport const level = env.LOG_LEVEL\n',
+  processViaGlobalThis: 'export const level = globalThis.process.env.LOG_LEVEL\n',
+  processAliased: 'const runtime = process\n\nexport const level = runtime.env.LOG_LEVEL\n',
+  rawRequestMember: 'export function name(req: { body: { name: string } }): string {\n  return req.body.name\n}\n',
+  rawRequestDestructured: 'export function name(req: { body: { name: string } }): string {\n  const { body } = req\n  return body.name\n}\n',
+  rawRequestAliased: 'export function name(req: { body: { name: string } }): string {\n  const request = req\n  return request.body.name\n}\n',
+  rawSqlCall: 'export const rows = sql.raw(\'select 1\')\n',
+  rawSqlTagged: 'export const rows = sql.raw`select 1`\n',
+  rawSqlComputed: 'export const rows = sql[\'raw\'](\'select 1\')\n',
+} as const
 
-const eslint = new ESLint({ cwd: REPO_ROOT })
+type SampleName = keyof typeof SAMPLES
 
-async function restrictedSelectors(file: string): Promise<string[]> {
-  const config = await eslint.calculateConfigForFile(file)
-  const [, ...restrictions] = config.rules['no-restricted-syntax'] as [unknown, ...Array<{ selector: string }>]
-  return restrictions.map(restriction => restriction.selector).sort()
-}
+const PROCESS_FORMS: SampleName[] = ['processMember', 'processDestructured', 'processViaGlobalThis', 'processAliased']
+const RAW_REQUEST_FORMS: SampleName[] = ['rawRequestMember', 'rawRequestDestructured', 'rawRequestAliased']
+const RAW_SQL_FORMS: SampleName[] = ['rawSqlCall', 'rawSqlTagged', 'rawSqlComputed']
 
-const ROLES: Array<{ role: string, file: string, selectors: string[] }> = [
-  { role: 'a service', file: 'src/things/things.service.ts', selectors: [PROCESS, RAW_REQUEST_DATA, RAW_SQL] },
-  { role: 'a controller', file: 'src/things/things.controller.ts', selectors: [PROCESS, RAW_SQL] },
-  { role: 'a middleware', file: 'src/http/error-handler.middleware.ts', selectors: [PROCESS, RAW_SQL] },
-  { role: 'the app config', file: 'src/config.ts', selectors: [RAW_SQL] },
-  { role: 'the process entry', file: 'src/server.ts', selectors: [RAW_SQL] },
+const ROLES: Array<{ role: string, file: string, reported: SampleName[], exempt: SampleName[] }> = [
+  {
+    role: 'a service',
+    file: 'src/things/things.service.ts',
+    reported: [...RAW_SQL_FORMS, ...PROCESS_FORMS, ...RAW_REQUEST_FORMS],
+    exempt: [],
+  },
+  {
+    role: 'a controller',
+    file: 'src/things/things.controller.ts',
+    reported: [...RAW_SQL_FORMS, ...PROCESS_FORMS],
+    exempt: RAW_REQUEST_FORMS,
+  },
+  {
+    role: 'a middleware',
+    file: 'src/http/error-handler.middleware.ts',
+    reported: [...RAW_SQL_FORMS, ...PROCESS_FORMS],
+    exempt: RAW_REQUEST_FORMS,
+  },
+  {
+    role: 'the app config',
+    file: 'src/config.ts',
+    reported: RAW_SQL_FORMS,
+    exempt: [...PROCESS_FORMS, ...RAW_REQUEST_FORMS],
+  },
+  {
+    role: 'the process entry',
+    file: 'src/server.ts',
+    reported: RAW_SQL_FORMS,
+    exempt: [...PROCESS_FORMS, ...RAW_REQUEST_FORMS],
+  },
 ]
 
+const eslint = new ESLint({
+  cwd: REPO_ROOT,
+  ruleFilter: ({ ruleId }) => ruleId === 'no-restricted-syntax',
+  overrideConfig: { languageOptions: { parserOptions: { projectService: false } } },
+})
+
+async function restrictionReports(file: string, sample: SampleName): Promise<string[]> {
+  const [result] = await eslint.lintText(SAMPLES[sample], { filePath: file })
+  const fatal = result.messages.find(message => message.fatal)
+  if (fatal)
+    throw new Error(`${file} (${sample}): ${fatal.message}`)
+  return result.messages
+    .filter(message => message.ruleId === 'no-restricted-syntax')
+    .map(message => message.message)
+}
+
 describe('syntax policy by file role', () => {
-  for (const { role, file, selectors } of ROLES) {
-    it(`keeps every restriction that applies to ${role}`, async () => {
-      expect(await restrictedSelectors(file)).toEqual([...selectors].sort())
+  for (const { role, file, reported, exempt } of ROLES) {
+    it(`reports every restricted form in ${role}`, async () => {
+      for (const sample of reported)
+        expect(await restrictionReports(file, sample), sample).not.toEqual([])
+    })
+
+    it(`reports nothing ${role} may legitimately write`, async () => {
+      for (const sample of ['plainModule' as SampleName, ...exempt])
+        expect(await restrictionReports(file, sample), sample).toEqual([])
     })
   }
 })

package/templates/presets/node-frontend/baseline/eslint.config.mjs

@@ -1,8 +1,17 @@
 import antfu from '@antfu/eslint-config'
 
-const CLASS_LIST_MUTATION = 'CallExpression[callee.object.property.name="classList"][callee.property.name=/^(add|remove|toggle|replace)$/]'
-const INLINE_STYLE_WRITE = 'AssignmentExpression[left.object.property.name="style"]'
-const INLINE_STYLE_PROPERTY = 'CallExpression[callee.object.property.name="style"][callee.property.name=/^(setProperty|removeProperty)$/]'
+const CLASS_LIST_ACCESS = ':matches([callee.object.property.name="classList"], [callee.object.property.value="classList"])'
+const CLASS_LIST_METHOD = ':matches([callee.property.name=/^(add|remove|toggle|replace)$/], [callee.property.value=/^(add|remove|toggle|replace)$/])'
+const CLASS_LIST_CALL = `CallExpression${CLASS_LIST_ACCESS}${CLASS_LIST_METHOD}`
+const CLASS_LIST_BINDING = 'VariableDeclarator:matches([init.property.name="classList"], [init.property.value="classList"])'
+const CLASS_LIST_MUTATION = `:matches(${CLASS_LIST_CALL}, ${CLASS_LIST_BINDING})`
+
+const STYLE_ACCESS = ':matches([left.object.property.name="style"], [left.object.property.value="style"])'
+const INLINE_STYLE_WRITE = `AssignmentExpression${STYLE_ACCESS}`
+const STYLE_METHOD = ':matches([callee.property.name=/^(setProperty|removeProperty)$/], [callee.property.value=/^(setProperty|removeProperty)$/])'
+const INLINE_STYLE_CALL = `CallExpression:matches([callee.object.property.name="style"], [callee.object.property.value="style"])${STYLE_METHOD}`
+const STYLE_BINDING = 'VariableDeclarator:matches([init.property.name="style"], [init.property.value="style"])'
+const INLINE_STYLE_PROPERTY = `:matches(${INLINE_STYLE_CALL}, ${STYLE_BINDING})`
 
 const NO_STATE_CLASSES = {
   selector: CLASS_LIST_MUTATION,

package/templates/presets/node-frontend/sample/scripts/tests/lint/syntax-policy.test.ts

@@ -0,0 +1,78 @@
+import { ESLint } from 'eslint'
+import { describe, expect, it } from 'vitest'
+import { REPO_ROOT } from '../../composition/files.js'
+
+const SAMPLES = {
+  plainModule: 'export function open(element: HTMLElement): void {\n  element.dataset.state = \'open\'\n}\n',
+  classListCall: 'export function open(element: HTMLElement): void {\n  element.classList.add(\'is-open\')\n}\n',
+  classListComputed: 'export function open(element: HTMLElement): void {\n  element.classList[\'add\'](\'is-open\')\n}\n',
+  classListOnComputedElement: 'export function open(element: HTMLElement): void {\n  element[\'classList\'].add(\'is-open\')\n}\n',
+  classListBound: 'export function open(element: HTMLElement): void {\n  const classes = element.classList\n  classes.add(\'is-open\')\n}\n',
+  inlineStyleWrite: 'export function open(element: HTMLElement): void {\n  element.style.display = \'block\'\n}\n',
+  inlineStyleWriteComputed: 'export function open(element: HTMLElement): void {\n  element[\'style\'].display = \'block\'\n}\n',
+  inlineStyleProperty: 'export function open(element: HTMLElement): void {\n  element.style.setProperty(\'--open\', \'1\')\n}\n',
+  inlineStylePropertyComputed: 'export function open(element: HTMLElement): void {\n  element.style[\'setProperty\'](\'--open\', \'1\')\n}\n',
+  inlineStyleBound: 'export function open(element: HTMLElement): void {\n  const style = element.style\n  style.display = \'block\'\n}\n',
+} as const
+
+type SampleName = keyof typeof SAMPLES
+
+const CLASS_LIST_FORMS: SampleName[] = ['classListCall', 'classListComputed', 'classListOnComputedElement', 'classListBound']
+const INLINE_STYLE_FORMS: SampleName[] = ['inlineStyleWrite', 'inlineStyleWriteComputed', 'inlineStyleProperty', 'inlineStylePropertyComputed', 'inlineStyleBound']
+
+const ROLES: Array<{ role: string, file: string, reported: SampleName[], exempt: SampleName[] }> = [
+  {
+    role: 'an application module',
+    file: 'src/app.ts',
+    reported: [...CLASS_LIST_FORMS, ...INLINE_STYLE_FORMS],
+    exempt: [],
+  },
+  {
+    role: 'the entry point',
+    file: 'src/main.ts',
+    reported: [...CLASS_LIST_FORMS, ...INLINE_STYLE_FORMS],
+    exempt: [],
+  },
+  {
+    role: 'a test',
+    file: 'tests/app.test.ts',
+    reported: [],
+    exempt: [...CLASS_LIST_FORMS, ...INLINE_STYLE_FORMS],
+  },
+  {
+    role: 'a repository script',
+    file: 'scripts/composition/check.ts',
+    reported: [],
+    exempt: [...CLASS_LIST_FORMS, ...INLINE_STYLE_FORMS],
+  },
+]
+
+const eslint = new ESLint({
+  cwd: REPO_ROOT,
+  ruleFilter: ({ ruleId }) => ruleId === 'no-restricted-syntax',
+  overrideConfig: { languageOptions: { parserOptions: { projectService: false } } },
+})
+
+async function restrictionReports(file: string, sample: SampleName): Promise<string[]> {
+  const [result] = await eslint.lintText(SAMPLES[sample], { filePath: file })
+  const fatal = result.messages.find(message => message.fatal)
+  if (fatal)
+    throw new Error(`${file} (${sample}): ${fatal.message}`)
+  return result.messages
+    .filter(message => message.ruleId === 'no-restricted-syntax')
+    .map(message => message.message)
+}
+
+describe('styling policy by file role', () => {
+  for (const { role, file, reported, exempt } of ROLES) {
+    it(`reports every restricted form in ${role}`, async () => {
+      for (const sample of reported)
+        expect(await restrictionReports(file, sample), sample).not.toEqual([])
+    })
+
+    it(`reports nothing ${role} may legitimately write`, async () => {
+      for (const sample of ['plainModule' as SampleName, ...exempt])
+        expect(await restrictionReports(file, sample), sample).toEqual([])
+    })
+  }
+})