bunsane 0.3.1 → 0.4.0

package/tests/benchmark/scripts/generate-db.ts

@@ -1,344 +0,0 @@
-#!/usr/bin/env bun
-/**
- * CLI script to generate persistent PGlite benchmark databases.
- *
- * This script is self-contained and does not depend on the framework's
- * database connection - it writes directly to PGlite.
- *
- * Usage:
- *   bun tests/benchmark/scripts/generate-db.ts [tier] [--force] [--all]
- *
- * Examples:
- *   bun tests/benchmark/scripts/generate-db.ts xs
- *   bun tests/benchmark/scripts/generate-db.ts md --force
- *   bun tests/benchmark/scripts/generate-db.ts --all
- */
-import { PGlite } from '@electric-sql/pglite';
-import { existsSync, rmSync, mkdirSync } from 'node:fs';
-import { join, dirname } from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { createHash } from 'node:crypto';
-
-import {
-    SeededRandom,
-    generateUserData,
-    generateProductData,
-    generateOrderData,
-    generateOrderItemData,
-    generateReviewData
-} from '../fixtures/EcommerceDataGenerators';
-import { RelationTracker } from '../fixtures/RelationTracker';
-
-const __dirname = dirname(fileURLToPath(import.meta.url));
-const DATABASES_DIR = join(__dirname, '..', 'databases');
-
-// Database tier configurations
-const TIERS = {
-    xs: { users: 1000, products: 2000, orders: 3000, orderItems: 3000, reviews: 1000 },
-    sm: { users: 5000, products: 10000, orders: 15000, orderItems: 15000, reviews: 5000 },
-    md: { users: 10000, products: 20000, orders: 30000, orderItems: 30000, reviews: 10000 },
-    lg: { users: 50000, products: 100000, orders: 150000, orderItems: 150000, reviews: 50000 },
-    xl: { users: 100000, products: 200000, orders: 300000, orderItems: 300000, reviews: 100000 }
-} as const;
-
-type Tier = keyof typeof TIERS;
-
-const DEFAULT_SEED = 42;
-const BATCH_SIZE = 1000;
-
-// Component names and their type IDs (generated deterministically)
-const COMPONENT_TYPE_IDS = new Map<string, string>();
-
-function generateTypeId(name: string): string {
-    if (COMPONENT_TYPE_IDS.has(name)) {
-        return COMPONENT_TYPE_IDS.get(name)!;
-    }
-    // Generate a SHA256 hash (64 hex chars, matches framework's metadata-storage.ts)
-    const typeId = createHash('sha256').update(name).digest('hex');
-    COMPONENT_TYPE_IDS.set(name, typeId);
-    return typeId;
-}
-
-// Simple UUID v7 implementation (time-ordered)
-function uuidv7(): string {
-    const now = Date.now();
-    const timeHex = now.toString(16).padStart(12, '0');
-    const randomBytes = crypto.getRandomValues(new Uint8Array(10));
-    const randomHex = Array.from(randomBytes).map(b => b.toString(16).padStart(2, '0')).join('');
-    return `${timeHex.slice(0, 8)}-${timeHex.slice(8, 12)}-7${randomHex.slice(0, 3)}-${(0x80 | (randomBytes[4]! & 0x3f)).toString(16)}${randomHex.slice(5, 7)}-${randomHex.slice(7, 19)}`;
-}
-
-interface GenerationResult {
-    tier: Tier;
-    totalEntities: number;
-    totalTime: number;
-    recordsPerSecond: number;
-    path: string;
-}
-
-async function initializeSchema(pg: PGlite): Promise<void> {
-    await pg.exec(`
-        CREATE TABLE IF NOT EXISTS entities (
-            id UUID PRIMARY KEY,
-            created_at TIMESTAMPTZ DEFAULT NOW(),
-            updated_at TIMESTAMPTZ DEFAULT NOW(),
-            deleted_at TIMESTAMPTZ DEFAULT NULL
-        );
-
-        CREATE TABLE IF NOT EXISTS components (
-            id UUID PRIMARY KEY,
-            entity_id UUID NOT NULL REFERENCES entities(id) ON DELETE CASCADE,
-            type_id VARCHAR(64) NOT NULL,
-            name VARCHAR(128),
-            data JSONB NOT NULL DEFAULT '{}',
-            created_at TIMESTAMPTZ DEFAULT NOW(),
-            updated_at TIMESTAMPTZ DEFAULT NOW(),
-            deleted_at TIMESTAMPTZ DEFAULT NULL
-        );
-
-        CREATE TABLE IF NOT EXISTS entity_components (
-            entity_id UUID NOT NULL REFERENCES entities(id) ON DELETE CASCADE,
-            type_id VARCHAR(64) NOT NULL,
-            component_id UUID NOT NULL REFERENCES components(id) ON DELETE CASCADE,
-            created_at TIMESTAMPTZ DEFAULT NOW(),
-            updated_at TIMESTAMPTZ DEFAULT NOW(),
-            deleted_at TIMESTAMPTZ DEFAULT NULL,
-            PRIMARY KEY (entity_id, type_id)
-        );
-
-        CREATE INDEX IF NOT EXISTS idx_components_entity_id ON components(entity_id);
-        CREATE INDEX IF NOT EXISTS idx_components_type_id ON components(type_id);
-        CREATE INDEX IF NOT EXISTS idx_components_name ON components(name);
-        CREATE INDEX IF NOT EXISTS idx_entity_components_type_id ON entity_components(type_id);
-        CREATE INDEX IF NOT EXISTS idx_entities_deleted_null ON entities(id) WHERE deleted_at IS NULL;
-    `);
-}
-
-async function seedComponent(
-    pg: PGlite,
-    componentName: string,
-    count: number,
-    dataGenerator: (index: number) => Record<string, any>,
-    tracker: RelationTracker,
-    trackFn?: (entityId: string, data: Record<string, any>) => void,
-    onProgress?: (current: number) => void
-): Promise<string[]> {
-    const typeId = generateTypeId(componentName);
-    const entityIds: string[] = [];
-
-    for (let i = 0; i < count; i += BATCH_SIZE) {
-        const batchSize = Math.min(BATCH_SIZE, count - i);
-        const now = new Date().toISOString();
-
-        let entitiesValues = '';
-        let componentsValues = '';
-        let entityComponentsValues = '';
-
-        for (let j = 0; j < batchSize; j++) {
-            const entityId = uuidv7();
-            const componentId = uuidv7();
-            const data = dataGenerator(i + j);
-
-            entityIds.push(entityId);
-
-            if (trackFn) {
-                trackFn(entityId, data);
-            }
-
-            const sep = j > 0 ? ',' : '';
-            entitiesValues += `${sep}('${entityId}', '${now}', '${now}')`;
-            componentsValues += `${sep}('${componentId}', '${entityId}', '${typeId}', '${componentName}', '${JSON.stringify(data).replace(/'/g, "''")}', '${now}', '${now}')`;
-            entityComponentsValues += `${sep}('${entityId}', '${typeId}', '${componentId}', '${now}', '${now}')`;
-        }
-
-        await pg.exec(`INSERT INTO entities (id, created_at, updated_at) VALUES ${entitiesValues}`);
-        await pg.exec(`INSERT INTO components (id, entity_id, type_id, name, data, created_at, updated_at) VALUES ${componentsValues}`);
-        await pg.exec(`INSERT INTO entity_components (entity_id, type_id, component_id, created_at, updated_at) VALUES ${entityComponentsValues} ON CONFLICT (entity_id, type_id) DO NOTHING`);
-
-        if (onProgress) {
-            onProgress(i + batchSize);
-        }
-    }
-
-    return entityIds;
-}
-
-async function generateDatabase(tier: Tier, force: boolean): Promise<GenerationResult> {
-    const config = TIERS[tier];
-    const dbPath = join(DATABASES_DIR, tier);
-
-    if (existsSync(dbPath)) {
-        if (!force) {
-            console.log(`Database for tier '${tier}' already exists at ${dbPath}`);
-            console.log('Use --force to regenerate');
-            process.exit(0);
-        }
-        console.log(`Removing existing database at ${dbPath}...`);
-        rmSync(dbPath, { recursive: true, force: true });
-    }
-
-    mkdirSync(dbPath, { recursive: true });
-
-    console.log(`\n=== Generating ${tier.toUpperCase()} tier database ===`);
-    console.log(`Path: ${dbPath}`);
-    console.log(`Configuration:`);
-    console.log(`  Users:       ${config.users.toLocaleString()}`);
-    console.log(`  Products:    ${config.products.toLocaleString()}`);
-    console.log(`  Orders:      ${config.orders.toLocaleString()}`);
-    console.log(`  Order Items: ${config.orderItems.toLocaleString()}`);
-    console.log(`  Reviews:     ${config.reviews.toLocaleString()}`);
-
-    const totalEntities = config.users + config.products + config.orders + config.orderItems + config.reviews;
-    console.log(`  Total:       ${totalEntities.toLocaleString()}`);
-    console.log('');
-
-    const startTime = performance.now();
-
-    console.log('Initializing PGlite...');
-    const pg = new PGlite(dbPath, { relaxedDurability: true });
-    await pg.waitReady;
-
-    console.log('Creating schema...');
-    await initializeSchema(pg);
-
-    const tracker = new RelationTracker();
-    const rng = new SeededRandom(DEFAULT_SEED);
-
-    // Seed Users
-    console.log('\nSeeding Users...');
-    const userStart = performance.now();
-    await seedComponent(
-        pg,
-        'BenchUser',
-        config.users,
-        (idx) => generateUserData(idx, rng),
-        tracker,
-        (entityId) => tracker.addUser(entityId),
-        (current) => process.stdout.write(`\r  Progress: ${current.toLocaleString()}/${config.users.toLocaleString()}`)
-    );
-    console.log(`\n  Done in ${((performance.now() - userStart) / 1000).toFixed(1)}s`);
-
-    // Seed Products
-    console.log('\nSeeding Products...');
-    const productStart = performance.now();
-    await seedComponent(
-        pg,
-        'BenchProduct',
-        config.products,
-        (idx) => generateProductData(idx, rng),
-        tracker,
-        (entityId) => tracker.addProduct(entityId),
-        (current) => process.stdout.write(`\r  Progress: ${current.toLocaleString()}/${config.products.toLocaleString()}`)
-    );
-    console.log(`\n  Done in ${((performance.now() - productStart) / 1000).toFixed(1)}s`);
-
-    // Seed Orders
-    console.log('\nSeeding Orders...');
-    const orderStart = performance.now();
-    await seedComponent(
-        pg,
-        'BenchOrder',
-        config.orders,
-        (idx) => generateOrderData(idx, rng, tracker),
-        tracker,
-        (entityId, data) => tracker.addOrder(entityId, data.userId),
-        (current) => process.stdout.write(`\r  Progress: ${current.toLocaleString()}/${config.orders.toLocaleString()}`)
-    );
-    console.log(`\n  Done in ${((performance.now() - orderStart) / 1000).toFixed(1)}s`);
-
-    // Seed Order Items
-    console.log('\nSeeding Order Items...');
-    const itemStart = performance.now();
-    await seedComponent(
-        pg,
-        'BenchOrderItem',
-        config.orderItems,
-        (idx) => generateOrderItemData(idx, rng, tracker),
-        tracker,
-        undefined,
-        (current) => process.stdout.write(`\r  Progress: ${current.toLocaleString()}/${config.orderItems.toLocaleString()}`)
-    );
-    console.log(`\n  Done in ${((performance.now() - itemStart) / 1000).toFixed(1)}s`);
-
-    // Seed Reviews
-    console.log('\nSeeding Reviews...');
-    const reviewStart = performance.now();
-    await seedComponent(
-        pg,
-        'BenchReview',
-        config.reviews,
-        (idx) => generateReviewData(idx, rng, tracker),
-        tracker,
-        undefined,
-        (current) => process.stdout.write(`\r  Progress: ${current.toLocaleString()}/${config.reviews.toLocaleString()}`)
-    );
-    console.log(`\n  Done in ${((performance.now() - reviewStart) / 1000).toFixed(1)}s`);
-
-    // Run VACUUM ANALYZE
-    console.log('\nRunning VACUUM ANALYZE...');
-    await pg.exec('VACUUM ANALYZE entities');
-    await pg.exec('VACUUM ANALYZE components');
-    await pg.exec('VACUUM ANALYZE entity_components');
-
-    console.log('Syncing to disk...');
-    await pg.close();
-
-    const totalTime = (performance.now() - startTime) / 1000;
-    const recordsPerSecond = Math.round(totalEntities / totalTime);
-
-    console.log('\n=== Generation Complete ===');
-    console.log(`Total time:       ${totalTime.toFixed(1)}s`);
-    console.log(`Records/second:   ${recordsPerSecond.toLocaleString()}`);
-    console.log(`Database path:    ${dbPath}`);
-
-    return {
-        tier,
-        totalEntities,
-        totalTime,
-        recordsPerSecond,
-        path: dbPath
-    };
-}
-
-// Parse CLI arguments
-const args = process.argv.slice(2);
-const force = args.includes('--force');
-const all = args.includes('--all');
-const tierArg = args.find(a => !a.startsWith('--'));
-
-if (!all && !tierArg) {
-    console.log('Usage: bun tests/benchmark/scripts/generate-db.ts [tier] [--force] [--all]');
-    console.log('\nTiers: xs, sm, md, lg, xl');
-    console.log('\nOptions:');
-    console.log('  --force   Regenerate even if database exists');
-    console.log('  --all     Generate all tiers');
-    console.log('\nExamples:');
-    console.log('  bun tests/benchmark/scripts/generate-db.ts xs');
-    console.log('  bun tests/benchmark/scripts/generate-db.ts md --force');
-    console.log('  bun tests/benchmark/scripts/generate-db.ts --all');
-    process.exit(1);
-}
-
-if (all) {
-    console.log('Generating all database tiers...\n');
-    const results: GenerationResult[] = [];
-
-    for (const tier of Object.keys(TIERS) as Tier[]) {
-        results.push(await generateDatabase(tier, force));
-        console.log('');
-    }
-
-    console.log('\n=== Summary ===');
-    for (const r of results) {
-        console.log(`${r.tier.toUpperCase().padEnd(3)} | ${r.totalEntities.toLocaleString().padStart(10)} entities | ${r.totalTime.toFixed(1).padStart(6)}s | ${r.recordsPerSecond.toLocaleString().padStart(8)} rec/s`);
-    }
-} else {
-    const tier = tierArg as Tier;
-    if (!TIERS[tier]) {
-        console.error(`Unknown tier: ${tier}`);
-        console.error('Valid tiers: xs, sm, md, lg, xl');
-        process.exit(1);
-    }
-
-    await generateDatabase(tier, force);
-}

package/tests/benchmark/scripts/run-benchmarks.ts

@@ -1,97 +0,0 @@
-#!/usr/bin/env bun
-/**
- * Benchmark runner script.
- *
- * Loads a pre-generated PGlite database and runs benchmarks against it.
- * Sets up the correct environment variables before spawning the test process.
- *
- * Usage:
- *   bun tests/benchmark/scripts/run-benchmarks.ts [tier]
- *   bun tests/benchmark/scripts/run-benchmarks.ts xs
- *   bun tests/benchmark/scripts/run-benchmarks.ts md
- */
-import { PGlite } from '@electric-sql/pglite';
-import { PGLiteSocketServer } from '@electric-sql/pglite-socket';
-import { existsSync } from 'node:fs';
-import { join, dirname } from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { spawn } from 'child_process';
-
-const __dirname = dirname(fileURLToPath(import.meta.url));
-const DATABASES_DIR = join(__dirname, '..', 'databases');
-const PORT = 54322;
-
-type Tier = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
-
-const tier = (process.argv[2] || 'xs') as Tier;
-const dbPath = join(DATABASES_DIR, tier);
-
-if (!existsSync(dbPath)) {
-    console.error(`Benchmark database for tier '${tier}' not found at ${dbPath}`);
-    console.error('\nGenerate it first with:');
-    console.error(`  bun tests/benchmark/scripts/generate-db.ts ${tier}`);
-    process.exit(1);
-}
-
-console.log(`[benchmark] Loading ${tier.toUpperCase()} tier database from ${dbPath}...`);
-
-const pg = new PGlite(dbPath);
-await pg.waitReady;
-
-// Verify database has data
-const countResult = await pg.query<{ count: string }>('SELECT COUNT(*) as count FROM entities');
-const entityCount = parseInt(countResult.rows[0]?.count || '0');
-
-if (entityCount === 0) {
-    await pg.close();
-    console.error(`Benchmark database for tier '${tier}' is empty.`);
-    console.error('Regenerate with:');
-    console.error(`  bun tests/benchmark/scripts/generate-db.ts ${tier} --force`);
-    process.exit(1);
-}
-
-console.log(`[benchmark] Loaded ${entityCount.toLocaleString()} entities`);
-
-const server = new PGLiteSocketServer({ db: pg, port: PORT });
-await server.start();
-console.log(`[benchmark] Socket server running on port ${PORT}`);
-
-// Spawn the test process with correct env vars set before import
-// Use --config to specify benchmark-specific bunfig without the standard preload
-const proc = spawn('bun', ['test', '--config', 'tests/benchmark/bunfig.toml', 'tests/benchmark/scenarios/', '--timeout', '300000'], {
-    env: {
-        ...process.env,
-        SKIP_TEST_DB_SETUP: 'true',
-        USE_PGLITE: 'true',
-        BENCHMARK_TIER: tier,
-        // Clear DB_CONNECTION_URL so individual POSTGRES_* vars take precedence
-        DB_CONNECTION_URL: '',
-        POSTGRES_HOST: 'localhost',
-        POSTGRES_PORT: String(PORT),
-        POSTGRES_USER: 'postgres',
-        POSTGRES_PASSWORD: 'postgres',
-        POSTGRES_DB: 'postgres',
-        POSTGRES_MAX_CONNECTIONS: '10',
-        LOG_LEVEL: 'info',
-        // Disable direct partition access since PGlite uses a single components table
-        BUNSANE_USE_DIRECT_PARTITION: 'false',
-        // Disable LATERAL joins - they don't work correctly with INTERSECT queries
-        BUNSANE_USE_LATERAL_JOINS: 'false',
-    },
-    stdio: 'inherit',
-    cwd: join(__dirname, '..', '..', '..'),
-});
-
-proc.on('exit', async (code) => {
-    console.log('[benchmark] Stopping server...');
-    try { await server.stop(); } catch {}
-    try { await pg.close(); } catch {}
-    process.exit(code ?? 1);
-});
-
-proc.on('error', async (err) => {
-    console.error('[benchmark] Failed to spawn bun test:', err);
-    try { await server.stop(); } catch {}
-    try { await pg.close(); } catch {}
-    process.exit(1);
-});

package/tests/e2e/http.test.ts

@@ -1,130 +0,0 @@
-import { describe, it, expect, beforeAll, afterAll } from "bun:test";
-import App from "../../core/App";
-
-const PORT = 19876;
-const BASE = `http://localhost:${PORT}`;
-
-let app: App;
-
-beforeAll(async () => {
-    app = new App("E2E Test App", "0.0.1");
-    // Start without init() — skips DB/component lifecycle
-    process.env.APP_PORT = String(PORT);
-    await app.start();
-});
-
-afterAll(async () => {
-    await app.shutdown();
-});
-
-describe("E2E HTTP Routes", () => {
-    it("GET /health returns JSON with expected structure", async () => {
-        const res = await fetch(`${BASE}/health`);
-        expect(res.headers.get("Content-Type")).toBe("application/json");
-        const body = await res.json();
-        expect(body).toHaveProperty("status");
-        expect(body).toHaveProperty("timestamp");
-        expect(body).toHaveProperty("uptime");
-        expect(body).toHaveProperty("checks");
-        expect(body.checks).toHaveProperty("database");
-        expect(body.checks).toHaveProperty("cache");
-    });
-
-    it("GET /health/ready returns 200 when server is up", async () => {
-        const res = await fetch(`${BASE}/health/ready`);
-        const body = await res.json();
-        expect(body).toHaveProperty("status");
-        expect(body).toHaveProperty("timestamp");
-        expect(body).toHaveProperty("uptime");
-    });
-
-    it("GET /metrics returns JSON with process and cache stats", async () => {
-        const res = await fetch(`${BASE}/metrics`);
-        expect(res.status).toBe(200);
-        expect(res.headers.get("Content-Type")).toBe("application/json");
-        const body = await res.json();
-        expect(body).toHaveProperty("timestamp");
-        expect(body).toHaveProperty("uptime");
-        expect(body).toHaveProperty("process");
-        expect(body.process).toHaveProperty("rss");
-        expect(body.process).toHaveProperty("heapUsed");
-        expect(body).toHaveProperty("scheduler");
-        expect(body).toHaveProperty("preparedStatements");
-    });
-
-    it("GET /openapi.json returns valid JSON", async () => {
-        const res = await fetch(`${BASE}/openapi.json`);
-        expect(res.status).toBe(200);
-        expect(res.headers.get("Content-Type")).toBe("application/json");
-        const body = await res.json();
-        expect(body).toHaveProperty("openapi");
-    });
-
-    it("GET /docs returns HTML with swagger-ui", async () => {
-        const res = await fetch(`${BASE}/docs`);
-        expect(res.status).toBe(200);
-        expect(res.headers.get("Content-Type")).toBe("text/html");
-        const html = await res.text();
-        expect(html).toContain("swagger-ui");
-        expect(html).toContain("E2E Test App");
-    });
-
-    it("GET /nonexistent returns 404", async () => {
-        const res = await fetch(`${BASE}/nonexistent`);
-        expect(res.status).toBe(404);
-    });
-
-    it("OPTIONS /health returns 204 when CORS configured", async () => {
-        app.setCors({ origin: "*" });
-        // Preflight must carry Origin header per CORS spec; otherwise the
-        // server emits no Access-Control-Allow-Origin (no `|| '*'` fallback).
-        const res = await fetch(`${BASE}/health`, {
-            method: "OPTIONS",
-            headers: { Origin: "https://client.example" },
-        });
-        expect(res.status).toBe(204);
-        expect(res.headers.get("Access-Control-Allow-Origin")).toBe("*");
-    });
-
-    it("Security headers: responses include standard security headers when middleware registered", async () => {
-        // Import and register the security headers middleware
-        const { securityHeaders } = await import("../../core/middleware/SecurityHeaders");
-        app.use(securityHeaders());
-        // Re-compose middleware to include new middleware - access start() sets composedHandler
-        // For this test, we need to trigger re-composition. Calling start() again would
-        // bind another server. Instead, test that middleware works by verifying next request.
-        // Actually, composedHandler is set in start(), adding middleware after start() won't
-        // take effect. So we just verify the security headers are NOT present (middleware not active).
-        const res = await fetch(`${BASE}/health`);
-        // Middleware was added after start(), so it's not in the composed chain yet.
-        // This verifies the baseline — security header tests belong in unit tests.
-        expect(res.headers.get("Content-Type")).toBe("application/json");
-    });
-
-    it("Shutdown completes without error and is idempotent", async () => {
-        const shutdownApp = new App("Shutdown Test", "0.0.1");
-        const shutdownPort = 19877;
-        process.env.APP_PORT = String(shutdownPort);
-        await shutdownApp.start();
-
-        // Verify server responds before shutdown
-        const before = await fetch(`http://localhost:${shutdownPort}/openapi.json`);
-        expect(before.status).toBe(200);
-
-        // Shutdown completes without throwing
-        await shutdownApp.shutdown();
-
-        // Second shutdown is a no-op (idempotent)
-        await shutdownApp.shutdown();
-
-        // Restore port for other tests
-        process.env.APP_PORT = String(PORT);
-    });
-
-    it("Request timeout returns 408 for long requests", async () => {
-        // This is hard to test without a slow endpoint. Verify the timeout
-        // mechanism exists by checking a fast request completes normally.
-        const res = await fetch(`${BASE}/openapi.json`);
-        expect(res.status).toBe(200);
-    });
-});

package/tests/fixtures/archetypes/TestUserArchetype.ts

@@ -1,21 +0,0 @@
-/**
- * Test archetype for user entities
- */
-import { BaseArcheType, ArcheType, ArcheTypeField } from '../../../core/ArcheType';
-import { TestUser } from '../components/TestUser';
-import { TestOrder } from '../components/TestOrder';
-
-@ArcheType({ name: 'TestUserArchetype' })
-export class TestUserArchetype extends BaseArcheType {
-    @ArcheTypeField(TestUser)
-    user!: TestUser;
-}
-
-@ArcheType({ name: 'TestUserWithOrdersArchetype' })
-export class TestUserWithOrdersArchetype extends BaseArcheType {
-    @ArcheTypeField(TestUser)
-    user!: TestUser;
-
-    @ArcheTypeField(TestOrder)
-    order!: TestOrder;
-}

package/tests/fixtures/components/TestOrder.ts

@@ -1,23 +0,0 @@
-/**
- * Test component representing an order
- */
-import { BaseComponent } from '../../../core/components/BaseComponent';
-import { Component, CompData } from '../../../core/components/Decorators';
-
-@Component
-export class TestOrder extends BaseComponent {
-    @CompData({ indexed: true })
-    orderNumber!: string;
-
-    @CompData()
-    total!: number;
-
-    @CompData()
-    status!: string;
-
-    @CompData()
-    createdAt!: Date;
-
-    @CompData({ nullable: true })
-    notes?: string;
-}

package/tests/fixtures/components/TestProduct.ts

@@ -1,23 +0,0 @@
-/**
- * Test component representing a product
- */
-import { BaseComponent } from '../../../core/components/BaseComponent';
-import { Component, CompData } from '../../../core/components/Decorators';
-
-@Component
-export class TestProduct extends BaseComponent {
-    @CompData({ indexed: true })
-    sku!: string;
-
-    @CompData()
-    name!: string;
-
-    @CompData()
-    price!: number;
-
-    @CompData({ nullable: true })
-    description?: string;
-
-    @CompData()
-    inStock!: boolean;
-}

package/tests/fixtures/components/TestUser.ts

@@ -1,20 +0,0 @@
-/**
- * Test component representing a user
- */
-import { BaseComponent } from '../../../core/components/BaseComponent';
-import { Component, CompData } from '../../../core/components/Decorators';
-
-@Component
-export class TestUser extends BaseComponent {
-    @CompData({ indexed: true })
-    name!: string;
-
-    @CompData({ indexed: true })
-    email!: string;
-
-    @CompData()
-    age!: number;
-
-    @CompData({ nullable: true })
-    bio?: string;
-}

package/tests/fixtures/components/index.ts

@@ -1,6 +0,0 @@
-/**
- * Re-export all test components
- */
-export { TestUser } from './TestUser';
-export { TestProduct } from './TestProduct';
-export { TestOrder } from './TestOrder';