exportc 0.0.4 → 0.0.6

package/README.md

@@ -1,6 +1,6 @@
 # exportc
 
-Add [export](https://github.com/ihasq/export) to existing Vite projects.
+Add [export](https://github.com/ihasq/export) to existing Vite projects. One command sets up server-side functions with full TypeScript support.
 
 ## Quick Start
 
@@ -8,9 +8,6 @@ Add [export](https://github.com/ihasq/export) to existing Vite projects.
 # In your existing Vite project
 npx exportc init
 
-# Install export dependencies
-cd export && npm install && cd ..
-
 # Start development (Wrangler starts automatically!)
 npm run dev
 
@@ -18,6 +15,15 @@ npm run dev
 npm run export
 ```
 
+That's it. Dependencies are installed automatically.
+
+## What You Get
+
+- **Single command dev** -- `npm run dev` starts both Vite and Wrangler
+- **Auto-generated types** -- TypeScript definitions from your actual code
+- **Workers Sites deploy** -- Static assets + server exports in one deployment
+- **Zero config** -- Production URL auto-detected from package name
+
 ## Usage
 
 After initialization, import your server exports using the `export/` prefix:
@@ -34,24 +40,17 @@ await counter.increment();  // 1
 
 ## Commands
 
-### `exportc init`
-
-Initialize export in your Vite project:
-- Creates `export/` directory with example server code
-- Updates `vite.config.ts` with the export plugin
-- Adds npm scripts for development and deployment
-
-### `exportc dev`
-
-Start the Wrangler development server for your exports.
-
-### `exportc deploy`
-
-Deploy your exports to Cloudflare Workers.
+| Command | Description |
+|---------|-------------|
+| `npm run dev` | Start Vite + Wrangler together, auto-generate types |
+| `npm run export` | Build Vite app and deploy to Workers Sites |
+| `exportc init` | Initialize export in your project |
+| `exportc dev` | Start Wrangler dev server standalone |
+| `exportc deploy` | Deploy exports only |
 
 ## Vite Plugin
 
-The `exportPlugin` automatically starts Wrangler and transforms `export/` imports:
+The `exportPlugin` handles everything automatically:
 
 ```typescript
 // vite.config.ts
@@ -67,15 +66,20 @@ export default defineConfig({
 });
 ```
 
-**Development** (`npm run dev`):
-1. Automatically starts Wrangler dev server
-2. Waits for it to be ready
-3. Transforms `export/` imports to `http://localhost:8787`
+### Development (`npm run dev`)
+
+1. Automatically starts Wrangler dev server in the background
+2. Waits for it to be ready before serving your app
+3. Generates `export-env.d.ts` with TypeScript declarations
+4. Watches for changes and regenerates types automatically
+5. Transforms `export/` imports to `http://localhost:8787`
+
+### Production (`npm run export`)
 
-**Production** (`npm run export`):
-1. Builds Vite app
+1. Builds your Vite app
 2. Deploys to Workers Sites (static assets + server exports)
 3. `export/` imports resolve to `https://{worker-name}.workers.dev`
+4. Everything runs on Cloudflare's edge network
 
 ## Project Structure
 
@@ -83,11 +87,12 @@ After running `exportc init`:
 
 ```
 my-vite-app/
-├── src/                    # Your Vite app
+├── src/                    # Your Vite app (unchanged)
 ├── export/                 # Server exports (Cloudflare Worker)
 │   ├── index.ts           # Your server code
-│   └── package.json       # Worker configuration
-├── export-env.d.ts        # TypeScript declarations
+│   ├── package.json       # Worker configuration
+│   └── .gitignore         # Generated files excluded
+├── export-env.d.ts        # TypeScript declarations (auto-generated)
 └── vite.config.ts         # Updated with exportPlugin
 ```
 

package/commands/init.js

@@ -3,19 +3,27 @@ import pc from "picocolors";
 import fs from "node:fs";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
+import { execSync } from "node:child_process";
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 
 export async function init(argv) {
   const cwd = process.cwd();
+  const isNonInteractive = argv.yes || argv.y || process.env.CI === "true";
 
-  p.intro(pc.bgCyan(pc.black(" exportc init ")));
+  if (!isNonInteractive) {
+    p.intro(pc.bgCyan(pc.black(" exportc init ")));
+  }
 
   // Check for Vite project
   const viteConfigFiles = ["vite.config.ts", "vite.config.js", "vite.config.mts", "vite.config.mjs"];
   const viteConfig = viteConfigFiles.find((f) => fs.existsSync(path.join(cwd, f)));
 
   if (!viteConfig) {
+    if (isNonInteractive) {
+      console.error("Error: No Vite config found. exportc currently only supports Vite projects.");
+      process.exit(1);
+    }
     p.cancel("No Vite config found. exportc currently only supports Vite projects.");
     process.exit(1);
   }
@@ -23,6 +31,10 @@ export async function init(argv) {
   // Check for package.json
   const pkgPath = path.join(cwd, "package.json");
   if (!fs.existsSync(pkgPath)) {
+    if (isNonInteractive) {
+      console.error("Error: No package.json found.");
+      process.exit(1);
+    }
     p.cancel("No package.json found.");
     process.exit(1);
   }
@@ -31,7 +43,7 @@ export async function init(argv) {
 
   // Check if already initialized
   const exportDir = path.join(cwd, "export");
-  if (fs.existsSync(exportDir)) {
+  if (fs.existsSync(exportDir) && !isNonInteractive) {
     const overwrite = await p.confirm({
       message: "export/ directory already exists. Continue and overwrite?",
       initialValue: false,
@@ -42,28 +54,40 @@ export async function init(argv) {
     }
   }
 
-  // Get worker name
-  const workerName = await p.text({
-    message: "Worker name:",
-    placeholder: pkg.name ? `${pkg.name}-api` : "my-api",
-    defaultValue: pkg.name ? `${pkg.name}-api` : "my-api",
-    validate: (v) => {
-      if (!v) return "Worker name is required";
-      if (!/^[a-z0-9-]+$/.test(v)) return "Use lowercase letters, numbers, and hyphens only";
-    },
-  });
+  // Get worker name (use default in non-interactive mode)
+  const defaultWorkerName = pkg.name ? `${pkg.name}-api` : "my-api";
+  let workerName;
+
+  if (isNonInteractive) {
+    workerName = argv.name || defaultWorkerName;
+  } else {
+    workerName = await p.text({
+      message: "Worker name:",
+      placeholder: defaultWorkerName,
+      defaultValue: defaultWorkerName,
+      validate: (v) => {
+        if (!v) return "Worker name is required";
+        if (!/^[a-z0-9-]+$/.test(v)) return "Use lowercase letters, numbers, and hyphens only";
+      },
+    });
 
-  if (p.isCancel(workerName)) {
-    p.cancel("Operation cancelled.");
-    process.exit(0);
+    if (p.isCancel(workerName)) {
+      p.cancel("Operation cancelled.");
+      process.exit(0);
+    }
   }
 
   // Check for TypeScript
   const isTypeScript = viteConfig.endsWith(".ts") || viteConfig.endsWith(".mts") ||
     fs.existsSync(path.join(cwd, "tsconfig.json"));
 
-  const s = p.spinner();
-  s.start("Initializing export...");
+  let s;
+  if (!isNonInteractive) {
+    s = p.spinner();
+    s.start("Initializing export...");
+  } else {
+    console.log("Initializing export...");
+  }
 
   // Create export directory
   if (!fs.existsSync(exportDir)) {
@@ -262,18 +286,22 @@ declare module "export/" {
       fs.writeFileSync(envDtsPath, envDtsContent);
     }
 
-    // Update tsconfig.json to include the type declarations
+    // Update tsconfig to include the type declarations
+    // Modern Vite uses tsconfig.app.json for app code, older uses tsconfig.json directly
+    const tsconfigAppPath = path.join(cwd, "tsconfig.app.json");
     const tsconfigPath = path.join(cwd, "tsconfig.json");
-    if (fs.existsSync(tsconfigPath)) {
+    const targetTsconfig = fs.existsSync(tsconfigAppPath) ? tsconfigAppPath : tsconfigPath;
+
+    if (fs.existsSync(targetTsconfig)) {
       try {
-        const tsconfigContent = fs.readFileSync(tsconfigPath, "utf8");
+        const tsconfigContent = fs.readFileSync(targetTsconfig, "utf8");
         const tsconfig = JSON.parse(tsconfigContent);
 
         // Add export-env.d.ts to include if not already present
         tsconfig.include = tsconfig.include || [];
         if (!tsconfig.include.includes("export-env.d.ts")) {
           tsconfig.include.push("export-env.d.ts");
-          fs.writeFileSync(tsconfigPath, JSON.stringify(tsconfig, null, 2) + "\n");
+          fs.writeFileSync(targetTsconfig, JSON.stringify(tsconfig, null, 2) + "\n");
         }
       } catch {
         // Ignore JSON parse errors (might have comments)
@@ -281,40 +309,65 @@ declare module "export/" {
     }
   }
 
-  s.stop("Export initialized!");
+  // Install dependencies in export directory
+  if (!isNonInteractive) {
+    s.stop("Files created!");
+    s.start("Installing dependencies...");
+  } else {
+    console.log("Installing dependencies...");
+  }
+
+  try {
+    execSync("npm install", {
+      cwd: exportDir,
+      stdio: isNonInteractive ? "inherit" : "pipe",
+    });
+  } catch (err) {
+    if (!isNonInteractive) {
+      s.stop("Failed to install dependencies");
+      p.log.error(`Run ${pc.cyan("cd export && npm install")} manually.`);
+    } else {
+      console.error("Failed to install dependencies. Run 'cd export && npm install' manually.");
+    }
+  }
+
+  if (!isNonInteractive) {
+    s.stop("Export initialized!");
 
-  const filesCreated = isTypeScript
-    ? `${pc.cyan("export/")}
+    const filesCreated = isTypeScript
+      ? `${pc.cyan("export/")}
 ├── index.${ext}        ${pc.dim("# Your server exports")}
 ├── package.json    ${pc.dim("# Worker configuration")}
 └── .gitignore
 
 ${pc.cyan("export-env.d.ts")}     ${pc.dim("# Type declarations for export/ imports")}`
-    : `${pc.cyan("export/")}
+      : `${pc.cyan("export/")}
 ├── index.${ext}        ${pc.dim("# Your server exports")}
 ├── package.json    ${pc.dim("# Worker configuration")}
 └── .gitignore`;
 
-  p.note(
-    `${filesCreated}
+    p.note(
+      `${filesCreated}
 
 ${pc.bold("Next steps:")}
 
-1. Install export dependencies:
-   ${pc.cyan("cd export && npm install && cd ..")}
-
-2. Start development (Vite + Wrangler auto-start):
+1. Start development (Vite + Wrangler auto-start):
    ${pc.cyan("npm run dev")}
 
-3. Import in your client code:
+2. Import in your client code:
    ${pc.cyan(`import { hello } from "export/";`)}
    ${pc.cyan(`const message = await hello("World");`)}
 
-4. Deploy to Cloudflare Workers Sites:
+3. Deploy to Cloudflare Workers Sites:
    ${pc.cyan("npm run export")}
    ${pc.dim("# Builds Vite + deploys everything to Workers")}`,
-    "Created"
-  );
-
-  p.outro(`Run ${pc.cyan("cd export && npm install")} to get started!`);
+      "Ready"
+    );
+
+    p.outro(`Run ${pc.cyan("npm run dev")} to start!`);
+  } else {
+    console.log("Export initialized successfully!");
+    console.log("\nNext steps:");
+    console.log("  npm run dev");
+  }
 }

package/package.json

@@ -1,9 +1,10 @@
 {
   "name": "exportc",
-  "version": "0.0.4",
+  "version": "0.0.6",
   "description": "CLI to add export to existing projects",
   "scripts": {
-    "test": "node --test test/*.test.mjs"
+    "test": "node --test test/init.test.mjs",
+    "test:e2e": "node --test test/e2e.test.mjs"
   },
   "keywords": [
     "cloudflare",