Restructure tree by role; rename mizan-runtime → mizan-base
packages/ flattens into: backends/ server protocol adapters (mizan-django, mizan-ts) frontends/ client kernel + framework adapters (mizan-base, mizan-react, mizan-vue, mizan-svelte) workers/ runtime workers (mizan-ssr) cores/ shared language-level primitives (empty for now; mizan-python forthcoming) The frontend kernel (was packages/mizan-runtime, now frontends/mizan-base) is renamed to reflect its role — it's the shared base that frontend adapters depend on directly. Reflects the substrate position that per-framework adapters wrap a single shared kernel; codegen targets the adapter, not the raw kernel. Path updates landed in: Makefile, two Gitea workflows, Dockerfile.test, four example/harness config files, .claude/settings.local.json, four docs (CLAUDE/ISSUES/ROADMAP/AFI_ARCHITECTURE), four codegen templates (stage1 + react/vue/svelte adapters), and three package.jsons (the mizan-base rename plus mizan-vue/svelte peerDeps). Generated files under examples/django-react-site/harness/src/api/ still reference @mizan/runtime — left as-is; they're regenerated artifacts and the harness is non-functional pending the React wrapper-layer codegen. Also folded in a pre-existing fix: the Gitea workflows had working-directory: react / django pointing at a layout that predates packages/, never updated. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
This commit is contained in:
425
backends/mizan-ts/tests/edge-compat.test.ts
Normal file
425
backends/mizan-ts/tests/edge-compat.test.ts
Normal file
@@ -0,0 +1,425 @@
|
||||
/**
|
||||
* Edge Compatibility Tests — mirrors Django's EdgeCompatibilityTests exactly.
|
||||
*
|
||||
* These prove that a Cloudflare Worker (Edge) can sit in front of a
|
||||
* TypeScript backend and behave identically to sitting in front of Django.
|
||||
*/
|
||||
|
||||
import { describe, test, expect, beforeEach } from 'bun:test'
|
||||
import { ReactContext, client, clearRegistry, handleContextFetch, handleMutationCall, formatInvalidateHeader, generateManifest, MemoryCache, setCache, resetCache, setCacheSecret, deriveCacheKey, cacheGet, cachePut, cachePurge } from '../src'
|
||||
|
||||
const UserCtx = new ReactContext('user')
|
||||
|
||||
function setupUserContext() {
|
||||
const userProfile = client({ context: UserCtx }, async function userProfile(userId: number) {
|
||||
return { name: `user_${userId}`, email: `user${userId}@test.com` }
|
||||
})
|
||||
|
||||
const userOrders = client({ context: UserCtx }, async function userOrders(userId: number) {
|
||||
return { count: userId * 10 }
|
||||
})
|
||||
|
||||
const updateProfile = client({ affects: UserCtx }, async function updateProfile(userId: number, name: string) {
|
||||
return { name, email: `user${userId}@test.com` }
|
||||
})
|
||||
|
||||
client({ affects: 'userProfile' }, async function updateName(userId: number, name: string) {
|
||||
return { name, email: `user${userId}@test.com` }
|
||||
})
|
||||
}
|
||||
|
||||
describe('Edge Compatibility', () => {
|
||||
beforeEach(() => {
|
||||
clearRegistry()
|
||||
setupUserContext()
|
||||
})
|
||||
|
||||
// ── Deterministic JSON ──────────────────────────────────────────────
|
||||
|
||||
test('deterministic JSON output', async () => {
|
||||
const r1 = await handleContextFetch('user', { userId: '5' })
|
||||
const r2 = await handleContextFetch('user', { userId: '5' })
|
||||
expect(JSON.stringify(r1.body)).toBe(JSON.stringify(r2.body))
|
||||
})
|
||||
|
||||
test('different params produce different responses', async () => {
|
||||
const r1 = await handleContextFetch('user', { userId: '5' })
|
||||
const r2 = await handleContextFetch('user', { userId: '6' })
|
||||
expect(JSON.stringify(r1.body)).not.toBe(JSON.stringify(r2.body))
|
||||
expect(r1.body.userProfile.name).toBe('user_5')
|
||||
expect(r2.body.userProfile.name).toBe('user_6')
|
||||
})
|
||||
|
||||
// ── Cache-Control correctness ───────────────────────────────────────
|
||||
|
||||
test('context GET emits no-store', async () => {
|
||||
const r = await handleContextFetch('user', { userId: '5' })
|
||||
expect(r.headers['Cache-Control']).toBe('no-store')
|
||||
})
|
||||
|
||||
test('mutation POST not cacheable', async () => {
|
||||
const r = await handleMutationCall('updateProfile', { userId: 5, name: 'X' })
|
||||
expect(r.headers['Cache-Control']).toBe('no-store')
|
||||
})
|
||||
|
||||
test('error response not cacheable', async () => {
|
||||
const r = await handleContextFetch('nonexistent', {})
|
||||
expect(r.status).toBe(404)
|
||||
expect(r.headers['Cache-Control']).toBe('no-store')
|
||||
})
|
||||
|
||||
// ── X-Mizan-Invalidate header ──────────────────────────────────────
|
||||
|
||||
test('mutation response includes invalidation header', async () => {
|
||||
const r = await handleMutationCall('updateProfile', { userId: 5, name: 'X' })
|
||||
expect(r.headers['X-Mizan-Invalidate']).toBeDefined()
|
||||
expect(r.headers['X-Mizan-Invalidate']).toContain('user')
|
||||
})
|
||||
|
||||
test('auto-scoped invalidation in header', async () => {
|
||||
const r = await handleMutationCall('updateProfile', { userId: 5, name: 'X' })
|
||||
expect(r.headers['X-Mizan-Invalidate']).toBe('user;userId=5')
|
||||
})
|
||||
|
||||
test('invalidation header matches JSON body', async () => {
|
||||
const r = await handleMutationCall('updateProfile', { userId: 5, name: 'X' })
|
||||
const body = r.body
|
||||
expect(body.invalidate[0].context).toBe('user')
|
||||
expect(body.invalidate[0].params.userId).toBe(5)
|
||||
expect(r.headers['X-Mizan-Invalidate']).toContain('user;userId=5')
|
||||
})
|
||||
|
||||
test('function-level invalidation in header', async () => {
|
||||
const r = await handleMutationCall('updateName', { userId: 7, name: 'X' })
|
||||
expect(r.headers['X-Mizan-Invalidate']).toContain('userProfile')
|
||||
})
|
||||
|
||||
test('no invalidation header on context GET', async () => {
|
||||
const r = await handleContextFetch('user', { userId: '5' })
|
||||
expect(r.headers['X-Mizan-Invalidate']).toBeUndefined()
|
||||
})
|
||||
|
||||
// ── Header format edge cases ───────────────────────────────────────
|
||||
|
||||
test('special characters in param values are URL-encoded', () => {
|
||||
const header = formatInvalidateHeader([
|
||||
{ context: 'search', params: { q: 'a;b' } },
|
||||
])
|
||||
expect(header).not.toContain(';b')
|
||||
expect(header).toContain('a%3Bb')
|
||||
})
|
||||
|
||||
test('spaces in param values are URL-encoded', () => {
|
||||
const header = formatInvalidateHeader([
|
||||
{ context: 'search', params: { q: 'hello world' } },
|
||||
])
|
||||
expect(header).not.toContain(' ')
|
||||
expect(header).toContain('hello%20world')
|
||||
})
|
||||
|
||||
test('header round-trip with special chars', () => {
|
||||
const header = formatInvalidateHeader([
|
||||
{ context: 'data', params: { name: "O'Brien", tag: 'a;b;c' } },
|
||||
])
|
||||
|
||||
// Parse (what Edge does)
|
||||
const segments = header.split(';')
|
||||
const ctx = segments[0]
|
||||
const params: Record<string, string> = {}
|
||||
for (const seg of segments.slice(1)) {
|
||||
const [k, v] = seg.split('=', 2)
|
||||
params[decodeURIComponent(k)] = decodeURIComponent(v)
|
||||
}
|
||||
|
||||
expect(ctx).toBe('data')
|
||||
expect(params.name).toBe("O'Brien")
|
||||
expect(params.tag).toBe('a;b;c')
|
||||
})
|
||||
|
||||
// ── Empty invalidation ─────────────────────────────────────────────
|
||||
|
||||
test('no affects = no header, no body key', async () => {
|
||||
client({ context: new ReactContext('plain') }, async function plainFn() {
|
||||
return { ok: true }
|
||||
})
|
||||
|
||||
// A context function called via mutation dispatch (shouldn't have invalidation)
|
||||
// Actually test a function without affects
|
||||
clearRegistry()
|
||||
client({}, async function noAffects() { return { ok: true } })
|
||||
const r = await handleMutationCall('noAffects', {})
|
||||
expect(r.body.invalidate).toBeUndefined()
|
||||
expect(r.headers['X-Mizan-Invalidate']).toBeUndefined()
|
||||
})
|
||||
|
||||
// ── Private functions ──────────────────────────────────────────────
|
||||
|
||||
test('private functions rejected from RPC', async () => {
|
||||
clearRegistry()
|
||||
client({ affects: 'subscription', private: true }, async function webhook() {
|
||||
return { ok: true }
|
||||
})
|
||||
const r = await handleMutationCall('webhook', {})
|
||||
expect(r.status).toBe(403)
|
||||
})
|
||||
|
||||
// ── Unknown function ───────────────────────────────────────────────
|
||||
|
||||
test('unknown function returns 404', async () => {
|
||||
const r = await handleMutationCall('doesNotExist', {})
|
||||
expect(r.status).toBe(404)
|
||||
})
|
||||
|
||||
test('unknown context returns 404', async () => {
|
||||
const r = await handleContextFetch('doesNotExist', {})
|
||||
expect(r.status).toBe(404)
|
||||
})
|
||||
})
|
||||
|
||||
describe('Manifest', () => {
|
||||
beforeEach(() => {
|
||||
clearRegistry()
|
||||
setupUserContext()
|
||||
})
|
||||
|
||||
test('manifest matches expected structure', () => {
|
||||
const m = generateManifest()
|
||||
|
||||
expect(m.version).toBe(1)
|
||||
expect(m.contexts.user).toBeDefined()
|
||||
expect(m.contexts.user.endpoints).toEqual(['/api/mizan/ctx/user/'])
|
||||
expect(m.contexts.user.params).toContain('userId')
|
||||
expect(m.contexts.user.user_scoped).toBe(true)
|
||||
expect(m.contexts.user.render_strategy).toBe('dynamic_cached')
|
||||
})
|
||||
|
||||
test('mutations section includes auto-scoped params', () => {
|
||||
const m = generateManifest()
|
||||
|
||||
expect(m.mutations.updateProfile).toBeDefined()
|
||||
expect(m.mutations.updateProfile.affects).toEqual(['user'])
|
||||
expect(m.mutations.updateProfile.auto_scoped_params).toContain('userId')
|
||||
})
|
||||
|
||||
test('PSR strategy for non-user-scoped context', () => {
|
||||
clearRegistry()
|
||||
const ProductCtx = new ReactContext('products')
|
||||
client({ context: ProductCtx }, async function productDetail(productId: number) {
|
||||
return { id: productId }
|
||||
})
|
||||
|
||||
const m = generateManifest()
|
||||
expect(m.contexts.products.user_scoped).toBe(false)
|
||||
expect(m.contexts.products.render_strategy).toBe('psr')
|
||||
})
|
||||
|
||||
test('private mutation in manifest', () => {
|
||||
clearRegistry()
|
||||
client(
|
||||
{ affects: 'subscription', private: true, route: '/webhooks/stripe/', methods: ['POST'] },
|
||||
async function stripeWebhook() { return new Response('ok') },
|
||||
)
|
||||
|
||||
const m = generateManifest()
|
||||
expect(m.mutations.stripeWebhook).toBeDefined()
|
||||
expect(m.mutations.stripeWebhook.private).toBe(true)
|
||||
expect(m.mutations.stripeWebhook.route).toBe('/webhooks/stripe/')
|
||||
expect(m.mutations.stripeWebhook.methods).toEqual(['POST'])
|
||||
})
|
||||
|
||||
test('rev appears in manifest', () => {
|
||||
clearRegistry()
|
||||
const Ctx = new ReactContext('data')
|
||||
client({ context: Ctx, rev: 3 }, async function versionedFn(itemId: number) {
|
||||
return { value: itemId }
|
||||
})
|
||||
|
||||
const m = generateManifest()
|
||||
const fn = m.contexts.data.functions[0]
|
||||
expect(fn.rev).toBe(3)
|
||||
})
|
||||
|
||||
test('cache TTL appears in manifest', () => {
|
||||
clearRegistry()
|
||||
const Ctx = new ReactContext('trending')
|
||||
client({ context: Ctx, cache: 60 }, async function trendingFn() {
|
||||
return { items: [] }
|
||||
})
|
||||
|
||||
const m = generateManifest()
|
||||
const fn = m.contexts.trending.functions[0]
|
||||
expect(fn.cache).toBe(60)
|
||||
})
|
||||
|
||||
test('cache=60 still emits no-store on HTTP', async () => {
|
||||
clearRegistry()
|
||||
const Ctx = new ReactContext('live')
|
||||
client({ context: Ctx, cache: 60 }, async function liveFn() {
|
||||
return { score: 42 }
|
||||
})
|
||||
|
||||
const r = await handleContextFetch('live', {})
|
||||
expect(r.headers['Cache-Control']).toBe('no-store')
|
||||
})
|
||||
|
||||
test('cache=false sets no-store', async () => {
|
||||
clearRegistry()
|
||||
const Ctx = new ReactContext('random')
|
||||
client({ context: Ctx, cache: false }, async function randomFn() {
|
||||
return { value: Math.random() }
|
||||
})
|
||||
|
||||
const r = await handleContextFetch('random', {})
|
||||
expect(r.headers['Cache-Control']).toBe('no-store')
|
||||
})
|
||||
})
|
||||
|
||||
// ── Cache Conformance Tests ────────────────────────────────────────────
|
||||
|
||||
describe('Cache Conformance', () => {
|
||||
const SECRET = 'test-pin-secret-that-is-32bytes!'
|
||||
|
||||
test('deriveCacheKey determinism', () => {
|
||||
const k1 = deriveCacheKey(SECRET, 'user', { user_id: '5' })
|
||||
const k2 = deriveCacheKey(SECRET, 'user', { user_id: '5' })
|
||||
expect(k1).toBe(k2)
|
||||
expect(k1).toStartWith('ctx:user:')
|
||||
expect(k1).toHaveLength('ctx:user:'.length + 64)
|
||||
})
|
||||
|
||||
test('deriveCacheKey param order irrelevant', () => {
|
||||
const k1 = deriveCacheKey(SECRET, 'ctx', { a: '1', b: '2' })
|
||||
const k2 = deriveCacheKey(SECRET, 'ctx', { b: '2', a: '1' })
|
||||
expect(k1).toBe(k2)
|
||||
})
|
||||
|
||||
test('deriveCacheKey cross-language pin (matches Python)', () => {
|
||||
// These exact values are pinned from Python's derive_cache_key output.
|
||||
// If this test fails, cross-language cache key compatibility is broken.
|
||||
const publicKey = deriveCacheKey(SECRET, 'user', { user_id: '5' }, undefined, 0)
|
||||
expect(publicKey).toBe('ctx:user:605a1ca5ad5994e9b765c8d1b330474c2a0d51a7b8fbbdc402f992da7ba902f6')
|
||||
|
||||
const userScopedKey = deriveCacheKey(SECRET, 'user', { user_id: '5' }, '5', 0)
|
||||
expect(userScopedKey).toBe('ctx:user:30fc08eb46ee4ff2cf7d317e97dca90fd616511e0587304416f71dc863338dc2')
|
||||
})
|
||||
|
||||
test('MemoryCache get/set/clear', () => {
|
||||
const cache = new MemoryCache()
|
||||
expect(cache.get('k1')).toBeNull()
|
||||
|
||||
cache.set('k1', '{"data":true}')
|
||||
expect(cache.get('k1')).toBe('{"data":true}')
|
||||
|
||||
cache.clear()
|
||||
expect(cache.get('k1')).toBeNull()
|
||||
})
|
||||
|
||||
test('scoped purge recomputes key directly', () => {
|
||||
const cache = new MemoryCache()
|
||||
cachePut(SECRET, cache, 'user', { user_id: '5' }, '{"u5":true}')
|
||||
cachePut(SECRET, cache, 'user', { user_id: '6' }, '{"u6":true}')
|
||||
|
||||
const count = cachePurge(cache, 'user', { user_id: '5' }, SECRET)
|
||||
expect(count).toBe(1)
|
||||
|
||||
expect(cacheGet(SECRET, cache, 'user', { user_id: '5' })).toBeNull()
|
||||
expect(cacheGet(SECRET, cache, 'user', { user_id: '6' })).not.toBeNull()
|
||||
})
|
||||
|
||||
test('broad purge removes all entries', () => {
|
||||
const cache = new MemoryCache()
|
||||
cachePut(SECRET, cache, 'user', { user_id: '5' }, '{"u5":true}')
|
||||
cachePut(SECRET, cache, 'user', { user_id: '6' }, '{"u6":true}')
|
||||
|
||||
const count = cachePurge(cache, 'user')
|
||||
expect(count).toBe(2)
|
||||
|
||||
expect(cacheGet(SECRET, cache, 'user', { user_id: '5' })).toBeNull()
|
||||
expect(cacheGet(SECRET, cache, 'user', { user_id: '6' })).toBeNull()
|
||||
})
|
||||
|
||||
test('handleContextFetch caches response', async () => {
|
||||
clearRegistry()
|
||||
const Ctx = new ReactContext('cached')
|
||||
client({ context: Ctx }, async function cachedFn(itemId: number) {
|
||||
return { value: itemId }
|
||||
})
|
||||
|
||||
const cache = new MemoryCache()
|
||||
setCache(cache)
|
||||
setCacheSecret(SECRET)
|
||||
|
||||
const r1 = await handleContextFetch('cached', { itemId: '1' })
|
||||
expect(r1.status).toBe(200)
|
||||
expect(r1.headers['X-Mizan-Cache']).toBe('MISS')
|
||||
|
||||
const r2 = await handleContextFetch('cached', { itemId: '1' })
|
||||
expect(r2.status).toBe(200)
|
||||
expect(r2.headers['X-Mizan-Cache']).toBe('HIT')
|
||||
expect(r2.body).toEqual(r1.body)
|
||||
|
||||
resetCache()
|
||||
setCacheSecret(null)
|
||||
})
|
||||
|
||||
test('handleMutationCall purges cache', async () => {
|
||||
clearRegistry()
|
||||
const Ctx = new ReactContext('product')
|
||||
client({ context: Ctx }, async function getProduct(productId: number) {
|
||||
return { id: productId }
|
||||
})
|
||||
client({ affects: Ctx }, async function updateProduct(productId: number, name: string) {
|
||||
return { ok: true }
|
||||
})
|
||||
|
||||
const cache = new MemoryCache()
|
||||
setCache(cache)
|
||||
setCacheSecret(SECRET)
|
||||
|
||||
// Prime cache
|
||||
await handleContextFetch('product', { productId: '1' })
|
||||
|
||||
// Mutate
|
||||
await handleMutationCall('updateProduct', { productId: 1, name: 'New' })
|
||||
|
||||
// Cache should be purged — next fetch is MISS
|
||||
const r = await handleContextFetch('product', { productId: '1' })
|
||||
expect(r.headers['X-Mizan-Cache']).toBe('MISS')
|
||||
|
||||
resetCache()
|
||||
setCacheSecret(null)
|
||||
})
|
||||
|
||||
test('scoped invalidation preserves other entries', async () => {
|
||||
clearRegistry()
|
||||
const Ctx = new ReactContext('user')
|
||||
client({ context: Ctx }, async function userProfile(userId: number) {
|
||||
return { name: `user_${userId}` }
|
||||
})
|
||||
client({ affects: Ctx }, async function editUser(userId: number, name: string) {
|
||||
return { ok: true }
|
||||
})
|
||||
|
||||
const cache = new MemoryCache()
|
||||
setCache(cache)
|
||||
setCacheSecret(SECRET)
|
||||
|
||||
// Prime both users
|
||||
await handleContextFetch('user', { userId: '5' })
|
||||
await handleContextFetch('user', { userId: '6' })
|
||||
|
||||
// Mutate only user 5
|
||||
await handleMutationCall('editUser', { userId: 5, name: 'New' })
|
||||
|
||||
// User 6 should still be cached
|
||||
const r6 = await handleContextFetch('user', { userId: '6' })
|
||||
expect(r6.headers['X-Mizan-Cache']).toBe('HIT')
|
||||
|
||||
// User 5 should be a miss
|
||||
const r5 = await handleContextFetch('user', { userId: '5' })
|
||||
expect(r5.headers['X-Mizan-Cache']).toBe('MISS')
|
||||
|
||||
resetCache()
|
||||
setCacheSecret(null)
|
||||
})
|
||||
})
|
||||
Reference in New Issue
Block a user