@cequrebackends/plugin-vite 1.0.0 → 1.0.1

package/dist/index.d.ts

@@ -0,0 +1,26 @@
+import type { Plugin } from "vite";
+export interface CequreViteOptions {
+    /** URL prefix for API routes. Defaults to `"/api"`. */
+    apiPrefix?: string;
+    /** Custom entry point for the Cequre server. Defaults to auto-detecting `cequre/server/app.ts`, `cequre/server/index.ts`, or legacy `src/server/index.ts`. */
+    entry?: string;
+    /** Automatically run backend production build during Vite build closeBundle hook. Defaults to `false`. */
+    autoBuild?: boolean;
+}
+export declare function resolveApiPrefix(customPrefix?: string): string;
+export declare function resolveEntryPoint(customEntry?: string): string;
+export declare function getExecutableCommand(): {
+    command: string;
+    argsPrefix: string[];
+};
+export declare function cequreVite(options?: CequreViteOptions): Plugin;
+export declare namespace cequreVite {
+    var build: (options?: CequreViteBuildOptions) => Promise<void>;
+}
+export interface CequreViteBuildOptions {
+    entry?: string;
+    outDir?: string;
+    outFile?: string;
+    minify?: boolean;
+}
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAiB,MAAM,MAAM,CAAC;AAalD,MAAM,WAAW,iBAAiB;IAChC,uDAAuD;IACvD,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,8JAA8J;IAC9J,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,0GAA0G;IAC1G,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB;AAOD,wBAAgB,gBAAgB,CAAC,YAAY,CAAC,EAAE,MAAM,GAAG,MAAM,CAsD9D;AAED,wBAAgB,iBAAiB,CAAC,WAAW,CAAC,EAAE,MAAM,GAAG,MAAM,CAuB9D;AAED,wBAAgB,oBAAoB,IAAI;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,EAAE,CAAA;CAAE,CAMhF;AAsFD,wBAAgB,UAAU,CAAC,OAAO,GAAE,iBAAsB,GAAG,MAAM,CAkMlE;yBAlMe,UAAU;0BA2MkB,sBAAsB;;AAPlE,MAAM,WAAW,sBAAsB;IACrC,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB"}

package/dist/index.js

@@ -0,0 +1,393 @@
+// @bun
+var __require = import.meta.require;
+
+// src/index.ts
+import { spawn, execSync } from "child_process";
+import path from "path";
+import fs from "fs";
+import os from "os";
+import { createHash } from "crypto";
+var logger = {
+  info: (msg) => console.log(msg),
+  error: (msg) => console.error(msg),
+  warn: (msg) => console.warn(msg)
+};
+var g = globalThis;
+var globalWsPort = g.__CEQURE_WS_PORT || 0;
+var globalCequreProcess = g.__CEQURE_PROCESS || null;
+var globalCleanupRegistered = g.__CEQURE_CLEANUP || false;
+function resolveApiPrefix(customPrefix) {
+  if (customPrefix) {
+    return customPrefix.startsWith("/") ? customPrefix : "/" + customPrefix;
+  }
+  const schemaPath = path.resolve(process.cwd(), "node_modules", ".cequre", "schema.json");
+  if (fs.existsSync(schemaPath)) {
+    try {
+      const schema = JSON.parse(fs.readFileSync(schemaPath, "utf-8"));
+      if (schema.core?.api?.prefix) {
+        const prefix = schema.core.api.prefix;
+        return prefix.startsWith("/") ? prefix : "/" + prefix;
+      }
+    } catch {}
+  }
+  const cequreSchemaDir = path.resolve(process.cwd(), "cequre", "schema");
+  if (fs.existsSync(cequreSchemaDir)) {
+    try {
+      const files = fs.readdirSync(cequreSchemaDir);
+      for (const f of files) {
+        if (f.endsWith(".cequre")) {
+          const content = fs.readFileSync(path.join(cequreSchemaDir, f), "utf-8");
+          const match = content.match(/prefix:\s*["']([^"']+)["']/);
+          if (match && match[1]) {
+            const prefix = match[1];
+            return prefix.startsWith("/") ? prefix : "/" + prefix;
+          }
+        }
+      }
+    } catch {}
+  }
+  const cequreDir = path.resolve(process.cwd(), "cequre");
+  if (fs.existsSync(cequreDir)) {
+    try {
+      const files = fs.readdirSync(cequreDir);
+      for (const f of files) {
+        if (f.endsWith(".cequre")) {
+          const content = fs.readFileSync(path.join(cequreDir, f), "utf-8");
+          const match = content.match(/prefix:\s*["']([^"']+)["']/);
+          if (match && match[1]) {
+            const prefix = match[1];
+            return prefix.startsWith("/") ? prefix : "/" + prefix;
+          }
+        }
+      }
+    } catch {}
+  }
+  return "/api";
+}
+function resolveEntryPoint(customEntry) {
+  if (customEntry) {
+    return customEntry;
+  }
+  const candidates = [
+    "cequre/index.ts",
+    "cequre/app.ts",
+    "cequre/server/app.ts",
+    "cequre/server/index.ts",
+    "src/server/app.ts",
+    "src/app.ts",
+    "src/server/index.ts",
+    "server/index.ts",
+    "server.ts",
+    "src/index.ts",
+    "api/index.ts"
+  ];
+  for (const cand of candidates) {
+    if (fs.existsSync(path.resolve(process.cwd(), cand))) {
+      return cand;
+    }
+  }
+  return "cequre/index.ts";
+}
+function getExecutableCommand() {
+  const localBin = path.join(process.cwd(), "node_modules", ".bin", "cequre");
+  if (fs.existsSync(localBin)) {
+    return { command: localBin, argsPrefix: [] };
+  }
+  return { command: "bunx", argsPrefix: ["cequre"] };
+}
+function lockPathFor(port) {
+  const root = path.resolve(process.cwd());
+  const digest = createHash("sha256").update(root).digest("hex").slice(0, 12);
+  return path.join(os.tmpdir(), `cequre-dev-${digest}-${port}.lock`);
+}
+function tryAcquireLock() {
+  if (!globalWsPort)
+    return false;
+  const lockPath = lockPathFor(globalWsPort);
+  try {
+    const fd = fs.openSync(lockPath, "wx");
+    fs.closeSync(fd);
+    return true;
+  } catch (e) {
+    if (e.code === "EEXIST")
+      return false;
+    throw e;
+  }
+}
+function releaseLock() {
+  if (!globalWsPort)
+    return;
+  const lockPath = lockPathFor(globalWsPort);
+  try {
+    fs.unlinkSync(lockPath);
+  } catch {}
+}
+function isGeneratedPath(filePath) {
+  const normalized = path.normalize(filePath);
+  return normalized.split(path.sep).some((part) => part === "_generated" || part === "generated") || normalized.endsWith("schema.json") || normalized.endsWith("cequre-sdk.ts");
+}
+function forwardStderr(stream, onLine) {
+  if (!stream)
+    return;
+  let pending = "";
+  stream.on("data", (data) => {
+    pending += data.toString();
+    const lines = pending.split(/\r?\n/);
+    pending = lines.pop() || "";
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (trimmed)
+        onLine(trimmed);
+    }
+  });
+  stream.on("end", () => {
+    const trimmed = pending.trim();
+    if (trimmed)
+      onLine(trimmed);
+  });
+}
+function attachBackendWatch(server, onReload) {
+  let reloadTimer;
+  let changedFile = "";
+  server.watcher.on("change", (filePath) => {
+    if (isGeneratedPath(filePath))
+      return;
+    const normalized = path.resolve(process.cwd(), filePath);
+    const relative = path.relative(process.cwd(), normalized);
+    const parts = relative.split(path.sep);
+    const startsWith = (...prefix) => prefix.every((part, index) => parts[index] === part);
+    const isBackendFile = startsWith("cequre") || startsWith("src", "server") || startsWith("src", "routes") || relative === "cequre.config.json" || relative.includes("cequre-generated");
+    if (!isBackendFile)
+      return;
+    changedFile = filePath;
+    if (reloadTimer)
+      clearTimeout(reloadTimer);
+    reloadTimer = setTimeout(() => {
+      reloadTimer = undefined;
+      const file = changedFile;
+      changedFile = "";
+      onReload(file);
+    }, 100);
+  });
+}
+function cequreVite(options = {}) {
+  let resolvedApiPrefix = resolveApiPrefix(options.apiPrefix);
+  if (!globalCleanupRegistered) {
+    globalCleanupRegistered = true;
+    g.__CEQURE_CLEANUP = true;
+    const cleanup = () => {
+      if (globalCequreProcess) {
+        globalCequreProcess.kill("SIGTERM");
+        globalCequreProcess = null;
+        g.__CEQURE_PROCESS = null;
+      }
+      releaseLock();
+    };
+    process.on("beforeExit", cleanup);
+    process.on("exit", cleanup);
+  }
+  return {
+    name: "cequre-vite-plugin",
+    async config(config, env) {
+      if (env.command === "serve") {
+        resolvedApiPrefix = resolveApiPrefix(options.apiPrefix);
+        const envPort = process.env.CEQURE_DEV_PORT;
+        if (envPort) {
+          globalWsPort = parseInt(envPort, 10);
+          g.__CEQURE_WS_PORT = globalWsPort;
+        } else if (!globalWsPort) {
+          const net = await import("net");
+          for (let port = 3001;port < 3100; port++) {
+            try {
+              await new Promise((resolve, reject) => {
+                const srv = net.createServer();
+                srv.unref();
+                srv.on("error", reject);
+                srv.listen(port, () => {
+                  srv.close(resolve);
+                });
+              });
+              globalWsPort = port;
+              g.__CEQURE_WS_PORT = port;
+              releaseLock();
+              break;
+            } catch (e) {}
+          }
+          if (!globalWsPort) {
+            throw new Error("[cequre.vite] No available port found in range 3001-3099. Set CEQURE_DEV_PORT env var or free a port in this range.");
+          }
+        }
+        const viteConfig = {
+          define: {
+            __CEQURE_DEV_WS_URL__: JSON.stringify(`ws://127.0.0.1:${globalWsPort}`)
+          },
+          server: {
+            proxy: {
+              "/admin": {
+                target: `http://127.0.0.1:${globalWsPort}`,
+                changeOrigin: false
+              },
+              [resolvedApiPrefix]: {
+                target: `http://127.0.0.1:${globalWsPort}`,
+                changeOrigin: true,
+                ws: true,
+                configure: (proxy, _options) => {
+                  proxy.on("proxyReq", (proxyReq, req) => {
+                    if (req && req.headers && req.headers.host) {
+                      proxyReq.setHeader("x-forwarded-host", req.headers.host);
+                      proxyReq.setHeader("x-forwarded-proto", req.socket?.encrypted ? "https" : "http");
+                    }
+                  });
+                  const originalEmit = proxy.emit.bind(proxy);
+                  proxy.emit = function(event, ...args) {
+                    if (event === "error" && args[0] && args[0].code === "ECONNREFUSED") {
+                      const res = args[2];
+                      if (res && !res.headersSent && typeof res.writeHead === "function") {
+                        res.writeHead(503, {
+                          "Content-Type": "application/json",
+                          "Retry-After": "1"
+                        });
+                        res.end(JSON.stringify({ error: "Cequre backend restarting", code: "ECONNREFUSED_CEQURE" }));
+                      }
+                      return false;
+                    }
+                    return originalEmit(event, ...args);
+                  };
+                }
+              }
+            }
+          }
+        };
+        return viteConfig;
+      }
+      return {};
+    },
+    async configureServer(server) {
+      const envName = server.environment?.name ?? server.config?.environments?.client?.name ?? "";
+      if (envName && envName !== "client")
+        return;
+      const spawnCequre = () => {
+        if (globalCequreProcess || !tryAcquireLock()) {
+          return;
+        }
+        const resolvedEntry = resolveEntryPoint(options.entry);
+        const exec = getExecutableCommand();
+        const args = [...exec.argsPrefix, "dev"];
+        if (resolvedEntry) {
+          args.push("--entry", resolvedEntry);
+        }
+        server.config.logger.info(`[cequre.vite] Attached Cequre API (${resolvedApiPrefix}) to Vite host.`);
+        globalCequreProcess = spawn(exec.command, args, {
+          cwd: process.cwd(),
+          stdio: ["ignore", "ignore", "pipe"],
+          env: { ...process.env, PORT: String(globalWsPort), HOST: "127.0.0.1", CEQURE_VITE_MODE: "1" }
+        });
+        g.__CEQURE_PROCESS = globalCequreProcess;
+        forwardStderr(globalCequreProcess.stderr, (msg) => {
+          server.config.logger.error(`[cequre] ${msg}`);
+        });
+        globalCequreProcess.on("close", (code) => {
+          if (code !== 0 && code !== null) {
+            server.config.logger.error(`[cequre.vite] Cequre binary exited with code ${code}`);
+          }
+          globalCequreProcess = null;
+          g.__CEQURE_PROCESS = null;
+          releaseLock();
+        });
+      };
+      const cequrePaths = [
+        path.resolve(process.cwd(), "cequre"),
+        path.resolve(process.cwd(), "cequre/server"),
+        path.resolve(process.cwd(), "cequre/schema"),
+        path.resolve(process.cwd(), "src/server"),
+        path.resolve(process.cwd(), "src/routes"),
+        path.resolve(process.cwd(), "cequre.config.json")
+      ].filter((p) => fs.existsSync(p));
+      if (cequrePaths.length > 0) {
+        server.watcher.add(cequrePaths);
+      }
+      attachBackendWatch(server, (filePath) => {
+        server.config.logger.info(`[cequre.vite] Backend / SDK updated (${path.basename(filePath)}), triggering Vite HMR reload`);
+        server.ws.send({ type: "full-reload" });
+      });
+      if (server.httpServer?.listening) {
+        spawnCequre();
+      } else if (server.httpServer?.once) {
+        server.httpServer.once("listening", spawnCequre);
+      } else {
+        server.httpServer?.on?.("listening", spawnCequre);
+      }
+    },
+    async closeBundle() {
+      if (options.autoBuild) {
+        const resolvedEntry = resolveEntryPoint(options.entry);
+        await cequreVite.build({ entry: resolvedEntry });
+      }
+    }
+  };
+}
+cequreVite.build = async function(options = {}) {
+  const entry = resolveEntryPoint(options.entry);
+  const outDir = options.outDir || "build/server";
+  const minify = options.minify !== false;
+  logger.info(`[cequre.vite] Starting production build...`);
+  const absEntry = path.resolve(process.cwd(), entry);
+  if (!fs.existsSync(absEntry)) {
+    throw new Error(`[cequre.vite] Entry point not found: ${absEntry}`);
+  }
+  let buildOutDir;
+  let naming;
+  if (options.outFile) {
+    const absOutFile = path.resolve(process.cwd(), options.outFile);
+    buildOutDir = path.dirname(absOutFile);
+    naming = path.basename(absOutFile);
+  } else {
+    buildOutDir = path.resolve(process.cwd(), outDir);
+    naming = "server.js";
+  }
+  if (!fs.existsSync(buildOutDir)) {
+    fs.mkdirSync(buildOutDir, { recursive: true });
+  }
+  logger.info(`[cequre.vite] Bundling Cequre API with Bun...`);
+  const targetOutputPath = path.join(buildOutDir, naming);
+  if (typeof Bun !== "undefined") {
+    const buildResult = await Bun.build({
+      entrypoints: [absEntry],
+      outdir: buildOutDir,
+      naming,
+      target: "bun",
+      minify
+    });
+    if (!buildResult.success) {
+      const errorDetails = buildResult.logs.map((log) => typeof log === "string" ? log : `${log.message ?? ""} (${log.position?.file ?? "?"}:${log.position?.line ?? "?"})`).join(`
+`);
+      throw new Error(`[cequre.vite] Bun.build failed:
+${errorDetails}`);
+    }
+  } else {
+    const localBin = path.join(process.cwd(), "node_modules", ".bin", "bun");
+    const bunCmd = fs.existsSync(localBin) ? localBin : "bun";
+    const minifyFlag = minify ? " --minify" : "";
+    try {
+      execSync(`${bunCmd} build "${absEntry}" --outfile "${targetOutputPath}" --target bun${minifyFlag}`, {
+        stdio: "inherit",
+        env: process.env
+      });
+    } catch (err) {
+      throw new Error(`[cequre.vite] Bundling Cequre API failed using '${bunCmd}'. Ensure Bun is installed on your system or run builds using Bun ('bun run build'). Error: ${err.message}`);
+    }
+  }
+  const entryBasename = path.basename(absEntry, path.extname(absEntry)) + ".js";
+  const entryFallbackPath = path.join(buildOutDir, entryBasename);
+  const actualPath = fs.existsSync(targetOutputPath) ? targetOutputPath : fs.existsSync(entryFallbackPath) ? entryFallbackPath : targetOutputPath;
+  logger.info(`[cequre.vite] API bundled successfully to: ${actualPath}`);
+  if (!fs.existsSync(actualPath)) {
+    throw new Error(`[cequre.vite] Build reported success but output not found: ${actualPath}`);
+  }
+};
+export {
+  cequreVite,
+  getExecutableCommand,
+  resolveApiPrefix,
+  resolveEntryPoint
+};

package/package.json

@@ -1,17 +1,17 @@
 {
   "name": "@cequrebackends/plugin-vite",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "license": "BSL-1.0",
   "type": "module",
-  "main": "./dist/next.js",
-  "module": "./dist/next.js",
-  "types": "./dist/next.d.ts",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
   "files": [
     "dist"
   ],
   "scripts": {
-    "build": "rm -rf dist && bun build ./src/next.ts --outdir ./dist --target bun --packages external && tsc --emitDeclarationOnly",
-    "dev": "bun build ./src/next.ts --outdir ./dist --target bun --packages external --watch"
+    "build": "rm -rf dist && bun build ./src/index.ts --outdir ./dist --target bun --packages external && tsc --emitDeclarationOnly",
+    "dev": "bun build ./src/index.ts --outdir ./dist --target bun --packages external --watch"
   },
   "peerDependencies": {
     "vite": "^8.0.0"
@@ -25,14 +25,9 @@
   "sideEffects": false,
   "exports": {
     ".": {
-      "types": "./dist/next.d.ts",
-      "import": "./dist/next.js",
-      "default": "./dist/next.js"
-    },
-    "./next": {
-      "types": "./dist/next.d.ts",
-      "import": "./dist/next.js",
-      "default": "./dist/next.js"
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
     }
   },
   "publishConfig": {

package/dist/bridge.d.ts

@@ -1,22 +0,0 @@
-import { IncomingMessage, ServerResponse } from "node:http";
-/**
- * Convert a Fetch Request into a node IncomingMessage suitable for Vite's
- * Connect-style middleware. Vite's dev server expects Node's http model;
- * Bun's server speaks Fetch — this shim is the entire bridge (spike-verified,
- * /tmp/vite-spike/spike1.ts).
- */
-export declare function fetchToIncoming(req: Request): IncomingMessage;
-export interface ShimmedResult {
-    status: number;
-    headers: Record<string, string | string[]>;
-    body: Buffer;
-}
-/**
- * Collects node-style writes and hands back a Fetch-shaped result on end().
- * Vite middleware writes via res.writeHead/setHeader/write/end; we capture
- * those calls and resolve once so Bun.serve can respond.
- */
-export declare class ShimResponse extends ServerResponse {
-    constructor(onFinish: (result: ShimmedResult) => void);
-}
-//# sourceMappingURL=bridge.d.ts.map

package/dist/bridge.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"bridge.d.ts","sourceRoot":"","sources":["../src/bridge.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AAI5D;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,GAAG,EAAE,OAAO,GAAG,eAAe,CAkB7D;AAED,MAAM,WAAW,aAAa;IAC5B,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC,CAAC;IAC3C,IAAI,EAAE,MAAM,CAAC;CACd;AAED;;;;GAIG;AACH,qBAAa,YAAa,SAAQ,cAAc;IAC9C,YAAY,QAAQ,EAAE,CAAC,MAAM,EAAE,aAAa,KAAK,IAAI,EAkCpD;CACF"}

package/dist/next.d.ts

@@ -1,38 +0,0 @@
-import type { CequrePlugin } from "cequre-ts";
-import { type InlineConfig } from "vite";
-export interface VitePluginNextOptions {
-    /** Frontend root dir containing index.html. Default: process.cwd() */
-    root?: string;
-    /**
-     * Built asset output dir (production). When present and readable at init,
-     * every file registers a route under /assets/<file> whose handler reads
-     * the file from disk lazily on first request — no eager in-memory load.
-     */
-    prodAssetsDir?: string;
-    /** URL prefixes owned by Cequre that never fall through to Vite. */
-    backendPrefixes?: string[];
-    /** Loopback port for the HMR websocket. Default: CEQURE_VITE_HMR_PORT env or Vite's auto-pick. */
-    hmrPort?: number;
-    /** Extra inline Vite config merged into the server config (user vite.config.ts wins where both specify). */
-    viteConfig?: InlineConfig;
-}
-/**
- * Vite as a first-class Cequre plugin.
- *
- * Dev mode: Vite dev server runs IN-PROCESS in middleware mode. preRequest
- * bridges frontend traffic to it; /api, /admin and /health stay with Cequre.
- * HMR runs on a dedicated loopback port (Fetch API cannot pass websocket
- * upgrades through — spike-verified).
- *
- * Prod mode: point prodAssetsDir at `vite build` output; hashed assets are
- * registered as routes whose handlers lazily read them from disk on first
- * request.
- *
- * Anti-lock-in guarantees:
- * - cequre-ts never imports this package (one-way dependency)
- * - options map to standard Vite config (mergeConfig), no proprietary schema
- * - eject = remove plugin from plugins[], run plain `vite` + proxy /api
- */
-export declare function vitePluginNext(options?: VitePluginNextOptions): CequrePlugin;
-export declare const cequreViteNext: typeof vitePluginNext;
-//# sourceMappingURL=next.d.ts.map

package/dist/next.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"next.d.ts","sourceRoot":"","sources":["../src/next.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,WAAW,CAAC;AAE9C,OAAO,EAAiD,KAAK,YAAY,EAAE,MAAM,MAAM,CAAC;AAKxF,MAAM,WAAW,qBAAqB;IACpC,sEAAsE;IACtE,IAAI,CAAC,EAAE,MAAM,CAAC;IACd;;;;OAIG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,oEAAoE;IACpE,eAAe,CAAC,EAAE,MAAM,EAAE,CAAC;IAC3B,kGAAkG;IAClG,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,4GAA4G;IAC5G,UAAU,CAAC,EAAE,YAAY,CAAC;CAC3B;AAwED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,cAAc,CAAC,OAAO,GAAE,qBAA0B,GAAG,YAAY,CAgEhF;AAID,eAAO,MAAM,cAAc,uBAAiB,CAAC"}

package/dist/next.js

@@ -1,164 +0,0 @@
-// @bun
-// src/next.ts
-import { createServer as createViteServer, mergeConfig } from "vite";
-import { readdirSync } from "fs";
-import path from "path";
-
-// src/bridge.ts
-import { IncomingMessage, ServerResponse } from "http";
-import { Socket } from "net";
-import { Readable } from "stream";
-function fetchToIncoming(req) {
-  const url = new URL(req.url);
-  const incoming = new IncomingMessage(new Socket);
-  incoming.method = req.method;
-  incoming.url = url.pathname + url.search;
-  incoming.httpVersion = "1.1";
-  incoming.rawHeaders = [];
-  req.headers.forEach((value, key) => incoming.rawHeaders.push(key, value));
-  if (req.body) {
-    const nodeStream = Readable.fromWeb(req.body);
-    nodeStream.on("data", (chunk) => incoming.push(chunk));
-    nodeStream.on("end", () => incoming.push(null));
-    nodeStream.on("error", (err) => incoming.destroy(err));
-  }
-  return incoming;
-}
-
-class ShimResponse extends ServerResponse {
-  constructor(onFinish) {
-    const stub = Object.create(null);
-    stub.writable = true;
-    stub.writableEnded = false;
-    stub.allowHalfOpen = false;
-    stub.emit = () => false;
-    stub.on = stub.once = stub.off = stub.removeListener = () => stub;
-    super(stub);
-    const chunks = [];
-    const headers = {};
-    this.writeHead = (status, ...rest) => {
-      const h = rest[rest.length - 1];
-      if (h && typeof h === "object")
-        Object.assign(headers, h);
-      this.statusCode = status;
-      return this;
-    };
-    this.setHeader = (k, v) => {
-      headers[k] = v;
-      return this;
-    };
-    this.write = (chunk) => {
-      chunks.push(typeof chunk === "string" ? Buffer.from(chunk) : Buffer.from(chunk));
-      return true;
-    };
-    this.end = (chunk) => {
-      if (chunk)
-        chunks.push(typeof chunk === "string" ? Buffer.from(chunk) : Buffer.from(chunk));
-      onFinish({ status: this.statusCode || 200, headers, body: Buffer.concat(chunks) });
-      return this;
-    };
-  }
-}
-
-// src/next.ts
-var DEFAULT_BACKEND_PREFIXES = ["/api", "/admin", "/health"];
-var MIME_BY_EXT = {
-  ".js": "application/javascript",
-  ".mjs": "application/javascript",
-  ".css": "text/css",
-  ".html": "text/html; charset=utf-8",
-  ".svg": "image/svg+xml",
-  ".json": "application/json",
-  ".png": "image/png",
-  ".jpg": "image/jpeg",
-  ".jpeg": "image/jpeg",
-  ".webp": "image/webp",
-  ".woff": "font/woff",
-  ".woff2": "font/woff2",
-  ".map": "application/json",
-  ".gif": "image/gif",
-  ".ico": "image/x-icon",
-  ".ttf": "font/ttf",
-  ".otf": "font/otf",
-  ".wasm": "application/wasm",
-  ".webm": "video/webm",
-  ".mp4": "video/mp4",
-  ".pdf": "application/pdf"
-};
-function contentTypeFor(file) {
-  return MIME_BY_EXT[path.extname(file).toLowerCase()] ?? "application/octet-stream";
-}
-async function registerProdAssets(app, prodAssetsDir) {
-  if (!prodAssetsDir)
-    return;
-  let files;
-  try {
-    files = readdirSync(prodAssetsDir);
-  } catch {
-    return;
-  }
-  for (const file of files) {
-    const filePath = path.join(prodAssetsDir, file);
-    const contentType = contentTypeFor(file);
-    app.router.get(`/assets/${file}`, async () => {
-      const bytes = await Bun.file(filePath).arrayBuffer();
-      return new Response(bytes, {
-        headers: {
-          "Content-Type": contentType,
-          "Cache-Control": "public, max-age=31536000, immutable"
-        }
-      });
-    }, {
-      ignorePrefix: true
-    });
-  }
-}
-function vitePluginNext(options = {}) {
-  let vite;
-  const backendPrefixes = options.backendPrefixes ?? DEFAULT_BACKEND_PREFIXES;
-  const isBackendPath = (pathname) => backendPrefixes.some((p) => pathname === p || pathname.startsWith(p + "/"));
-  return {
-    name: "cequre:vite",
-    async onInit(app) {
-      const hmrPort = options.hmrPort ?? (process.env.CEQURE_VITE_HMR_PORT ? Number(process.env.CEQURE_VITE_HMR_PORT) : undefined);
-      vite = await createViteServer(mergeConfig({
-        root: options.root ?? process.cwd(),
-        logLevel: "info",
-        server: {
-          middlewareMode: true,
-          hmr: hmrPort ? { port: hmrPort } : undefined
-        },
-        appType: "spa"
-      }, options.viteConfig ?? {}));
-      app.__vite = vite;
-      await registerProdAssets(app, options.prodAssetsDir);
-    },
-    preRequest(request) {
-      const pathname = new URL(request.url).pathname;
-      if (isBackendPath(pathname))
-        return;
-      if (!vite)
-        return;
-      return new Promise((resolve) => {
-        const shim = new ShimResponse(({ status, headers, body }) => resolve(new Response(new Uint8Array(body), { status, headers })));
-        try {
-          vite.middlewares(fetchToIncoming(request), shim, () => {
-            resolve(undefined);
-          });
-        } catch (err) {
-          console.error("[cequre:vite] middleware error:", err);
-          resolve(undefined);
-        }
-      });
-    },
-    async onDestroy() {
-      await vite?.close();
-      vite = undefined;
-    }
-  };
-}
-var cequreViteNext = vitePluginNext;
-export {
-  cequreViteNext,
-  vitePluginNext
-};