@zap-js/client 0.1.1 → 0.1.3

package/dist/cli/commands/build.js

@@ -3,6 +3,7 @@ import { join, resolve } from 'path';
 import { existsSync, mkdirSync, copyFileSync, readdirSync, statSync, rmSync, writeFileSync } from 'fs';
 import { cliLogger } from '../utils/logger.js';
 import { resolveBinary, getPlatformIdentifier } from '../utils/binary-resolver.js';
+import { validateBuildStructure } from '../utils/build-validator.js';
 /**
  * Build for production
  */
@@ -17,6 +18,33 @@ export async function buildCommand(options) {
         }
         // Step 2: TypeScript type checking (optional but recommended)
         await typeCheck();
+        // Step 2.5: Validate build structure
+        cliLogger.spinner('validate', 'Validating build structure...');
+        const validation = validateBuildStructure(process.cwd());
+        if (!validation.valid) {
+            cliLogger.failSpinner('validate', 'Build validation failed');
+            for (const error of validation.errors) {
+                cliLogger.error(error);
+            }
+            cliLogger.newline();
+            cliLogger.error('Server imports found in restricted locations');
+            cliLogger.newline();
+            cliLogger.info('Allowed locations for server imports:');
+            cliLogger.info('  - routes/api/** (server-side routes)');
+            cliLogger.info('  - routes/ws/** (WebSocket routes)');
+            cliLogger.info('  - src/api/** (API clients)');
+            cliLogger.info('  - src/services/** (business logic)');
+            cliLogger.info('  - src/generated/** (generated code)');
+            cliLogger.newline();
+            cliLogger.info('Move server imports to allowed directories or remove them.');
+            throw new Error('Build validation failed');
+        }
+        if (validation.warnings.length > 0) {
+            for (const warning of validation.warnings) {
+                cliLogger.warn(warning);
+            }
+        }
+        cliLogger.succeedSpinner('validate', 'Build structure valid');
         // Clean output directory
         if (existsSync(outputDir)) {
             cliLogger.spinner('clean', 'Cleaning output directory...');
@@ -29,6 +57,8 @@ export async function buildCommand(options) {
         if (!options.skipFrontend) {
             staticDir = await buildFrontend(outputDir);
         }
+        // Step 3.5: Compile server routes separately
+        await compileRoutes(outputDir);
         // Step 4: Create bin directory and build Rust binary
         // This happens AFTER frontend build so Vite doesn't overwrite it
         mkdirSync(join(outputDir, 'bin'), { recursive: true });
@@ -168,17 +198,48 @@ async function buildFrontend(outputDir) {
         return null;
     }
     cliLogger.spinner('vite', 'Building frontend (Vite)...');
+    // Create temporary vite config that externalizes server packages
+    const tempConfigPath = join(process.cwd(), '.vite.config.temp.mjs');
+    const tempConfig = `import { defineConfig } from 'vite';
+import react from '@vitejs/plugin-react';
+import { fileURLToPath } from 'url';
+import path from 'path';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+export default defineConfig({
+  plugins: [react()],
+  build: {
+    rollupOptions: {
+      external: [
+        '@zap-js/server',
+        '@zap-js/client/node',
+        '@zap-js/client/server',
+      ],
+    }
+  },
+  resolve: {
+    alias: {
+      '@': path.resolve(__dirname, './src')
+    }
+  }
+});
+`;
     try {
+        // Write temporary config
+        writeFileSync(tempConfigPath, tempConfig);
         // Build to a temporary directory to avoid conflicts
         const tempDist = join(process.cwd(), '.dist-temp');
         // Clean temp directory if it exists
         if (existsSync(tempDist)) {
             rmSync(tempDist, { recursive: true, force: true });
         }
-        execSync(`npx vite build --outDir ${tempDist}`, {
+        execSync(`npx vite build --config ${tempConfigPath} --outDir ${tempDist}`, {
             cwd: process.cwd(),
             stdio: 'pipe',
         });
+        // Clean up temp config
+        rmSync(tempConfigPath, { force: true });
         const staticDir = join(outputDir, 'static');
         if (existsSync(tempDist)) {
             copyDirectory(tempDist, staticDir);
@@ -193,11 +254,58 @@ async function buildFrontend(outputDir) {
         }
     }
     catch (error) {
+        // Clean up temp config on error
+        if (existsSync(tempConfigPath)) {
+            rmSync(tempConfigPath, { force: true });
+        }
         cliLogger.failSpinner('vite', 'Frontend build failed');
         cliLogger.warn('Continuing without frontend');
         return null;
     }
 }
+async function compileRoutes(outputDir) {
+    const routesDir = join(process.cwd(), 'routes');
+    if (!existsSync(routesDir)) {
+        cliLogger.info('No routes directory, skipping route compilation');
+        return;
+    }
+    cliLogger.spinner('routes', 'Compiling server routes...');
+    const tempTsConfig = '.tsconfig.routes.json';
+    try {
+        // Create temporary tsconfig for routes only
+        const routesTsConfig = {
+            extends: './tsconfig.json',
+            compilerOptions: {
+                outDir: join(outputDir, 'routes'),
+                rootDir: './routes',
+                module: 'NodeNext',
+                moduleResolution: 'NodeNext',
+                noEmit: false,
+                declaration: false,
+                sourceMap: true,
+            },
+            include: ['routes/**/*.ts'],
+            exclude: ['routes/**/*.tsx', 'node_modules']
+        };
+        writeFileSync(tempTsConfig, JSON.stringify(routesTsConfig, null, 2));
+        execSync(`npx tsc --project ${tempTsConfig}`, {
+            cwd: process.cwd(),
+            stdio: 'pipe',
+        });
+        // Clean up temp config
+        rmSync(tempTsConfig, { force: true });
+        cliLogger.succeedSpinner('routes', 'Server routes compiled');
+    }
+    catch (error) {
+        // Clean up temp config on error
+        if (existsSync(tempTsConfig)) {
+            rmSync(tempTsConfig, { force: true });
+        }
+        cliLogger.failSpinner('routes', 'Route compilation failed');
+        // Don't throw - routes may not exist or may not need compilation
+        cliLogger.warn('Continuing without compiled routes');
+    }
+}
 async function typeCheck() {
     // Check if tsconfig exists
     const tsconfigPath = join(process.cwd(), 'tsconfig.json');

package/dist/cli/commands/new.js

@@ -216,6 +216,7 @@ export const POST = async ({ request }: { request: Request }) => {
             '@types/react': '^18.0.0',
             '@types/react-dom': '^18.0.0',
             '@zapjs/cli': '^0.1.0',
+            '@vitejs/plugin-react': '^4.0.0',
             'typescript': '^5.0.0',
             'vite': '^5.0.0',
         },
@@ -268,6 +269,23 @@ export default defineConfig({
         references: [{ path: './tsconfig.node.json' }],
     };
     // Write files
+    // Create vite.config.ts
+    const viteConfig = `import { defineConfig } from 'vite';
+import react from '@vitejs/plugin-react';
+
+export default defineConfig({
+  plugins: [react()],
+  build: {
+    rollupOptions: {
+      external: [
+        '@zap-js/server',
+        '@zap-js/client/node',
+        '@zap-js/client/server',
+      ]
+    }
+  }
+});
+`;
     writeFileSync(join(projectDir, 'server/src/main.rs'), mainRs);
     writeFileSync(join(projectDir, 'routes/__root.tsx'), rootTsx);
     writeFileSync(join(projectDir, 'routes/index.tsx'), indexRoute);
@@ -277,6 +295,7 @@ export default defineConfig({
     writeFileSync(join(projectDir, 'Cargo.toml'), cargoToml);
     writeFileSync(join(projectDir, 'zap.config.ts'), zapConfig);
     writeFileSync(join(projectDir, 'tsconfig.json'), JSON.stringify(tsconfig, null, 2));
+    writeFileSync(join(projectDir, 'vite.config.ts'), viteConfig);
     // Create .gitignore
     const gitignore = `# Dependencies
 node_modules/

package/dist/cli/utils/build-validator.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Validates that frontend code doesn't import server-only packages
+ * Returns array of error messages (empty if valid)
+ */
+export declare function validateNoServerImportsInFrontend(srcDir: string): string[];
+/**
+ * Validates the entire project structure for build
+ */
+export declare function validateBuildStructure(projectDir: string): {
+    valid: boolean;
+    errors: string[];
+    warnings: string[];
+};

package/dist/cli/utils/build-validator.js

@@ -0,0 +1,133 @@
+import { existsSync, readFileSync, readdirSync } from 'fs';
+import { join } from 'path';
+const SERVER_ONLY_IMPORTS = [
+    '@zap-js/server',
+    '@zap-js/client/node',
+    '@zap-js/client/server',
+];
+// Path classification tiers
+const ALWAYS_ALLOWED = ['/routes/api/', '/routes/ws/'];
+const BUSINESS_LOGIC_ALLOWED = ['/src/api/', '/src/services/', '/src/generated/', '/src/lib/api/'];
+const UI_LAYER_BLOCKED = ['/src/components/', '/src/pages/', '/src/ui/'];
+const ALLOWED_FILE_PATTERNS = [/\/rpc-client\.(ts|js)$/, /\/api-client\.(ts|js)$/];
+/**
+ * Validates that frontend code doesn't import server-only packages
+ * Returns array of error messages (empty if valid)
+ */
+export function validateNoServerImportsInFrontend(srcDir) {
+    const errors = [];
+    function scanFile(filePath) {
+        // Only scan TypeScript/JavaScript files
+        if (!filePath.match(/\.(tsx?|jsx?)$/))
+            return;
+        // Skip node_modules
+        if (filePath.includes('node_modules'))
+            return;
+        // Tier 1: Check server-side paths first (early exit)
+        for (const allowed of ALWAYS_ALLOWED) {
+            if (filePath.includes(allowed))
+                return;
+        }
+        // Tier 2: Check business logic paths
+        for (const allowed of BUSINESS_LOGIC_ALLOWED) {
+            if (filePath.includes(allowed))
+                return;
+        }
+        // Tier 3: Check special file patterns
+        for (const pattern of ALLOWED_FILE_PATTERNS) {
+            if (pattern.test(filePath))
+                return;
+        }
+        // Now scan file for server imports
+        try {
+            const content = readFileSync(filePath, 'utf-8');
+            let serverImportFound = null;
+            for (const serverImport of SERVER_ONLY_IMPORTS) {
+                // Check for both single and double quotes
+                const patterns = [
+                    `from '${serverImport}'`,
+                    `from "${serverImport}"`,
+                    `require('${serverImport}')`,
+                    `require("${serverImport}")`,
+                ];
+                for (const pattern of patterns) {
+                    if (content.includes(pattern)) {
+                        serverImportFound = serverImport;
+                        break;
+                    }
+                }
+                if (serverImportFound)
+                    break; // Only report once per file
+            }
+            // Tier 4: Classify and report errors
+            if (serverImportFound) {
+                // Check if in UI layer (explicit block)
+                let inUILayer = false;
+                for (const blocked of UI_LAYER_BLOCKED) {
+                    if (filePath.includes(blocked)) {
+                        inUILayer = true;
+                        break;
+                    }
+                }
+                if (inUILayer) {
+                    errors.push(`${filePath}: Server import '${serverImportFound}' in UI layer`);
+                }
+                else {
+                    errors.push(`${filePath}: Server import '${serverImportFound}' in unclassified path`);
+                }
+            }
+        }
+        catch (err) {
+            // Ignore files that can't be read
+        }
+    }
+    function scanDir(dir) {
+        if (!existsSync(dir))
+            return;
+        try {
+            const entries = readdirSync(dir, { withFileTypes: true });
+            for (const entry of entries) {
+                const fullPath = join(dir, entry.name);
+                // Skip node_modules and hidden directories
+                if (entry.name === 'node_modules' || entry.name.startsWith('.')) {
+                    continue;
+                }
+                if (entry.isDirectory()) {
+                    scanDir(fullPath);
+                }
+                else {
+                    scanFile(fullPath);
+                }
+            }
+        }
+        catch (err) {
+            // Ignore directories that can't be read
+        }
+    }
+    scanDir(srcDir);
+    return errors;
+}
+/**
+ * Validates the entire project structure for build
+ */
+export function validateBuildStructure(projectDir) {
+    const errors = [];
+    const warnings = [];
+    // Check src directory for server imports
+    const srcDir = join(projectDir, 'src');
+    if (existsSync(srcDir)) {
+        const srcErrors = validateNoServerImportsInFrontend(srcDir);
+        errors.push(...srcErrors);
+    }
+    // Check routes directory for server imports (excluding api and ws routes)
+    const routesDir = join(projectDir, 'routes');
+    if (existsSync(routesDir)) {
+        const routesErrors = validateNoServerImportsInFrontend(routesDir);
+        errors.push(...routesErrors);
+    }
+    return {
+        valid: errors.length === 0,
+        errors,
+        warnings,
+    };
+}

package/dist/dev-server/route-scanner.d.ts

@@ -76,6 +76,11 @@ export declare class RouteScannerRunner extends EventEmitter {
      * Stop watching
      */
     stopWatching(): Promise<void>;
+    /**
+     * Scan compiled routes from a production build (dist/routes/)
+     * Used when running production builds
+     */
+    scanCompiledRoutes(distDir: string): Promise<RouteTree | null>;
     /**
      * Check if routes directory exists
      */

package/dist/dev-server/route-scanner.js

@@ -104,6 +104,30 @@ export class RouteScannerRunner extends EventEmitter {
             this.watcher = null;
         }
     }
+    /**
+     * Scan compiled routes from a production build (dist/routes/)
+     * Used when running production builds
+     */
+    async scanCompiledRoutes(distDir) {
+        const compiledRoutesDir = join(distDir, 'routes');
+        if (!existsSync(compiledRoutesDir)) {
+            return null;
+        }
+        try {
+            const router = await this.loadRouter();
+            if (!router) {
+                return null;
+            }
+            // Scan the compiled routes directory
+            const tree = router.scanRoutes(compiledRoutesDir);
+            this.emit('scan-complete', tree);
+            return tree;
+        }
+        catch (err) {
+            this.emit('error', err);
+            return null;
+        }
+    }
     /**
      * Check if routes directory exists
      */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zap-js/client",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "description": "High-performance fullstack React framework - Client package",
   "homepage": "https://github.com/saint0x/zapjs",
   "repository": {
@@ -71,9 +71,9 @@
     "ws": "^8.16.0"
   },
   "optionalDependencies": {
-    "@zap-js/darwin-arm64": "0.1.1",
-    "@zap-js/darwin-x64": "0.1.1",
-    "@zap-js/linux-x64": "0.1.1"
+    "@zap-js/darwin-arm64": "0.1.3",
+    "@zap-js/darwin-x64": "0.1.3",
+    "@zap-js/linux-x64": "0.1.3"
   },
   "peerDependencies": {
     "react": "^18.0.0",