@torpor/build 0.0.5 → 0.1.0

package/dist/bin/index.cjs

@@ -24,115 +24,563 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 
 // src/bin/index.ts
-var import_node_fs = __toESM(require("fs"), 1);
-var import_path = __toESM(require("path"), 1);
+var import_node_fs4 = __toESM(require("fs"), 1);
+var import_node_path4 = __toESM(require("path"), 1);
+var import_vite5 = require("vite");
 
-// src/site/defineConfig.ts
+// src/site/runBuild.ts
 var import_vite = __toESM(require("@torpor/unplugin/vite"), 1);
+var import_node_fs2 = require("fs");
+var import_node_path2 = __toESM(require("path"), 1);
+var import_node_url = require("url");
+var import_vite2 = require("vite");
+
+// src/site/manifest.ts
+var import_node_fs = require("fs");
 var import_node_path = __toESM(require("path"), 1);
-var import_vinxi = require("vinxi");
-var import_config = require("vinxi/plugins/config");
-
-// src/site/FileSystemRouter.ts
-var import_fs_router = require("vinxi/fs-router");
-var FileSystemRouter = class extends import_fs_router.BaseFileSystemRouter {
-  toPath(src) {
-    let routePath = (0, import_fs_router.cleanPath)(src, this.config).replace(/^\//, "").replace(/_hook.server$/, "_hook/~server").replace(/_layout.server$/, "_layout/~server").replace(/\+page.server$/, "~server").replace(/\+page$/, "").replace(/\+server$/, "").replace(/\/$/, "");
-    return routePath?.length > 0 ? `/${routePath}` : "/";
-  }
-  toRoute(filePath) {
-    return {
-      path: this.toPath(filePath),
-      $handler: {
-        src: filePath,
-        pick: ["default"]
+var moduleId = "@torpor/build/manifest";
+function manifest(site, server = false) {
+  return {
+    name: "torpor-manifest",
+    resolveId: {
+      order: "pre",
+      handler(id) {
+        if (id === moduleId) {
+          return id;
+        }
       }
-    };
-  }
+    },
+    load(id) {
+      if (id === moduleId) {
+        return `
+${!server ? "const load = { default: { load: true } };" : ""}
+export default {
+  routes: [
+    ${site.routes.map((r) => {
+          if (server || !/server\.(ts|js)$/.test(r.file)) {
+            return `{ path: "${r.path}", file: "${r.file}", type: ${r.type}, endPoint: ${server || !/server\.(ts|js)$/.test(r.file) ? `() => import(/* @vite-ignore */ "${import_node_path.default.join(site.root, r.file)}")` : "undefined"} }`;
+          } else {
+            const haveLoad = (0, import_node_fs.readFileSync)(import_node_path.default.join(site.root, r.file)).includes("load:");
+            return `{ path: "${r.path}", file: "${r.file}", type: ${r.type}, endPoint: ${haveLoad ? "() => load" : "undefined"} }`;
+          }
+        }).join(",\n    ")}
+  ],
 };
+`;
+      }
+    }
+  };
+}
 
-// src/site/defineConfig.ts
-function defineConfig(options2) {
-  process.env.PORT = (options2?.port || 7059).toString();
-  return (0, import_vinxi.createApp)({
-    name: "torpor",
-    routers: [
-      {
-        name: "assets",
-        type: "static",
-        dir: "./src/assets"
-      },
-      // Doesn't look like we can have two server routes?
-      // Have to put api in /routes
-      // Maybe we can support having /routes/api and routes/site and stripping /site from the start?
-      //{
-      //	name: "api",
-      //	type: "http",
-      //	target: "server",
-      //	// TODO: change this when published
-      //	handler: "node_modules/@torpor/build/src/site/serverEntry.ts",
-      //	routes: apiRoutes,
-      //	plugins: () => [config("custom", viteOptions())],
-      //},
-      {
-        name: "server",
-        type: "http",
-        target: "server",
-        // TODO: change this when published
-        handler: "./node_modules/@torpor/build/src/site/serverEntry.ts",
-        routes,
-        plugins: () => [(0, import_config.config)("custom", viteOptions()), (0, import_vite.default)({ server: true })]
-      },
-      {
-        name: "client",
-        type: "client",
-        target: "browser",
-        // TODO: change this when published
-        handler: "./node_modules/@torpor/build/src/site/clientEntry.ts",
-        base: "/_build",
-        routes,
-        plugins: () => [(0, import_config.config)("custom", viteOptions()), (0, import_vite.default)()]
+// src/site/runBuild.ts
+var import_meta = {};
+var __dirname = import_node_path2.default.dirname((0, import_node_url.fileURLToPath)(import_meta.url));
+async function runBuild(site) {
+  const distFolder = import_node_path2.default.resolve(site.root, "dist");
+  if ((0, import_node_fs2.existsSync)(distFolder)) {
+    await import_node_fs2.promises.rm(distFolder, { recursive: true });
+  }
+  const clientFolder = import_node_path2.default.join(distFolder, "client");
+  const serverFolder = import_node_path2.default.join(distFolder, "server");
+  if (site.adapter.prebuild) {
+    await site.adapter.prebuild(site);
+  }
+  let siteHtml = import_node_path2.default.resolve(site.root, "src/site.html");
+  let clientScript = import_node_path2.default.resolve(__dirname, "../../src/site/clientEntry.ts");
+  let serverScript = import_node_path2.default.resolve(__dirname, "../../src/site/serverEntry.ts");
+  await (0, import_vite2.build)(
+    (0, import_vite2.defineConfig)({
+      plugins: [
+        manifest(site),
+        // @ts-ignore
+        (0, import_vite.default)(),
+        ...site.plugins
+      ],
+      build: {
+        outDir: clientFolder,
+        rollupOptions: {
+          input: [
+            siteHtml,
+            clientScript,
+            ...site.routes.filter((r) => !/server\.(ts|js)$/.test(r.file)).map((r) => import_node_path2.default.resolve(site.root, r.file))
+          ]
+        },
+        ssrManifest: true
       }
-    ]
+    })
+  );
+  await (0, import_vite2.build)(
+    (0, import_vite2.defineConfig)({
+      plugins: [
+        manifest(site, true),
+        // @ts-ignore
+        (0, import_vite.default)(),
+        ...site.plugins
+      ],
+      build: {
+        outDir: serverFolder,
+        rollupOptions: {
+          input: [serverScript, ...site.routes.map((r) => import_node_path2.default.resolve(site.root, r.file))]
+        },
+        ssr: serverScript
+      }
+    })
+  );
+  siteHtml = import_node_path2.default.join(clientFolder, "site.html");
+  await import_node_fs2.promises.rename(import_node_path2.default.join(clientFolder, "src", "site.html"), siteHtml);
+  await import_node_fs2.promises.rm(import_node_path2.default.join(clientFolder, "src"), { recursive: true });
+  if (site.adapter.postbuild) {
+    await site.adapter.postbuild(site);
+  }
+}
+
+// src/site/runDev.ts
+var import_vite3 = __toESM(require("@torpor/unplugin/vite"), 1);
+var import_dotenv = require("dotenv");
+var import_node_fs3 = require("fs");
+var import_node_path3 = __toESM(require("path"), 1);
+var import_node_url2 = require("url");
+var import_vite4 = require("vite");
+
+// src/adapters/node/flattenHeaders.ts
+function flattenHeaders(headers) {
+  const flatHeaders = new Headers();
+  for (const [key, value] of Object.entries(headers)) {
+    if (value === void 0 || value === null) {
+      continue;
+    } else if (Array.isArray(value)) {
+      for (const v of value) {
+        if (v !== void 0 && v !== null) {
+          value.forEach((v2) => flatHeaders.append(key, v2));
+        }
+      }
+    } else {
+      flatHeaders.set(key, String(value));
+    }
+  }
+  return flatHeaders;
+}
+
+// src/adapters/node/nodeMessageToNodeResponse.ts
+var import_node_http = require("http");
+var import_node_stream = require("stream");
+function nodeMessageToNodeResponse(incomingMessage) {
+  const res = new import_node_http.ServerResponse(incomingMessage);
+  const passThrough = new import_node_stream.PassThrough();
+  let handled = false;
+  const onReadable = (cb) => {
+    const handleReadable = () => {
+      if (handled) return;
+      handled = true;
+      cb({
+        readable: import_node_stream.Readable.from(passThrough),
+        headers: res.getHeaders(),
+        status: res.statusCode
+      });
+    };
+    passThrough.once("readable", handleReadable);
+    passThrough.once("end", handleReadable);
+  };
+  passThrough.once("finish", () => {
+    res.emit("finish");
+  });
+  passThrough.once("close", () => {
+    res.destroy();
+    res.emit("close");
   });
+  passThrough.on("drain", () => {
+    res.emit("drain");
+  });
+  res.write = passThrough.write.bind(passThrough);
+  res.end = passThrough.end.bind(passThrough);
+  res.writeHead = function writeHead(statusCode, statusMessage, headers) {
+    res.statusCode = statusCode;
+    if (typeof statusMessage === "object") {
+      headers = statusMessage;
+      statusMessage = void 0;
+    }
+    if (headers) {
+      for (const [key, value] of Object.entries(headers)) {
+        if (value !== void 0) {
+          res.setHeader(key, value);
+        }
+      }
+    }
+    return res;
+  };
+  return {
+    res,
+    onReadable
+  };
 }
-function routes(router, app) {
-  return new FileSystemRouter(
-    {
-      dir: import_node_path.default.resolve("src/routes"),
-      extensions: ["js", "ts"]
-    },
-    router,
-    app
+
+// src/adapters/node/readableToBuffer.ts
+function readableToBuffer(req) {
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    req.on("data", (chunk) => {
+      chunks.push(chunk);
+    });
+    req.on("end", () => {
+      resolve(Buffer.concat(chunks));
+    });
+    req.on("error", (err) => {
+      reject(err);
+    });
+  });
+}
+
+// src/adapters/node/requestToNodeMessage.ts
+var import_node_stream2 = require("stream");
+var DUMMY_BASE_URL = "http://localhost";
+function requestToNodeMessage(request) {
+  const parsedUrl = new URL(request.url, DUMMY_BASE_URL);
+  const pathAndQuery = (parsedUrl.pathname || "") + (parsedUrl.search || "");
+  const body = (
+    /*request.body ? Readable.fromWeb(request.body as any) :*/
+    import_node_stream2.Readable.from([])
   );
+  return Object.assign(body, {
+    url: pathAndQuery,
+    method: request.method,
+    headers: Object.fromEntries(request.headers)
+  });
 }
-function viteOptions() {
-  return {
-    resolve: {
-      alias: {
-        "@": import_node_path.default.resolve("src")
+
+// src/adapters/node/createMiddlewareHandler.ts
+function createMiddlewareHandler(handler) {
+  return async (ev, next) => {
+    const req = requestToNodeMessage(ev.request);
+    const { res, onReadable } = nodeMessageToNodeResponse(req);
+    return new Promise(async (resolve, reject) => {
+      onReadable(async ({ readable, headers, status }) => {
+        const responseBody = statusCodesWithoutBody.includes(status) ? null : (
+          //(Readable.toWeb(readable) as ReadableStream);
+          // HACK: Chunked bodies are not being
+          // read correctly somewhere...
+          await readableToBuffer(readable)
+        );
+        ev.response = new Response(responseBody, {
+          status,
+          headers: flattenHeaders(headers)
+        });
+        resolve();
+      });
+      const cnext = async (error) => {
+        if (error) {
+          reject(error instanceof Error ? error : new Error(String(error)));
+        } else {
+          await next();
+          resolve();
+        }
+      };
+      try {
+        const handled = await handler(req, res, cnext);
+        if (handled === false) {
+          res.destroy();
+          resolve();
+        }
+      } catch (e) {
+        cnext(e);
       }
+    });
+  };
+}
+var statusCodesWithoutBody = [
+  100,
+  // Continue
+  101,
+  // Switching Protocols
+  102,
+  // Processing (WebDAV)
+  103,
+  // Early Hints
+  204,
+  // No Content
+  205,
+  // Reset Content
+  304
+  // Not Modified
+];
+
+// src/response/response.ts
+function response(status, body) {
+  let headers = void 0;
+  if (body) {
+    if (typeof body === "object") {
+      headers = { "content-type": "application/json" };
+      body = JSON.stringify(body);
+    } else {
+      headers = { "content-type": "text/plain" };
     }
+  }
+  return new Response(body, {
+    status,
+    headers
+  });
+}
+
+// src/response/serverError.ts
+function serverError(body) {
+  return response(500, body);
+}
+
+// src/site/pathToRegex.ts
+function pathToRegex(path5) {
+  const pattern = path5.split("/").map((p) => {
+    return p.replace(/\[([^\/]+?)\]/, "(?<$1>[^\\/]+?)");
+  }).join("\\/").replaceAll("*", ".*");
+  return new RegExp(`^${pattern}$`);
+}
+
+// src/server/CookieHelper.ts
+var import_cookie = require("cookie");
+var CookieHelper = class {
+  request;
+  cookies = /* @__PURE__ */ new Map();
+  constructor(request) {
+    this.request = request;
+  }
+  get(name) {
+    if (this.cookies.has(name)) {
+      return this.cookies.get(name);
+    }
+    const header = this.request.headers.get("cookie");
+    return (0, import_cookie.parse)(header ?? "")[name];
+  }
+  set(name, value, options) {
+    options ??= {};
+    options.httpOnly ??= true;
+    options.secure ??= true;
+    options.sameSite ??= "lax";
+    this.cookies.set(name, (0, import_cookie.serialize)(name, value, options));
+  }
+  delete(name, options) {
+    options ??= {};
+    options.expires = /* @__PURE__ */ new Date(0);
+    this.cookies.set(name, (0, import_cookie.serialize)(name, "", options));
+  }
+};
+
+// src/server/HeaderHelper.ts
+var HeaderHelper = class {
+  request;
+  headers = /* @__PURE__ */ new Map();
+  constructor(request) {
+    this.request = request;
+  }
+  get(name) {
+    if (this.headers.has(name)) {
+      return this.headers.get(name);
+    }
+    return this.request.headers.get(name) ?? void 0;
+  }
+  set(name, value) {
+    this.headers.set(name, value);
+  }
+  delete(name) {
+    this.headers.delete(name);
+  }
+};
+
+// src/server/ServerEvent.ts
+var ServerEvent = class {
+  request;
+  response;
+  // TODO: Should we cast types??
+  params;
+  cookies;
+  headers;
+  constructor(request, params) {
+    this.request = request;
+    this.params = params;
+    this.cookies = new CookieHelper(request);
+    this.headers = new HeaderHelper(request);
+  }
+  addHeaders() {
+    if (!this.response) {
+      throw new Error("Response not created yet");
+    }
+    for (let cookie of this.cookies.cookies.values()) {
+      this.response.headers.append("set-cookie", cookie);
+    }
+    for (let header of this.headers.headers.entries()) {
+      this.response.headers.append(header[0], header[1]);
+    }
+  }
+};
+
+// src/server/Server.ts
+var noop = () => {
+};
+var Server = class {
+  // TODO: We don't use any of the routes, just add("*") in runDev/runBuild...
+  routes = [];
+  // TODO: We only use the Vite middleware here
+  middleware = [];
+  constructor() {
+    this.routes = [];
+    this.middleware = [];
+  }
+  /**
+   * The standard Fetch API method that should work in any runtime (including
+   * Node with polyfills).
+   * @returns
+   */
+  fetch = async (input, init) => {
+    const request = new Request(input, init);
+    const url = new URL(request.url);
+    const match = this.match(url.pathname);
+    let ev = new ServerEvent(request, match?.params);
+    if (this.middleware.length) {
+      let buildNext2 = function(middleware, i) {
+        if (ev.response) {
+          return noop;
+        }
+        if (i < middleware.length - 1) {
+          let next = middleware[i + 1];
+          return async () => next(ev, buildNext2(middleware, i + 1));
+        } else {
+          return match ? async () => {
+            ev.response = await match.fn(ev);
+          } : noop;
+        }
+      };
+      var buildNext = buildNext2;
+      await this.middleware[0](ev, buildNext2(this.middleware, 0));
+    } else if (match) {
+      ev.response = await match.fn(ev);
+    } else {
+      return new Response(null, { status: 404 });
+    }
+    ev.response ??= new Response(null, { status: 200 });
+    ev.addHeaders();
+    return ev.response;
   };
+  /**
+   * Adds a server function at a route path.
+   * @param path The route path pattern.
+   * @param fn The function to call when the pattern is matched.
+   * @returns
+   */
+  add(path5, fn) {
+    this.routes.push(new RouteHandler(path5, fn));
+    return this;
+  }
+  match(path5) {
+    for (let handler of this.routes) {
+      let match = path5.match(handler.regex);
+      if (match) {
+        return {
+          fn: handler.fn,
+          params: match.groups
+        };
+      }
+    }
+    console.log(`Server path not found: ${path5}`);
+  }
+  // TODO:
+  //use(path: string, ...fn: MiddlewareFunction[])
+  use(...fn) {
+    this.middleware = this.middleware.concat(fn);
+    return this;
+  }
+};
+var RouteHandler = class {
+  path;
+  regex;
+  fn;
+  constructor(path5, fn) {
+    this.path = path5;
+    this.regex = pathToRegex(path5);
+    this.fn = fn;
+  }
+};
+
+// src/site/prepareTemplate.ts
+function prepareTemplate(template, clientScript) {
+  let contentStart = regexIndexOf(template, /\<div\s+id=("app"|'app'|app)\s+/);
+  contentStart = template.indexOf(">", contentStart) + 1;
+  let contentEnd = template.indexOf("</div>", contentStart);
+  if (contentStart === -1 || contentEnd === -1) {
+    throw new Error(`Couldn't find <div id="app"></div>`);
+  }
+  return template.substring(0, contentStart) + "%COMPONENT_HTML%" + template.substring(contentEnd) + `<script type="module" src="${clientScript}"></script>`;
+}
+function regexIndexOf(string, regex, position) {
+  var indexOf = string.substring(position || 0).search(regex);
+  return indexOf >= 0 ? indexOf + (position || 0) : indexOf;
 }
 
-// src/bin/index.ts
-var options;
-var workingDir = process.cwd();
-var jsConfigFile = import_path.default.join(workingDir, "torpor.config.js");
-var tsConfigFile = import_path.default.join(workingDir, "torpor.config.ts");
-var source;
-if (import_node_fs.default.existsSync(jsConfigFile)) {
-  source = import_node_fs.default.readFileSync(jsConfigFile, "utf8");
-  source = source.replace(
-    /import\s+\{\s+defineConfig\s+\}\s+from\s+["']@torpor\/build["']/,
-    "const defineConfig = (x) => x"
-  ).replace("export default", "");
-} else if (import_node_fs.default.existsSync(tsConfigFile)) {
-  console.log("TS config file is not supported");
+// src/site/runDev.ts
+var import_meta2 = {};
+var __dirname2 = import_node_path3.default.dirname((0, import_node_url2.fileURLToPath)(import_meta2.url));
+async function runDev(site) {
+  const server = new Server();
+  const vite = await (0, import_vite4.createServer)({
+    server: { middlewareMode: true },
+    appType: "custom",
+    plugins: [
+      manifest(site, true),
+      // @ts-ignore not sure...
+      (0, import_vite3.default)(),
+      ...site.plugins
+    ]
+  });
+  const templateFile = import_node_path3.default.resolve(site.root, "src/site.html");
+  let template = await import_node_fs3.promises.readFile(templateFile, "utf-8");
+  template = await vite.transformIndexHtml("", template);
+  const clientScript = import_node_path3.default.resolve(__dirname2, "../../src/site/clientEntry.ts");
+  const serverScript = import_node_path3.default.resolve(__dirname2, "../../src/site/serverEntry.ts");
+  template = prepareTemplate(template, clientScript);
+  server.use(createMiddlewareHandler(vite.middlewares));
+  server.add("*", async (ev) => {
+    try {
+      const { load } = await vite.ssrLoadModule(serverScript);
+      return await load(ev, template);
+    } catch (e) {
+      vite.ssrFixStacktrace(e);
+      return serverError(e);
+    }
+  });
+  (0, import_dotenv.configDotenv)();
+  process.env.PROTOCOL ??= "http:";
+  process.env.HOST ??= "localhost";
+  process.env.PORT ??= "7059";
+  site.adapter.serve(server, site);
 }
-if (source) {
-  options = eval(source);
+
+// src/bin/index.ts
+run();
+async function run() {
+  const workingDir = process.cwd();
+  let configFile = "";
+  let deleteConfigFile = false;
+  const jsConfigFile = import_node_path4.default.join(workingDir, "site.config.js");
+  const tsConfigFile = import_node_path4.default.join(workingDir, "site.config.ts");
+  if (import_node_fs4.default.existsSync(jsConfigFile)) {
+    configFile = jsConfigFile;
+  } else if (import_node_fs4.default.existsSync(tsConfigFile)) {
+    configFile = import_node_path4.default.join(workingDir, "site.config.temp.js");
+    let source = (await (0, import_vite5.transformWithEsbuild)(import_node_fs4.default.readFileSync(tsConfigFile, "utf-8"), tsConfigFile, {
+      loader: "ts"
+    })).code;
+    import_node_fs4.default.writeFileSync(configFile, source);
+    deleteConfigFile = true;
+  } else {
+    throw new Error("site.config file not found");
+  }
+  const site = (await import(configFile)).default;
+  if (!site || !site.root || !site.routes) {
+    throw new Error("Invalid site in config file");
+  }
+  if (deleteConfigFile) {
+    import_node_fs4.default.rmSync(configFile);
+  }
+  if (process.argv.includes("--dev")) {
+    await runDev(site);
+  } else if (process.argv.includes("--build")) {
+    await runBuild(site);
+  }
 }
-defineConfig(options);
 //# sourceMappingURL=index.cjs.map