cvx-kit 0.1.2 → 0.1.4

package/scripts/test-packed-ids.mjs

@@ -0,0 +1,149 @@
+import { execFileSync } from 'node:child_process'
+import { mkdtempSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+
+const root = join(import.meta.dirname, '..')
+const temporary = mkdtempSync(join(tmpdir(), 'cvx-kit-ids-'))
+const manifest = JSON.parse(readFileSync(join(root, 'package.json'), 'utf8'))
+function run(command, args, cwd) {
+	return execFileSync(command, args, {
+		cwd,
+		encoding: 'utf8',
+		stdio: 'pipe',
+	})
+}
+try {
+	run('bun', ['pm', 'pack', '--destination', temporary, '--ignore-scripts'], root)
+	for (const installer of ['npm', 'bun']) {
+		const fixture = join(temporary, installer)
+		mkdirSync(fixture)
+		writeFileSync(
+			join(fixture, 'package.json'),
+			JSON.stringify({
+				private: true,
+				type: 'module',
+				dependencies: {
+					'cvx-kit': `file:${join(temporary, `cvx-kit-${manifest.version}.tgz`)}`,
+					'convex-helpers': '0.1.123',
+					convex: manifest.devDependencies.convex,
+					zod: manifest.devDependencies.zod,
+				},
+				devDependencies: {
+					'convex-test': manifest.devDependencies['convex-test'],
+					'vite-plus': manifest.devDependencies['vite-plus'],
+					'@edge-runtime/vm': manifest.devDependencies['@edge-runtime/vm'],
+				},
+			}),
+		)
+		run(installer, ['install', '--ignore-scripts'], fixture)
+		writeFileSync(
+			join(fixture, 'probe.mjs'),
+			`
+import { strict as assert } from 'node:assert'
+import { tenantTable, zodToConvex as kitConverter, zid as kitId } from 'cvx-kit/zod-table'
+import { zid, zodToConvex } from 'convex-helpers/server/zod4'
+import { z } from 'zod'
+const table = tenantTable('children', id => ({
+ parentId: id('parents'), nested: z.object({ parentId: id('parents') }),
+}), { commandFields: ['parentId', 'nested'], publicFields: ['parentId', 'nested'] })
+for (const validator of [
+ zodToConvex(zid('parents')), table.table.validator.fields.parentId,
+ zodToConvex(table.storage).fields.parentId,
+ zodToConvex(table.commandInput).fields.parentId,
+ zodToConvex(table.publicDto).fields.parentId,
+ zodToConvex(table.storage).fields.nested.fields.parentId,
+ kitConverter(kitId('parents')),
+ kitConverter(table.commandInput).fields.nested.fields.parentId,
+ kitConverter(table.publicDto).fields.nested.fields.parentId,
+]) {
+ assert.equal(validator.kind, 'id', 'exported schema lost ID validation')
+ assert.equal(validator.tableName, 'parents')
+}
+`,
+		)
+		run('node', ['probe.mjs'], fixture)
+		for (const testFile of ['command.test.ts', 'command-lifecycle.test.ts']) {
+			const source = readFileSync(join(root, 'test', testFile), 'utf8')
+				.replace('../src/components/foundation/client', 'cvx-kit/components/foundation')
+				.replace(
+					"const modules = import.meta.glob('./fixture/**/*.ts')",
+					"const modules = { './_generated/server.ts': async () => ({}) }",
+				)
+			writeFileSync(join(fixture, testFile), source)
+		}
+		for (const testFile of ['zod-table.test.ts', 'agent-tools.test.ts']) {
+			const source = readFileSync(join(root, 'test', testFile), 'utf8')
+				.replaceAll('../src/zod-table', 'cvx-kit/zod-table')
+				.replaceAll('../src/agent-tools', 'cvx-kit/agent-tools')
+			writeFileSync(join(fixture, testFile), source)
+		}
+		writeFileSync(
+			join(fixture, 'command-types.ts'),
+			readFileSync(join(root, 'test/command-types.ts'), 'utf8').replace(
+				'../src/components/foundation/client',
+				'cvx-kit/components/foundation',
+			),
+		)
+		writeFileSync(
+			join(fixture, 'registration.test.ts'),
+			`
+import { convexTest } from 'convex-test'
+import { defineSchema, defineTable } from 'convex/server'
+import { v } from 'convex/values'
+import { registerFoundation, registerApprovals } from 'cvx-kit/test'
+import { it } from 'vite-plus/test'
+it('registers concrete and generic backends from the packed package', () => {
+ const modules = { './_generated/server.ts': async () => ({}) }
+ const concrete = convexTest(defineSchema({ items: defineTable({ name: v.string() }) }), modules)
+ const generic = convexTest(undefined, modules)
+ for (const backend of [concrete, generic]) {
+  registerFoundation(backend)
+  registerApprovals(backend)
+  registerFoundation(backend, 'customFoundation')
+  registerApprovals(backend, 'customApprovals')
+ }
+})
+`,
+		)
+		run(
+			join(root, 'node_modules/.bin/tsc'),
+			[
+				'--noEmit',
+				'--strict',
+				'--skipLibCheck',
+				'--target',
+				'es2025',
+				'--module',
+				'esnext',
+				'--moduleResolution',
+				'bundler',
+				'--types',
+				'vite/client',
+				'command-types.ts',
+				'registration.test.ts',
+				'zod-table.test.ts',
+				'agent-tools.test.ts',
+			],
+			fixture,
+		)
+		run(
+			join(fixture, 'node_modules/.bin/vp'),
+			[
+				'test',
+				'run',
+				'registration.test.ts',
+				'command.test.ts',
+				'command-lifecycle.test.ts',
+				'zod-table.test.ts',
+				'agent-tools.test.ts',
+			],
+			fixture,
+		)
+		console.log(
+			`${installer}: packed IDs, table/tool types, registration, and command lifecycle pass with host convex-helpers 0.1.123`,
+		)
+	}
+} finally {
+	rmSync(temporary, { recursive: true, force: true })
+}

package/scripts/test-packed-oxlint.mjs

@@ -0,0 +1,121 @@
+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, 6)
+
+try {
+	run('bun', ['pm', 'pack', '--destination', temporary, '--ignore-scripts'], root)
+	for (const installer of ['npm', 'bun']) {
+		const fixture = join(temporary, installer)
+		mkdirSync(join(fixture, 'src/components/example'), { 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'])),
+					'cvx/no-internal-reexports': ['error', { entryPoints: ['src/public.ts'] }],
+				},
+			}),
+		)
+		writeFileSync(
+			join(fixture, 'src/public.ts'),
+			"export { run } from './components/example/client'\n",
+		)
+		writeFileSync(
+			join(fixture, 'src/components/example/client.ts'),
+			'export function run() { return 1 }\n',
+		)
+		const oxlint = join(fixture, 'node_modules/.bin/oxlint')
+		run(oxlint, ['--config', '.oxlintrc.json', 'src'], fixture)
+		writeFileSync(
+			join(fixture, 'src/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, 'src/host.ts'),
+			"export const host = 1\nimport './components/example/bad'\n",
+		)
+		const invalid = spawnSync(oxlint, ['--config', '.oxlintrc.json', '--format', 'json', 'src'], {
+			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 six 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,29 +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: unknown,
-		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)
 }