exportc 0.0.3 → 0.0.5

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
 
@@ -18,13 +18,20 @@ npm run dev
 npm run export
 ```
 
+## 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:
+After initialization, import your server exports using the `export/` prefix:
 
 ```typescript
 // In your Vite app
-import { hello, Counter } from "export:/";
+import { hello, Counter } from "export/";
 
 const message = await hello("World");  // "Hello, World!"
 
@@ -34,24 +41,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 +67,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`):
-1. Builds Vite app
+### Production (`npm run export`)
+
+1. Builds your Vite app
 2. Deploys to Workers Sites (static assets + server exports)
-3. `export:/` imports resolve to `https://{worker-name}.workers.dev`
+3. `export/` imports resolve to `https://{worker-name}.workers.dev`
+4. Everything runs on Cloudflare's edge network
 
 ## Project Structure
 
@@ -83,30 +88,37 @@ 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
 ```
 
 ## TypeScript Support
 
-The `export-env.d.ts` file provides type declarations for `export:/` imports. Update it when you add new exports:
+The `export-env.d.ts` file is **automatically generated** when you run `npm run dev`. The Vite plugin watches for changes to your export files and regenerates type declarations automatically.
 
 ```typescript
-// export-env.d.ts
-declare module "export:/" {
+// export-env.d.ts (auto-generated)
+declare module "export/" {
   export function hello(name: string): Promise<string>;
-  export function myNewFunction(): Promise<void>;
+  export class Counter {
+    constructor(initial?: number);
+    increment(): Promise<number>;
+    [Symbol.dispose](): Promise<void>;
+  }
 }
 
-declare module "export:/utils" {
+declare module "export/utils" {
   export function formatDate(date: Date): Promise<string>;
 }
 ```
 
+Types are inferred from your actual export code, so you get accurate type information with zero manual maintenance.
+
 ## License
 
 MIT

package/commands/dev.js

@@ -45,7 +45,7 @@ export async function dev(argv) {
     `Wrangler dev server is running at ${pc.cyan("http://localhost:8787")}
 
 ${pc.bold("In your Vite app:")}
-${pc.cyan(`import { hello } from "export:/";`)}
+${pc.cyan(`import { hello } from "export/";`)}
 ${pc.cyan(`const message = await hello("World");`)}
 
 ${pc.dim("Press Ctrl+C to stop")}`,

package/commands/init.js

@@ -8,14 +8,21 @@ 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 +30,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 +42,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 +53,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)) {
@@ -76,7 +99,7 @@ export async function init(argv) {
   if (!fs.existsSync(indexPath)) {
     const template = isTypeScript
       ? `// Server-side exports - these will be available to your client code
-// Import from "export:/" in your client code
+// Import from "export/" in your client code
 
 export async function hello(name: string): Promise<string> {
   return \`Hello, \${name}!\`;
@@ -103,7 +126,7 @@ export class Counter {
 }
 `
       : `// Server-side exports - these will be available to your client code
-// Import from "export:/" in your client code
+// Import from "export/" in your client code
 
 export async function hello(name) {
   return \`Hello, \${name}!\`;
@@ -237,13 +260,13 @@ wrangler.toml
   if (isTypeScript) {
     const envDtsPath = path.join(cwd, "export-env.d.ts");
     if (!fs.existsSync(envDtsPath)) {
-      const envDtsContent = `// Type declarations for export:/ imports
+      const envDtsContent = `// Type declarations for export/ imports
 // This file is auto-generated by exportc. You can modify it to add custom types.
 
 // Re-export types from your export directory
 // Update this when you add new exports
 
-declare module "export:/" {
+declare module "export/" {
   export function hello(name: string): Promise<string>;
   export function add(a: number, b: number): Promise<number>;
   export class Counter {
@@ -255,25 +278,29 @@ declare module "export:/" {
 }
 
 // Add more module declarations for subpaths:
-// declare module "export:/utils" {
+// declare module "export/utils" {
 //   export function myUtil(): Promise<void>;
 // }
 `;
       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,22 +308,23 @@ declare module "export:/" {
     }
   }
 
-  s.stop("Export initialized!");
+  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-env.d.ts")}     ${pc.dim("# Type declarations for export/ imports")}`
+      : `${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:")}
 
@@ -307,14 +335,20 @@ ${pc.bold("Next steps:")}
    ${pc.cyan("npm run dev")}
 
 3. Import in your client code:
-   ${pc.cyan(`import { hello } from "export:/";`)}
+   ${pc.cyan(`import { hello } from "export/";`)}
    ${pc.cyan(`const message = await hello("World");`)}
 
 4. 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!`);
+      "Created"
+    );
+
+    p.outro(`Run ${pc.cyan("cd export && npm install")} to get started!`);
+  } else {
+    console.log("Export initialized successfully!");
+    console.log("\nNext steps:");
+    console.log("  cd export && npm install && cd ..");
+    console.log("  npm run dev");
+  }
 }

package/package.json

@@ -1,9 +1,10 @@
 {
   "name": "exportc",
-  "version": "0.0.3",
+  "version": "0.0.5",
   "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",

package/vite-plugin.d.ts

@@ -37,11 +37,11 @@ export interface ExportPluginOptions {
  * Vite plugin for export integration
  *
  * Automatically starts Wrangler when you run `npm run dev` and allows
- * importing server exports using the "export:/" prefix:
+ * importing server exports using the "export/" prefix:
  *
  * ```ts
- * import { hello } from "export:/";
- * import { utils } from "export:/utils";
+ * import { hello } from "export/";
+ * import { utils } from "export/utils";
  * ```
  *
  * @example

package/vite-plugin.js

@@ -1,9 +1,9 @@
 /**
  * Vite plugin for export integration
  *
- * Allows importing server exports using the "export:/" prefix:
- *   import { hello } from "export:/";
- *   import { utils } from "export:/utils";
+ * Allows importing server exports using the "export/" prefix:
+ *   import { hello } from "export/";
+ *   import { utils } from "export/utils";
  *
  * In development:
  *   - Automatically starts Wrangler dev server
@@ -14,10 +14,10 @@
  */
 
 import { spawn } from "node:child_process";
-import { existsSync, readFileSync } from "node:fs";
+import { existsSync, readFileSync, writeFileSync, watchFile, unwatchFile } from "node:fs";
 import { resolve } from "node:path";
 
-const EXPORT_PREFIX = "export:";
+const EXPORT_PREFIX = "export/";
 const DEFAULT_DEV_PORT = 8787;
 
 /**
@@ -55,6 +55,44 @@ export function exportPlugin(options = {}) {
     return null;
   };
 
+  // Generate export-env.d.ts from .export-types.js
+  const generateTypeDeclarations = (root) => {
+    try {
+      const typesFilePath = resolve(root, exportDir, ".export-types.js");
+      if (!existsSync(typesFilePath)) return;
+
+      const typesContent = readFileSync(typesFilePath, "utf8");
+      // Extract the first line which contains the default export
+      const firstLine = typesContent.split('\n')[0];
+      if (!firstLine.startsWith('export default ')) return;
+
+      // Remove "export default " prefix and trailing ";"
+      const jsonStr = firstLine.slice('export default '.length).replace(/;$/, '');
+
+      // Parse the types map
+      const typesMap = JSON.parse(jsonStr);
+
+      // Generate declare module statements
+      const declarations = ['// Auto-generated by exportc. Do not edit manually.', '// Re-run "npm run dev" to regenerate after changing export/ files.', ''];
+
+      for (const [route, types] of Object.entries(typesMap)) {
+        const modulePath = route === "" ? "export/" : `export/${route}`;
+        declarations.push(`declare module "${modulePath}" {`);
+        // Indent the type declarations
+        const indented = types.split('\n').map(line => line ? `  ${line}` : '').join('\n');
+        declarations.push(indented);
+        declarations.push('}');
+        declarations.push('');
+      }
+
+      const envDtsPath = resolve(root, "export-env.d.ts");
+      writeFileSync(envDtsPath, declarations.join('\n'));
+      console.log(`[exportc] Generated type declarations: export-env.d.ts`);
+    } catch (err) {
+      console.warn(`[exportc] Failed to generate type declarations:`, err.message);
+    }
+  };
+
   const startWrangler = (root) => {
     const exportPath = resolve(root, exportDir);
 
@@ -164,8 +202,27 @@ export function exportPlugin(options = {}) {
         const root = server.config.root || process.cwd();
         wranglerReadyPromise = startWrangler(root);
 
+        // Generate types after Wrangler is ready
+        wranglerReadyPromise.then(() => {
+          // Initial generation
+          setTimeout(() => generateTypeDeclarations(root), 1000);
+
+          // Watch for changes to .export-types.js
+          const typesFilePath = resolve(root, exportDir, ".export-types.js");
+          if (existsSync(typesFilePath)) {
+            watchFile(typesFilePath, { interval: 1000 }, () => {
+              generateTypeDeclarations(root);
+            });
+          }
+        });
+
         // Cleanup on server close
-        server.httpServer?.on("close", stopWrangler);
+        server.httpServer?.on("close", () => {
+          stopWrangler();
+          // Stop watching
+          const typesFilePath = resolve(root, exportDir, ".export-types.js");
+          unwatchFile(typesFilePath);
+        });
       }
     },
 
@@ -233,7 +290,7 @@ export { default } from "${fullUrl}";
         return null;
       }
 
-      if (code.includes('import("export:') || code.includes("import('export:")) {
+      if (code.includes('import("export/') || code.includes("import('export/")) {
         const baseUrl = isDev ? devUrl : prodUrl;
         if (!baseUrl && !isDev) {
           this.warn(`[exportc] Production URL not configured for dynamic imports in ${id}`);
@@ -241,7 +298,7 @@ export { default } from "${fullUrl}";
         }
 
         const transformed = code.replace(
-          /import\((['"])export:([^'"]*)\1\)/g,
+          /import\((['"])export\/([^'"]*)\1\)/g,
           (match, quote, path) => {
             const fullUrl = new URL(path || "/", baseUrl).href;
             return `import(${quote}${fullUrl}${quote})`;