cvx-kit 0.1.0 → 0.1.2

package/scripts/smoke-packed-components.mjs

@@ -0,0 +1,374 @@
+import { execFileSync } from 'node:child_process'
+import {
+	copyFileSync,
+	mkdirSync,
+	mkdtempSync,
+	readFileSync,
+	rmSync,
+	writeFileSync,
+} from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+
+const installer = process.argv[2] ?? 'bun'
+if (installer !== 'bun' && installer !== 'npm') {
+	throw new Error('Usage: smoke-packed-components.mjs [bun|npm]')
+}
+
+const root = join(import.meta.dirname, '..')
+const temporaryRoot = mkdtempSync(join(tmpdir(), 'cvx-kit-smoke-'))
+const fixture = join(temporaryRoot, 'fixture')
+const packageVersion = JSON.parse(
+	readFileSync(join(root, 'package.json'), 'utf8'),
+).version
+const tarball = join(temporaryRoot, `cvx-kit-${packageVersion}.tgz`)
+
+function run(command, args, cwd = fixture) {
+	return execFileSync(command, args, {
+		cwd,
+		encoding: 'utf8',
+		stdio: ['ignore', 'pipe', 'pipe'],
+		env: { ...process.env, CONVEX_AGENT_MODE: 'anonymous' },
+	})
+}
+
+function runStreaming(command, args, cwd = fixture) {
+	execFileSync(command, args, {
+		cwd,
+		stdio: 'inherit',
+		env: { ...process.env, CONVEX_AGENT_MODE: 'anonymous' },
+	})
+}
+
+function runConvex(...args) {
+	return run('node', [
+		join(fixture, 'node_modules', 'convex', 'bin', 'main.js'),
+		...args,
+	])
+}
+
+function write(relativePath, contents) {
+	const path = join(fixture, relativePath)
+	writeFileSync(path, contents)
+}
+
+function step(label, callback) {
+	console.log(`smoke step: ${label}`)
+	return callback()
+}
+
+try {
+	run(
+		'bun',
+		['pm', 'pack', '--destination', temporaryRoot, '--ignore-scripts'],
+		root,
+	)
+	mkdirSync(join(fixture, 'convex'), { recursive: true })
+	write(
+		'package.json',
+		JSON.stringify(
+			{
+				private: true,
+				type: 'module',
+				dependencies: {
+					'cvx-kit': `file:${tarball}`,
+					convex: '1.43.0',
+					zod: '4.4.3',
+				},
+				devDependencies: {
+					'vite-plus': '0.2.8',
+				},
+			},
+			null,
+			2,
+		),
+	)
+	write(
+		'packed-test-helper.test.ts',
+		`import { describe, expect, it } from 'vite-plus/test'
+import { registerApprovals, registerFoundation } from 'cvx-kit/test'
+
+describe('packed cvx-kit test helpers', () => {
+  it('registers both compiled component bundles and their discoverable schemas', () => {
+    const registrations = []
+    const testRuntime = {
+      registerComponent(name, schema, modules) {
+        registrations.push({ name, schema, modules })
+      },
+    }
+
+    registerApprovals(testRuntime)
+    registerFoundation(testRuntime)
+
+    expect(registrations.map(({ name }) => name)).toEqual(['approvals', 'foundation'])
+    expect(Object.keys(registrations[0].schema.tables).sort()).toEqual([
+      'approvalDecisions',
+      'approvalRuns',
+    ])
+    expect(Object.keys(registrations[0].modules)).toContain(
+      '../dist/components/approvals/health.mjs',
+    )
+  })
+})
+`,
+	)
+	write(
+		'convex/convex.config.ts',
+		`import { defineApp } from 'convex/server'
+import approvals from 'cvx-kit/components/approvals/convex.config'
+import foundation from 'cvx-kit/components/foundation/convex.config'
+
+const app = defineApp()
+app.use(approvals)
+app.use(foundation)
+export default app
+`,
+	)
+	write(
+		'convex/smoke.ts',
+		`import { approvalCallbackArgs } from 'cvx-kit/components/approvals'
+import { createFunctionHandle, paginationOptsValidator } from 'convex/server'
+import { v } from 'convex/values'
+import { components, internal } from './_generated/api'
+import { internalMutation, mutation, query } from './_generated/server'
+
+export const applyDecision = internalMutation({
+  args: approvalCallbackArgs,
+  returns: v.null(),
+  handler: (_ctx, input) => {
+    if (input.decision?.evidence[0]?.stepKey !== 'releaseDecision') {
+      throw new Error('Missing callback decision step key')
+    }
+    return null
+  },
+})
+
+export const rejectDecision = internalMutation({
+  args: approvalCallbackArgs,
+  returns: v.null(),
+  handler: () => null,
+})
+
+export const health = query({
+  args: {},
+  returns: v.any(),
+  handler: (ctx) => ctx.runQuery(components.approvals.health.check, {}),
+})
+
+export const foundationHealth = query({
+  args: {},
+  returns: v.literal('ready'),
+  handler: (ctx) => ctx.runQuery(components.foundation.functions.status, {}),
+})
+
+export const start = mutation({
+  args: { resourceRef: v.optional(v.string()) },
+  returns: v.object({ runId: v.string() }),
+  handler: async (ctx, args) => {
+    const approvedHandle = await createFunctionHandle(internal.smoke.applyDecision)
+    const rejectedHandle = await createFunctionHandle(internal.smoke.rejectDecision)
+    return ctx.runMutation(components.approvals.requests.start, {
+      scopeRef: 'smoke',
+      resourceType: 'release',
+      resourceRef: args.resourceRef ?? 'packed-component',
+      requester: { actorRef: 'requester', capabilities: [] },
+      workflow: {
+        schemaVersion: 1,
+        compatibilityKey: 'packedSmoke',
+        name: 'packedSmoke',
+        steps: [
+          {
+            kind: 'decision',
+            key: 'releaseDecision',
+            decisions: ['approved', 'rejected'],
+            quorum: { kind: 'count', approvals: 1 },
+            makerChecker: true,
+          },
+          {
+            kind: 'branch',
+            key: 'routeDecision',
+            approvedStepKey: 'applyDecision',
+            rejectedStepKey: 'rejectDecision',
+          },
+          {
+            kind: 'mutation',
+            key: 'applyDecision',
+            callback: { kind: 'mutation', handle: approvedHandle, retry: false },
+          },
+          {
+            kind: 'mutation',
+            key: 'rejectDecision',
+            callback: { kind: 'mutation', handle: rejectedHandle, retry: false },
+          },
+        ],
+      },
+    })
+  },
+})
+
+export const list = query({
+  args: {
+    paginationOpts: paginationOptsValidator,
+    state: v.optional(v.union(v.literal('pending'), v.literal('approved'))),
+  },
+  returns: v.any(),
+  handler: (ctx, args) => ctx.runQuery(components.approvals.requests.list, {
+    scopeRef: 'smoke',
+    ...args,
+  }),
+})
+
+export const decide = mutation({
+  args: { runId: v.string() },
+  returns: v.any(),
+  handler: (ctx, args) => ctx.runMutation(components.approvals.decisions.decide, {
+    runId: args.runId,
+    decision: 'approved',
+    actor: { actorRef: 'approver', capabilities: [] },
+    compatibilityKey: 'packedSmoke',
+  }),
+})
+
+export const history = query({
+  args: { runId: v.string() },
+  returns: v.any(),
+  handler: (ctx, args) => ctx.runQuery(components.approvals.decisions.list, args),
+})
+
+export const status = query({
+  args: { runId: v.string() },
+  returns: v.any(),
+  handler: (ctx, args) => ctx.runQuery(components.approvals.requests.status, {
+    ...args,
+    compatibilityKey: 'packedSmoke',
+  }),
+})
+`,
+	)
+
+	if (installer === 'bun') {
+		copyFileSync(join(root, 'bun.lock'), join(fixture, 'bun.lock'))
+	}
+	if (installer === 'bun')
+		step('install with bun', () =>
+			runStreaming('bun', ['install', '--ignore-scripts']),
+		)
+	else
+		step('install with npm', () =>
+			runStreaming('npm', ['install', '--ignore-scripts']),
+		)
+	if (installer === 'bun')
+		step('test helper with bun', () =>
+			runStreaming('bunx', ['vp', 'test', 'run', 'packed-test-helper.test.ts']),
+		)
+	else
+		step('test helper with npm', () =>
+			runStreaming('npx', ['vp', 'test', 'run', 'packed-test-helper.test.ts']),
+		)
+
+	step('deploy Convex fixture', () =>
+		runConvex('dev', '--once', '--typecheck=disable'),
+	)
+	const health = JSON.parse(runConvex('run', 'smoke:health'))
+	if (health.status !== 'ready' || health.schemaVersion !== 1) {
+		throw new Error(
+			`Unexpected approvals health response: ${JSON.stringify(health)}`,
+		)
+	}
+	const foundationHealth = JSON.parse(
+		runConvex('run', 'smoke:foundationHealth'),
+	)
+	if (foundationHealth !== 'ready') {
+		throw new Error(
+			`Unexpected foundation health response: ${JSON.stringify(foundationHealth)}`,
+		)
+	}
+	const { runId } = JSON.parse(runConvex('run', 'smoke:start'))
+	const { runId: secondRunId } = JSON.parse(
+		runConvex(
+			'run',
+			'smoke:start',
+			JSON.stringify({ resourceRef: 'packed-component-2' }),
+		),
+	)
+	const firstPage = JSON.parse(
+		runConvex(
+			'run',
+			'smoke:list',
+			JSON.stringify({
+				state: 'pending',
+				paginationOpts: { cursor: null, numItems: 1 },
+			}),
+		),
+	)
+	if (firstPage.page.length !== 1 || firstPage.page[0]._id !== secondRunId) {
+		throw new Error(`Unexpected first approval page: ${JSON.stringify(firstPage)}`)
+	}
+	const secondPage = JSON.parse(
+		runConvex(
+			'run',
+			'smoke:list',
+			JSON.stringify({
+				state: 'pending',
+				paginationOpts: {
+					cursor: firstPage.continueCursor,
+					numItems: 10,
+				},
+			}),
+		),
+	)
+	if (
+		secondPage.page.length !== 1 ||
+		secondPage.page[0]._id !== runId ||
+		secondPage.page[0]._id === firstPage.page[0]._id
+	) {
+		throw new Error(
+			`Unexpected continuation approval page: ${JSON.stringify(secondPage)}`,
+		)
+	}
+
+	let decision
+	let lastError
+	for (let attempt = 0; attempt < 10; attempt += 1) {
+		try {
+			decision = JSON.parse(
+				runConvex('run', 'smoke:decide', JSON.stringify({ runId })),
+			)
+			break
+		} catch (error) {
+			lastError = error
+			const currentStatus = JSON.parse(
+				runConvex('run', 'smoke:status', JSON.stringify({ runId })),
+			)
+			if (currentStatus.state === 'approved') {
+				decision = currentStatus
+				break
+			}
+			await new Promise((resolve) => setTimeout(resolve, 500))
+		}
+	}
+	if (!decision) throw lastError
+	if (decision.state !== 'approved') {
+		throw new Error(`Unexpected decision response: ${JSON.stringify(decision)}`)
+	}
+	const history = JSON.parse(
+		runConvex('run', 'smoke:history', JSON.stringify({ runId })),
+	)
+	if (history.length !== 1 || history[0].decision !== 'approved') {
+		throw new Error(`Unexpected approval history: ${JSON.stringify(history)}`)
+	}
+	let status
+	for (let attempt = 0; attempt < 20; attempt += 1) {
+		status = JSON.parse(
+			runConvex('run', 'smoke:status', JSON.stringify({ runId })),
+		)
+		if (status.execution?.type === 'completed') break
+		await new Promise((resolve) => setTimeout(resolve, 500))
+	}
+	if (status?.execution?.type !== 'completed') {
+		throw new Error(`Approval callback did not complete: ${JSON.stringify(status)}`)
+	}
+	console.log(`packed component smoke passed with ${installer}`)
+} finally {
+	rmSync(temporaryRoot, { recursive: true, force: true })
+}

package/src/test.ts

@@ -6,8 +6,8 @@
  * registers the COMPILED component modules from dist, so dist is the only
  * code the package ships.
  */
-import approvalsSchema from '../dist/components/approvals/schema.mjs'
-import foundationSchema from '../dist/components/foundation/schema.mjs'
+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',

package/dist/components/approvals/schema.mjs

@@ -1,2 +0,0 @@
-import{approvalDecisionDocument as e,approvalRunDocument as t}from"./validators.mjs";import{zodToConvex as n}from"convex-helpers/server/zod4";import{defineSchema as r,defineTable as i}from"convex/server";var a=r({approvalRuns:i(n(t)).index(`by_resourceType_and_resourceRef`,[`resourceType`,`resourceRef`]).index(`by_scopeRef_and_state`,[`scopeRef`,`state`]).index(`by_state_and_expiresAt`,[`state`,`expiresAt`]),approvalDecisions:i(n(e)).index(`by_runId_and_stepKey_and_actor_actorRef`,[`runId`,`stepKey`,`actor.actorRef`]).index(`by_runId_and_stepKey_and_decidedAt`,[`runId`,`stepKey`,`decidedAt`]).index(`by_runId_and_decidedAt`,[`runId`,`decidedAt`])});export{a as default};
-//# sourceMappingURL=schema.mjs.map

package/dist/components/approvals/schema.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"schema.mjs","names":[],"sources":["../../../src/components/approvals/schema.ts"],"sourcesContent":["import { zodToConvex } from 'convex-helpers/server/zod4'\nimport { defineSchema, defineTable } from 'convex/server'\n\nimport { approvalDecisionDocument, approvalRunDocument } from './validators'\n\nexport default defineSchema({\n\tapprovalRuns: defineTable(zodToConvex(approvalRunDocument))\n\t\t.index('by_resourceType_and_resourceRef', ['resourceType', 'resourceRef'])\n\t\t.index('by_scopeRef_and_state', ['scopeRef', 'state'])\n\t\t.index('by_state_and_expiresAt', ['state', 'expiresAt']),\n\tapprovalDecisions: defineTable(zodToConvex(approvalDecisionDocument))\n\t\t.index('by_runId_and_stepKey_and_actor_actorRef', [\n\t\t\t'runId',\n\t\t\t'stepKey',\n\t\t\t'actor.actorRef',\n\t\t])\n\t\t.index('by_runId_and_stepKey_and_decidedAt', [\n\t\t\t'runId',\n\t\t\t'stepKey',\n\t\t\t'decidedAt',\n\t\t])\n\t\t.index('by_runId_and_decidedAt', ['runId', 'decidedAt']),\n})\n"],"mappings":"4MAKA,IAAA,EAAe,EAAa,CAC3B,aAAc,EAAY,EAAY,CAAmB,CAAC,CAAC,CACzD,MAAM,kCAAmC,CAAC,eAAgB,aAAa,CAAC,CAAC,CACzE,MAAM,wBAAyB,CAAC,WAAY,OAAO,CAAC,CAAC,CACrD,MAAM,yBAA0B,CAAC,QAAS,WAAW,CAAC,EACxD,kBAAmB,EAAY,EAAY,CAAwB,CAAC,CAAC,CACnE,MAAM,0CAA2C,CACjD,QACA,UACA,gBACD,CAAC,CAAC,CACD,MAAM,qCAAsC,CAC5C,QACA,UACA,WACD,CAAC,CAAC,CACD,MAAM,yBAA0B,CAAC,QAAS,WAAW,CAAC,CACzD,CAAC"}

package/dist/components/foundation/schema.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"schema.mjs","names":[],"sources":["../../../src/components/foundation/schema.ts"],"sourcesContent":["import { defineSchema } from 'convex/server'\n\n/** Foundation is a capability-free in-process kernel and owns no business data. */\nexport default defineSchema({})\n"],"mappings":"6CAGA,IAAA,EAAe,EAAa,CAAC,CAAC"}