fix(build): use lazy initialization for build compatibility

- Make drizzle db connection lazy (defer DATABASE_URL check)
- Make DI container initialize on first access
- Make ResendEmailService validate env vars lazily
- Make BetterAuth instance initialize on first access

Fixes build failures when env vars are not available at build time.

Author: axelhamil

apps/nextjs/common/auth.ts

@@ -4,41 +4,60 @@ import { betterAuth } from "better-auth";
 import { drizzleAdapter } from "better-auth/adapters/drizzle";
 import { nextCookies } from "better-auth/next-js";
 
-export const auth = betterAuth({
-  database: drizzleAdapter(db, {
-    provider: "pg",
-    schema: {
-      user: schema.user,
-      session: schema.session,
-      account: schema.account,
-      verification: schema.verification,
+type AuthInstance = ReturnType<typeof betterAuth>;
+
+let _auth: AuthInstance | null = null;
+
+function createAuth(): AuthInstance {
+  return betterAuth({
+    database: drizzleAdapter(db, {
+      provider: "pg",
+      schema: {
+        user: schema.user,
+        session: schema.session,
+        account: schema.account,
+        verification: schema.verification,
+      },
+    }),
+    emailAndPassword: {
+      enabled: true,
+      minPasswordLength: 8,
     },
-  }),
-  emailAndPassword: {
-    enabled: true,
-    minPasswordLength: 8,
-  },
-  socialProviders: {
-    google: {
-      clientId: process.env.GOOGLE_CLIENT_ID ?? "",
-      clientSecret: process.env.GOOGLE_CLIENT_SECRET ?? "",
+    socialProviders: {
+      google: {
+        clientId: process.env.GOOGLE_CLIENT_ID ?? "",
+        clientSecret: process.env.GOOGLE_CLIENT_SECRET ?? "",
+      },
+      github: {
+        clientId: process.env.GITHUB_CLIENT_ID ?? "",
+        clientSecret: process.env.GITHUB_CLIENT_SECRET ?? "",
+      },
     },
-    github: {
-      clientId: process.env.GITHUB_CLIENT_ID ?? "",
-      clientSecret: process.env.GITHUB_CLIENT_SECRET ?? "",
-    },
-  },
-  session: {
-    expiresIn: 60 * 60 * 24 * 7, // 7 days
-    updateAge: 60 * 60 * 24, // 1 day
-    cookieCache: {
-      enabled: true,
-      maxAge: 5 * 60, // 5 minutes
+    session: {
+      expiresIn: 60 * 60 * 24 * 7, // 7 days
+      updateAge: 60 * 60 * 24, // 1 day
+      cookieCache: {
+        enabled: true,
+        maxAge: 5 * 60, // 5 minutes
+      },
     },
+    plugins: [nextCookies()],
+  });
+}
+
+function getAuth(): AuthInstance {
+  if (!_auth) {
+    _auth = createAuth();
+  }
+  return _auth;
+}
+
+export const auth = new Proxy({} as AuthInstance, {
+  get(_target, prop) {
+    return Reflect.get(getAuth(), prop);
   },
-  plugins: [nextCookies()],
 });
 
-export type BetterAuthSession = typeof auth.$Infer.Session;
+export type BetterAuthSession = AuthInstance["$Infer"]["Session"];
 export type BetterAuthUser = BetterAuthSession["user"];
 export type BetterAuthSessionData = BetterAuthSession["session"];

apps/nextjs/common/di/container.ts

@@ -1,4 +1,4 @@
-import { createContainer } from "@evyweb/ioctopus";
+import { type Container, createContainer } from "@evyweb/ioctopus";
 import type { InMemoryEventDispatcher } from "@/adapters/events/in-memory-event-dispatcher";
 import { createAuthModule } from "./modules/auth.module";
 import { createBillingModule } from "./modules/billing.module";
@@ -9,24 +9,36 @@ import {
 } from "./modules/events.module";
 import { type DI_RETURN_TYPES, DI_SYMBOLS } from "./types";
 
-const ApplicationContainer = createContainer();
+let _container: Container | null = null;
+let _initialized = false;
 
-ApplicationContainer.load(Symbol("EventsModule"), createEventsModule());
-ApplicationContainer.load(Symbol("AuthModule"), createAuthModule());
-ApplicationContainer.load(Symbol("BillingModule"), createBillingModule());
-ApplicationContainer.load(Symbol("EmailModule"), createEmailModule());
+function getContainer(): Container {
+  if (!_container) {
+    _container = createContainer();
 
-const dispatcher = ApplicationContainer.get(
-  DI_SYMBOLS.IEventDispatcher,
-) as InMemoryEventDispatcher;
+    _container.load(Symbol("EventsModule"), createEventsModule());
+    _container.load(Symbol("AuthModule"), createAuthModule());
+    _container.load(Symbol("BillingModule"), createBillingModule());
+    _container.load(Symbol("EmailModule"), createEmailModule());
+  }
 
-const emailService = ApplicationContainer.get(
-  DI_SYMBOLS.IEmailService,
-) as DI_RETURN_TYPES["IEmailService"];
-registerEventHandlers(dispatcher, emailService);
+  if (!_initialized) {
+    _initialized = true;
+    const dispatcher = _container.get(
+      DI_SYMBOLS.IEventDispatcher,
+    ) as InMemoryEventDispatcher;
+
+    const emailService = _container.get(
+      DI_SYMBOLS.IEmailService,
+    ) as DI_RETURN_TYPES["IEmailService"];
+    registerEventHandlers(dispatcher, emailService);
+  }
+
+  return _container;
+}
 
 export function getInjection<K extends keyof typeof DI_SYMBOLS>(
   symbol: K,
 ): DI_RETURN_TYPES[K] {
-  return ApplicationContainer.get(DI_SYMBOLS[symbol]);
+  return getContainer().get(DI_SYMBOLS[symbol]);
 }

apps/nextjs/src/adapters/email/resend-email.service.ts

@@ -6,22 +6,29 @@ import type {
 } from "@/application/ports/email.service.port";
 
 export class ResendEmailService implements IEmailService {
-  private resend: Resend;
-  private fromAddress: string;
-
-  constructor() {
-    const apiKey = process.env.RESEND_API_KEY;
-    if (!apiKey) {
-      throw new Error("RESEND_API_KEY is not configured");
+  private _resend: Resend | null = null;
+  private _fromAddress: string | null = null;
+
+  private getResend(): Resend {
+    if (!this._resend) {
+      const apiKey = process.env.RESEND_API_KEY;
+      if (!apiKey) {
+        throw new Error("RESEND_API_KEY is not configured");
+      }
+      this._resend = new Resend(apiKey);
     }
+    return this._resend;
+  }
 
-    const fromAddress = process.env.EMAIL_FROM;
-    if (!fromAddress) {
-      throw new Error("EMAIL_FROM is not configured");
+  private getFromAddress(): string {
+    if (!this._fromAddress) {
+      const fromAddress = process.env.EMAIL_FROM;
+      if (!fromAddress) {
+        throw new Error("EMAIL_FROM is not configured");
+      }
+      this._fromAddress = fromAddress;
     }
-
-    this.resend = new Resend(apiKey);
-    this.fromAddress = fromAddress;
+    return this._fromAddress;
   }
 
   async send(params: SendEmailParams): Promise<Result<void>> {
@@ -30,8 +37,8 @@ export class ResendEmailService implements IEmailService {
         return Result.fail("Email must have either html or text content");
       }
 
-      const { error } = await this.resend.emails.send({
-        from: this.fromAddress,
+      const { error } = await this.getResend().emails.send({
+        from: this.getFromAddress(),
         to: params.to,
         subject: params.subject,
         html: params.html ?? "",

packages/drizzle/src/config.ts

@@ -4,16 +4,27 @@ import type { ExtractTablesWithRelations } from "drizzle-orm/relations";
 import { Pool } from "pg";
 import * as schema from "./schema";
 
-const connectionString = process.env.DATABASE_URL;
+let _db: ReturnType<typeof drizzle<typeof schema>> | null = null;
 
-if (!connectionString) {
-  throw new Error("DATABASE_URL is not set");
+function getDb(): ReturnType<typeof drizzle<typeof schema>> {
+  if (!_db) {
+    const connectionString = process.env.DATABASE_URL;
+    if (!connectionString) {
+      throw new Error("DATABASE_URL is not set");
+    }
+    const pool = new Pool({ connectionString });
+    _db = drizzle(pool, { schema });
+  }
+  return _db;
 }
 
-const pool = new Pool({ connectionString });
-export const db = drizzle(pool, { schema });
+export const db = new Proxy({} as ReturnType<typeof drizzle<typeof schema>>, {
+  get(_target, prop) {
+    return Reflect.get(getDb(), prop);
+  },
+});
 
-export type DbClient = typeof db;
+export type DbClient = ReturnType<typeof drizzle<typeof schema>>;
 
 export type Transaction = NodePgTransaction<
   typeof schema,