@batijs/cli 0.0.184 → 0.0.186

package/dist/boilerplates/@batijs/hono/files/$package.json.js

@@ -0,0 +1,121 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// package.json
+var require_package = __commonJS({
+  "package.json"(exports, module) {
+    module.exports = {
+      name: "@batijs/hono",
+      private: true,
+      version: "0.0.1",
+      description: "",
+      type: "module",
+      scripts: {
+        "check-types": "tsc --noEmit",
+        build: "bati-compile-boilerplate"
+      },
+      keywords: [],
+      author: "",
+      license: "MIT",
+      devDependencies: {
+        "@auth/core": "^0.29.0",
+        "@batijs/compile": "workspace:*",
+        "@batijs/firebase-auth": "workspace:*",
+        "@batijs/trpc": "workspace:^",
+        "@hono/node-server": "^1.11.1",
+        "@hono/vite-dev-server": "^0.12.0",
+        "@trpc/server": "^10.45.2",
+        "@types/node": "^18.19.14",
+        "firebase-admin": "^12.1.0",
+        hono: "^4.2.9",
+        telefunc: "^0.1.72",
+        tsx: "^4.7.2",
+        vike: "^0.4.168",
+        "vike-authjs": "^0.1.5",
+        vite: "^5.2.8"
+      },
+      dependencies: {
+        "@batijs/core": "workspace:*"
+      },
+      files: [
+        "dist/"
+      ],
+      bati: {
+        if: {
+          flag: "hono"
+        }
+      },
+      exports: {
+        "./hono-entry": {
+          types: "./dist/types/hono-entry.d.ts"
+        }
+      },
+      typesVersions: {
+        "*": {
+          "hono-entry": [
+            "./dist/types/hono-entry.d.ts"
+          ]
+        }
+      }
+    };
+  }
+});
+
+// files/$package.json.ts
+import { addDependency, loadAsJson, setScripts } from "@batijs/core";
+async function getPackageJson(props) {
+  const packageJson = await loadAsJson(props);
+  setScripts(packageJson, {
+    dev: {
+      value: "vite",
+      precedence: 20,
+      warnIfReplaced: true
+    },
+    build: {
+      value: "vite build",
+      precedence: 1,
+      warnIfReplaced: true
+    },
+    preview: {
+      value: "NODE_ENV=production tsx ./hono-entry.ts",
+      precedence: 20
+    }
+  });
+  return addDependency(packageJson, await Promise.resolve().then(() => __toESM(require_package(), 1)).then((x) => x.default), {
+    devDependencies: ["@hono/vite-dev-server", "@types/node"],
+    dependencies: [
+      "@hono/node-server",
+      "hono",
+      "tsx",
+      "vite",
+      "vike",
+      ...props.meta.BATI.has("authjs") ? ["@auth/core", "vike-authjs"] : []
+    ]
+  });
+}
+export {
+  getPackageJson as default
+};

package/dist/boilerplates/@batijs/hono/files/$vite.config.ts.js

@@ -0,0 +1,26 @@
+// files/$vite.config.ts.ts
+import { addVitePlugin, loadAsMagicast } from "@batijs/core";
+async function getViteConfig(props) {
+  const mod = await loadAsMagicast(props);
+  addVitePlugin(mod, {
+    from: "@hono/vite-dev-server",
+    constructor: "devServer",
+    options: {
+      entry: "hono-entry.ts",
+      exclude: [
+        /^\/@.+$/,
+        /.*\.(ts|tsx|vue)($|\?)/,
+        /.*\.(s?css|less)($|\?)/,
+        /^\/favicon\.ico$/,
+        /.*\.(svg|png)($|\?)/,
+        /^\/(public|assets|static)\/.+/,
+        /^\/node_modules\/.*/
+      ],
+      injectClientScript: false
+    }
+  });
+  return mod.generate().code;
+}
+export {
+  getViteConfig as default
+};

package/dist/boilerplates/@batijs/hono/files/hono-entry.ts

@@ -0,0 +1,183 @@
+import CredentialsProvider from "@auth/core/providers/credentials";
+import { firebaseAdmin } from "@batijs/firebase-auth/libs/firebaseAdmin";
+import { appRouter } from "@batijs/trpc/trpc/server";
+import { serve } from "@hono/node-server";
+import { serveStatic } from "@hono/node-server/serve-static";
+import { fetchRequestHandler, type FetchCreateContextFnOptions } from "@trpc/server/adapters/fetch";
+import { getAuth } from "firebase-admin/auth";
+import { Hono } from "hono";
+import { compress } from "hono/compress";
+import { deleteCookie, getCookie, setCookie } from "hono/cookie";
+import { telefunc } from "telefunc";
+import { VikeAuth } from "vike-authjs";
+import { renderPage } from "vike/server";
+
+const isProduction = process.env.NODE_ENV === "production";
+const port = process.env.PORT ? parseInt(process.env.PORT, 10) : 3000;
+
+const app = new Hono();
+
+app.use(compress());
+
+if (isProduction) {
+  app.use(
+    "/*",
+    serveStatic({
+      root: `dist/client/`,
+    }),
+  );
+}
+
+if (BATI.has("authjs")) {
+  /**
+   * AuthJS
+   *
+   * TODO: Replace secret {@see https://authjs.dev/reference/core#secret}
+   * TODO: Choose and implement providers
+   *
+   * @link {@see https://authjs.dev/guides/providers/custom-provider}
+   **/
+  const Auth = VikeAuth({
+    secret: "MY_SECRET",
+    providers: [
+      CredentialsProvider({
+        name: "Credentials",
+        credentials: {
+          username: { label: "Username", type: "text", placeholder: "jsmith" },
+          password: { label: "Password", type: "password" },
+        },
+        async authorize() {
+          // Add logic here to look up the user from the credentials supplied
+          const user = { id: "1", name: "J Smith", email: "jsmith@example.com" };
+
+          // Any object returned will be saved in `user` property of the JWT
+          // If you return null then an error will be displayed advising the user to check their details.
+          // You can also Reject this callback with an Error thus the user will be sent to the error page with the error message as a query parameter
+          return user ?? null;
+        },
+      }),
+    ],
+  });
+
+  app.use("/api/auth/**", (c) =>
+    Auth({
+      request: c.req.raw,
+    }),
+  );
+}
+
+if (BATI.has("firebase-auth")) {
+  app.use(async (c, next) => {
+    const sessionCookie: string = getCookie(c, "__session") || "";
+    if (sessionCookie) {
+      const auth = getAuth(firebaseAdmin);
+      try {
+        const decodedIdToken = await auth.verifySessionCookie(sessionCookie, true);
+        const user = await auth.getUser(decodedIdToken.sub);
+        c.set("user", user);
+      } catch (error) {
+        console.debug("verifySessionCookie:", error);
+        c.set("user", null);
+      }
+    }
+    await next();
+  });
+
+  app.post("/api/sessionLogin", async (c) => {
+    const body = await c.req.json();
+    const idToken: string = body.idToken || "";
+
+    let expiresIn = 60 * 60 * 24 * 5 * 1000; // 5 days. The auth.createSessionCookie() function of Firebase expects time to be specified in miliseconds.
+
+    const auth = getAuth(firebaseAdmin);
+    try {
+      const sessionCookie = await auth.createSessionCookie(idToken, { expiresIn });
+      const options = { maxAge: expiresIn, httpOnly: true, secure: true };
+
+      expiresIn = 60 * 60 * 24 * 5; // 5 days. The setCookie() function of Hono expects time to be specified in seconds.
+      setCookie(c, "__session", sessionCookie, options);
+
+      return c.json({ status: "success" }, 200);
+    } catch (error) {
+      console.error("createSessionCookie failed :", error);
+      return c.text("Unathorized", 401);
+    }
+  });
+
+  app.post("/api/sessionLogout", (c) => {
+    deleteCookie(c, "__session");
+    return c.text("Logged Out", 200);
+  });
+}
+
+if (BATI.has("trpc")) {
+  /**
+   * tRPC route
+   *
+   * @link {@see https://trpc.io/docs/server/adapters}
+   **/
+  app.use("/api/trpc/*", (c) => {
+    return fetchRequestHandler({
+      endpoint: "/api/trpc",
+      req: c.req.raw,
+      router: appRouter,
+      createContext({ req, resHeaders }): FetchCreateContextFnOptions {
+        return { req, resHeaders };
+      },
+    });
+  });
+}
+
+if (BATI.has("telefunc")) {
+  /**
+   * Telefunc route
+   *
+   * @link {@see https://telefunc.com}
+   **/
+  app.post("/_telefunc", async (c) => {
+    const httpResponse = await telefunc({
+      url: c.req.url.toString(),
+      method: c.req.method,
+      body: await c.req.text(),
+      context: c,
+    });
+    const { body, statusCode, contentType } = httpResponse;
+
+    c.status(statusCode);
+    c.header("Content-Type", contentType);
+
+    return c.body(body);
+  });
+}
+
+app.all("*", async (c, next) => {
+  const pageContextInit = BATI.has("firebase-auth")
+    ? {
+        urlOriginal: c.req.url,
+        user: c.get("user"),
+      }
+    : {
+        urlOriginal: c.req.url,
+      };
+  const pageContext = await renderPage(pageContextInit);
+  const { httpResponse } = pageContext;
+  if (!httpResponse) {
+    return next();
+  } else {
+    const { body, statusCode, headers } = httpResponse;
+    headers.forEach(([name, value]) => c.header(name, value));
+    c.status(statusCode);
+
+    return c.body(body);
+  }
+});
+
+if (isProduction) {
+  console.log(`Server listening on http://localhost:${port}`);
+  serve({
+    fetch: app.fetch,
+    port: port,
+  });
+}
+
+export default app;

package/dist/boilerplates/@batijs/hono/files/vike.d.ts

@@ -0,0 +1,10 @@
+import type { UserRecord } from "firebase-admin/auth";
+
+//# BATI.has("firebase-auth")
+declare module "hono" {
+  interface ContextVariableMap {
+    user?: UserRecord | null;
+  }
+}
+
+export {};

package/dist/boilerplates/@batijs/hono/types/hono-entry.d.ts

@@ -0,0 +1,3 @@
+import { Hono } from "hono";
+declare const app: Hono<import("hono").Env, import("hono/types").BlankSchema, "/">;
+export default app;

package/dist/boilerplates/boilerplates.json

@@ -98,6 +98,17 @@
       "files"
     ]
   },
+  {
+    "config": {
+      "if": {
+        "flag": "hono"
+      }
+    },
+    "folder": "@batijs/hono",
+    "subfolders": [
+      "files"
+    ]
+  },
   {
     "config": {
       "if": {

package/dist/index.js

@@ -1537,7 +1537,7 @@ var createDefaultQueryTester = function(query, options) {
 // package.json
 var package_default = {
   name: "@batijs/cli",
-  version: "0.0.184",
+  version: "0.0.186",
   type: "module",
   scripts: {
     "check-types": "tsc --noEmit",
@@ -1596,11 +1596,14 @@ var rulesMessages = {
   [RulesMessage.ERROR_AUTH_R_SERVER]: error(
     `A ${inverse(bold("Server"))} is required when using ${inverse(
       bold("Auth")
-    )}. Check https://vite-plugin-ssr.com/integration#server-side-tools for details and https://batijs.dev for available servers`
+    )}. Check https://vike.dev/integration#server-side-tools for details and https://batijs.dev for available servers`
   ),
   [RulesMessage.ERROR_COMPILED_R_REACT]: error(
     `${inverse(bold("React"))} is required when using ${inverse(bold("Compiled"))}.`
   ),
+  [RulesMessage.ERROR_AUTH0_E_HONO]: error(
+    `${inverse(bold("Auth0"))} does not support running on ${inverse(bold("Hono"))} with official plugins. Check https://batijs.dev for details`
+  ),
   [RulesMessage.INFO_HATTIP]: info(`${inverse(bold("HatTip"))} is an experimental project`)
 };
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@batijs/cli",
-  "version": "0.0.184",
+  "version": "0.0.186",
   "type": "module",
   "keywords": [],
   "description": "Next-gen scaffolder. Get started with fully-functional apps, and choose any tool you want",
@@ -19,12 +19,12 @@
     "tsup": "^8.0.2",
     "typescript": "^5.4.5",
     "vite": "^5.2.11",
-    "@batijs/compile": "0.0.184",
-    "@batijs/build": "0.0.184"
+    "@batijs/compile": "0.0.186",
+    "@batijs/build": "0.0.186"
   },
   "dependencies": {
-    "@batijs/features": "0.0.184",
-    "@batijs/core": "0.0.184"
+    "@batijs/features": "0.0.186",
+    "@batijs/core": "0.0.186"
   },
   "bin": "./dist/index.js",
   "exports": {