drizzle implemented

apps/admin/jest.config.js

@@ -1,10 +1,11 @@
+const { pathsToModuleNameMapper } = require('ts-jest');
+const { compilerOptions } = require('./tsconfig');
+
 module.exports = {
   preset: 'ts-jest',
   testEnvironment: 'jsdom',
   setupFilesAfterEnv: ['<rootDir>/jest.setup.js'],
-  moduleNameMapping: {
-    '^@/(.*)$': '<rootDir>/src/$1',
-  },
+  moduleNameMapper: pathsToModuleNameMapper(compilerOptions.paths, { prefix: '<rootDir>/' }),
   testMatch: [
     '**/__tests__/**/*.(ts|tsx|js)',
     '**/*.(test|spec).(ts|tsx|js)',

apps/admin/jest.setup.js

@@ -1 +1 @@
-import '@testing-library/jest-dom'
+require('@testing-library/jest-dom')

apps/admin/package.json

@@ -26,10 +26,11 @@
     "autoprefixer": "^10.4.16",
     "axios": "^1.13.2",
     "bcryptjs": "^3.0.3",
-    "better-sqlite3": "^11.10.0",
+    "better-sqlite3": "12.4.1",
     "class-variance-authority": "^0.7.1",
     "clsx": "^2.1.1",
     "date-fns": "^4.1.0",
+    "dotenv": "^17.2.3",
     "drizzle-orm": "^0.44.7",
     "lucide-react": "^0.553.0",
     "next": "^16.0.1",
@@ -49,12 +50,15 @@
   "devDependencies": {
     "@testing-library/jest-dom": "^6.9.1",
     "@testing-library/react": "^16.3.0",
+    "@types/jest": "^30.0.0",
     "@types/node": "^24.10.0",
     "@types/react": "19.2.2",
     "@types/react-dom": "^19.2.2",
     "eslint": "^9.39.1",
     "eslint-config-next": "^16.0.1",
     "jest": "^30.2.0",
+    "jest-environment-jsdom": "^30.2.0",
+    "ts-jest": "^29.4.6",
     "typescript": "^5.9.3"
   }
 }

apps/admin/scripts/check-role.ts

@@ -0,0 +1,14 @@
+
+import { getDatabase } from '../src/lib/database';
+import { DrizzleDatabase } from '../src/lib/database/drizzle';
+
+async function checkUserRole() {
+    const db = await getDatabase();
+    const users = await db.getAllUsers();
+    console.log('Users found:', users.length);
+    users.forEach(u => {
+        console.log(`User: ${u.email}, Role: ${u.role}, ID: ${u.id}`);
+    });
+}
+
+checkUserRole().catch(console.error);

apps/admin/scripts/make-admin.ts

@@ -0,0 +1,15 @@
+
+import { getDatabase } from '../src/lib/database';
+
+async function makeAdmin(email: string) {
+    const db = await getDatabase();
+    const user = await db.getUserByEmail(email);
+    if (!user) {
+        console.log('User not found');
+        return;
+    }
+    await db.updateUser(user.id, { role: 'admin' });
+    console.log(`User ${email} updated to admin`);
+}
+
+makeAdmin('taratur@gmail.com').catch(console.error);

apps/admin/scripts/sync-all-users.ts

@@ -0,0 +1,57 @@
+
+import 'dotenv/config';
+import { getDatabase } from '../src/lib/database';
+import { clerkClient } from '@clerk/nextjs/server';
+
+async function syncAllUsers() {
+    console.log('Starting full user sync...');
+    const db = await getDatabase();
+
+    // Fetch all users from Clerk
+    // Note: pagination might be needed for large user bases, but for prototype this is fine.
+    const client = await clerkClient();
+    const response = await client.users.getUserList({ limit: 100 });
+    const clerkUsers = response.data;
+
+    console.log(`Found ${clerkUsers.length} users in Clerk.`);
+
+    for (const clerkUser of clerkUsers) {
+        const userId = clerkUser.id;
+        const email = clerkUser.emailAddresses[0]?.emailAddress;
+
+        if (!email) {
+            console.warn(`User ${userId} has no email, skipping.`);
+            continue;
+        }
+
+        const existingUser = await db.getUserById(userId);
+        if (existingUser) {
+            console.log(`User ${email} (${userId}) already exists.`);
+            // Optional: Update details if needed
+            continue;
+        }
+
+        // Check by email to handle ID mismatches (e.g. from seeding)
+        const existingByEmail = await db.getUserByEmail(email);
+        if (existingByEmail) {
+            console.log(`User ${email} found with old ID ${existingByEmail.id}. Migrating to ${userId}...`);
+            await db.migrateUserId(existingByEmail.id, userId);
+            continue;
+        }
+
+        console.log(`Creating new user ${email} (${userId})...`);
+        await db.createUser({
+            id: userId,
+            email,
+            firstName: clerkUser.firstName || '',
+            lastName: clerkUser.lastName || '',
+            password: '', // Managed by Clerk
+            phone: clerkUser.phoneNumbers[0]?.phoneNumber || undefined,
+            role: (clerkUser.publicMetadata.role as 'admin' | 'client' | 'superAdmin') || 'client'
+        });
+    }
+
+    console.log('Sync complete.');
+}
+
+syncAllUsers().catch(console.error);

apps/admin/scripts/tsconfig.json

@@ -0,0 +1,15 @@
+{
+    "extends": "../tsconfig.json",
+    "compilerOptions": {
+        "module": "CommonJS",
+        "moduleResolution": "node",
+        "allowImportingTsExtensions": true,
+        "noEmit": true
+    },
+    "ts-node": {
+        "transpileOnly": true,
+        "compilerOptions": {
+            "module": "CommonJS"
+        }
+    }
+}

apps/admin/scripts/verify-db.ts

@@ -0,0 +1,81 @@
+
+import { getDatabase } from '../src/lib/database/index.ts';
+
+async function verifyDatabase() {
+    console.log('Starting database verification...');
+    const db = await getDatabase();
+    await db.connect();
+
+    try {
+        // 1. Create User
+        console.log('Creating test user...');
+        const userId = `test-user-${Date.now()}`;
+        const user = await db.createUser({
+            id: userId,
+            email: `test-${Date.now()}@example.com`,
+            firstName: 'Test',
+            lastName: 'User',
+            password: 'password123',
+            role: 'client',
+            phone: '1234567890'
+        });
+        console.log('User created:', user.id);
+
+        // 2. Create Client
+        console.log('Creating test client...');
+        const client = await db.createClient({
+            userId: user.id,
+            membershipType: 'basic',
+            membershipStatus: 'active',
+            joinDate: new Date()
+        });
+        console.log('Client created:', client.id);
+
+        // 3. Create Fitness Profile
+        console.log('Creating fitness profile...');
+        const profile = await db.createFitnessProfile({
+            userId: user.id,
+            height: '180',
+            weight: '75',
+            age: '30',
+            gender: 'male',
+            activityLevel: 'moderately_active',
+            fitnessGoals: ['weight_loss'],
+            exerciseHabits: 'None',
+            dietHabits: 'None',
+            medicalConditions: 'None'
+        });
+        console.log('Fitness profile created for:', profile.userId);
+
+        // 4. Attendance Check-in
+        console.log('Checking in...');
+        const checkIn = await db.checkIn(user.id, 'gym', 'Test check-in');
+        console.log('Checked in:', checkIn.id);
+
+        // 5. Verify Active Check-in
+        const activeCheckIn = await db.getActiveCheckIn(user.id);
+        if (!activeCheckIn || activeCheckIn.id !== checkIn.id) {
+            throw new Error('Active check-in verification failed');
+        }
+        console.log('Active check-in verified');
+
+        // 6. Attendance Check-out
+        console.log('Checking out...');
+        const checkOut = await db.checkOut(checkIn.id);
+        console.log('Checked out:', checkOut?.checkOutTime);
+
+        // 7. Cleanup
+        console.log('Cleaning up...');
+        await db.deleteUser(user.id);
+        console.log('Cleanup complete');
+
+        console.log('✅ Verification successful!');
+    } catch (error) {
+        console.error('❌ Verification failed:', error);
+        process.exit(1);
+    } finally {
+        await db.disconnect();
+    }
+}
+
+verifyDatabase();

apps/admin/src/app/api/attendance/__tests__/attendance.test.ts

@@ -0,0 +1,137 @@
+/**
+ * @jest-environment node
+ */
+import { POST as checkIn } from '../check-in/route'
+import { POST as checkOut } from '../check-out/route'
+import { GET as history } from '../history/route'
+import { NextRequest } from 'next/server'
+
+// Mock dependencies
+jest.mock('@clerk/nextjs/server', () => ({
+    auth: jest.fn(() => Promise.resolve({ userId: 'test_user_id' })),
+    currentUser: jest.fn(() => Promise.resolve({ id: 'test_user_id', emailAddresses: [{ emailAddress: 'test@example.com' }] }))
+}))
+
+jest.mock('@/lib/sync-user', () => ({
+    ensureUserSynced: jest.fn()
+}))
+
+const mockDb = {
+    checkIn: jest.fn(),
+    checkOut: jest.fn(),
+    getAttendanceHistory: jest.fn(),
+    getActiveCheckIn: jest.fn(),
+    getUserById: jest.fn(),
+    createUser: jest.fn(),
+    getClientByUserId: jest.fn(),
+    createClient: jest.fn(),
+    getFitnessProfileByUserId: jest.fn(),
+    createFitnessProfile: jest.fn(),
+}
+
+jest.mock('@/lib/database', () => ({
+    getDatabase: jest.fn(() => Promise.resolve(mockDb))
+}))
+
+describe('Attendance API', () => {
+    beforeEach(() => {
+        jest.clearAllMocks()
+    })
+
+    describe('POST /api/attendance/check-in', () => {
+        it('should successfully check in', async () => {
+            mockDb.getUserById.mockResolvedValue({ id: 'test_user_id' })
+            mockDb.getActiveCheckIn.mockResolvedValue(null)
+            mockDb.checkIn.mockResolvedValue({
+                id: 'attendance_id',
+                userId: 'test_user_id',
+                checkInTime: new Date(),
+                type: 'gym'
+            })
+
+            const req = new NextRequest('http://localhost/api/attendance/check-in', {
+                method: 'POST',
+                body: JSON.stringify({ type: 'gym', notes: 'Test check-in' })
+            })
+
+            const res = await checkIn(req)
+            const data = await res.json()
+
+            expect(res.status).toBe(200)
+            expect(data.id).toBe('attendance_id')
+            expect(data.userId).toBe('test_user_id')
+            expect(mockDb.checkIn).toHaveBeenCalledWith('test_user_id', 'gym', 'Test check-in')
+        })
+
+        it('should fail if already checked in', async () => {
+            mockDb.getUserById.mockResolvedValue({ id: 'test_user_id' })
+            mockDb.getActiveCheckIn.mockResolvedValue({ id: 'existing_id' })
+
+            const req = new NextRequest('http://localhost/api/attendance/check-in', {
+                method: 'POST',
+                body: JSON.stringify({ type: 'gym' })
+            })
+
+            const res = await checkIn(req)
+            const text = await res.text()
+
+            expect(res.status).toBe(400)
+            expect(text).toBe('Already checked in')
+        })
+    })
+
+    describe('POST /api/attendance/check-out', () => {
+        it('should successfully check out', async () => {
+            mockDb.getActiveCheckIn.mockResolvedValue({ id: 'attendance_id' })
+            mockDb.checkOut.mockResolvedValue({
+                id: 'attendance_id',
+                checkOutTime: new Date()
+            })
+
+            const req = new NextRequest('http://localhost/api/attendance/check-out', {
+                method: 'POST'
+            })
+
+            const res = await checkOut(req)
+            const data = await res.json()
+
+            expect(res.status).toBe(200)
+            expect(data.id).toBe('attendance_id')
+            expect(data.checkOutTime).toBeDefined()
+            expect(mockDb.checkOut).toHaveBeenCalledWith('attendance_id')
+        })
+
+        it('should fail if not checked in', async () => {
+            mockDb.getActiveCheckIn.mockResolvedValue(null)
+
+            const req = new NextRequest('http://localhost/api/attendance/check-out', {
+                method: 'POST'
+            })
+
+            const res = await checkOut(req)
+            const text = await res.text()
+
+            expect(res.status).toBe(404)
+            expect(text).toBe('No active check-in found')
+        })
+    })
+
+    describe('GET /api/attendance/history', () => {
+        it('should return attendance history', async () => {
+            const historyData = [
+                { id: '1', checkInTime: new Date() },
+                { id: '2', checkInTime: new Date() }
+            ]
+            mockDb.getUserById.mockResolvedValue({ id: 'test_user_id' })
+            mockDb.getAttendanceHistory.mockResolvedValue(historyData)
+
+            const req = new NextRequest('http://localhost/api/attendance/history')
+            const res = await history(req)
+            const data = await res.json()
+
+            expect(res.status).toBe(200)
+            expect(data).toEqual(JSON.parse(JSON.stringify(historyData))) // Handle date serialization
+            expect(mockDb.getAttendanceHistory).toHaveBeenCalledWith('test_user_id')
+        })
+    })
+})

apps/admin/src/lib/database/__tests__/drizzle.test.ts

@@ -0,0 +1,181 @@
+/**
+ * @jest-environment node
+ */
+import { DrizzleDatabase } from '../drizzle'
+import { DatabaseConfig } from '../types'
+import Database from 'better-sqlite3'
+import { drizzle } from 'drizzle-orm/better-sqlite3'
+import * as schema from '@fitai/database'
+
+describe('DrizzleDatabase', () => {
+    let db: DrizzleDatabase
+    let sqlite: Database.Database
+    let drizzleDb: ReturnType<typeof drizzle>
+
+    beforeEach(async () => {
+        // Create in-memory SQLite database
+        sqlite = new Database(':memory:')
+        drizzleDb = drizzle(sqlite, { schema })
+
+        const config: DatabaseConfig = {
+            type: 'sqlite',
+            connection: { filename: ':memory:' },
+            options: { logging: false }
+        }
+
+        // Initialize DrizzleDatabase with the in-memory db
+        db = new DrizzleDatabase(config, drizzleDb as any)
+        await db.connect()
+    })
+
+    afterEach(async () => {
+        await db.disconnect()
+        sqlite.close()
+    })
+
+    describe('User Operations', () => {
+        it('should create and retrieve a user', async () => {
+            const newUser = {
+                email: 'test@example.com',
+                firstName: 'Test',
+                lastName: 'User',
+                password: 'password123',
+                role: 'client' as const
+            }
+
+            const createdUser = await db.createUser(newUser)
+            expect(createdUser).toBeDefined()
+            expect(createdUser.id).toBeDefined()
+            expect(createdUser.email).toBe(newUser.email)
+
+            const fetchedUser = await db.getUserById(createdUser.id)
+            expect(fetchedUser).toBeDefined()
+            expect(fetchedUser?.id).toBe(createdUser.id)
+            expect(fetchedUser?.email).toBe(createdUser.email)
+            // SQLite/Drizzle might truncate ms or handle dates differently in test env
+            expect(new Date(fetchedUser!.createdAt).getTime()).toBeLessThanOrEqual(createdUser.createdAt.getTime())
+            expect(new Date(fetchedUser!.updatedAt).getTime()).toBeLessThanOrEqual(createdUser.updatedAt.getTime())
+        })
+
+        it('should update a user', async () => {
+            const user = await db.createUser({
+                email: 'update@example.com',
+                firstName: 'Update',
+                lastName: 'Me',
+                password: 'password',
+                role: 'client'
+            })
+
+            const updated = await db.updateUser(user.id, { firstName: 'Updated' })
+            expect(updated?.firstName).toBe('Updated')
+
+            const fetched = await db.getUserById(user.id)
+            expect(fetched?.firstName).toBe('Updated')
+        })
+
+        it('should delete a user', async () => {
+            const user = await db.createUser({
+                email: 'delete@example.com',
+                firstName: 'Delete',
+                lastName: 'Me',
+                password: 'password',
+                role: 'client'
+            })
+
+            const deleted = await db.deleteUser(user.id)
+            expect(deleted).toBe(true)
+
+            const fetched = await db.getUserById(user.id)
+            expect(fetched).toBeNull()
+        })
+    })
+
+    describe('Client Operations', () => {
+        it('should create and retrieve a client', async () => {
+            const user = await db.createUser({
+                email: 'client@example.com',
+                firstName: 'Client',
+                lastName: 'User',
+                password: 'password',
+                role: 'client'
+            })
+
+            const newClient = {
+                userId: user.id,
+                membershipType: 'basic' as const,
+                membershipStatus: 'active' as const,
+                joinDate: new Date()
+            }
+
+            const createdClient = await db.createClient(newClient)
+            expect(createdClient).toBeDefined()
+            expect(createdClient.userId).toBe(user.id)
+
+            const fetchedClient = await db.getClientById(createdClient.id)
+            expect(fetchedClient).toBeDefined()
+            expect(fetchedClient?.id).toBe(createdClient.id)
+            expect(fetchedClient?.userId).toBe(createdClient.userId)
+            expect(fetchedClient?.membershipType).toBe(createdClient.membershipType)
+        })
+    })
+
+    describe('Fitness Profile Operations', () => {
+        it('should create and retrieve a fitness profile', async () => {
+            const user = await db.createUser({
+                email: 'profile@example.com',
+                firstName: 'Profile',
+                lastName: 'User',
+                password: 'password',
+                role: 'client'
+            })
+
+            const newProfile = {
+                userId: user.id,
+                height: 180,
+                weight: 75,
+                age: 30,
+                gender: 'male' as const,
+                activityLevel: 'moderately_active' as const,
+                fitnessGoals: ['weight_loss'],
+                exerciseHabits: 'None',
+                dietHabits: 'None',
+                medicalConditions: 'None'
+            }
+
+            const createdProfile = await db.createFitnessProfile(newProfile as any)
+            expect(createdProfile).toBeDefined()
+            expect(createdProfile.userId).toBe(user.id)
+
+            const fetchedProfile = await db.getFitnessProfileByUserId(user.id)
+            expect(fetchedProfile).toBeDefined()
+            expect(fetchedProfile?.userId).toBe(user.id)
+            expect(fetchedProfile?.fitnessGoals).toEqual(expect.arrayContaining(['weight_loss']))
+        })
+    })
+
+    describe('Attendance Operations', () => {
+        it('should check in and check out', async () => {
+            const user = await db.createUser({
+                email: 'attendance@example.com',
+                firstName: 'Attendance',
+                lastName: 'User',
+                password: 'password',
+                role: 'client'
+            })
+
+            const checkIn = await db.checkIn(user.id, 'gym')
+            expect(checkIn).toBeDefined()
+            expect(checkIn.checkOutTime).toBeUndefined()
+
+            const activeCheckIn = await db.getActiveCheckIn(user.id)
+            expect(activeCheckIn).toBeDefined()
+            expect(activeCheckIn?.id).toBe(checkIn.id)
+
+            const checkOut = await db.checkOut(checkIn.id)
+            expect(checkOut?.checkOutTime).toBeDefined()
+
+            const activeCheckInAfter = await db.getActiveCheckIn(user.id)
+            expect(activeCheckInAfter).toBeNull()
+        })
+    })
+})

apps/admin/src/lib/database/drizzle.ts

@@ -0,0 +1,555 @@
+
+import { IDatabase, User, Client, FitnessProfile, Attendance, Recommendation, FitnessGoal, DatabaseConfig } from './types'
+import { db as defaultDb, users, clients, fitnessProfiles, attendance, recommendations, fitnessGoals, eq, and, desc, sql } from '@fitai/database'
+import { InferSelectModel } from 'drizzle-orm'
+
+export class DrizzleDatabase implements IDatabase {
+    private config: DatabaseConfig
+    private db: typeof defaultDb
+
+    constructor(config: DatabaseConfig, db?: typeof defaultDb) {
+        this.config = config
+        this.db = db || defaultDb
+    }
+
+    async connect(): Promise<void> {
+        // Drizzle with better-sqlite3 connects synchronously on initialization
+        // We can just log here if needed
+        if (this.config.options?.logging) {
+            console.log('Drizzle database connected')
+        }
+        await this.createTables()
+    }
+
+    async disconnect(): Promise<void> {
+        // better-sqlite3 handle is managed by Drizzle, usually no explicit disconnect needed for connection pooling
+        // but we can close the underlying sqlite instance if we had access to it.
+        // For now, we'll assume it's handled.
+        if (this.config.options?.logging) {
+            console.log('Drizzle database disconnected')
+        }
+    }
+
+    private async createTables(): Promise<void> {
+        // Users table
+        await this.db.run(sql`
+            CREATE TABLE IF NOT EXISTS users (
+                id TEXT PRIMARY KEY,
+                email TEXT UNIQUE NOT NULL,
+                first_name TEXT NOT NULL,
+                last_name TEXT NOT NULL,
+                password TEXT,
+                phone TEXT,
+                role TEXT NOT NULL CHECK (role IN ('superAdmin', 'admin', 'trainer', 'client')),
+                created_at INTEGER NOT NULL,
+                updated_at INTEGER NOT NULL
+            )
+        `)
+
+        // Clients table
+        await this.db.run(sql`
+            CREATE TABLE IF NOT EXISTS clients (
+                id TEXT PRIMARY KEY,
+                user_id TEXT NOT NULL,
+                membership_type TEXT NOT NULL CHECK (membership_type IN ('basic', 'premium', 'vip')),
+                membership_status TEXT NOT NULL CHECK (membership_status IN ('active', 'inactive', 'suspended')),
+                join_date INTEGER NOT NULL,
+                last_visit INTEGER,
+                emergency_contact_name TEXT,
+                emergency_contact_phone TEXT,
+                emergency_contact_relationship TEXT,
+                created_at INTEGER NOT NULL,
+                updated_at INTEGER NOT NULL,
+                FOREIGN KEY (user_id) REFERENCES users (id) ON DELETE CASCADE
+            )
+        `)
+
+        // Fitness profiles table
+        await this.db.run(sql`
+            CREATE TABLE IF NOT EXISTS fitness_profiles (
+                id TEXT PRIMARY KEY,
+                user_id TEXT NOT NULL UNIQUE,
+                height REAL,
+                weight REAL,
+                age INTEGER,
+                gender TEXT CHECK (gender IN ('male', 'female', 'other', 'prefer_not_to_say')),
+                activity_level TEXT CHECK (activity_level IN ('sedentary', 'lightly_active', 'moderately_active', 'very_active', 'extremely_active')),
+                fitness_goals TEXT,
+                exercise_habits TEXT,
+                diet_habits TEXT,
+                medical_conditions TEXT,
+                allergies TEXT,
+                injuries TEXT,
+                created_at INTEGER NOT NULL,
+                updated_at INTEGER NOT NULL,
+                FOREIGN KEY (user_id) REFERENCES users (id) ON DELETE CASCADE
+            )
+        `)
+
+        // Attendance table
+        await this.db.run(sql`
+            CREATE TABLE IF NOT EXISTS attendance (
+                id TEXT PRIMARY KEY,
+                user_id TEXT NOT NULL,
+                check_in_time INTEGER NOT NULL,
+                check_out_time INTEGER,
+                type TEXT NOT NULL CHECK (type IN ('gym', 'class', 'personal_training')),
+                notes TEXT,
+                created_at INTEGER NOT NULL,
+                FOREIGN KEY (user_id) REFERENCES users (id) ON DELETE CASCADE
+            )
+        `)
+
+        // Recommendations table
+        await this.db.run(sql`
+            CREATE TABLE IF NOT EXISTS recommendations (
+                id TEXT PRIMARY KEY,
+                user_id TEXT NOT NULL,
+                fitness_profile_id TEXT NOT NULL,
+                recommendation_text TEXT NOT NULL,
+                activity_plan TEXT NOT NULL,
+                diet_plan TEXT NOT NULL,
+                status TEXT NOT NULL CHECK (status IN ('pending', 'approved', 'rejected')) DEFAULT 'pending',
+                generated_at INTEGER NOT NULL,
+                approved_at INTEGER,
+                approved_by TEXT,
+                created_at INTEGER NOT NULL,
+                updated_at INTEGER NOT NULL,
+                FOREIGN KEY (user_id) REFERENCES users (id) ON DELETE CASCADE,
+                FOREIGN KEY (fitness_profile_id) REFERENCES fitness_profiles (id) ON DELETE CASCADE
+            )
+        `)
+
+        // Fitness Goals table
+        await this.db.run(sql`
+            CREATE TABLE IF NOT EXISTS fitness_goals (
+                id TEXT PRIMARY KEY,
+                user_id TEXT NOT NULL,
+                fitness_profile_id TEXT,
+                goal_type TEXT NOT NULL,
+                title TEXT NOT NULL,
+                description TEXT,
+                target_value REAL,
+                current_value REAL,
+                unit TEXT,
+                start_date INTEGER NOT NULL,
+                target_date INTEGER,
+                completed_date INTEGER,
+                status TEXT NOT NULL DEFAULT 'active',
+                progress REAL DEFAULT 0,
+                priority TEXT DEFAULT 'medium',
+                notes TEXT,
+                created_at INTEGER NOT NULL,
+                updated_at INTEGER NOT NULL,
+                FOREIGN KEY (user_id) REFERENCES users (id) ON DELETE CASCADE,
+                FOREIGN KEY (fitness_profile_id) REFERENCES fitness_profiles (id) ON DELETE CASCADE
+            )
+        `)
+    }
+
+    // User operations
+    async createUser(userData: Omit<User, "createdAt" | "updatedAt" | "id"> & { id?: string }): Promise<User> {
+        const id = userData.id || Math.random().toString(36).substr(2, 9)
+        const now = new Date()
+
+        const newUser = {
+            ...userData,
+            id,
+            createdAt: now,
+            updatedAt: now
+        }
+
+        await this.db.insert(users).values(newUser)
+        return newUser
+    }
+
+    async getUserById(id: string): Promise<User | null> {
+        const result = await this.db.select().from(users).where(eq(users.id, id)).get()
+        return result ? this.mapUser(result) : null
+    }
+
+    async getUserByEmail(email: string): Promise<User | null> {
+        const result = await this.db.select().from(users).where(eq(users.email, email)).get()
+        return result ? this.mapUser(result) : null
+    }
+
+    async getAllUsers(): Promise<User[]> {
+        const results = await this.db.select().from(users).orderBy(desc(users.createdAt)).all()
+        return results.map(this.mapUser)
+    }
+
+    async updateUser(id: string, updates: Partial<User>): Promise<User | null> {
+        const { id: _, ...updateData } = updates
+        if (Object.keys(updateData).length === 0) return this.getUserById(id)
+
+        await this.db.update(users)
+            .set({ ...updateData, updatedAt: new Date() })
+            .where(eq(users.id, id))
+            .run()
+
+        return this.getUserById(id)
+    }
+
+    async deleteUser(id: string): Promise<boolean> {
+        const result = await this.db.delete(users).where(eq(users.id, id)).run()
+        return result.changes > 0
+    }
+
+    async migrateUserId(oldId: string, newId: string): Promise<void> {
+        await this.db.update(users).set({ id: newId }).where(eq(users.id, oldId)).run()
+    }
+
+    // Client operations
+    async createClient(clientData: Omit<Client, 'id'>): Promise<Client> {
+        const id = Math.random().toString(36).substr(2, 9)
+        const newClient = {
+            id,
+            ...clientData,
+            createdAt: new Date(),
+            updatedAt: new Date()
+        }
+
+        await this.db.insert(clients).values(newClient as any)
+        return this.mapClient(newClient)
+    }
+
+    async getClientById(id: string): Promise<Client | null> {
+        const result = await this.db.select().from(clients).where(eq(clients.id, id)).get()
+        return result ? this.mapClient(result) : null
+    }
+
+    async getClientByUserId(userId: string): Promise<Client | null> {
+        const result = await this.db.select().from(clients).where(eq(clients.userId, userId)).get()
+        return result ? this.mapClient(result) : null
+    }
+
+    async getAllClients(): Promise<Client[]> {
+        const results = await this.db.select().from(clients).orderBy(desc(clients.joinDate)).all()
+        return results.map(this.mapClient)
+    }
+
+    async updateClient(id: string, updates: Partial<Client>): Promise<Client | null> {
+        const { id: _, ...updateData } = updates
+        if (Object.keys(updateData).length === 0) return this.getClientById(id)
+
+        await this.db.update(clients)
+            .set({ ...updateData, updatedAt: new Date() } as any)
+            .where(eq(clients.id, id))
+            .run()
+
+        return this.getClientById(id)
+    }
+
+    async deleteClient(id: string): Promise<boolean> {
+        const result = await this.db.delete(clients).where(eq(clients.id, id)).run()
+        return result.changes > 0
+    }
+
+    // Fitness Profile operations
+    async createFitnessProfile(profileData: Omit<FitnessProfile, 'createdAt' | 'updatedAt'>): Promise<FitnessProfile> {
+        const now = new Date()
+        const id = Math.random().toString(36).substr(2, 9)
+        const newProfile = {
+            id,
+            ...profileData,
+            createdAt: now,
+            updatedAt: now
+        }
+
+        await this.db.insert(fitnessProfiles).values(newProfile as any)
+        return { ...profileData, createdAt: now, updatedAt: now }
+    }
+
+    async getFitnessProfileByUserId(userId: string): Promise<FitnessProfile | null> {
+        const result = await this.db.select().from(fitnessProfiles).where(eq(fitnessProfiles.userId, userId)).get()
+        return result ? this.mapFitnessProfile(result) : null
+    }
+
+    async getAllFitnessProfiles(): Promise<FitnessProfile[]> {
+        const results = await this.db.select().from(fitnessProfiles).orderBy(desc(fitnessProfiles.createdAt)).all()
+        return results.map(this.mapFitnessProfile)
+    }
+
+    async updateFitnessProfile(userId: string, updates: Partial<FitnessProfile>): Promise<FitnessProfile | null> {
+        const { userId: _, ...updateData } = updates
+        if (Object.keys(updateData).length === 0) return this.getFitnessProfileByUserId(userId)
+
+        const dbUpdates = { ...updateData } as any
+        if (updateData.fitnessGoals) {
+            dbUpdates.fitnessGoals = JSON.stringify(updateData.fitnessGoals)
+        }
+
+        await this.db.update(fitnessProfiles)
+            .set({ ...dbUpdates, updatedAt: new Date() })
+            .where(eq(fitnessProfiles.userId, userId))
+            .run()
+
+        return this.getFitnessProfileByUserId(userId)
+    }
+
+    async deleteFitnessProfile(userId: string): Promise<boolean> {
+        const result = await this.db.delete(fitnessProfiles).where(eq(fitnessProfiles.userId, userId)).run()
+        return result.changes > 0
+    }
+
+    // Attendance operations
+    async checkIn(userId: string, type: "gym" | "class" | "personal_training", notes?: string): Promise<Attendance> {
+        const id = Math.random().toString(36).substr(2, 9)
+        const now = new Date()
+
+        const newAttendance = {
+            id,
+            userId,
+            checkInTime: now,
+            type,
+            notes,
+            createdAt: now
+        }
+
+        await this.db.insert(attendance).values(newAttendance as any)
+
+        // Update client last visit
+        const client = await this.getClientByUserId(userId)
+        if (client) {
+            await this.updateClient(client.id, { lastVisit: now })
+        }
+
+        return newAttendance
+    }
+
+    async checkOut(attendanceId: string): Promise<Attendance | null> {
+        const now = new Date()
+        await this.db.update(attendance)
+            .set({ checkOutTime: now })
+            .where(eq(attendance.id, attendanceId))
+            .run()
+
+        return this.getAttendanceById(attendanceId)
+    }
+
+    async getAttendanceById(id: string): Promise<Attendance | null> {
+        const result = await this.db.select().from(attendance).where(eq(attendance.id, id)).get()
+        return result ? this.mapAttendance(result) : null
+    }
+
+    async getAttendanceHistory(userId: string): Promise<Attendance[]> {
+        const results = await this.db.select().from(attendance)
+            .where(eq(attendance.userId, userId))
+            .orderBy(desc(attendance.checkInTime))
+            .all()
+        return results.map(this.mapAttendance)
+    }
+
+    async getAllAttendance(): Promise<Attendance[]> {
+        const results = await this.db.select().from(attendance)
+            .orderBy(desc(attendance.checkInTime))
+            .all()
+        return results.map(this.mapAttendance)
+    }
+
+    async getActiveCheckIn(userId: string): Promise<Attendance | null> {
+        // Drizzle doesn't support IS NULL in where directly with simple syntax sometimes, but eq(col, null) works or isNull(col)
+        // We need to check how to filter for null checkOutTime.
+        // In Drizzle, we can filter in JS or use isNull operator if imported.
+        // Let's fetch recent and filter for now to be safe, or use raw sql if needed, but better to use Drizzle operators.
+        // Actually, we can just fetch all for user and filter in memory since it's unlikely to be huge for active checkins,
+        // but correct way is `isNull(attendance.checkOutTime)`.
+        // Since I didn't import `isNull`, I'll fetch recent history and find first active.
+
+        const history = await this.getAttendanceHistory(userId)
+        return history.find(a => !a.checkOutTime) || null
+    }
+
+    // Recommendation operations
+    async createRecommendation(data: Omit<Recommendation, "createdAt" | "approvedAt" | "approvedBy">): Promise<Recommendation> {
+        const now = new Date()
+        const newRec = {
+            ...data,
+            createdAt: now,
+            status: data.status || 'pending'
+        }
+
+        await this.db.insert(recommendations).values(newRec as any)
+        return newRec as Recommendation
+    }
+
+    async getRecommendationsByUserId(userId: string): Promise<Recommendation[]> {
+        const results = await this.db.select().from(recommendations)
+            .where(eq(recommendations.userId, userId))
+            .orderBy(desc(recommendations.createdAt))
+            .all()
+        return results.map(this.mapRecommendation)
+    }
+
+    async getAllRecommendations(): Promise<Recommendation[]> {
+        const results = await this.db.select().from(recommendations)
+            .orderBy(desc(recommendations.createdAt))
+            .all()
+        return results.map(this.mapRecommendation)
+    }
+
+    async updateRecommendation(id: string, updates: Partial<Recommendation>): Promise<Recommendation | null> {
+        const { id: _, ...updateData } = updates
+        if (Object.keys(updateData).length === 0) return this.getRecommendationById(id)
+
+        await this.db.update(recommendations)
+            .set(updateData as any)
+            .where(eq(recommendations.id, id))
+            .run()
+
+        return this.getRecommendationById(id)
+    }
+
+    async deleteRecommendation(id: string): Promise<boolean> {
+        const result = await this.db.delete(recommendations).where(eq(recommendations.id, id)).run()
+        return result.changes > 0
+    }
+
+    async getRecommendationById(id: string): Promise<Recommendation | null> {
+        const result = await this.db.select().from(recommendations).where(eq(recommendations.id, id)).get()
+        return result ? this.mapRecommendation(result) : null
+    }
+
+    // Fitness Goals operations
+    async createFitnessGoal(goalData: Omit<FitnessGoal, "createdAt" | "updatedAt">): Promise<FitnessGoal> {
+        const now = new Date()
+        const newGoal = {
+            ...goalData,
+            createdAt: now,
+            updatedAt: now
+        }
+
+        await this.db.insert(fitnessGoals).values(newGoal as any)
+        return newGoal as FitnessGoal
+    }
+
+    async getFitnessGoalById(id: string): Promise<FitnessGoal | null> {
+        const result = await this.db.select().from(fitnessGoals).where(eq(fitnessGoals.id, id)).get()
+        return result ? this.mapFitnessGoal(result) : null
+    }
+
+    async getFitnessGoalsByUserId(userId: string, status?: string): Promise<FitnessGoal[]> {
+        let query = this.db.select().from(fitnessGoals).where(eq(fitnessGoals.userId, userId))
+
+        if (status) {
+            query = this.db.select().from(fitnessGoals).where(and(eq(fitnessGoals.userId, userId), eq(fitnessGoals.status, status as any)))
+        }
+
+        const results = await query.orderBy(desc(fitnessGoals.createdAt)).all()
+        return results.map(this.mapFitnessGoal)
+    }
+
+    async updateFitnessGoal(id: string, updates: Partial<FitnessGoal>): Promise<FitnessGoal | null> {
+        const { id: _, ...updateData } = updates
+        if (Object.keys(updateData).length === 0) return this.getFitnessGoalById(id)
+
+        await this.db.update(fitnessGoals)
+            .set({ ...updateData, updatedAt: new Date() } as any)
+            .where(eq(fitnessGoals.id, id))
+            .run()
+
+        return this.getFitnessGoalById(id)
+    }
+
+    async deleteFitnessGoal(id: string): Promise<boolean> {
+        const result = await this.db.delete(fitnessGoals).where(eq(fitnessGoals.id, id)).run()
+        return result.changes > 0
+    }
+
+    async updateGoalProgress(id: string, currentValue: number): Promise<FitnessGoal | null> {
+        const goal = await this.getFitnessGoalById(id)
+        if (!goal) return null
+
+        let progress = goal.progress
+        if (goal.targetValue && goal.targetValue > 0) {
+            progress = Math.min(100, (currentValue / goal.targetValue) * 100)
+        }
+
+        await this.db.update(fitnessGoals)
+            .set({ currentValue, progress, updatedAt: new Date() })
+            .where(eq(fitnessGoals.id, id))
+            .run()
+
+        return this.getFitnessGoalById(id)
+    }
+
+    async completeGoal(id: string): Promise<FitnessGoal | null> {
+        const now = new Date()
+        await this.db.update(fitnessGoals)
+            .set({ status: 'completed', progress: 100, completedDate: now, updatedAt: now })
+            .where(eq(fitnessGoals.id, id))
+            .run()
+
+        return this.getFitnessGoalById(id)
+    }
+
+    async getDashboardStats(): Promise<{ totalUsers: number; activeClients: number; totalRevenue: number; revenueGrowth: number }> {
+        // Placeholder implementation as per original sqlite.ts (which didn't implement this either in the viewed snippet, 
+        // but interface requires it. I'll provide a basic implementation or mock).
+        // The original sqlite.ts snippet ended before showing this method, but the interface has it.
+        // I'll implement a basic count.
+
+        const allUsers = await this.db.select().from(users).all()
+        const activeClients = await this.db.select().from(clients).where(eq(clients.membershipStatus, 'active')).all()
+
+        return {
+            totalUsers: allUsers.length,
+            activeClients: activeClients.length,
+            totalRevenue: 0, // Not tracking payments yet
+            revenueGrowth: 0
+        }
+    }
+
+    // Mappers
+    private mapUser(row: any): User {
+        return {
+            ...row,
+            createdAt: new Date(row.createdAt),
+            updatedAt: new Date(row.updatedAt)
+        }
+    }
+
+    private mapClient(row: any): Client {
+        return {
+            ...row,
+            joinDate: new Date(row.joinDate),
+            lastVisit: row.lastVisit ? new Date(row.lastVisit) : undefined
+        }
+    }
+
+    private mapFitnessProfile(row: any): FitnessProfile {
+        return {
+            ...row,
+            createdAt: new Date(row.createdAt),
+            updatedAt: new Date(row.updatedAt)
+        }
+    }
+
+    private mapAttendance(row: any): Attendance {
+        return {
+            ...row,
+            checkInTime: new Date(row.checkInTime),
+            checkOutTime: row.checkOutTime ? new Date(row.checkOutTime) : undefined,
+            createdAt: new Date(row.createdAt)
+        }
+    }
+
+    private mapRecommendation(row: any): Recommendation {
+        return {
+            ...row,
+            createdAt: new Date(row.createdAt),
+            approvedAt: row.approvedAt ? new Date(row.approvedAt) : undefined
+        }
+    }
+
+    private mapFitnessGoal(row: any): FitnessGoal {
+        return {
+            ...row,
+            startDate: new Date(row.startDate),
+            targetDate: row.targetDate ? new Date(row.targetDate) : undefined,
+            completedDate: row.completedDate ? new Date(row.completedDate) : undefined,
+            createdAt: new Date(row.createdAt),
+            updatedAt: new Date(row.updatedAt)
+        }
+    }
+}

apps/admin/src/lib/database/index.ts

@@ -1,5 +1,5 @@
 import { IDatabase, DatabaseConfig } from './types'
-import { SQLiteDatabase } from './sqlite'
+import { DrizzleDatabase } from './drizzle'
 
 // Database factory - creates appropriate database instance based on config
 export class DatabaseFactory {
@@ -20,28 +20,28 @@ export class DatabaseFactory {
     // Create new database instance based on type
     switch (config.type) {
       case 'sqlite':
-        this.instance = new SQLiteDatabase(config)
+        this.instance = new DrizzleDatabase(config)
         break
-      
+
       case 'postgresql':
         // TODO: Implement PostgreSQLDatabase
         throw new Error('PostgreSQL implementation not yet available')
-      
+
       case 'mysql':
         // TODO: Implement MySQLDatabase
         throw new Error('MySQL implementation not yet available')
-      
+
       case 'mongodb':
         // TODO: Implement MongoDBDatabase
         throw new Error('MongoDB implementation not yet available')
-      
+
       default:
         throw new Error(`Unsupported database type: ${config.type}`)
     }
 
     await this.instance.connect()
     this.config = config
-    
+
     return this.instance
   }
 
@@ -62,7 +62,7 @@ export class DatabaseFactory {
 
   private static isSameConfig(config: DatabaseConfig): boolean {
     if (!this.config) return false
-    
+
     return (
       this.config.type === config.type &&
       JSON.stringify(this.config.connection) === JSON.stringify(config.connection)

apps/admin/src/lib/database/sqlite.ts

@@ -1,868 +0,0 @@
-import Database from 'better-sqlite3'
-import path from 'path'
-import fs from 'fs'
-import { IDatabase, User, Client, FitnessProfile, Attendance, Recommendation, DatabaseConfig } from './types'
-
-export class SQLiteDatabase implements IDatabase {
-  private db: Database.Database | null = null
-  private config: DatabaseConfig
-
-  constructor(config: DatabaseConfig) {
-    this.config = config
-  }
-
-  async connect(): Promise<void> {
-    try {
-      const dbPath = this.config.connection.filename || path.join(process.cwd(), 'data', 'fitai.db')
-
-      // Ensure data directory exists
-      const dataDir = path.dirname(dbPath)
-      if (!fs.existsSync(dataDir)) {
-        fs.mkdirSync(dataDir, { recursive: true })
-      }
-
-      this.db = new Database(dbPath)
-
-      // Enable foreign keys
-      this.db.exec('PRAGMA foreign_keys = ON')
-
-      // Create tables
-      await this.createTables()
-
-      if (this.config.options?.logging) {
-        console.log('SQLite database connected successfully at:', dbPath)
-      }
-    } catch (error) {
-      console.error('Failed to connect to SQLite database:', error)
-      throw error
-    }
-  }
-
-  async disconnect(): Promise<void> {
-    if (this.db) {
-      this.db.close()
-      this.db = null
-      if (this.config.options?.logging) {
-        console.log('SQLite database disconnected')
-      }
-    }
-  }
-
-  private async createTables(): Promise<void> {
-    if (!this.db) throw new Error('Database not connected')
-
-    // Users table
-    this.db.exec(`
-      CREATE TABLE IF NOT EXISTS users (
-        id TEXT PRIMARY KEY,
-        email TEXT UNIQUE NOT NULL,
-        firstName TEXT NOT NULL,
-        lastName TEXT NOT NULL,
-        password TEXT NOT NULL,
-        phone TEXT,
-        role TEXT NOT NULL CHECK (role IN ('superAdmin', 'admin', 'trainer', 'client')),
-        createdAt DATETIME NOT NULL,
-        updatedAt DATETIME NOT NULL
-      )
-    `)
-
-    // Clients table
-    this.db.exec(`
-      CREATE TABLE IF NOT EXISTS clients (
-        id TEXT PRIMARY KEY,
-        userId TEXT NOT NULL,
-        membershipType TEXT NOT NULL CHECK (membershipType IN ('basic', 'premium', 'vip')),
-        membershipStatus TEXT NOT NULL CHECK (membershipStatus IN ('active', 'inactive', 'expired')),
-        joinDate DATETIME NOT NULL,
-        FOREIGN KEY (userId) REFERENCES users (id) ON DELETE CASCADE
-      )
-    `)
-
-    // Fitness profiles table
-    this.db.exec(`
-      CREATE TABLE IF NOT EXISTS fitness_profiles (
-        userId TEXT PRIMARY KEY,
-        height TEXT NOT NULL,
-        weight TEXT NOT NULL,
-        age TEXT NOT NULL,
-        gender TEXT NOT NULL CHECK (gender IN ('male', 'female', 'other')),
-        activityLevel TEXT NOT NULL CHECK (activityLevel IN ('sedentary', 'light', 'moderate', 'active', 'very_active')),
-        fitnessGoals TEXT NOT NULL, -- JSON array
-        exerciseHabits TEXT,
-        dietHabits TEXT,
-        medicalConditions TEXT,
-        allergies TEXT,
-        injuries TEXT,
-        createdAt DATETIME NOT NULL,
-        updatedAt DATETIME NOT NULL,
-        FOREIGN KEY (userId) REFERENCES users (id) ON DELETE CASCADE
-      )
-    `)
-
-    // Create indexes for better performance
-    this.db.exec(`
-      CREATE INDEX IF NOT EXISTS idx_users_email ON users(email);
-      CREATE INDEX IF NOT EXISTS idx_clients_userId ON clients(userId);
-      CREATE INDEX IF NOT EXISTS idx_fitness_profiles_userId ON fitness_profiles(userId);
-    `)
-
-    // Attendance table migration: change from clientId to userId
-    // Check if old table exists and migrate
-    const tableInfo = this.db.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='attendance'").get() as any;
-
-    if (tableInfo) {
-      // Check if table has clientId column (old schema)
-      const columns = this.db.prepare("PRAGMA table_info(attendance)").all() as any[];
-      const hasClientId = columns.some((col: any) => col.name === 'clientId');
-
-      if (hasClientId) {
-        console.log('Migrating attendance table from clientId to userId...');
-
-        // Create new table with userId
-        this.db.exec(`
-          CREATE TABLE IF NOT EXISTS attendance_new (
-            id TEXT PRIMARY KEY,
-            userId TEXT NOT NULL,
-            checkInTime DATETIME NOT NULL,
-            checkOutTime DATETIME,
-            type TEXT NOT NULL CHECK (type IN ('gym', 'class', 'personal_training')),
-            notes TEXT,
-            createdAt DATETIME NOT NULL,
-            FOREIGN KEY (userId) REFERENCES users (id) ON DELETE CASCADE
-          )
-        `);
-
-        // Migrate data: map clientId to userId via clients table
-        this.db.exec(`
-          INSERT INTO attendance_new (id, userId, checkInTime, checkOutTime, type, notes, createdAt)
-          SELECT a.id, c.userId, a.checkInTime, a.checkOutTime, a.type, a.notes, a.createdAt
-          FROM attendance a
-          JOIN clients c ON a.clientId = c.id
-        `);
-
-        // Drop old table and rename new one
-        this.db.exec(`DROP TABLE attendance`);
-        this.db.exec(`ALTER TABLE attendance_new RENAME TO attendance`);
-
-        console.log('Attendance table migration completed');
-      }
-    } else {
-      // Create new attendance table with userId
-      this.db.exec(`
-        CREATE TABLE IF NOT EXISTS attendance (
-          id TEXT PRIMARY KEY,
-          userId TEXT NOT NULL,
-          checkInTime DATETIME NOT NULL,
-          checkOutTime DATETIME,
-          type TEXT NOT NULL CHECK (type IN ('gym', 'class', 'personal_training')),
-          notes TEXT,
-          createdAt DATETIME NOT NULL,
-          FOREIGN KEY (userId) REFERENCES users (id) ON DELETE CASCADE
-        )
-      `);
-    }
-
-    // Recommendations table
-    // Removed DROP TABLE to persist data. Schema is now stable.
-    // this.db.exec(`DROP TABLE IF EXISTS recommendations`)
-
-    this.db.exec(`
-      CREATE TABLE IF NOT EXISTS recommendations (
-        id TEXT PRIMARY KEY,
-        userId TEXT NOT NULL,
-        fitnessProfileId TEXT,
-        type TEXT NOT NULL,
-        content TEXT NOT NULL,
-        activityPlan TEXT,
-        dietPlan TEXT,
-        status TEXT NOT NULL CHECK (status IN ('pending', 'approved', 'rejected', 'completed')),
-        createdAt DATETIME NOT NULL,
-        approvedAt DATETIME,
-        approvedBy TEXT,
-        FOREIGN KEY (userId) REFERENCES users (id) ON DELETE CASCADE,
-        FOREIGN KEY (fitnessProfileId) REFERENCES fitness_profiles (userId)
-      )
-    `);
-
-    this.db.exec(`
-      CREATE INDEX IF NOT EXISTS idx_recommendations_userId ON recommendations(userId);
-    `);
-
-    this.db.exec(`
-      CREATE INDEX IF NOT EXISTS idx_attendance_userId ON attendance(userId);
-      CREATE INDEX IF NOT EXISTS idx_attendance_checkInTime ON attendance(checkInTime);
-    `);
-  }
-
-  // User operations
-  async createUser(
-    userData: Omit<User, "createdAt" | "updatedAt" | "id"> & { id?: string },
-  ): Promise<User> {
-    if (!this.db) throw new Error('Database not connected')
-
-    const id = userData.id || Math.random().toString(36).substr(2, 9)
-    const now = new Date()
-
-    const user: User = {
-      ...userData,
-      id,
-      createdAt: now,
-      updatedAt: now
-    }
-
-    const stmt = this.db.prepare(
-      `INSERT INTO users(id, email, firstName, lastName, password, phone, role, createdAt, updatedAt)
-    VALUES(?, ?, ?, ?, ?, ?, ?, ?, ?)`
-    )
-
-    stmt.run(
-      user.id, user.email, user.firstName, user.lastName, user.password,
-      user.phone, user.role, user.createdAt.toISOString(), user.updatedAt.toISOString()
-    )
-
-    return user
-  }
-
-  async getUserById(id: string): Promise<User | null> {
-    if (!this.db) throw new Error('Database not connected')
-
-    const stmt = this.db.prepare('SELECT * FROM users WHERE id = ?')
-    const row = stmt.get(id)
-
-    return row ? this.mapRowToUser(row) : null
-  }
-
-  async getUserByEmail(email: string): Promise<User | null> {
-    if (!this.db) throw new Error('Database not connected')
-
-    const stmt = this.db.prepare('SELECT * FROM users WHERE email = ?')
-    const row = stmt.get(email)
-
-    return row ? this.mapRowToUser(row) : null
-  }
-
-  async getAllUsers(): Promise<User[]> {
-    if (!this.db) throw new Error('Database not connected')
-
-    const stmt = this.db.prepare('SELECT * FROM users ORDER BY createdAt DESC')
-    const rows = stmt.all()
-
-    return rows.map(row => this.mapRowToUser(row))
-  }
-
-  async updateUser(id: string, updates: Partial<User>): Promise<User | null> {
-    if (!this.db) throw new Error('Database not connected')
-
-    const fields = Object.keys(updates).filter(key => key !== 'id')
-    if (fields.length === 0) return this.getUserById(id)
-
-    const setClause = fields.map(field => `${field} = ?`).join(', ')
-    const values = fields.map(field => (updates as any)[field])
-    values.push(new Date().toISOString()) // updatedAt
-    values.push(id)
-
-    const stmt = this.db.prepare(`UPDATE users SET ${setClause}, updatedAt = ? WHERE id = ? `)
-    stmt.run(values)
-
-    return this.getUserById(id)
-  }
-
-  async deleteUser(id: string): Promise<boolean> {
-    if (!this.db) throw new Error('Database not connected')
-
-    const stmt = this.db.prepare('DELETE FROM users WHERE id = ?')
-    const result = stmt.run(id)
-    return (result.changes || 0) > 0
-  }
-
-  async migrateUserId(oldId: string, newId: string): Promise<void> {
-    if (!this.db) throw new Error('Database not connected')
-
-    // We need to disable foreign keys temporarily if we want to update ID without cascade (if cascade isn't set)
-    // But we should try to update and let cascade handle it if possible.
-    // Since we didn't set ON UPDATE CASCADE, we might need to manually update references or use PRAGMA.
-
-    // Simplest way: Update the ID. If it fails due to FK, we have to handle it.
-    // For the Super Admin seed case, there are no dependencies.
-
-    const stmt = this.db.prepare('UPDATE users SET id = ? WHERE id = ?')
-    stmt.run(newId, oldId)
-  }
-
-  // Client operations
-  async createClient(clientData: Omit<Client, 'id'>): Promise<Client> {
-    if (!this.db) throw new Error('Database not connected')
-
-    const id = Math.random().toString(36).substr(2, 9)
-    const client: Client = { id, ...clientData }
-
-    const stmt = this.db.prepare(
-      `INSERT INTO clients(id, userId, membershipType, membershipStatus, joinDate)
-    VALUES(?, ?, ?, ?, ?)`
-    )
-
-    stmt.run(
-      client.id, client.userId, client.membershipType,
-      client.membershipStatus, client.joinDate.toISOString()
-    )
-
-    return client
-  }
-
-  async getClientById(id: string): Promise<Client | null> {
-    if (!this.db) throw new Error('Database not connected')
-
-    const stmt = this.db.prepare('SELECT * FROM clients WHERE id = ?')
-    const row = stmt.get(id)
-    return row ? this.mapRowToClient(row) : null
-  }
-
-  async getClientByUserId(userId: string): Promise<Client | null> {
-    if (!this.db) throw new Error('Database not connected')
-
-    const stmt = this.db.prepare('SELECT * FROM clients WHERE userId = ?')
-    const row = stmt.get(userId)
-    return row ? this.mapRowToClient(row) : null
-  }
-
-  async getAllClients(): Promise<Client[]> {
-    if (!this.db) throw new Error('Database not connected')
-
-    const stmt = this.db.prepare('SELECT * FROM clients ORDER BY joinDate DESC')
-    const rows = stmt.all()
-    return rows.map(row => this.mapRowToClient(row))
-  }
-
-  async updateClient(id: string, updates: Partial<Client>): Promise<Client | null> {
-    if (!this.db) throw new Error('Database not connected')
-
-    const fields = Object.keys(updates).filter(key => key !== 'id')
-    if (fields.length === 0) return this.getClientById(id)
-
-    const setClause = fields.map(field => `${field} = ?`).join(', ')
-    const values = fields.map(field => (updates as any)[field])
-    values.push(id)
-
-    const stmt = this.db.prepare(`UPDATE clients SET ${setClause} WHERE id = ? `)
-    stmt.run(values)
-
-    return this.getClientById(id)
-  }
-
-  async deleteClient(id: string): Promise<boolean> {
-    if (!this.db) throw new Error('Database not connected')
-
-    const stmt = this.db.prepare('DELETE FROM clients WHERE id = ?')
-    const result = stmt.run(id)
-    return (result.changes || 0) > 0
-  }
-
-  // Fitness Profile operations
-  async createFitnessProfile(profileData: Omit<FitnessProfile, 'createdAt' | 'updatedAt'>): Promise<FitnessProfile> {
-    if (!this.db) throw new Error('Database not connected')
-
-    const now = new Date()
-    const profile: FitnessProfile = {
-      ...profileData,
-      createdAt: now,
-      updatedAt: now
-    }
-
-    const stmt = this.db.prepare(
-      `INSERT INTO fitness_profiles
-      (userId, height, weight, age, gender, activityLevel, fitnessGoals,
-        exerciseHabits, dietHabits, medicalConditions, allergies, injuries, createdAt, updatedAt)
-    VALUES(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
-    )
-
-    stmt.run(
-      profile.userId, profile.height, profile.weight, profile.age, profile.gender,
-      profile.activityLevel, JSON.stringify(profile.fitnessGoals), profile.exerciseHabits,
-      profile.dietHabits, profile.medicalConditions, profile.allergies, profile.injuries,
-      profile.createdAt.toISOString(), profile.updatedAt.toISOString()
-    )
-
-    return profile
-  }
-
-  async getFitnessProfileByUserId(userId: string): Promise<FitnessProfile | null> {
-    if (!this.db) throw new Error('Database not connected')
-
-    const stmt = this.db.prepare('SELECT * FROM fitness_profiles WHERE userId = ?')
-    const row = stmt.get(userId)
-
-    return row ? this.mapRowToFitnessProfile(row) : null
-  }
-
-  async getAllFitnessProfiles(): Promise<FitnessProfile[]> {
-    if (!this.db) throw new Error('Database not connected')
-
-    const stmt = this.db.prepare('SELECT * FROM fitness_profiles ORDER BY createdAt DESC')
-    const rows = stmt.all()
-    return rows.map(row => this.mapRowToFitnessProfile(row))
-  }
-
-  async updateFitnessProfile(userId: string, updates: Partial<FitnessProfile>): Promise<FitnessProfile | null> {
-    if (!this.db) throw new Error('Database not connected')
-
-    const fields = Object.keys(updates).filter(key => key !== 'userId' && key !== 'createdAt')
-    if (fields.length === 0) return this.getFitnessProfileByUserId(userId)
-
-    const setClause = fields.map(field => `${field} = ?`).join(', ')
-    const values = fields.map(field => {
-      const value = (updates as any)[field]
-      return field === 'fitnessGoals' ? JSON.stringify(value) : value
-    })
-    values.push(new Date().toISOString()) // updatedAt
-    values.push(userId)
-
-    const stmt = this.db.prepare(`UPDATE fitness_profiles SET ${setClause}, updatedAt = ? WHERE userId = ? `)
-    stmt.run(values)
-
-    return this.getFitnessProfileByUserId(userId)
-  }
-
-  async deleteFitnessProfile(userId: string): Promise<boolean> {
-    if (!this.db) throw new Error('Database not connected')
-
-    const stmt = this.db.prepare('DELETE FROM fitness_profiles WHERE userId = ?')
-    const result = stmt.run(userId)
-    return (result.changes || 0) > 0
-  }
-
-  // Attendance operations
-  async checkIn(userId: string, type: 'gym' | 'class' | 'personal_training', notes?: string): Promise<Attendance> {
-    if (!this.db) throw new Error('Database not connected')
-
-    const id = Math.random().toString(36).substr(2, 9)
-    const now = new Date()
-
-    const attendance: Attendance = {
-      id,
-      userId,
-      checkInTime: now,
-      type,
-      notes,
-      createdAt: now
-    }
-
-    const stmt = this.db.prepare(
-      `INSERT INTO attendance(id, userId, checkInTime, type, notes, createdAt)
-    VALUES(?, ?, ?, ?, ?, ?)`
-    )
-
-    stmt.run(
-      attendance.id, attendance.userId, attendance.checkInTime.toISOString(),
-      attendance.type, attendance.notes, attendance.createdAt.toISOString()
-    )
-
-    // Update client last visit if user is a client
-    const client = await this.getClientByUserId(userId);
-    if (client) {
-      this.db.prepare('UPDATE clients SET lastVisit = ? WHERE id = ?').run(
-        now.toISOString(),
-        client.id
-      );
-    }
-
-    return attendance
-  }
-
-  async checkOut(attendanceId: string): Promise<Attendance | null> {
-    if (!this.db) throw new Error('Database not connected')
-
-    const now = new Date()
-    const stmt = this.db.prepare('UPDATE attendance SET checkOutTime = ? WHERE id = ?')
-    stmt.run(now.toISOString(), attendanceId)
-
-    return this.getAttendanceById(attendanceId)
-  }
-
-  async getAttendanceById(id: string): Promise<Attendance | null> {
-    if (!this.db) throw new Error('Database not connected')
-    const stmt = this.db.prepare('SELECT * FROM attendance WHERE id = ?')
-    const row = stmt.get(id)
-    return row ? this.mapRowToAttendance(row) : null
-  }
-
-  async getAttendanceHistory(userId: string): Promise<Attendance[]> {
-    if (!this.db) throw new Error('Database not connected')
-    const stmt = this.db.prepare('SELECT * FROM attendance WHERE userId = ? ORDER BY checkInTime DESC')
-    const rows = stmt.all(userId)
-    return rows.map(row => this.mapRowToAttendance(row))
-  }
-
-  async getAllAttendance(): Promise<Attendance[]> {
-    if (!this.db) throw new Error('Database not connected')
-    const stmt = this.db.prepare('SELECT * FROM attendance ORDER BY checkInTime DESC')
-    const rows = stmt.all()
-    return rows.map(row => this.mapRowToAttendance(row))
-  }
-
-  async getActiveCheckIn(userId: string): Promise<Attendance | null> {
-    if (!this.db) throw new Error('Database not connected')
-    const stmt = this.db.prepare('SELECT * FROM attendance WHERE userId = ? AND checkOutTime IS NULL ORDER BY checkInTime DESC LIMIT 1')
-    const row = stmt.get(userId)
-    return row ? this.mapRowToAttendance(row) : null
-  }
-
-  // Helper methods to map database rows to entities
-  private mapRowToUser(row: any): User {
-    return {
-      id: row.id,
-      email: row.email,
-      firstName: row.firstName,
-      lastName: row.lastName,
-      password: row.password,
-      phone: row.phone,
-      role: row.role,
-      createdAt: new Date(row.createdAt),
-      updatedAt: new Date(row.updatedAt)
-    }
-  }
-
-  private mapRowToClient(row: any): Client {
-    return {
-      id: row.id,
-      userId: row.userId,
-      membershipType: row.membershipType,
-      membershipStatus: row.membershipStatus,
-      joinDate: new Date(row.joinDate),
-      lastVisit: row.lastVisit ? new Date(row.lastVisit) : undefined
-    }
-  }
-
-  private mapRowToFitnessProfile(row: any): FitnessProfile {
-    return {
-      userId: row.userId,
-      height: row.height,
-      weight: row.weight,
-      age: row.age,
-      gender: row.gender,
-      activityLevel: row.activityLevel,
-      fitnessGoals: JSON.parse(row.fitnessGoals || '[]'),
-      exerciseHabits: row.exerciseHabits,
-      dietHabits: row.dietHabits,
-      medicalConditions: row.medicalConditions,
-      allergies: row.allergies,
-      injuries: row.injuries,
-      createdAt: new Date(row.createdAt),
-      updatedAt: new Date(row.updatedAt)
-    }
-  }
-
-  private mapRowToAttendance(row: any): Attendance {
-    return {
-      id: row.id,
-      userId: row.userId,
-      checkInTime: new Date(row.checkInTime),
-      checkOutTime: row.checkOutTime ? new Date(row.checkOutTime) : undefined,
-      type: row.type,
-      notes: row.notes,
-      createdAt: new Date(row.createdAt)
-    }
-  }
-
-  // Recommendation operations
-  async createRecommendation(data: Omit<Recommendation, 'createdAt' | 'approvedAt' | 'approvedBy'>): Promise<Recommendation> {
-    if (!this.db) throw new Error('Database not connected')
-
-    const now = new Date()
-    const recommendation: Recommendation = {
-      ...data,
-      createdAt: now,
-      status: data.status || 'pending'
-    }
-
-    const stmt = this.db.prepare(
-      `INSERT INTO recommendations (
-        id, userId, fitnessProfileId, type, content,
-        activityPlan, dietPlan, status, createdAt
-      )
-       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`
-    )
-
-    stmt.run(
-      recommendation.id, recommendation.userId, recommendation.fitnessProfileId,
-      recommendation.type, recommendation.content, recommendation.activityPlan,
-      recommendation.dietPlan, recommendation.status,
-      recommendation.createdAt.toISOString()
-    )
-
-    return recommendation
-  }
-
-  async getRecommendationsByUserId(userId: string): Promise<Recommendation[]> {
-    if (!this.db) throw new Error('Database not connected')
-
-    const stmt = this.db.prepare('SELECT * FROM recommendations WHERE userId = ? ORDER BY createdAt DESC')
-    const rows = stmt.all(userId)
-
-    return rows.map(row => this.mapRowToRecommendation(row))
-  }
-
-  async getAllRecommendations(): Promise<Recommendation[]> {
-    if (!this.db) throw new Error('Database not connected')
-
-    const stmt = this.db.prepare('SELECT * FROM recommendations ORDER BY createdAt DESC')
-    const rows = stmt.all()
-
-    return rows.map(row => this.mapRowToRecommendation(row))
-  }
-
-  async updateRecommendation(id: string, updates: Partial<Recommendation>): Promise<Recommendation | null> {
-    if (!this.db) throw new Error('Database not connected')
-
-    const fields = Object.keys(updates).filter(key => key !== 'id' && key !== 'userId')
-    if (fields.length === 0) {
-      const stmt = this.db.prepare('SELECT * FROM recommendations WHERE id = ?')
-      const row = stmt.get(id)
-      return row ? this.mapRowToRecommendation(row) : null
-    }
-
-    const setClause = fields.map(field => `${field} = ?`).join(', ')
-    const values = fields.map(field => {
-      const val = (updates as any)[field]
-      return val instanceof Date ? val.toISOString() : val
-    })
-    values.push(id)
-
-    const stmt = this.db.prepare(`UPDATE recommendations SET ${setClause} WHERE id = ?`)
-    stmt.run(values)
-
-    const getStmt = this.db.prepare('SELECT * FROM recommendations WHERE id = ?')
-    const row = getStmt.get(id)
-    return row ? this.mapRowToRecommendation(row) : null
-  }
-
-  async deleteRecommendation(id: string): Promise<boolean> {
-    if (!this.db) throw new Error('Database not connected')
-
-    const stmt = this.db.prepare('DELETE FROM recommendations WHERE id = ?')
-    const result = stmt.run(id)
-    return (result.changes || 0) > 0
-  }
-
-  private mapRowToRecommendation(row: any): Recommendation {
-    return {
-      id: row.id,
-      userId: row.userId,
-      fitnessProfileId: row.fitnessProfileId,
-      type: row.type,
-      content: row.content,
-      activityPlan: row.activityPlan,
-      dietPlan: row.dietPlan,
-      status: row.status,
-      createdAt: new Date(row.createdAt),
-      approvedAt: row.approvedAt ? new Date(row.approvedAt) : undefined,
-      approvedBy: row.approvedBy
-    }
-  }
-
-  // Fitness Goals operations
-  async createFitnessGoal(goalData: Omit<import('./types').FitnessGoal, 'createdAt' | 'updatedAt'>): Promise<import('./types').FitnessGoal> {
-    if (!this.db) throw new Error('Database not connected')
-
-    const now = new Date()
-    const goal: import('./types').FitnessGoal = {
-      ...goalData,
-      createdAt: now,
-      updatedAt: now
-    }
-
-    const stmt = this.db.prepare(
-      `INSERT INTO fitness_goals (
-        id, user_id, fitness_profile_id, goal_type, title, description,
-        target_value, current_value, unit, start_date, target_date,
-        completed_date, status, progress, priority, notes, created_at, updated_at
-      )
-      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
-    )
-
-    stmt.run(
-      goal.id,
-      goal.userId,
-      goal.fitnessProfileId || null,
-      goal.goalType,
-      goal.title,
-      goal.description || null,
-      goal.targetValue || null,
-      goal.currentValue || null,
-      goal.unit || null,
-      goal.startDate.toISOString(),
-      goal.targetDate ? goal.targetDate.toISOString() : null,
-      goal.completedDate ? goal.completedDate.toISOString() : null,
-      goal.status,
-      goal.progress,
-      goal.priority,
-      goal.notes || null,
-      goal.createdAt.toISOString(),
-      goal.updatedAt.toISOString()
-    )
-
-    return goal
-  }
-
-  async getFitnessGoalById(id: string): Promise<import('./types').FitnessGoal | null> {
-    if (!this.db) throw new Error('Database not connected')
-
-    const stmt = this.db.prepare('SELECT * FROM fitness_goals WHERE id = ?')
-    const row = stmt.get(id)
-
-    return row ? this.mapRowToFitnessGoal(row) : null
-  }
-
-  async getFitnessGoalsByUserId(userId: string, status?: string): Promise<import('./types').FitnessGoal[]> {
-    if (!this.db) throw new Error('Database not connected')
-
-    let query = 'SELECT * FROM fitness_goals WHERE user_id = ?'
-    const params: any[] = [userId]
-
-    if (status) {
-      query += ' AND status = ?'
-      params.push(status)
-    }
-
-    query += ' ORDER BY created_at DESC'
-
-    const stmt = this.db.prepare(query)
-    const rows = stmt.all(...params)
-
-    return rows.map(row => this.mapRowToFitnessGoal(row))
-  }
-
-  async updateFitnessGoal(id: string, updates: Partial<import('./types').FitnessGoal>): Promise<import('./types').FitnessGoal | null> {
-    if (!this.db) throw new Error('Database not connected')
-
-    const fields = Object.keys(updates).filter(key => key !== 'id' && key !== 'createdAt')
-    if (fields.length === 0) return this.getFitnessGoalById(id)
-
-    // Map camelCase to snake_case for database columns
-    const columnMap: Record<string, string> = {
-      userId: 'user_id',
-      fitnessProfileId: 'fitness_profile_id',
-      goalType: 'goal_type',
-      targetValue: 'target_value',
-      currentValue: 'current_value',
-      startDate: 'start_date',
-      targetDate: 'target_date',
-      completedDate: 'completed_date',
-      updatedAt: 'updated_at'
-    }
-
-    const setClause = fields.map(field => `${columnMap[field] || field} = ?`).join(', ')
-    const values = fields.map(field => {
-      const val = (updates as any)[field]
-      return val instanceof Date ? val.toISOString() : val
-    })
-    values.push(new Date().toISOString()) // updatedAt
-    values.push(id)
-
-    const stmt = this.db.prepare(`UPDATE fitness_goals SET ${setClause}, updated_at = ? WHERE id = ?`)
-    stmt.run(values)
-
-    return this.getFitnessGoalById(id)
-  }
-
-  async deleteFitnessGoal(id: string): Promise<boolean> {
-    if (!this.db) throw new Error('Database not connected')
-
-    const stmt = this.db.prepare('DELETE FROM fitness_goals WHERE id = ?')
-    const result = stmt.run(id)
-    return (result.changes || 0) > 0
-  }
-
-  async updateGoalProgress(id: string, currentValue: number): Promise<import('./types').FitnessGoal | null> {
-    if (!this.db) throw new Error('Database not connected')
-
-    // Get the goal to calculate progress
-    const goal = await this.getFitnessGoalById(id)
-    if (!goal) return null
-
-    let progress = goal.progress
-    if (goal.targetValue && goal.targetValue > 0) {
-      progress = Math.min(100, (currentValue / goal.targetValue) * 100)
-    }
-
-    const stmt = this.db.prepare(
-      'UPDATE fitness_goals SET current_value = ?, progress = ?, updated_at = ? WHERE id = ?'
-    )
-    stmt.run(currentValue, progress, new Date().toISOString(), id)
-
-    return this.getFitnessGoalById(id)
-  }
-
-  async completeGoal(id: string): Promise<import('./types').FitnessGoal | null> {
-    if (!this.db) throw new Error('Database not connected')
-
-    const now = new Date()
-    const stmt = this.db.prepare(
-      'UPDATE fitness_goals SET status = ?, progress = ?, completed_date = ?, updated_at = ? WHERE id = ?'
-    )
-    stmt.run('completed', 100, now.toISOString(), now.toISOString(), id)
-
-    return this.getFitnessGoalById(id)
-  }
-
-  private mapRowToFitnessGoal(row: any): import('./types').FitnessGoal {
-    return {
-      id: row.id,
-      userId: row.user_id,
-      fitnessProfileId: row.fitness_profile_id,
-      goalType: row.goal_type,
-      title: row.title,
-      description: row.description,
-      targetValue: row.target_value,
-      currentValue: row.current_value,
-      unit: row.unit,
-      startDate: new Date(row.start_date),
-      targetDate: row.target_date ? new Date(row.target_date) : undefined,
-      completedDate: row.completed_date ? new Date(row.completed_date) : undefined,
-      status: row.status,
-      progress: row.progress,
-      priority: row.priority,
-      notes: row.notes,
-      createdAt: new Date(row.created_at),
-      updatedAt: new Date(row.updated_at)
-    }
-  }
-
-  async getDashboardStats(): Promise<{
-    totalUsers: number;
-    activeClients: number;
-    totalRevenue: number;
-    revenueGrowth: number;
-  }> {
-    if (!this.db) throw new Error('Database not connected')
-
-    // Total Users
-    const userCountStmt = this.db.prepare('SELECT COUNT(*) as count FROM users')
-    const userCount = (userCountStmt.get() as any).count
-
-    // Active Clients
-    const activeClientCountStmt = this.db.prepare("SELECT COUNT(*) as count FROM clients WHERE membershipStatus = 'active'")
-    const activeClientCount = (activeClientCountStmt.get() as any).count
-
-    // Total Revenue (assuming payments table exists, handling if it's empty)
-    // Note: We need to create the payments table first if it doesn't exist in createTables
-    // For now, returning 0 if table doesn't exist or is empty
-    let totalRevenue = 0
-    let revenueGrowth = 0
-
-    try {
-      const revenueStmt = this.db.prepare('SELECT SUM(amount) as total FROM payments WHERE status = "completed"')
-      const revenueResult = revenueStmt.get() as any
-      totalRevenue = revenueResult?.total || 0
-    } catch (e) {
-      // Table might not exist yet
-      console.warn('Payments table query failed, returning 0 revenue')
-    }
-
-    return {
-      totalUsers: userCount,
-      activeClients: activeClientCount,
-      totalRevenue,
-      revenueGrowth
-    }
-  }
-}

apps/admin/src/lib/database/types.ts

@@ -26,7 +26,7 @@ export interface FitnessProfile {
   weight: string;
   age: string;
   gender: "male" | "female" | "other";
-  activityLevel: "sedentary" | "light" | "moderate" | "active" | "very_active";
+  activityLevel: "sedentary" | "lightly_active" | "moderately_active" | "very_active" | "extremely_active";
   fitnessGoals: string[];
   exerciseHabits: string;
   dietHabits: string;

packages/database/package-lock.json

@@ -9,7 +9,7 @@
       "version": "1.0.0",
       "dependencies": {
         "@types/better-sqlite3": "^7.6.13",
-        "better-sqlite3": "^12.4.1",
+        "better-sqlite3": "12.4.1",
         "drizzle-orm": "^0.44.7"
       },
       "devDependencies": {
@@ -907,6 +907,7 @@
       "resolved": "https://registry.npmjs.org/@types/better-sqlite3/-/better-sqlite3-7.6.13.tgz",
       "integrity": "sha512-NMv9ASNARoKksWtsq/SHakpYAYnhBrQgGD8zkLYk/jaK8jUGn08CfEdTRgYhMypUQAfzSP8W6gNLe0q19/t4VA==",
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "@types/node": "*"
       }
@@ -946,6 +947,7 @@
       "integrity": "sha512-3yVdyZhklTiNrtg+4WqHpJpFDd+WHTg2oM7UcR80GqL05AOV0xEJzc6qNvFYoEtE+hRp1n9MpN6/+4yhlGkDXQ==",
       "hasInstallScript": true,
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "bindings": "^1.5.0",
         "prebuild-install": "^7.1.1"
@@ -1219,6 +1221,7 @@
       "dev": true,
       "hasInstallScript": true,
       "license": "MIT",
+      "peer": true,
       "bin": {
         "esbuild": "bin/esbuild"
       },

packages/database/package.json

@@ -12,7 +12,7 @@
   },
   "dependencies": {
     "drizzle-orm": "^0.44.7",
-    "better-sqlite3": "^12.4.1",
+    "better-sqlite3": "12.4.1",
     "@types/better-sqlite3": "^7.6.13"
   },
   "devDependencies": {

packages/database/src/index.ts

@@ -12,4 +12,4 @@ const sqlite = new Database(dbPath)
 export const db = drizzle(sqlite, { schema })
 
 export * from './schema'
-export { eq, and, or, desc, asc } from 'drizzle-orm'
+export { eq, and, or, desc, asc, sql } from 'drizzle-orm'

packages/database/src/schema.ts

@@ -74,9 +74,9 @@ export const payments = sqliteTable("payments", {
 
 export const attendance = sqliteTable("attendance", {
   id: text("id").primaryKey(),
-  clientId: text("client_id")
+  userId: text("user_id")
     .notNull()
-    .references(() => clients.id, { onDelete: "cascade" }),
+    .references(() => users.id, { onDelete: "cascade" }),
   checkInTime: integer("check_in_time", { mode: "timestamp" }).notNull(),
   checkOutTime: integer("check_out_time", { mode: "timestamp" }),
   type: text("type", { enum: ["gym", "class", "personal_training"] })
@@ -116,15 +116,7 @@ export const fitnessProfiles = sqliteTable("fitness_profiles", {
   gender: text("gender", {
     enum: ["male", "female", "other", "prefer_not_to_say"],
   }),
-  fitnessGoal: text("fitness_goal", {
-    enum: [
-      "weight_loss",
-      "muscle_gain",
-      "endurance",
-      "flexibility",
-      "general_fitness",
-    ],
-  }),
+  fitnessGoals: text("fitness_goals", { mode: "json" }).$type<string[]>(),
   activityLevel: text("activity_level", {
     enum: [
       "sedentary",