fix: lazy-init server drivers to fix build without env vars

SvelteKit's static analysis imports server modules during build,
causing env validation to fail when DATABASE_URL etc. aren't set.
Changed env, db, s3, and auth to use lazy initialization via Proxy.

Author: aster-void

src/lib/env/env.server.test.ts

@@ -31,9 +31,11 @@ describe("env production guard", () => {
     process.env.UNSAFE_DISABLE_AUTH = "true";
 
     expect(() => {
-      // Force re-import to trigger validation
+      // Force re-import to clear cache and trigger fresh validation
       delete require.cache[require.resolve("./env.server.ts")];
-      require("./env.server.ts");
+      const { env } = require("./env.server.ts");
+      // Access env to trigger lazy evaluation
+      void env.DATABASE_URL;
     }).toThrow("UNSAFE_DISABLE_AUTH cannot be enabled in production");
   });
 
@@ -43,7 +45,8 @@ describe("env production guard", () => {
 
     expect(() => {
       delete require.cache[require.resolve("./env.server.ts")];
-      require("./env.server.ts");
+      const { env } = require("./env.server.ts");
+      void env.DATABASE_URL;
     }).not.toThrow();
   });
 
@@ -53,7 +56,8 @@ describe("env production guard", () => {
 
     expect(() => {
       delete require.cache[require.resolve("./env.server.ts")];
-      require("./env.server.ts");
+      const { env } = require("./env.server.ts");
+      void env.DATABASE_URL;
     }).not.toThrow();
   });
 });

src/lib/env/env.server.ts

@@ -18,9 +18,26 @@ const Env = v.object({
   CLOUDFLARE_API_TOKEN: v.optional(v.string()),
 });
 
-export const env = v.parse(Env, process.env);
+type EnvType = v.InferOutput<typeof Env>;
 
-// Production guard: UNSAFE_DISABLE_AUTH must never be enabled in production
-if (env.UNSAFE_DISABLE_AUTH === "true" && process.env.NODE_ENV === "production") {
-  throw new Error("UNSAFE_DISABLE_AUTH cannot be enabled in production");
+let _env: EnvType | null = null;
+
+function getEnv(): EnvType {
+  if (_env) return _env;
+
+  _env = v.parse(Env, process.env);
+
+  // Production guard: UNSAFE_DISABLE_AUTH must never be enabled in production
+  if (_env.UNSAFE_DISABLE_AUTH === "true" && process.env.NODE_ENV === "production") {
+    throw new Error("UNSAFE_DISABLE_AUTH cannot be enabled in production");
+  }
+
+  return _env;
 }
+
+// Lazy evaluation via Proxy - env is only parsed when accessed at runtime
+export const env: EnvType = new Proxy({} as EnvType, {
+  get(_, prop: string) {
+    return getEnv()[prop as keyof EnvType];
+  },
+});

src/lib/server/database/storage.server.ts

@@ -1,5 +1,5 @@
 import { env } from "$lib/env/env.server";
-import { bucket, ensureBucket, s3 } from "$lib/server/drivers/s3";
+import { ensureBucket, getBucket, s3 } from "$lib/server/drivers/s3";
 
 export async function uploadBuffer(
   buffer: Buffer,
@@ -11,7 +11,7 @@ export async function uploadBuffer(
 
   const key = `${path}/${crypto.randomUUID()}-${fileName}`;
 
-  await s3.putObject(bucket, key, buffer, buffer.length, {
+  await s3.putObject(getBucket(), key, buffer, buffer.length, {
     "Content-Type": contentType,
   });
 
@@ -20,11 +20,11 @@ export async function uploadBuffer(
 }
 
 export async function deleteFile(key: string): Promise<void> {
-  await s3.removeObject(bucket, key);
+  await s3.removeObject(getBucket(), key);
 }
 
 export async function listFiles(prefix: string): Promise<string[]> {
-  const stream = s3.listObjects(bucket, prefix, true);
+  const stream = s3.listObjects(getBucket(), prefix, true);
   const keys: string[] = [];
 
   return new Promise((resolve, reject) => {

src/lib/server/drivers/auth.ts

@@ -4,19 +4,40 @@ import { env } from "$lib/env/env.server";
 import { db } from "$lib/server/drivers/db";
 import * as schema from "$lib/shared/models/schema";
 
-export const auth = betterAuth({
-  database: drizzleAdapter(db, {
-    provider: "pg",
-    schema,
-  }),
-  baseURL: env.BETTER_AUTH_URL,
-  secret: env.BETTER_AUTH_SECRET,
-  socialProviders: {
-    github: {
-      clientId: env.GITHUB_CLIENT_ID,
-      clientSecret: env.GITHUB_CLIENT_SECRET,
-      scope: ["read:user", "user:email", "read:org"],
-      disableDefaultScope: true,
-    },
+type AuthType = ReturnType<typeof betterAuth>;
+
+let _auth: AuthType | null = null;
+
+function getAuth(): AuthType {
+  if (!_auth) {
+    _auth = betterAuth({
+      database: drizzleAdapter(db, {
+        provider: "pg",
+        schema,
+      }),
+      baseURL: env.BETTER_AUTH_URL,
+      secret: env.BETTER_AUTH_SECRET,
+      socialProviders: {
+        github: {
+          clientId: env.GITHUB_CLIENT_ID,
+          clientSecret: env.GITHUB_CLIENT_SECRET,
+          scope: ["read:user", "user:email", "read:org"],
+          disableDefaultScope: true,
+        },
+      },
+    });
+  }
+  return _auth;
+}
+
+// Lazy-initialized auth instance via Proxy
+export const auth: AuthType = new Proxy({} as AuthType, {
+  get(_, prop) {
+    const instance = getAuth();
+    const value = instance[prop as keyof AuthType];
+    if (typeof value === "function") {
+      return (value as (...args: unknown[]) => unknown).bind(instance);
+    }
+    return value;
   },
 });

src/lib/server/drivers/db.ts

@@ -1,8 +1,29 @@
+import type { PostgresJsDatabase } from "drizzle-orm/postgres-js";
 import { drizzle } from "drizzle-orm/postgres-js";
 import postgres from "postgres";
 import { env } from "$lib/env/env.server";
 import * as schema from "$lib/shared/models/schema";
 
-const client = postgres(env.DATABASE_URL);
+type DbType = PostgresJsDatabase<typeof schema>;
 
-export const db = drizzle(client, { schema });
+let _db: DbType | null = null;
+
+function getDb(): DbType {
+  if (!_db) {
+    const client = postgres(env.DATABASE_URL);
+    _db = drizzle(client, { schema });
+  }
+  return _db;
+}
+
+// Lazy-initialized db instance via Proxy
+export const db: DbType = new Proxy({} as DbType, {
+  get(_, prop) {
+    const instance = getDb();
+    const value = instance[prop as keyof DbType];
+    if (typeof value === "function") {
+      return value.bind(instance);
+    }
+    return value;
+  },
+});

src/lib/server/drivers/s3.ts

@@ -1,39 +1,60 @@
 import { Client } from "minio";
 import { env } from "$lib/env/env.server";
 
-const url = new URL(env.S3_ENDPOINT);
+let _s3: Client | null = null;
 
-export const s3 = new Client({
-  endPoint: url.hostname,
-  port: url.port ? parseInt(url.port, 10) : url.protocol === "https:" ? 443 : 80,
-  useSSL: url.protocol === "https:",
-  accessKey: env.S3_ACCESS_KEY,
-  secretKey: env.S3_SECRET_KEY,
+function getS3(): Client {
+  if (!_s3) {
+    const url = new URL(env.S3_ENDPOINT);
+    _s3 = new Client({
+      endPoint: url.hostname,
+      port: url.port ? parseInt(url.port, 10) : url.protocol === "https:" ? 443 : 80,
+      useSSL: url.protocol === "https:",
+      accessKey: env.S3_ACCESS_KEY,
+      secretKey: env.S3_SECRET_KEY,
+    });
+  }
+  return _s3;
+}
+
+// Lazy-initialized s3 client via Proxy
+export const s3: Client = new Proxy({} as Client, {
+  get(_, prop) {
+    const instance = getS3();
+    const value = instance[prop as keyof Client];
+    if (typeof value === "function") {
+      return (value as (...args: unknown[]) => unknown).bind(instance);
+    }
+    return value;
+  },
 });
 
-export const bucket = env.S3_BUCKET;
+export function getBucket(): string {
+  return env.S3_BUCKET;
+}
 
 // Ensure bucket exists and is public (for dev)
-const publicPolicy = {
-  Version: "2012-10-17",
-  Statement: [
-    {
-      Effect: "Allow",
-      Principal: { AWS: ["*"] },
-      Action: ["s3:GetObject"],
-      Resource: [`arn:aws:s3:::${bucket}/*`],
-    },
-  ],
-};
-
 let initialized = false;
 export async function ensureBucket() {
   if (initialized) return;
   initialized = true;
 
-  const exists = await s3.bucketExists(bucket);
+  const bucketName = env.S3_BUCKET;
+  const publicPolicy = {
+    Version: "2012-10-17",
+    Statement: [
+      {
+        Effect: "Allow",
+        Principal: { AWS: ["*"] },
+        Action: ["s3:GetObject"],
+        Resource: [`arn:aws:s3:::${bucketName}/*`],
+      },
+    ],
+  };
+
+  const exists = await s3.bucketExists(bucketName);
   if (!exists) {
-    await s3.makeBucket(bucket);
+    await s3.makeBucket(bucketName);
   }
-  await s3.setBucketPolicy(bucket, JSON.stringify(publicPolicy));
+  await s3.setBucketPolicy(bucketName, JSON.stringify(publicPolicy));
 }