@zap-js/client 0.1.0 → 0.1.2

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,25 @@ 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('Cannot use server-side imports in frontend code');
+            cliLogger.info('Server imports (@zap-js/server, @zap-js/client/node) should only be used in routes/api/ or routes/ws/');
+            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 +49,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 +190,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 +246,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,97 @@
+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',
+];
+/**
+ * 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 API routes (these are server-side)
+        if (filePath.includes('/routes/api/'))
+            return;
+        if (filePath.includes('/routes/ws/'))
+            return;
+        // Skip node_modules
+        if (filePath.includes('node_modules'))
+            return;
+        try {
+            const content = readFileSync(filePath, 'utf-8');
+            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)) {
+                        errors.push(`${filePath}: Illegal server import '${serverImport}' in frontend code`);
+                        break; // Only report once per file
+                    }
+                }
+            }
+        }
+        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/dist/runtime/index.js

@@ -3,13 +3,6 @@ import { tmpdir } from "os";
 import { existsSync, readFileSync } from "fs";
 import { ProcessManager } from "./process-manager.js";
 import { IpcServer } from "./ipc-client.js";
-// DEPRECATION WARNING - Show in development only
-if (typeof process !== 'undefined' && process.env.NODE_ENV !== 'production') {
-    console.warn('\x1b[33m[DEPRECATION]\x1b[0m Importing from @zap-js/client is deprecated.\n' +
-        'Use explicit imports:\n' +
-        '  - Server/Node.js: import { Zap } from "@zap-js/client/node"\n' +
-        '  - Browser/Client: import { router } from "@zap-js/client/browser"');
-}
 // Re-export type guards
 export { isInvokeHandlerMessage, isHandlerResponseMessage, isErrorMessage, isHealthCheckMessage, isHealthCheckResponseMessage, isRpcResponseMessage, isRpcErrorMessage, isAsyncIterable, } from "./types.js";
 // Re-export internal modules for dev-server usage

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zap-js/client",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "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.0",
-    "@zap-js/darwin-x64": "0.1.0",
-    "@zap-js/linux-x64": "0.1.0"
+    "@zap-js/darwin-arm64": "0.1.2",
+    "@zap-js/darwin-x64": "0.1.2",
+    "@zap-js/linux-x64": "0.1.2"
   },
   "peerDependencies": {
     "react": "^18.0.0",