@batijs/cli 0.0.195 → 0.0.197

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

@@ -2,22 +2,23 @@
 import "dotenv/config";
 import { dirname } from "node:path";
 import { fileURLToPath } from "node:url";
-import CredentialsProvider from "@auth/core/providers/credentials";
-import { firebaseAdmin } from "@batijs/firebase-auth/libs/firebaseAdmin";
+import { authjsHandler, authjsSessionMiddleware } from "@batijs/authjs/server/authjs-handler";
+import {
+  firebaseAuthLoginHandler,
+  firebaseAuthLogoutHandler,
+  firebaseAuthMiddleware,
+} from "@batijs/firebase-auth/server/firebase-auth-middleware";
+import { vikeHandler } from "@batijs/shared-server/server/vike-handler";
+import { telefuncHandler } from "@batijs/telefunc/server/telefunc-handler";
 import { appRouter, type AppRouter } from "@batijs/trpc/trpc/server";
-import { createMiddleware } from "@hattip/adapter-node";
 import {
   fastifyTRPCPlugin,
   type CreateFastifyContextOptions,
   type FastifyTRPCPluginOptions,
 } from "@trpc/server/adapters/fastify";
-import express from "express";
-import { auth, type ConfigParams } from "express-openid-connect";
+import { createRequestAdapter } from "@universal-middleware/express";
 import Fastify from "fastify";
-import { getAuth } from "firebase-admin/auth";
-import { telefunc } from "telefunc";
-import { VikeAuth } from "vike-authjs";
-import { renderPage } from "vike/server";
+import type { RouteHandlerMethod } from "fastify/types/route";
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
@@ -26,11 +27,51 @@ const root = __dirname;
 const port = process.env.PORT ? parseInt(process.env.PORT, 10) : 3000;
 const hmrPort = process.env.HMR_PORT ? parseInt(process.env.HMR_PORT, 10) : 24678;
 
+interface Middleware<Context extends Record<string | number | symbol, unknown>> {
+  (request: Request, context: Context): Response | void | Promise<Response> | Promise<void>;
+}
+
+export function handlerAdapter<Context extends Record<string | number | symbol, unknown>>(
+  handler: Middleware<Context>,
+) {
+  const requestAdapter = createRequestAdapter();
+  return (async (request, reply) => {
+    const config = request.routeOptions.config as unknown as Record<string, unknown>;
+    config.context ??= {};
+    const response = await handler(requestAdapter(request.raw)[0], config.context as Context);
+
+    if (response) {
+      if (!response.body) {
+        // Fastify currently doesn't send a response for body is null.
+        // To mimic express behavior, we convert the body to an empty ReadableStream.
+        Object.defineProperty(response, "body", {
+          value: new ReadableStream({
+            start(controller) {
+              controller.close();
+            },
+          }),
+          writable: false,
+          configurable: true,
+        });
+      }
+
+      return reply.send(response);
+    }
+  }) satisfies RouteHandlerMethod;
+}
+
 startServer();
 
 async function startServer() {
   const app = Fastify();
 
+  // Avoid pre-parsing body, otherwise it will cause issue with universal handlers
+  // This will probably change in the future though, you can follow https://github.com/magne4000/universal-handler for updates
+  app.removeAllContentTypeParsers();
+  app.addContentTypeParser("*", function (_request, _payload, done) {
+    done(null, "");
+  });
+
   await app.register(await import("@fastify/middie"));
 
   if (isProduction) {
@@ -52,118 +93,23 @@ async function startServer() {
     app.use(viteDevMiddleware);
   }
 
-  if (BATI.has("authjs")) {
-    await app.register(await import("@fastify/formbody"));
+  if (BATI.has("authjs") || BATI.has("auth0")) {
     /**
-     * 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}
+     * Append Auth.js session to context
      **/
-    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.addHook("onRequest", handlerAdapter(authjsSessionMiddleware));
 
-    app.addHook("onRequest", async (request, reply) => {
-      const vikeAuth = createMiddleware(Auth, {
-        alwaysCallNext: false,
-      });
-      const next = () =>
-        new Promise<void>((resolve) => {
-          vikeAuth(request.raw, reply.raw, () => resolve());
-        });
-      if (request.url.startsWith("/api/auth/")) {
-        await next();
-      }
-      return;
-    });
+    /**
+     * Auth.js route
+     * @link {@see https://authjs.dev/getting-started/installation}
+     **/
+    app.all("/api/auth/*", handlerAdapter(authjsHandler));
   }
 
   if (BATI.has("firebase-auth")) {
-    await app.register(await import("@fastify/cookie"));
-
-    app.addHook("onRequest", async (request) => {
-      const sessionCookie = request.cookies.__session;
-      if (sessionCookie) {
-        try {
-          const auth = getAuth(firebaseAdmin);
-          const decodedIdToken = await auth.verifySessionCookie(sessionCookie);
-          const user = await auth.getUser(decodedIdToken.sub);
-          request.user = user;
-        } catch (error) {
-          console.debug("verifySessionCookie:", error);
-          request.user = null;
-        }
-      }
-    });
-
-    app.post<{ Body: { idToken: string } }>("/api/sessionLogin", async (request, reply) => {
-      const idToken = request.body.idToken || "";
-
-      const expiresIn = 60 * 60 * 24 * 5 * 1000; // 5 days
-
-      try {
-        const auth = getAuth(firebaseAdmin);
-        const sessionCookie = await auth.createSessionCookie(idToken, { expiresIn });
-        reply.setCookie("__session", sessionCookie, {
-          path: "/", // The path needs to be set manually; otherwise, it will default to "/api" in this case.
-          maxAge: expiresIn,
-          httpOnly: true,
-          secure: true,
-        });
-
-        reply.code(200);
-        return reply.send({ status: "success" });
-      } catch (error) {
-        console.error("createSessionCookie failed :", error);
-
-        reply.code(401);
-        return reply.send({ status: "Unauthorized" });
-      }
-    });
-
-    app.post("/api/sessionLogout", (_, reply) => {
-      reply.clearCookie("__session");
-      reply.code(200);
-      return reply.send({ status: "Logged Out" });
-    });
-  }
-
-  if (BATI.has("auth0")) {
-    const config: ConfigParams = {
-      authRequired: false, // Controls whether authentication is required for all routes
-      auth0Logout: true, // Uses Auth0 logout feature
-      baseURL: process.env.BASE_URL?.startsWith("http") ? process.env.BASE_URL : `http://localhost:${port}`, // The URL where the application is served
-      routes: {
-        login: "/api/auth/login", // Custom login route, default is "/login"
-        logout: "/api/auth/logout", // Custom logout route, default is "/logout"
-        callback: "/api/auth/callback", // Custom callback route, default is "/callback"
-      },
-    };
-
-    const expressApp = express();
-
-    app.use(expressApp.use(auth(config)));
+    app.addHook("onRequest", handlerAdapter(firebaseAuthMiddleware));
+    app.post("/api/sessionLogin", handlerAdapter(firebaseAuthLoginHandler));
+    app.post("/api/sessionLogout", handlerAdapter(firebaseAuthLogoutHandler));
   }
 
   if (BATI.has("trpc")) {
@@ -193,19 +139,7 @@ async function startServer() {
      *
      * @link {@see https://telefunc.com}
      **/
-    app.post<{ Body: string }>("/_telefunc", async (request, reply) => {
-      const httpResponse = await telefunc({
-        url: request.originalUrl || request.url,
-        method: request.method,
-        body: request.body,
-        context: request,
-      });
-      const { body, statusCode, contentType } = httpResponse;
-
-      reply.code(statusCode);
-      reply.type(contentType);
-      return reply.send(body);
-    });
+    app.post<{ Body: string }>("/_telefunc", handlerAdapter(telefuncHandler));
   }
 
   /**
@@ -213,27 +147,7 @@ async function startServer() {
    *
    * @link {@see https://vike.dev}
    **/
-  app.all("/*", async function (request, reply) {
-    const pageContextInit = BATI.has("auth0")
-      ? { urlOriginal: request.originalUrl || request.url, user: request.raw.oidc.user }
-      : BATI.has("firebase-auth")
-        ? { urlOriginal: request.originalUrl || request.url, user: request.user }
-        : { urlOriginal: request.originalUrl || request.url };
-
-    const pageContext = await renderPage(pageContextInit);
-    const { httpResponse } = pageContext;
-
-    if (!httpResponse) {
-      return;
-    } else {
-      const { statusCode, headers, body } = httpResponse;
-
-      headers.forEach(([name, value]) => reply.header(name, value));
-      reply.code(statusCode);
-
-      return reply.send(body);
-    }
-  });
+  app.all("/*", handlerAdapter(vikeHandler));
 
   app.listen(
     {

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

@@ -1 +1,7 @@
+/// <reference types="node" />
 import "dotenv/config";
+interface Middleware<Context extends Record<string | number | symbol, unknown>> {
+    (request: Request, context: Context): Response | void | Promise<Response> | Promise<void>;
+}
+export declare function handlerAdapter<Context extends Record<string | number | symbol, unknown>>(handler: Middleware<Context>): (this: import("fastify").FastifyInstance<import("fastify").RawServerDefault, import("http").IncomingMessage, import("http").ServerResponse<import("http").IncomingMessage>, import("fastify").FastifyBaseLogger, import("fastify").FastifyTypeProviderDefault>, request: import("fastify").FastifyRequest<import("fastify").RouteGenericInterface, import("fastify").RawServerDefault, import("http").IncomingMessage, import("fastify").FastifySchema, import("fastify").FastifyTypeProviderDefault, unknown, import("fastify").FastifyBaseLogger, import("fastify/types/type-provider").ResolveFastifyRequestType<import("fastify").FastifyTypeProviderDefault, import("fastify").FastifySchema, import("fastify").RouteGenericInterface>>, reply: import("fastify").FastifyReply<import("fastify").RawServerDefault, import("http").IncomingMessage, import("http").ServerResponse<import("http").IncomingMessage>, import("fastify").RouteGenericInterface, unknown, import("fastify").FastifySchema, import("fastify").FastifyTypeProviderDefault, unknown>) => Promise<undefined>;
+export {};

package/dist/boilerplates/@batijs/firebase-auth/files/$package.json.js

@@ -42,7 +42,9 @@ var require_package = __commonJS({
       license: "MIT",
       devDependencies: {
         "@batijs/compile": "workspace:*",
+        "@types/cookie": "^0.6.0",
         "@types/node": "^18.19.14",
+        cookie: "^0.6.0",
         dotenv: "^16.4.5",
         firebase: "^10.12.1",
         "firebase-admin": "^12.1.1",
@@ -76,6 +78,9 @@ var require_package = __commonJS({
         },
         "./pages/login/+guard": {
           types: "./dist/types/pages/login/+guard.d.ts"
+        },
+        "./server/firebase-auth-middleware": {
+          types: "./dist/types/server/firebase-auth-middleware.d.ts"
         }
       },
       typesVersions: {
@@ -94,6 +99,9 @@ var require_package = __commonJS({
           ],
           "pages/login/+guard": [
             "./dist/types/pages/login/+guard.d.ts"
+          ],
+          "server/firebase-auth-middleware": [
+            "./dist/types/server/firebase-auth-middleware.d.ts"
           ]
         }
       }

package/dist/boilerplates/@batijs/firebase-auth/files/libs/firebaseAdmin.ts

@@ -1,5 +1,6 @@
 import "dotenv/config";
 import { applicationDefault, getApp, getApps, initializeApp, type App } from "firebase-admin/app";
+import { getAuth } from "firebase-admin/auth";
 
 let firebaseAdmin: App | undefined;
 
@@ -11,4 +12,4 @@ if (!getApps().length) {
   firebaseAdmin = getApp();
 }
 
-export { firebaseAdmin };
+export { firebaseAdmin, getAuth };

package/dist/boilerplates/@batijs/firebase-auth/files/server/firebase-auth-middleware.ts

@@ -0,0 +1,72 @@
+import { parse, serialize } from "cookie";
+import { getAuth } from "firebase-admin/auth";
+import { firebaseAdmin } from "../libs/firebaseAdmin";
+
+export async function firebaseAuthMiddleware(
+  request: Request,
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  context: any,
+): Promise<void> {
+  if (!request.headers.has("cookie")) return;
+
+  const cookies = parse(request.headers.get("cookie")!);
+  const sessionCookie: string = cookies.__session || "";
+
+  try {
+    const auth = getAuth(firebaseAdmin);
+    const decodedIdToken = await auth.verifySessionCookie(sessionCookie, true);
+    context.user = await auth.getUser(decodedIdToken.sub);
+  } catch (error) {
+    console.debug("verifySessionCookie:", error);
+    context.user = null;
+  }
+}
+
+export async function firebaseAuthLoginHandler<Context extends Record<string | number | symbol, unknown>>(
+  request: Request,
+  _context?: Context,
+): Promise<Response> {
+  const body = await request.json();
+  const idToken: string = (body as { idToken?: string }).idToken || "";
+
+  const expiresIn = 60 * 60 * 24 * 5 * 1000; // 5 days
+
+  try {
+    const sessionCookie = await getAuth(firebaseAdmin).createSessionCookie(idToken, { expiresIn });
+
+    const options = { maxAge: expiresIn / 1000, httpOnly: true, secure: true };
+
+    return new Response(JSON.stringify({ status: "success" }), {
+      status: 200,
+      headers: {
+        "content-type": "application/json",
+        "set-cookie": serialize("__session", sessionCookie, options),
+      },
+    });
+  } catch (error) {
+    console.error("createSessionCookie:", error);
+
+    return new Response("Unauthorized Request", {
+      status: 401,
+    });
+  }
+}
+
+export async function firebaseAuthLogoutHandler<Context extends Record<string | number | symbol, unknown>>(
+  _request: Request,
+  _context?: Context,
+): Promise<Response> {
+  return new Response(JSON.stringify({ status: "success" }), {
+    status: 200,
+    headers: {
+      "content-type": "application/json",
+      "set-cookie": serialize("__session", "", {
+        maxAge: 0,
+        httpOnly: true,
+        secure: true,
+        expires: new Date(1),
+        path: "/",
+      }),
+    },
+  });
+}

package/dist/boilerplates/@batijs/firebase-auth/types/libs/firebaseAdmin.d.ts

@@ -1,4 +1,5 @@
 import "dotenv/config";
 import { type App } from "firebase-admin/app";
+import { getAuth } from "firebase-admin/auth";
 declare let firebaseAdmin: App | undefined;
-export { firebaseAdmin };
+export { firebaseAdmin, getAuth };

package/dist/boilerplates/@batijs/firebase-auth/types/server/firebase-auth-middleware.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="node" />
+export declare function firebaseAuthMiddleware(request: Request, context: any): Promise<void>;
+export declare function firebaseAuthLoginHandler<Context extends Record<string | number | symbol, unknown>>(request: Request, _context?: Context): Promise<Response>;
+export declare function firebaseAuthLogoutHandler<Context extends Record<string | number | symbol, unknown>>(_request: Request, _context?: Context): Promise<Response>;

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

@@ -42,8 +42,11 @@ var require_package = __commonJS({
       license: "MIT",
       devDependencies: {
         "@auth/core": "^0.31.0",
+        "@batijs/authjs": "workspace:*",
         "@batijs/compile": "workspace:*",
         "@batijs/firebase-auth": "workspace:*",
+        "@batijs/shared-server": "workspace:^",
+        "@batijs/telefunc": "workspace:^",
         "@batijs/trpc": "workspace:^",
         "@hattip/polyfills": "^0.0.45",
         "@trpc/server": "^10.45.2",
@@ -51,15 +54,11 @@ var require_package = __commonJS({
         "@types/node": "^18.19.14",
         "@types/serve-static": "^1.15.7",
         dotenv: "^16.4.5",
-        express: "^4.19.2",
-        "express-openid-connect": "^2.17.1",
-        "firebase-admin": "^12.1.1",
         h3: "~1.11.1",
         "serve-static": "^1.15.0",
         telefunc: "^0.1.72",
         tsx: "^4.11.0",
         vike: "^0.4.172",
-        "vike-authjs": "^0.1.6",
         vite: "^5.2.11"
       },
       dependencies: {
@@ -121,8 +120,7 @@ async function getPackageJson(props) {
       "tsx",
       "vike",
       "vite",
-      ...props.meta.BATI.has("authjs") ? ["@auth/core", "vike-authjs"] : [],
-      ...props.meta.BATI.has("auth0") ? ["express", "express-openid-connect"] : []
+      ...props.meta.BATI.has("authjs") || props.meta.BATI.has("auth0") ? ["@auth/core"] : []
     ]
   });
 }