step 2 to migration

Author: Hyteq

apps/api2/package.json

@@ -3,6 +3,9 @@
   "module": "index.ts",
   "type": "module",
   "private": true,
+  "scripts": {
+    "dev": "bun --hot src/index.ts"
+  },
   "devDependencies": {
     "@types/bun": "latest"
   },

apps/api2/src/index.ts

@@ -1,9 +1,22 @@
 import { Elysia } from "elysia";
+import domainsRouter from "./routes/v1/domains";
 
 const app = new Elysia();
 
 app.get('/', () => {
   return 'Hello World';
+})
+.use(domainsRouter)
+
+app.listen(3500)
+.onStart(() => {
+  console.log('Server is running on port 3500');
 });
 
-app.listen(3000);
+app.onError(({ error, code }) => {
+  console.error(error);
+  return {
+    success: false,
+    code: code
+  };
+});

apps/api2/src/lib/auth.ts

@@ -0,0 +1,78 @@
+import { betterAuth } from "better-auth";
+import { db, eq, user } from "@databuddy/db";
+import { getRedisCache } from "@databuddy/redis";
+import { drizzleAdapter } from "better-auth/adapters/drizzle";
+import { customSession } from "better-auth/plugins";
+
+function isProduction() {
+  return process.env.NODE_ENV === 'production';
+}
+
+const redisCache = getRedisCache();
+
+export const auth = betterAuth({
+    database: drizzleAdapter(db, {
+        provider: "pg",
+    }),
+    security: {
+        ipAddress: {
+            ipAddressHeaders: ["cf-connecting-ip", "x-forwarded-for"],
+        }
+    },
+    appName: "databuddy.cc",
+    advanced: {
+        crossSubDomainCookies: {
+            enabled: isProduction(),
+            domain: ".databuddy.cc"
+        },
+        cookiePrefix: "databuddy",
+        useSecureCookies: isProduction()
+    },
+    trustedOrigins: [
+        'https://databuddy.cc',
+        'https://app.databuddy.cc',
+        'https://api.databuddy.cc'
+    ],
+    session: {
+        expiresIn: 60 * 60 * 24 * 30, // 30 days
+        updateAge: 60 * 60 * 24, // 1 day
+        cookieCache: {
+            enabled: true,
+            maxAge: 5 * 60 // 5 minutes
+        }
+    },
+    secondaryStorage: {
+        get: async (key) => {
+            const value = await redisCache.get(key);
+            return value ? value : null;
+        },
+        set: async (key, value, ttl) => {
+            if (ttl) await redisCache.setex(key, ttl, value);
+            else await redisCache.set(key, value);
+        },
+        delete: async (key) => {
+            await redisCache.del(key);
+        },
+    },
+    plugins: [
+        customSession(async ({ user: sessionUser, session }) => {
+            const [dbUser] = await db.query.user.findMany({
+                where: eq(user.id, session.userId),
+                columns: {
+                    role: true,
+                }
+            });
+            return {
+                role: dbUser?.role,
+                user: {
+                    ...sessionUser,
+                    role: dbUser?.role,
+                },
+                session
+            };
+        }),
+    ]
+})
+
+export type User = (typeof auth)["$Infer"]["Session"]["user"];
+export type Session = (typeof auth)["$Infer"]["Session"];

apps/api2/src/lib/timezone.ts

@@ -0,0 +1,176 @@
+/**
+ * Timezone utilities for handling user timezone detection and date conversions
+ */
+
+export interface TimezoneInfo {
+  timezone: string;
+  detected: boolean;
+  source: 'explicit' | 'header' | 'cloudflare' | 'accept-language' | 'default';
+}
+
+/**
+ * Detect user timezone from various sources
+ */
+export function detectUserTimezone(headers: Headers, explicitTimezone?: string): TimezoneInfo {
+  // Use explicit timezone if provided and valid
+  if (explicitTimezone) {
+    try {
+      Intl.DateTimeFormat(undefined, { timeZone: explicitTimezone });
+      return {
+        timezone: explicitTimezone,
+        detected: true,
+        source: 'explicit'
+      };
+    } catch {
+      // Invalid timezone, fall through to header detection
+    }
+  }
+
+  // Try to get timezone from various headers
+  const timezoneHeader = headers.get('x-timezone') || 
+                        headers.get('timezone') || 
+                        headers.get('x-user-timezone');
+  
+  if (timezoneHeader) {
+    try {
+      // Validate timezone
+      Intl.DateTimeFormat(undefined, { timeZone: timezoneHeader });
+      return {
+        timezone: timezoneHeader,
+        detected: true,
+        source: 'header'
+      };
+    } catch {
+      // Invalid timezone, fall through to other methods
+    }
+  }
+
+  // Try to infer from CloudFlare headers (if using CloudFlare)
+  const cfTimezone = headers.get('cf-timezone');
+  if (cfTimezone) {
+    try {
+      Intl.DateTimeFormat(undefined, { timeZone: cfTimezone });
+      return {
+        timezone: cfTimezone,
+        detected: true,
+        source: 'cloudflare'
+      };
+    } catch {
+      // Invalid timezone
+    }
+  }
+
+  // Try to extract from Accept-Language header
+  const acceptLanguage = headers.get('accept-language');
+  if (acceptLanguage) {
+    // Look for timezone info in accept-language (some browsers include it)
+    const timezoneMatch = acceptLanguage.match(/timezone=([^,;]+)/i);
+    if (timezoneMatch) {
+      try {
+        Intl.DateTimeFormat(undefined, { timeZone: timezoneMatch[1] });
+        return {
+          timezone: timezoneMatch[1],
+          detected: true,
+          source: 'accept-language'
+        };
+      } catch {
+        // Invalid timezone
+      }
+    }
+  }
+
+  // Default to UTC if no timezone detected
+  return {
+    timezone: 'UTC',
+    detected: false,
+    source: 'default'
+  };
+}
+
+/**
+ * Convert date to user's timezone
+ */
+export function convertToUserTimezone(date: string, timezone: string): string {
+  try {
+    const utcDate = new Date(`${date}T00:00:00Z`);
+    const userDate = new Date(utcDate.toLocaleString('en-US', { timeZone: timezone }));
+    return userDate.toISOString().split('T')[0];
+  } catch {
+    // If timezone conversion fails, return original date
+    return date;
+  }
+}
+
+/**
+ * Adjust date range for user timezone to ensure we capture all relevant data
+ */
+export function adjustDateRangeForTimezone(
+  startDate: string, 
+  endDate: string, 
+  timezone: string
+): { startDate: string, endDate: string } {
+  if (timezone === 'UTC') {
+    return { startDate, endDate };
+  }
+
+  try {
+    // Convert start date to user timezone (might need to go back a day)
+    const startUTC = new Date(`${startDate}T00:00:00Z`);
+    const startInUserTZ = new Date(startUTC.toLocaleString('en-US', { timeZone: timezone }));
+    
+    // Convert end date to user timezone (might need to go forward a day)
+    const endUTC = new Date(`${endDate}T23:59:59Z`);
+    const endInUserTZ = new Date(endUTC.toLocaleString('en-US', { timeZone: timezone }));
+
+    // Adjust the range to ensure we capture all data for the user's timezone
+    const adjustedStart = new Date(startInUserTZ.getTime() - 24 * 60 * 60 * 1000); // Go back 1 day
+    const adjustedEnd = new Date(endInUserTZ.getTime() + 24 * 60 * 60 * 1000); // Go forward 1 day
+
+    return {
+      startDate: adjustedStart.toISOString().split('T')[0],
+      endDate: adjustedEnd.toISOString().split('T')[0]
+    };
+  } catch {
+    // If timezone conversion fails, return original dates
+    return { startDate, endDate };
+  }
+}
+
+/**
+ * Validate timezone string
+ */
+export function isValidTimezone(timezone: string): boolean {
+  try {
+    Intl.DateTimeFormat(undefined, { timeZone: timezone });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Get current date in user's timezone
+ */
+export function getCurrentDateInTimezone(timezone: string): string {
+  try {
+    const now = new Date();
+    const userDate = new Date(now.toLocaleString('en-US', { timeZone: timezone }));
+    return userDate.toISOString().split('T')[0];
+  } catch {
+    // If timezone conversion fails, return UTC date
+    return new Date().toISOString().split('T')[0];
+  }
+}
+
+/**
+ * Convert timestamp to user's timezone
+ */
+export function convertTimestampToUserTimezone(timestamp: number, timezone: string): Date {
+  try {
+    const utcDate = new Date(timestamp);
+    return new Date(utcDate.toLocaleString('en-US', { timeZone: timezone }));
+  } catch {
+    // If timezone conversion fails, return original date
+    return new Date(timestamp);
+  }
+}

apps/api2/src/middleware/auth.ts

@@ -0,0 +1,42 @@
+import { Elysia } from "elysia";
+import { auth } from "../lib/auth";
+
+type AuthMiddlewareOptions = {
+    required: boolean;
+}
+
+export const authMiddleware = (options: AuthMiddlewareOptions = { required: false }) => {
+    return new Elysia({ name: 'middleware.auth' })
+        .derive(async ({ request }) => {
+            try {
+                const session = await auth.api.getSession({
+                    headers: request.headers,
+                });
+
+                if (!session) {
+                    return { user: null, session: null };
+                }
+                
+                return { 
+                    user: session.user, 
+                    session,
+                 };
+
+            } catch (error) {
+                console.error("Error getting session:", error);
+                return { user: null, session: null };
+            }
+        })
+        .onBeforeHandle(({ user, session, set }) => {
+            if (options.required && (!user || !session)) {
+                set.status = 401;
+                return {
+                    success: false,
+                    error: 'Unauthorized',
+                    code: 'AUTH_REQUIRED'
+                }
+            }
+        });
+};
+
+export type AuthMiddleware = ReturnType<typeof authMiddleware>;

apps/api2/src/middleware/timezone.ts

@@ -0,0 +1,19 @@
+import { Elysia } from 'elysia';
+import { detectUserTimezone, isValidTimezone } from '../lib/timezone';
+
+export const timezoneMiddleware = new Elysia({ name: 'middleware.timezone' })
+    .derive(({ request, query }) => {
+        const explicitTimezone = query.timezone as string | undefined;
+
+        if (explicitTimezone && !isValidTimezone(explicitTimezone)) {
+            throw new Error('Invalid timezone provided');
+        }
+
+        const timezoneInfo = detectUserTimezone(request.headers, explicitTimezone);
+
+        return {
+            timezoneInfo
+        };
+    });
+
+export type TimezoneMiddleware = typeof timezoneMiddleware;