cvx-kit 0.1.3 → 0.1.5

package/scripts/test-packed-oxlint.mjs

@@ -0,0 +1,141 @@
+import { strict as assert } from 'node:assert'
+import { execFileSync, spawnSync } from 'node:child_process'
+import { mkdtempSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { rules } from '../dist/oxlint.mjs'
+
+const root = join(import.meta.dirname, '..')
+const temporary = mkdtempSync(join(tmpdir(), 'cvx-kit-oxlint-'))
+const manifest = JSON.parse(readFileSync(join(root, 'package.json'), 'utf8'))
+const ruleNames = Object.keys(rules)
+assert.equal(ruleNames.length, 15)
+
+try {
+	run('bun', ['pm', 'pack', '--destination', temporary, '--ignore-scripts'], root)
+	for (const installer of ['npm', 'bun']) {
+		const fixture = join(temporary, installer)
+		mkdirSync(join(fixture, 'convex/components/example'), { recursive: true })
+		mkdirSync(join(fixture, 'convex/api'), { recursive: true })
+		mkdirSync(join(fixture, 'convex/domain/orders'), { recursive: true })
+		writeFileSync(
+			join(fixture, 'package.json'),
+			JSON.stringify({
+				private: true,
+				type: 'module',
+				dependencies: {
+					'cvx-kit': `file:${join(temporary, `cvx-kit-${manifest.version}.tgz`)}`,
+					convex: manifest.devDependencies.convex,
+					'convex-helpers': manifest.devDependencies['convex-helpers'],
+					zod: manifest.devDependencies.zod,
+				},
+				devDependencies: { oxlint: manifest.devDependencies.oxlint },
+			}),
+		)
+		run(installer, ['install', '--ignore-scripts'], fixture)
+		writeFileSync(
+			join(fixture, '.oxlintrc.json'),
+			JSON.stringify({
+				jsPlugins: [{ name: 'cvx', specifier: 'cvx-kit/oxlint' }],
+				rules: Object.fromEntries(ruleNames.map((name) => [`cvx/${name}`, 'error'])),
+			}),
+		)
+		writeFileSync(
+			join(fixture, 'convex/api/orders.ts'),
+			"import { authMutation } from '../functions'; import { executeSaveOrder } from '../domain/orders/commands'; export const save = authMutation({ handler: (ctx, args) => executeSaveOrder(ctx, args) })\n",
+		)
+		writeFileSync(
+			join(fixture, 'convex/components/example/client.ts'),
+			'export function run() { return 1 }\n',
+		)
+		const oxlint = join(fixture, 'node_modules/.bin/oxlint')
+		run(oxlint, ['--config', '.oxlintrc.json', 'convex'], fixture)
+		writeFileSync(
+			join(fixture, 'convex/components/example/bad.ts'),
+			`
+import { defineTable } from 'convex/server'
+import { host } from '../../host'
+function helper() { return process.env.SECRET }
+const privateHelper = () => helper()
+export const table = defineTable({})
+export { host }
+export const value = privateHelper()
+`,
+		)
+		writeFileSync(
+			join(fixture, 'convex/host.ts'),
+			"import { authMutation } from './functions'; export const save = authMutation({}); export const host = 1; import './components/example/bad'\n",
+		)
+		writeFileSync(
+			join(fixture, 'convex/api/orders.ts'),
+			`import { mutation } from '../_generated/server'
+import { makeFunctionReference as ref } from 'convex/server'
+import { z } from 'zod'
+import { createAuthFunctions } from 'cvx-kit/auth'
+import { other } from '../domain/users/commands'
+export const save = mutation({ handler: async (ctx) => {
+  await ctx.db.insert('orders', { updatedAt: Date.now() })
+  return ctx.db.query('orders').collect()
+}})
+export const constructors = createAuthFunctions({})
+export const state = z.enum(['draft'])
+export const target = ref('orders:save')
+export const value = other
+`,
+		)
+		const invalid = spawnSync(
+			oxlint,
+			['--config', '.oxlintrc.json', '--format', 'json', 'convex'],
+			{
+				cwd: fixture,
+				encoding: 'utf8',
+			},
+		)
+		assert.ifError(invalid.error)
+		assert.equal(invalid.status, 1, invalid.stderr)
+		const diagnostics = JSON.parse(invalid.stdout).diagnostics
+		for (const name of ruleNames) {
+			assert.ok(
+				diagnostics.some((item) => item.code === `cvx(${name})`),
+				`${installer}: missing ${name}: ${invalid.stdout}`,
+			)
+		}
+		writeFileSync(
+			join(fixture, 'plugin-types.ts'),
+			`
+import plugin, { rules, type RuleName } from 'cvx-kit/oxlint'
+import type { Plugin, Rule } from '@oxlint/plugins'
+const compatible: Plugin = plugin
+const name: RuleName = 'component-boundaries'
+const rule: Rule = rules[name]
+void compatible
+void rule
+`,
+		)
+		run(
+			join(root, 'node_modules/.bin/tsc'),
+			[
+				'--noEmit',
+				'--strict',
+				'--skipLibCheck',
+				'--target',
+				'es2025',
+				'--module',
+				'esnext',
+				'--moduleResolution',
+				'bundler',
+				'plugin-types.ts',
+			],
+			fixture,
+		)
+		console.log(
+			`${installer}: packed Oxlint plugin loads, all consumer rules report, and declarations typecheck`,
+		)
+	}
+} finally {
+	rmSync(temporary, { recursive: true, force: true })
+}
+
+function run(command, args, cwd) {
+	return execFileSync(command, args, { cwd, encoding: 'utf8', stdio: 'pipe' })
+}

package/src/test.ts

@@ -6,30 +6,21 @@
  * registers the COMPILED component modules from dist, so dist is the only
  * code the package ships.
  */
+import type { TestConvex } from 'convex-test'
 import type { GenericSchema, SchemaDefinition } from 'convex/server'
 import approvalsSchema from '../dist/components/approvals/schema.js'
 import foundationSchema from '../dist/components/foundation/schema.js'
 
-const foundationModules = import.meta.glob(
-	'../dist/components/foundation/**/*.mjs',
-)
-const approvalsModules = import.meta.glob(
-	'../dist/components/approvals/**/*.mjs',
-)
+const foundationModules = import.meta.glob('../dist/components/foundation/**/*.mjs')
+const approvalsModules = import.meta.glob('../dist/components/approvals/**/*.mjs')
 
-type RegistersComponents = {
-	registerComponent: (
-		name: string,
-		schema: SchemaDefinition<GenericSchema, boolean>,
-		modules: Record<string, () => Promise<unknown>>,
-	) => void
-}
+type RegistersComponents = Pick<
+	TestConvex<SchemaDefinition<GenericSchema, boolean>>,
+	'registerComponent'
+>
 
 /** Registers the foundation component under its default install name. */
-export function registerFoundation(
-	t: RegistersComponents,
-	name = 'foundation',
-) {
+export function registerFoundation(t: RegistersComponents, name = 'foundation') {
 	t.registerComponent(name, foundationSchema, foundationModules)
 }