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

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

apps/admin/src/app/api/attendance/check-in/route.ts

@@ -2,12 +2,12 @@ import { auth } from "@clerk/nextjs/server";
 import { NextRequest, NextResponse } from "next/server";
 import { getDatabase } from "@/lib/database";
 import { ensureUserSynced } from "@/lib/sync-user";
-import {
-  getUserGymGeofence,
-  parseUserLocation,
-  validateCheckInGeofence,
-} from "@/lib/geofence";
 import log from "@/lib/logger";
+import { checkInSchema } from "@/lib/validation/schemas";
+import {
+  validateRequestBody,
+  validationErrorResponse,
+} from "@/lib/validation/helpers";
 
 export async function POST(req: NextRequest) {
   try {
@@ -25,26 +25,8 @@ export async function POST(req: NextRequest) {
       return new NextResponse("Already checked in", { status: 400 });
     }
 
-    const body = await req.json().catch(() => ({}));
+    const body = await req.json();
     const { type = "gym", notes } = body;
-    const fallbackRequested = Boolean(body.fallbackRequested);
-
-    const gym = await getUserGymGeofence(userId);
-    if (!gym) {
-      return NextResponse.json(
-        { error: "No gym assigned for this user" },
-        { status: 400 },
-      );
-    }
-
-    const location = parseUserLocation(body.location);
-    const geofence = validateCheckInGeofence(gym, location, fallbackRequested);
-    if (!geofence.ok) {
-      return NextResponse.json(
-        { error: geofence.error },
-        { status: geofence.status },
-      );
-    }
 
     const attendance = await db.checkIn(userId, type, notes);
     return NextResponse.json(attendance);

apps/admin/src/app/api/attendance/check-out/route.ts

@@ -1,11 +1,6 @@
 import { auth } from "@clerk/nextjs/server";
 import { NextResponse } from "next/server";
 import { getDatabase } from "@/lib/database";
-import {
-  getUserGymGeofence,
-  parseUserLocation,
-  validateGeofenceWithFallback,
-} from "@/lib/geofence";
 import log from "@/lib/logger";
 
 export async function POST(req: Request) {
@@ -20,30 +15,6 @@ export async function POST(req: Request) {
       return new NextResponse("No active check-in found", { status: 404 });
     }
 
-    const body = await req.json().catch(() => ({}));
-    const fallbackRequested = Boolean(body.fallbackRequested);
-
-    const gym = await getUserGymGeofence(userId);
-    if (!gym) {
-      return NextResponse.json(
-        { error: "No gym assigned for this user" },
-        { status: 400 },
-      );
-    }
-
-    const location = parseUserLocation(body.location);
-    const geofence = validateGeofenceWithFallback(
-      gym,
-      location,
-      fallbackRequested,
-    );
-    if (!geofence.ok) {
-      return NextResponse.json(
-        { error: geofence.error },
-        { status: geofence.status },
-      );
-    }
-
     const attendance = await db.checkOut(activeCheckIn.id);
     return NextResponse.json(attendance);
   } catch (error) {

apps/admin/src/app/api/gyms/[id]/route.ts

@@ -18,178 +18,6 @@ async function ensureGymsTable() {
       updated_at INTEGER NOT NULL
     )
   `);
-
-  const columns = await db.all(sql`PRAGMA table_info('gyms')`);
-  const columnNames = new Set(
-    (columns as Array<{ name?: string }>)
-      .map((col) => col.name)
-      .filter(Boolean),
-  );
-
-  if (!columnNames.has("latitude")) {
-    await db.run(sql`ALTER TABLE gyms ADD COLUMN latitude REAL`);
-  }
-
-  if (!columnNames.has("longitude")) {
-    await db.run(sql`ALTER TABLE gyms ADD COLUMN longitude REAL`);
-  }
-
-  if (!columnNames.has("geofence_radius_meters")) {
-    await db.run(
-      sql`ALTER TABLE gyms ADD COLUMN geofence_radius_meters REAL NOT NULL DEFAULT 30`,
-    );
-  }
-
-  if (!columnNames.has("geofence_enabled")) {
-    await db.run(
-      sql`ALTER TABLE gyms ADD COLUMN geofence_enabled INTEGER NOT NULL DEFAULT 1`,
-    );
-  }
-}
-
-// PATCH /api/gyms/[id]
-// Update gym details and geofence configuration
-export async function PATCH(
-  request: Request,
-  { params }: { params: Promise<{ id: string }> },
-) {
-  try {
-    const { id: gymId } = await params;
-    const { userId } = await auth();
-
-    if (!userId) {
-      return NextResponse.json({ error: "Unauthorized" }, { status: 401 });
-    }
-
-    const appDb = await getDatabase();
-    const currentUser = await ensureUserSynced(userId, appDb);
-
-    if (
-      !currentUser ||
-      (currentUser.role !== "superAdmin" && currentUser.role !== "admin")
-    ) {
-      return NextResponse.json({ error: "Forbidden" }, { status: 403 });
-    }
-
-    await ensureGymsTable();
-
-    const existingGym = await db
-      .select()
-      .from(gymsTable)
-      .where(eq(gymsTable.id, gymId))
-      .get();
-
-    if (!existingGym) {
-      return NextResponse.json({ error: "Gym not found" }, { status: 404 });
-    }
-
-    if (
-      currentUser.role === "admin" &&
-      currentUser.gymId &&
-      currentUser.gymId !== gymId
-    ) {
-      return NextResponse.json({ error: "Forbidden" }, { status: 403 });
-    }
-
-    const body = await request.json().catch(() => null);
-    if (!body || typeof body !== "object") {
-      return NextResponse.json({ error: "Invalid body" }, { status: 400 });
-    }
-
-    const latitude =
-      body.latitude === undefined || body.latitude === null
-        ? null
-        : Number(body.latitude);
-    const longitude =
-      body.longitude === undefined || body.longitude === null
-        ? null
-        : Number(body.longitude);
-    const geofenceRadiusMeters =
-      body.geofenceRadiusMeters === undefined ||
-      body.geofenceRadiusMeters === null
-        ? 30
-        : Number(body.geofenceRadiusMeters);
-    const geofenceEnabled =
-      body.geofenceEnabled === undefined ? true : Boolean(body.geofenceEnabled);
-
-    if (
-      latitude !== null &&
-      (!Number.isFinite(latitude) || latitude < -90 || latitude > 90)
-    ) {
-      return NextResponse.json(
-        { error: "latitude must be between -90 and 90" },
-        { status: 400 },
-      );
-    }
-
-    if (
-      longitude !== null &&
-      (!Number.isFinite(longitude) || longitude < -180 || longitude > 180)
-    ) {
-      return NextResponse.json(
-        { error: "longitude must be between -180 and 180" },
-        { status: 400 },
-      );
-    }
-
-    if (!Number.isFinite(geofenceRadiusMeters) || geofenceRadiusMeters <= 0) {
-      return NextResponse.json(
-        { error: "geofenceRadiusMeters must be a positive number" },
-        { status: 400 },
-      );
-    }
-
-    await db.run(sql`
-      UPDATE gyms
-      SET
-        latitude = ${latitude},
-        longitude = ${longitude},
-        geofence_radius_meters = ${geofenceRadiusMeters},
-        geofence_enabled = ${geofenceEnabled ? 1 : 0},
-        updated_at = ${Math.floor(Date.now() / 1000)}
-      WHERE id = ${gymId}
-    `);
-
-    const updatedRows = await db.all(sql`
-      SELECT
-        id,
-        name,
-        location,
-        latitude,
-        longitude,
-        geofence_radius_meters as geofenceRadiusMeters,
-        geofence_enabled as geofenceEnabled,
-        status,
-        admin_user_id as adminUserId,
-        created_at as createdAt,
-        updated_at as updatedAt
-      FROM gyms
-      WHERE id = ${gymId}
-      LIMIT 1
-    `);
-
-    const updated = updatedRows?.[0]
-      ? {
-          ...updatedRows[0],
-          geofenceEnabled:
-            typeof (updatedRows[0] as { geofenceEnabled?: unknown })
-              .geofenceEnabled === "boolean"
-              ? (updatedRows[0] as { geofenceEnabled: boolean }).geofenceEnabled
-              : Boolean(
-                  (updatedRows[0] as { geofenceEnabled?: unknown })
-                    .geofenceEnabled,
-                ),
-        }
-      : null;
-
-    return NextResponse.json(updated);
-  } catch (error) {
-    log.error("Failed to update gym", error);
-    return NextResponse.json(
-      { error: "Internal Server Error" },
-      { status: 500 },
-    );
-  }
 }
 
 // DELETE /api/gyms/[id]

apps/admin/src/app/api/gyms/route.ts

@@ -18,33 +18,6 @@ async function ensureGymsTable() {
       updated_at INTEGER NOT NULL
     )
   `);
-
-  const columns = await db.all(sql`PRAGMA table_info('gyms')`);
-  const columnNames = new Set(
-    (columns as Array<{ name?: string }>)
-      .map((col) => col.name)
-      .filter(Boolean),
-  );
-
-  if (!columnNames.has("latitude")) {
-    await db.run(sql`ALTER TABLE gyms ADD COLUMN latitude REAL`);
-  }
-
-  if (!columnNames.has("longitude")) {
-    await db.run(sql`ALTER TABLE gyms ADD COLUMN longitude REAL`);
-  }
-
-  if (!columnNames.has("geofence_radius_meters")) {
-    await db.run(
-      sql`ALTER TABLE gyms ADD COLUMN geofence_radius_meters REAL NOT NULL DEFAULT 30`,
-    );
-  }
-
-  if (!columnNames.has("geofence_enabled")) {
-    await db.run(
-      sql`ALTER TABLE gyms ADD COLUMN geofence_enabled INTEGER NOT NULL DEFAULT 1`,
-    );
-  }
 }
 
 // GET /api/gyms
@@ -68,35 +41,12 @@ export async function GET() {
     }
 
     await ensureGymsTable();
-    let rows = (await db.all(sql`
+    let rows = await db
-      SELECT
+      .select()
-        id,
+      .from(gymsTable)
-        name,
+      .where(eq(gymsTable.status, "active"))
-        location,
+      .orderBy(sql`created_at DESC`)
-        latitude,
+      .all();
-        longitude,
-        geofence_radius_meters as geofenceRadiusMeters,
-        geofence_enabled as geofenceEnabled,
-        status,
-        admin_user_id as adminUserId,
-        created_at as createdAt,
-        updated_at as updatedAt
-      FROM gyms
-      WHERE status = 'active'
-      ORDER BY created_at DESC
-    `)) as Array<{
-      id: string;
-      name: string;
-      location: string | null;
-      latitude: number | null;
-      longitude: number | null;
-      geofenceRadiusMeters: number | null;
-      geofenceEnabled: number | boolean | null;
-      status: "active" | "inactive";
-      adminUserId: string;
-      createdAt: number;
-      updatedAt: number;
-    }>;
 
     if (currentUser.role !== "superAdmin") {
       if (!currentUser.gymId) {
@@ -105,15 +55,7 @@ export async function GET() {
       rows = rows.filter((row) => row.id === currentUser.gymId);
     }
 
-    return NextResponse.json(
+    return NextResponse.json(rows);
-      rows.map((row) => ({
-        ...row,
-        geofenceEnabled:
-          typeof row.geofenceEnabled === "boolean"
-            ? row.geofenceEnabled
-            : Boolean(row.geofenceEnabled),
-      })),
-    );
   } catch (error) {
     log.error("Failed to get gyms", error);
     return new NextResponse("Internal Server Error", { status: 500 });
@@ -147,21 +89,6 @@ export async function POST(req: Request) {
 
     const name = String(body.name ?? "").trim();
     const location = body.location ? String(body.location).trim() : null;
-    const latitude =
-      body.latitude === undefined || body.latitude === null
-        ? null
-        : Number(body.latitude);
-    const longitude =
-      body.longitude === undefined || body.longitude === null
-        ? null
-        : Number(body.longitude);
-    const geofenceRadiusMeters =
-      body.geofenceRadiusMeters === undefined ||
-      body.geofenceRadiusMeters === null
-        ? 30
-        : Number(body.geofenceRadiusMeters);
-    const geofenceEnabled =
-      body.geofenceEnabled === undefined ? true : Boolean(body.geofenceEnabled);
     let adminUserId: string | null = body.adminUserId
       ? String(body.adminUserId)
       : null;
@@ -170,33 +97,6 @@ export async function POST(req: Request) {
       return NextResponse.json({ error: "name is required" }, { status: 400 });
     }
 
-    if (
-      latitude !== null &&
-      (!Number.isFinite(latitude) || latitude < -90 || latitude > 90)
-    ) {
-      return NextResponse.json(
-        { error: "latitude must be between -90 and 90" },
-        { status: 400 },
-      );
-    }
-
-    if (
-      longitude !== null &&
-      (!Number.isFinite(longitude) || longitude < -180 || longitude > 180)
-    ) {
-      return NextResponse.json(
-        { error: "longitude must be between -180 and 180" },
-        { status: 400 },
-      );
-    }
-
-    if (!Number.isFinite(geofenceRadiusMeters) || geofenceRadiusMeters <= 0) {
-      return NextResponse.json(
-        { error: "geofenceRadiusMeters must be a positive number" },
-        { status: 400 },
-      );
-    }
-
     // Enforce admin ownership rules
     if (currentUser.role === "admin") {
       adminUserId = currentUser.id;
@@ -224,33 +124,15 @@ export async function POST(req: Request) {
     const nowTs = new Date();
 
     // Use Drizzle's insert method instead of raw SQL
-    await db.run(sql`
+    await db.insert(gymsTable).values({
-      INSERT INTO gyms (
+      id,
-        id,
+      name,
-        name,
+      location: location ?? null,
-        location,
+      status: "active",
-        latitude,
+      adminUserId: adminUserId!,
-        longitude,
+      createdAt: nowTs,
-        geofence_radius_meters,
+      updatedAt: nowTs,
-        geofence_enabled,
+    });
-        status,
-        admin_user_id,
-        created_at,
-        updated_at
-      ) VALUES (
-        ${id},
-        ${name},
-        ${location ?? null},
-        ${latitude},
-        ${longitude},
-        ${geofenceRadiusMeters},
-        ${geofenceEnabled ? 1 : 0},
-        ${"active"},
-        ${adminUserId!},
-        ${Math.floor(nowTs.getTime() / 1000)},
-        ${Math.floor(nowTs.getTime() / 1000)}
-      )
-    `);
 
     // Assign the admin to this gym immediately after creation
     await db
@@ -258,36 +140,11 @@ export async function POST(req: Request) {
       .set({ gymId: id, updatedAt: nowTs })
       .where(eq(usersTable.id, adminUserId!));
 
-    const rowsCreated = await db.all(sql`
+    const created = await db
-      SELECT
+      .select()
-        id,
+      .from(gymsTable)
-        name,
+      .where(eq(gymsTable.id, id))
-        location,
+      .get();
-        latitude,
-        longitude,
-        geofence_radius_meters as geofenceRadiusMeters,
-        geofence_enabled as geofenceEnabled,
-        status,
-        admin_user_id as adminUserId,
-        created_at as createdAt,
-        updated_at as updatedAt
-      FROM gyms
-      WHERE id = ${id}
-      LIMIT 1
-    `);
-    const createdRow = rowsCreated?.[0] ?? null;
-    const created = createdRow
-      ? {
-          ...createdRow,
-          geofenceEnabled:
-            typeof (createdRow as { geofenceEnabled?: unknown })
-              .geofenceEnabled === "boolean"
-              ? (createdRow as { geofenceEnabled: boolean }).geofenceEnabled
-              : Boolean(
-                  (createdRow as { geofenceEnabled?: unknown }).geofenceEnabled,
-                ),
-        }
-      : null;
     return NextResponse.json(created, { status: 201 });
   } catch (error) {
     log.error("Failed to create gym", error);

apps/admin/src/app/api/recommendations/approve/route.ts

@@ -4,101 +4,6 @@ import { getDatabase } from "@/lib/database";
 import log from "@/lib/logger";
 import { ensureUserSynced } from "@/lib/sync-user";
 
-const AI_LINK_PREFIX = "[AI_LINKED]";
-
-type GoalType =
-  | "weight_target"
-  | "strength_milestone"
-  | "endurance_target"
-  | "flexibility_goal"
-  | "habit_building"
-  | "custom";
-
-interface ParsedPlanItem {
-  id: string;
-  title: string;
-  description: string;
-  goalType: GoalType;
-}
-
-function inferGoalType(text: string): GoalType {
-  const normalized = text.toLowerCase();
-
-  if (
-    normalized.includes("strength") ||
-    normalized.includes("bench") ||
-    normalized.includes("squat") ||
-    normalized.includes("deadlift") ||
-    normalized.includes("weights")
-  ) {
-    return "strength_milestone";
-  }
-
-  if (
-    normalized.includes("run") ||
-    normalized.includes("cardio") ||
-    normalized.includes("endurance") ||
-    normalized.includes("cycle")
-  ) {
-    return "endurance_target";
-  }
-
-  if (
-    normalized.includes("stretch") ||
-    normalized.includes("mobility") ||
-    normalized.includes("yoga") ||
-    normalized.includes("flexibility")
-  ) {
-    return "flexibility_goal";
-  }
-
-  if (
-    normalized.includes("daily") ||
-    normalized.includes("routine") ||
-    normalized.includes("habit")
-  ) {
-    return "habit_building";
-  }
-
-  return "custom";
-}
-
-function parseActivityPlanToItems(activityPlan: string): ParsedPlanItem[] {
-  const lines = activityPlan
-    .replace(/\r\n/g, "\n")
-    .split(/\n+/)
-    .flatMap((line) => line.split(/(?<=[.!?])\s+(?=[A-Z0-9])/g))
-    .map((line) => line.trim())
-    .filter(Boolean)
-    .map((line) => line.replace(/^[-*•\d.)\s]+/, "").trim())
-    .filter((line) => line.length > 10)
-    .slice(0, 8);
-
-  const uniqueLines = Array.from(new Set(lines));
-
-  return uniqueLines.map((line) => ({
-    id: crypto.randomUUID(),
-    title: line.length > 72 ? `${line.slice(0, 69)}...` : line,
-    description: line,
-    goalType: inferGoalType(line),
-  }));
-}
-
-function getDefaultPlanItems(): ParsedPlanItem[] {
-  const defaults = [
-    "Complete 3 strength sessions this week with progressive overload.",
-    "Add 2 cardio sessions of 25-30 minutes for endurance.",
-    "Do a 10-minute mobility routine daily after training.",
-  ];
-
-  return defaults.map((line) => ({
-    id: crypto.randomUUID(),
-    title: line.length > 72 ? `${line.slice(0, 69)}...` : line,
-    description: line,
-    goalType: inferGoalType(line),
-  }));
-}
-
 export async function POST(req: Request) {
   try {
     const { userId: clerkUserId } = await auth();
@@ -189,103 +94,8 @@ export async function POST(req: Request) {
       );
     }
 
-    let pausedGoalsCount = 0;
+    // If approved, create a notification for the user
-    let createdGoalsCount = 0;
-
-    // If approved, regenerate linked AI goals and create a notification for the user
     if (status === "approved") {
-      try {
-        const existingActiveGoals = await db.getFitnessGoalsByUserId(
-          updatedRecommendation.userId,
-          "active",
-        );
-
-        const linkedGoals = existingActiveGoals.filter((goal) =>
-          goal.notes?.startsWith(AI_LINK_PREFIX),
-        );
-
-        pausedGoalsCount = linkedGoals.length;
-
-        await Promise.all(
-          linkedGoals.map((goal) =>
-            db.updateFitnessGoal(goal.id, {
-              status: "paused",
-              notes: `${goal.notes || ""}\nPaused due to recommendation approval on ${new Date().toISOString()}`,
-            }),
-          ),
-        );
-
-        let planItems = parseActivityPlanToItems(
-          updatedRecommendation.activityPlan || "",
-        );
-
-        if (
-          planItems.length === 0 &&
-          updatedRecommendation.recommendationText
-        ) {
-          planItems = parseActivityPlanToItems(
-            updatedRecommendation.recommendationText,
-          );
-        }
-
-        if (planItems.length === 0) {
-          planItems = getDefaultPlanItems();
-        }
-
-        const fitnessProfileId =
-          updatedRecommendation.fitnessProfileId ||
-          (await db.getFitnessProfileByUserId(updatedRecommendation.userId))
-            ?.id;
-
-        if (!fitnessProfileId) {
-          log.warn("No fitness profile available for AI goal creation", {
-            recommendationId,
-            userId: updatedRecommendation.userId,
-          });
-        } else {
-          const createdGoals = await Promise.all(
-            planItems.map((item) =>
-              db.createFitnessGoal({
-                id: crypto.randomUUID(),
-                userId: updatedRecommendation.userId,
-                fitnessProfileId,
-                goalType: item.goalType,
-                title: item.title,
-                description: item.description,
-                targetValue: undefined,
-                currentValue: 0,
-                unit: undefined,
-                startDate: new Date(),
-                targetDate: undefined,
-                completedDate: undefined,
-                status: "active",
-                progress: 0,
-                priority: "medium",
-                notes: `${AI_LINK_PREFIX} recommendationId=${updatedRecommendation.id}; itemId=${item.id}`,
-              }),
-            ),
-          );
-
-          createdGoalsCount = createdGoals.length;
-        }
-
-        log.info("Regenerated linked AI goals from approved recommendation", {
-          recommendationId: updatedRecommendation.id,
-          userId: updatedRecommendation.userId,
-          pausedGoals: pausedGoalsCount,
-          createdGoals: createdGoalsCount,
-        });
-      } catch (goalConversionError) {
-        log.error(
-          "Failed to regenerate linked goals for approved recommendation",
-          goalConversionError,
-          {
-            recommendationId,
-            userId: updatedRecommendation.userId,
-          },
-        );
-      }
-
       try {
         await db.createNotification({
           id: crypto.randomUUID(),
@@ -312,8 +122,6 @@ export async function POST(req: Request) {
       data: updatedRecommendation,
       meta: {
         timestamp: new Date().toISOString(),
-        pausedGoals: pausedGoalsCount,
-        createdGoals: createdGoalsCount,
       },
     });
   } catch (error) {

apps/admin/src/app/api/users/gym/route.ts

@@ -1,78 +1,8 @@
 import { NextResponse } from "next/server";
 import { auth } from "@clerk/nextjs/server";
 import { db, users as usersTable, eq, sql } from "@fitai/database";
-import { ensureGymsGeofenceColumns } from "@/lib/geofence";
 import log from "@/lib/logger";
 
-export async function GET() {
-  try {
-    const { userId } = await auth();
-    if (!userId) return new NextResponse("Unauthorized", { status: 401 });
-
-    const user = await db
-      .select()
-      .from(usersTable)
-      .where(eq(usersTable.id, userId))
-      .get();
-
-    if (!user) {
-      return new NextResponse("User not found", { status: 404 });
-    }
-
-    if (!user.gymId) {
-      return NextResponse.json({ gymId: null, gym: null });
-    }
-
-    await ensureGymsGeofenceColumns();
-
-    const rows = await db.all(sql`
-      SELECT
-        id,
-        name,
-        location,
-        latitude,
-        longitude,
-        geofence_radius_meters as geofenceRadiusMeters,
-        geofence_enabled as geofenceEnabled,
-        status
-      FROM gyms
-      WHERE id = ${user.gymId}
-      LIMIT 1
-    `);
-
-    const gym = rows?.[0] as
-      | {
-          id: string;
-          name: string;
-          location: string | null;
-          latitude: number | null;
-          longitude: number | null;
-          geofenceRadiusMeters: number | null;
-          geofenceEnabled: number | boolean | null;
-          status: "active" | "inactive";
-        }
-      | undefined;
-
-    if (!gym || gym.status !== "active") {
-      return NextResponse.json({ gymId: user.gymId, gym: null });
-    }
-
-    return NextResponse.json({
-      gymId: user.gymId,
-      gym: {
-        ...gym,
-        geofenceEnabled:
-          typeof gym.geofenceEnabled === "boolean"
-            ? gym.geofenceEnabled
-            : Boolean(gym.geofenceEnabled),
-      },
-    });
-  } catch (error) {
-    log.error("Failed to fetch current user gym", error);
-    return new NextResponse("Internal Server Error", { status: 500 });
-  }
-}
-
 /**
  * PATCH /api/users/gym
  * Body: { gymId: string | null }

apps/admin/src/app/settings/page.tsx

@@ -29,10 +29,6 @@ interface Gym {
   id: string;
   name: string;
   location?: string | null;
-  latitude?: number | null;
-  longitude?: number | null;
-  geofenceRadiusMeters?: number | null;
-  geofenceEnabled?: boolean;
   status: "active" | "inactive";
   adminUserId: string;
   createdAt?: number;
@@ -76,11 +72,6 @@ export default function SettingsPage() {
   const [gymStats, setGymStats] = useState<GymStats | null>(null);
   const [statsLoading, setStatsLoading] = useState(false);
   const [deletingGym, setDeletingGym] = useState(false);
-  const [savingGeofence, setSavingGeofence] = useState(false);
-  const [geofenceLatitude, setGeofenceLatitude] = useState("");
-  const [geofenceLongitude, setGeofenceLongitude] = useState("");
-  const [geofenceRadiusMeters, setGeofenceRadiusMeters] = useState("30");
-  const [geofenceEnabled, setGeofenceEnabled] = useState(true);
 
   // Create Gym modal state
   const [showCreateGym, setShowCreateGym] = useState(false);
@@ -195,87 +186,6 @@ export default function SettingsPage() {
   const handleSelectGym = async (gym: Gym | null) => {
     setSelectedGym(gym);
     setGymStats(null);
-
-    if (gym) {
-      setGeofenceLatitude(
-        gym.latitude !== null && gym.latitude !== undefined
-          ? String(gym.latitude)
-          : "",
-      );
-      setGeofenceLongitude(
-        gym.longitude !== null && gym.longitude !== undefined
-          ? String(gym.longitude)
-          : "",
-      );
-      setGeofenceRadiusMeters(String(gym.geofenceRadiusMeters ?? 30));
-      setGeofenceEnabled(gym.geofenceEnabled ?? true);
-    }
-  };
-
-  const handleSaveGeofence = async () => {
-    if (!selectedGym) return;
-
-    const latitude =
-      geofenceLatitude.trim() === "" ? null : Number(geofenceLatitude);
-    const longitude =
-      geofenceLongitude.trim() === "" ? null : Number(geofenceLongitude);
-    const radius = Number(geofenceRadiusMeters);
-
-    if (
-      latitude !== null &&
-      (!Number.isFinite(latitude) || latitude < -90 || latitude > 90)
-    ) {
-      setGymMessage({
-        type: "error",
-        text: "Latitude must be between -90 and 90",
-      });
-      return;
-    }
-
-    if (
-      longitude !== null &&
-      (!Number.isFinite(longitude) || longitude < -180 || longitude > 180)
-    ) {
-      setGymMessage({
-        type: "error",
-        text: "Longitude must be between -180 and 180",
-      });
-      return;
-    }
-
-    if (!Number.isFinite(radius) || radius <= 0) {
-      setGymMessage({
-        type: "error",
-        text: "Radius must be a positive number",
-      });
-      return;
-    }
-
-    setSavingGeofence(true);
-    setGymMessage(null);
-
-    try {
-      const response = await axios.patch(`/api/gyms/${selectedGym.id}`, {
-        latitude,
-        longitude,
-        geofenceRadiusMeters: radius,
-        geofenceEnabled,
-      });
-      setGymMessage({ type: "success", text: "Geofence settings updated" });
-      const updatedGym = response.data as Gym;
-      setSelectedGym(updatedGym);
-      setGyms((prev) =>
-        prev.map((gym) => (gym.id === updatedGym.id ? updatedGym : gym)),
-      );
-    } catch (error) {
-      log.error("Failed to update geofence settings", error);
-      setGymMessage({
-        type: "error",
-        text: "Failed to update geofence settings",
-      });
-    } finally {
-      setSavingGeofence(false);
-    }
   };
 
   const handleDeleteGym = async (gymId: string) => {
@@ -565,91 +475,6 @@ export default function SettingsPage() {
                       {selectedGym.status}
                     </p>
                   </div>
-                  <div>
-                    <p className="text-xs text-slate-500">Geofence</p>
-                    <p className="font-medium">
-                      {selectedGym.geofenceEnabled === false
-                        ? "Disabled"
-                        : `${selectedGym.geofenceRadiusMeters ?? 30}m`}
-                    </p>
-                  </div>
-                </div>
-
-                {/* Geofence Settings */}
-                <div className="p-4 border rounded-lg space-y-3">
-                  <div className="flex items-center justify-between">
-                    <h5 className="text-sm font-medium text-slate-700">
-                      Attendance Geofence
-                    </h5>
-                    <label className="inline-flex items-center gap-2 text-sm text-slate-700">
-                      <input
-                        type="checkbox"
-                        checked={geofenceEnabled}
-                        onChange={(e) => setGeofenceEnabled(e.target.checked)}
-                      />
-                      Enabled
-                    </label>
-                  </div>
-
-                  <div className="grid grid-cols-1 md:grid-cols-3 gap-3">
-                    <div>
-                      <label className="block text-xs text-slate-500 mb-1">
-                        Latitude
-                      </label>
-                      <input
-                        type="number"
-                        step="any"
-                        value={geofenceLatitude}
-                        onChange={(e) => setGeofenceLatitude(e.target.value)}
-                        className="w-full border border-gray-300 rounded px-3 py-2"
-                        placeholder="e.g. 37.7749"
-                      />
-                    </div>
-                    <div>
-                      <label className="block text-xs text-slate-500 mb-1">
-                        Longitude
-                      </label>
-                      <input
-                        type="number"
-                        step="any"
-                        value={geofenceLongitude}
-                        onChange={(e) => setGeofenceLongitude(e.target.value)}
-                        className="w-full border border-gray-300 rounded px-3 py-2"
-                        placeholder="e.g. -122.4194"
-                      />
-                    </div>
-                    <div>
-                      <label className="block text-xs text-slate-500 mb-1">
-                        Radius (meters)
-                      </label>
-                      <input
-                        type="number"
-                        min="1"
-                        value={geofenceRadiusMeters}
-                        onChange={(e) =>
-                          setGeofenceRadiusMeters(e.target.value)
-                        }
-                        className="w-full border border-gray-300 rounded px-3 py-2"
-                      />
-                    </div>
-                  </div>
-
-                  <div className="flex items-center justify-between">
-                    <p className="text-xs text-slate-500">
-                      Default radius is 30m and geofence is enabled by default.
-                    </p>
-                    <Button
-                      size="sm"
-                      onClick={handleSaveGeofence}
-                      disabled={savingGeofence}
-                    >
-                      {savingGeofence ? (
-                        <Loader2 className="w-4 h-4 animate-spin" />
-                      ) : (
-                        "Save Geofence"
-                      )}
-                    </Button>
-                  </div>
                 </div>
 
                 {/* Stats */}

apps/admin/src/lib/geofence.ts

@@ -1,277 +0,0 @@
-import { db, eq, sql, users } from "@fitai/database";
-
-export const DEFAULT_GEOFENCE_RADIUS_METERS = 30;
-export const MAX_LOCATION_ACCURACY_METERS = 50;
-export const MAX_FALLBACK_ACCURACY_MARGIN_METERS = 120;
-
-export interface UserLocation {
-  latitude: number;
-  longitude: number;
-  accuracy: number;
-}
-
-export async function ensureGymsGeofenceColumns(): Promise<void> {
-  const rows = await db.all(sql`PRAGMA table_info('gyms')`);
-  const columns = new Set(
-    (rows as Array<{ name?: string }>).map((row) => row.name).filter(Boolean),
-  );
-
-  if (!columns.has("latitude")) {
-    await db.run(sql`ALTER TABLE gyms ADD COLUMN latitude REAL`);
-  }
-
-  if (!columns.has("longitude")) {
-    await db.run(sql`ALTER TABLE gyms ADD COLUMN longitude REAL`);
-  }
-
-  if (!columns.has("geofence_radius_meters")) {
-    await db.run(
-      sql`ALTER TABLE gyms ADD COLUMN geofence_radius_meters REAL NOT NULL DEFAULT 30`,
-    );
-  }
-
-  if (!columns.has("geofence_enabled")) {
-    await db.run(
-      sql`ALTER TABLE gyms ADD COLUMN geofence_enabled INTEGER NOT NULL DEFAULT 1`,
-    );
-  }
-}
-
-interface GymGeofenceConfig {
-  id: string;
-  name: string;
-  latitude: number | null;
-  longitude: number | null;
-  geofenceRadiusMeters: number | null;
-  geofenceEnabled: boolean | null;
-}
-
-export async function getUserGymGeofence(
-  userId: string,
-): Promise<GymGeofenceConfig | null> {
-  await ensureGymsGeofenceColumns();
-
-  const user = await db.select().from(users).where(eq(users.id, userId)).get();
-  if (!user?.gymId) {
-    return null;
-  }
-
-  const rows = await db.all(sql`
-    SELECT
-      id,
-      name,
-      latitude,
-      longitude,
-      geofence_radius_meters as geofenceRadiusMeters,
-      geofence_enabled as geofenceEnabled
-    FROM gyms
-    WHERE id = ${user.gymId}
-    LIMIT 1
-  `);
-  const gym = rows?.[0] as
-    | {
-        id: string;
-        name: string;
-        latitude: number | null;
-        longitude: number | null;
-        geofenceRadiusMeters: number | null;
-        geofenceEnabled: number | boolean | null;
-      }
-    | undefined;
-  if (!gym) {
-    return null;
-  }
-
-  return {
-    id: gym.id,
-    name: gym.name,
-    latitude: gym.latitude,
-    longitude: gym.longitude,
-    geofenceRadiusMeters: gym.geofenceRadiusMeters,
-    geofenceEnabled:
-      typeof gym.geofenceEnabled === "boolean"
-        ? gym.geofenceEnabled
-        : gym.geofenceEnabled === null
-          ? null
-          : Boolean(gym.geofenceEnabled),
-  };
-}
-
-export function parseUserLocation(payload: unknown): UserLocation | null {
-  if (!payload || typeof payload !== "object") {
-    return null;
-  }
-
-  const raw = payload as Record<string, unknown>;
-  const latitude = Number(raw.latitude);
-  const longitude = Number(raw.longitude);
-  const accuracy = Number(raw.accuracy);
-
-  if (
-    !Number.isFinite(latitude) ||
-    !Number.isFinite(longitude) ||
-    !Number.isFinite(accuracy)
-  ) {
-    return null;
-  }
-
-  return { latitude, longitude, accuracy };
-}
-
-export function validateGeofence(
-  gym: GymGeofenceConfig,
-  location: UserLocation | null,
-): { ok: true } | { ok: false; status: number; error: string } {
-  const geofenceEnabled = gym.geofenceEnabled ?? true;
-  if (!geofenceEnabled) {
-    return { ok: true };
-  }
-
-  if (!location) {
-    return {
-      ok: false,
-      status: 400,
-      error: "Location is required for gym check-in/check-out",
-    };
-  }
-
-  if (location.accuracy > MAX_LOCATION_ACCURACY_METERS) {
-    return {
-      ok: false,
-      status: 400,
-      error: `Location accuracy too low (${Math.round(location.accuracy)}m). Move to an open area and try again.`,
-    };
-  }
-
-  if (gym.latitude === null || gym.longitude === null) {
-    return {
-      ok: false,
-      status: 400,
-      error: "Gym geofence is enabled but gym coordinates are not configured",
-    };
-  }
-
-  const radius = gym.geofenceRadiusMeters ?? DEFAULT_GEOFENCE_RADIUS_METERS;
-  const distanceMeters = haversineDistanceMeters(
-    gym.latitude,
-    gym.longitude,
-    location.latitude,
-    location.longitude,
-  );
-
-  if (distanceMeters > radius) {
-    return {
-      ok: false,
-      status: 403,
-      error: `You are outside the gym geofence (${Math.round(distanceMeters)}m away, allowed ${Math.round(radius)}m).`,
-    };
-  }
-
-  return { ok: true };
-}
-
-export function validateGeofenceWithFallback(
-  gym: GymGeofenceConfig,
-  location: UserLocation | null,
-  fallbackRequested: boolean,
-): { ok: true } | { ok: false; status: number; error: string } {
-  const geofenceEnabled = gym.geofenceEnabled ?? true;
-  if (!geofenceEnabled) {
-    return { ok: true };
-  }
-
-  if (!location) {
-    return {
-      ok: false,
-      status: 400,
-      error: "Location is required for gym check-in/check-out",
-    };
-  }
-
-  if (gym.latitude === null || gym.longitude === null) {
-    return {
-      ok: false,
-      status: 400,
-      error: "Gym geofence is enabled but gym coordinates are not configured",
-    };
-  }
-
-  const radius = gym.geofenceRadiusMeters ?? DEFAULT_GEOFENCE_RADIUS_METERS;
-  const distanceMeters = haversineDistanceMeters(
-    gym.latitude,
-    gym.longitude,
-    location.latitude,
-    location.longitude,
-  );
-
-  if (location.accuracy <= MAX_LOCATION_ACCURACY_METERS) {
-    if (distanceMeters > radius) {
-      return {
-        ok: false,
-        status: 403,
-        error: `You are outside the gym geofence (${Math.round(distanceMeters)}m away, allowed ${Math.round(radius)}m).`,
-      };
-    }
-
-    return { ok: true };
-  }
-
-  if (!fallbackRequested) {
-    return {
-      ok: false,
-      status: 400,
-      error: `Location accuracy too low (${Math.round(location.accuracy)}m). Move to an open area and try again.`,
-    };
-  }
-
-  const fallbackMargin = Math.min(
-    location.accuracy,
-    MAX_FALLBACK_ACCURACY_MARGIN_METERS,
-  );
-  const fallbackAllowedDistance = radius + fallbackMargin;
-
-  if (distanceMeters > fallbackAllowedDistance) {
-    return {
-      ok: false,
-      status: 403,
-      error: `You are outside the gym geofence (${Math.round(distanceMeters)}m away, fallback allowed ${Math.round(fallbackAllowedDistance)}m).`,
-    };
-  }
-
-  return { ok: true };
-}
-
-export function validateCheckInGeofence(
-  gym: GymGeofenceConfig,
-  location: UserLocation | null,
-  fallbackRequested: boolean,
-): { ok: true } | { ok: false; status: number; error: string } {
-  return validateGeofenceWithFallback(gym, location, fallbackRequested);
-}
-
-function haversineDistanceMeters(
-  latitude1: number,
-  longitude1: number,
-  latitude2: number,
-  longitude2: number,
-): number {
-  const earthRadiusMeters = 6371000;
-  const dLat = toRadians(latitude2 - latitude1);
-  const dLng = toRadians(longitude2 - longitude1);
-  const lat1Rad = toRadians(latitude1);
-  const lat2Rad = toRadians(latitude2);
-
-  const a =
-    Math.sin(dLat / 2) * Math.sin(dLat / 2) +
-    Math.sin(dLng / 2) *
-      Math.sin(dLng / 2) *
-      Math.cos(lat1Rad) *
-      Math.cos(lat2Rad);
-
-  const c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
-  return earthRadiusMeters * c;
-}
-
-function toRadians(degrees: number): number {
-  return (degrees * Math.PI) / 180;
-}

apps/mobile/app.json

@@ -17,13 +17,7 @@
       "infoPlist": {
         "NSCameraUsageDescription": "This app uses the camera to scan food barcodes and identify nutritional information.",
         "NSUserNotificationsUsageDescription": "This app uses notifications to keep you updated on your fitness progress, recommendation approvals, and important reminders.",
-        "NSMotionUsageDescription": "This app uses motion data to track your daily steps and activity progress.",
+        "NSMotionUsageDescription": "This app uses motion data to track your daily steps and activity progress."
-        "NSLocationWhenInUseUsageDescription": "This app uses your location to verify you are at your gym when checking in and checking out.",
-        "NSLocationAlwaysAndWhenInUseUsageDescription": "This app uses your location in the background to automatically start and end workouts when you enter or leave your gym geofence."
-      },
-      "bundleIdentifier": "com.anonymous.fitai",
-      "config": {
-        "usesNonExemptEncryption": false
       }
     },
     "android": {
@@ -35,10 +29,7 @@
         "CAMERA",
         "POST_NOTIFICATIONS",
         "android.permission.CAMERA",
-        "android.permission.ACTIVITY_RECOGNITION",
+        "android.permission.ACTIVITY_RECOGNITION"
-        "android.permission.ACCESS_FINE_LOCATION",
-        "android.permission.ACCESS_COARSE_LOCATION",
-        "android.permission.ACCESS_BACKGROUND_LOCATION"
       ],
       "package": "com.anonymous.fitai"
     },
@@ -49,15 +40,6 @@
       "expo-router",
       "expo-font",
       "expo-barcode-scanner",
-      [
-        "expo-location",
-        {
-          "locationWhenInUsePermission": "Allow FitAI to use your location to verify gym check-ins and check-outs.",
-          "locationAlwaysAndWhenInUsePermission": "Allow FitAI to use your location in the background to automatically start and end workouts at your gym.",
-          "isIosBackgroundLocationEnabled": true,
-          "isAndroidBackgroundLocationEnabled": true
-        }
-      ],
       [
         "expo-notifications",
         {

apps/mobile/package-lock.json

@@ -29,13 +29,11 @@
         "expo-haptics": "^15.0.7",
         "expo-linear-gradient": "~15.0.7",
         "expo-linking": "~8.0.0",
-        "expo-location": "~19.0.7",
         "expo-notifications": "~0.32.0",
         "expo-router": "~6.0.14",
         "expo-secure-store": "~15.0.7",
         "expo-sensors": "~14.1.4",
         "expo-status-bar": "^3.0.8",
-        "expo-task-manager": "~14.0.8",
         "expo-web-browser": "^15.0.10",
         "react": "19.1.0",
         "react-dom": "^19.1.0",
@@ -7466,15 +7464,6 @@
         "react-native": "*"
       }
     },
-    "node_modules/expo-location": {
-      "version": "19.0.8",
-      "resolved": "https://registry.npmjs.org/expo-location/-/expo-location-19.0.8.tgz",
-      "integrity": "sha512-H/FI75VuJ1coodJbbMu82pf+Zjess8X8Xkiv9Bv58ZgPKS/2ztjC1YO1/XMcGz7+s9DrbLuMIw22dFuP4HqneA==",
-      "license": "MIT",
-      "peerDependencies": {
-        "expo": "*"
-      }
-    },
     "node_modules/expo-modules-autolinking": {
       "version": "3.0.22",
       "resolved": "https://registry.npmjs.org/expo-modules-autolinking/-/expo-modules-autolinking-3.0.22.tgz",
@@ -7651,19 +7640,6 @@
         "react-native": "*"
       }
     },
-    "node_modules/expo-task-manager": {
-      "version": "14.0.9",
-      "resolved": "https://registry.npmjs.org/expo-task-manager/-/expo-task-manager-14.0.9.tgz",
-      "integrity": "sha512-GKWtXrkedr4XChHfTm5IyTcSfMtCPxzx89y4CMVqKfyfROATibrE/8UI5j7UC/pUOfFoYlQvulQEvECMreYuUA==",
-      "license": "MIT",
-      "dependencies": {
-        "unimodules-app-loader": "~6.0.8"
-      },
-      "peerDependencies": {
-        "expo": "*",
-        "react-native": "*"
-      }
-    },
     "node_modules/expo-web-browser": {
       "version": "15.0.10",
       "resolved": "https://registry.npmjs.org/expo-web-browser/-/expo-web-browser-15.0.10.tgz",
@@ -13457,12 +13433,6 @@
         "node": ">=4"
       }
     },
-    "node_modules/unimodules-app-loader": {
-      "version": "6.0.8",
-      "resolved": "https://registry.npmjs.org/unimodules-app-loader/-/unimodules-app-loader-6.0.8.tgz",
-      "integrity": "sha512-fqS8QwT/MC/HAmw1NKCHdzsPA6WaLm0dNmoC5Pz6lL+cDGYeYCNdHMO9fy08aL2ZD7cVkNM0pSR/AoNRe+rslA==",
-      "license": "MIT"
-    },
     "node_modules/unique-string": {
       "version": "2.0.0",
       "resolved": "https://registry.npmjs.org/unique-string/-/unique-string-2.0.0.tgz",

apps/mobile/package.json

@@ -35,10 +35,8 @@
     "expo-haptics": "^15.0.7",
     "expo-linear-gradient": "~15.0.7",
     "expo-linking": "~8.0.0",
-    "expo-location": "~19.0.7",
     "expo-notifications": "~0.32.0",
     "expo-router": "~6.0.14",
-    "expo-task-manager": "~14.0.8",
     "expo-secure-store": "~15.0.7",
     "expo-sensors": "~14.1.4",
     "expo-status-bar": "^3.0.8",

apps/mobile/src/api/attendance.ts

@@ -1,88 +1,47 @@
 import { apiClient } from "./client";
 import { API_ENDPOINTS } from "../config/api";
-import { isAxiosError } from "axios";
 
 export interface Attendance {
-  id: string;
+    id: string;
-  checkInTime: string;
+    checkInTime: string;
-  checkOutTime?: string;
+    checkOutTime?: string;
-  type: string;
+    type: string;
-  notes?: string;
+    notes?: string;
-}
-
-export interface AttendanceLocationPayload {
-  latitude: number;
-  longitude: number;
-  accuracy: number;
 }
 
 export const attendanceApi = {
-  getHistory: async (token: string): Promise<Attendance[]> => {
+    getHistory: async (token: string): Promise<Attendance[]> => {
-    try {
+        try {
-      const response = await apiClient.get(API_ENDPOINTS.ATTENDANCE.HISTORY, {
+            const response = await apiClient.get(API_ENDPOINTS.ATTENDANCE.HISTORY, {
-        headers: { Authorization: `Bearer ${token}` },
+                headers: { Authorization: `Bearer ${token}` },
-      });
+            });
-      return response.data;
+            return response.data;
-    } catch (error) {
+        } catch (error) {
-      throw new Error(
+            throw error;
-        getAttendanceErrorMessage(error, "Failed to load attendance history."),
+        }
-      );
+    },
-    }
-  },
 
-  checkIn: async (
+    checkIn: async (type: string, token: string): Promise<void> => {
-    type: string,
+        try {
-    token: string,
+            await apiClient.post(
-    location: AttendanceLocationPayload,
+                API_ENDPOINTS.ATTENDANCE.CHECK_IN,
-    fallbackRequested = false,
+                { type },
-  ): Promise<void> => {
+                { headers: { Authorization: `Bearer ${token}` } },
-    try {
+            );
-      await apiClient.post(
+        } catch (error) {
-        API_ENDPOINTS.ATTENDANCE.CHECK_IN,
+            throw error;
-        { type, location, fallbackRequested },
+        }
-        { headers: { Authorization: `Bearer ${token}` } },
+    },
-      );
-    } catch (error) {
-      throw new Error(
-        getAttendanceErrorMessage(error, "Failed to start workout."),
-      );
-    }
-  },
 
-  checkOut: async (
+    checkOut: async (token: string): Promise<void> => {
-    token: string,
+        try {
-    location: AttendanceLocationPayload,
+            await apiClient.post(
-    fallbackRequested = false,
+                API_ENDPOINTS.ATTENDANCE.CHECK_OUT,
-  ): Promise<void> => {
+                {},
-    try {
+                { headers: { Authorization: `Bearer ${token}` } },
-      await apiClient.post(
+            );
-        API_ENDPOINTS.ATTENDANCE.CHECK_OUT,
+        } catch (error) {
-        { location, fallbackRequested },
+            throw error;
-        { headers: { Authorization: `Bearer ${token}` } },
+        }
-      );
+    },
-    } catch (error) {
-      throw new Error(
-        getAttendanceErrorMessage(error, "Failed to end workout."),
-      );
-    }
-  },
 };
-
-function getAttendanceErrorMessage(error: unknown, fallback: string): string {
-  if (isAxiosError(error)) {
-    const payload = error.response?.data;
-
-    if (typeof payload === "string" && payload.trim()) {
-      return payload;
-    }
-
-    if (payload && typeof payload === "object") {
-      const message = (payload as { error?: unknown }).error;
-      if (typeof message === "string" && message.trim()) {
-        return message;
-      }
-    }
-  }
-
-  return fallback;
-}

apps/mobile/src/api/gyms.ts

@@ -6,10 +6,6 @@ export interface Gym {
   id: string;
   name: string;
   location?: string;
-  latitude?: number | null;
-  longitude?: number | null;
-  geofenceRadiusMeters?: number;
-  geofenceEnabled?: boolean;
 }
 
 export const gymsApi = {

apps/mobile/src/api/userGym.ts

@@ -1,28 +0,0 @@
-import { API_ENDPOINTS } from "../config/api";
-import { apiClient, withAuth } from "./client";
-
-export interface UserGymGeofence {
-  id: string;
-  name: string;
-  location: string | null;
-  latitude: number | null;
-  longitude: number | null;
-  geofenceRadiusMeters: number | null;
-  geofenceEnabled: boolean;
-  status: "active" | "inactive";
-}
-
-export interface UserGymResponse {
-  gymId: string | null;
-  gym: UserGymGeofence | null;
-}
-
-export const userGymApi = {
-  getCurrentGym: async (token: string | null): Promise<UserGymResponse> => {
-    const response = await apiClient.get<UserGymResponse>(
-      API_ENDPOINTS.USERS.GYM,
-      withAuth(token),
-    );
-    return response.data;
-  },
-};

apps/mobile/src/app/(auth)/onboarding.tsx

@@ -17,7 +17,6 @@ import { useTheme } from "../../contexts/ThemeContext";
 import { Input } from "../../components/Input";
 import { MinimalButton } from "../../components/MinimalButton";
 import { MinimalCard } from "../../components/MinimalCard";
-import { syncAutoWorkoutGeofenceWithToken } from "../../services/autoWorkoutGeofence";
 import log from "../../utils/logger";
 
 export default function OnboardingScreen() {
@@ -82,9 +81,6 @@ export default function OnboardingScreen() {
       // selectedGymId: string gym id, or null to proceed without gym
       try {
         await gymsApi.updateUserGym(selectedGymId, token);
-        await syncAutoWorkoutGeofenceWithToken(token, {
-          requestPermissions: true,
-        });
       } catch (e) {
         log.warn("Failed to update gym selection", { gymId: selectedGymId });
       }

apps/mobile/src/app/(tabs)/_layout.tsx

@@ -83,6 +83,12 @@ export default function TabLayout() {
           title: "Plans",
         }}
       />
+      <Tabs.Screen
+        name="attendance"
+        options={{
+          title: "Attendance",
+        }}
+      />
       <Tabs.Screen
         name="profile"
         options={{

apps/mobile/src/app/(tabs)/attendance.tsx

@@ -0,0 +1,348 @@
+import {
+  View,
+  Text,
+  StyleSheet,
+  TouchableOpacity,
+  ActivityIndicator,
+  ScrollView,
+  Alert,
+} from "react-native";
+import { useState, useEffect } from "react";
+import { useAuth } from "@clerk/clerk-expo";
+import { Ionicons } from "@expo/vector-icons";
+import { useTheme } from "../../contexts/ThemeContext";
+import { MinimalCard } from "../../components/MinimalCard";
+import { SectionHeader } from "../../components/SectionHeader";
+import { MinimalButton } from "../../components/MinimalButton";
+import { Badge } from "../../components/Badge";
+import { IconContainer } from "../../components/IconContainer";
+import { attendanceApi, Attendance } from "../../api/attendance";
+import { AttendanceCalendar } from "../../components/AttendanceCalendar";
+import { useStatistics } from "../../contexts/StatisticsContext";
+import { getErrorMessage } from "../../utils/error-helpers";
+import log from "../../utils/logger";
+
+export default function AttendanceScreen() {
+  const { getToken, userId } = useAuth();
+  const { colors, typography } = useTheme();
+  const { clearCache: clearStatisticsCache } = useStatistics();
+  const [loading, setLoading] = useState(true);
+  const [activeCheckIn, setActiveCheckIn] = useState<Attendance | null>(null);
+  const [history, setHistory] = useState<Attendance[]>([]);
+
+  const fetchAttendance = async () => {
+    try {
+      setLoading(true);
+      const token = await getToken();
+      if (!token) return;
+
+      log.debug("Fetching attendance history");
+      const data = await attendanceApi.getHistory(token);
+      setHistory(data);
+
+      // Check if there's an active check-in (latest one has no checkOutTime)
+      if (data.length > 0 && !data[0].checkOutTime) {
+        setActiveCheckIn(data[0]);
+      } else {
+        setActiveCheckIn(null);
+      }
+    } catch (error) {
+      log.error("Failed to fetch attendance", error);
+      Alert.alert("Error", "Failed to load attendance data");
+    } finally {
+      setLoading(false);
+    }
+  };
+
+  useEffect(() => {
+    fetchAttendance();
+  }, []);
+
+  const handleCheckIn = async () => {
+    try {
+      const token = await getToken();
+      if (!token) return;
+
+      await attendanceApi.checkIn("gym", token);
+      clearStatisticsCache();
+      fetchAttendance();
+      Alert.alert("Success", "Checked in successfully!");
+    } catch (error: unknown) {
+      log.error("Failed to check in", error);
+      Alert.alert("Error", getErrorMessage(error, "Failed to check in"));
+    }
+  };
+
+  const handleCheckOut = async () => {
+    try {
+      const token = await getToken();
+      if (!token) return;
+
+      await attendanceApi.checkOut(token);
+      clearStatisticsCache();
+      fetchAttendance();
+      Alert.alert("Success", "Checked out successfully!");
+    } catch (error: unknown) {
+      log.error("Failed to check out", error);
+      Alert.alert("Error", getErrorMessage(error, "Failed to check out"));
+    }
+  };
+
+  if (loading && !history.length) {
+    return (
+      <View style={[styles.centered, { backgroundColor: colors.background }]}>
+        <ActivityIndicator size="large" color={colors.primary} />
+      </View>
+    );
+  }
+
+  return (
+    <ScrollView
+      style={[styles.container, { backgroundColor: colors.background }]}
+      contentContainerStyle={styles.content}
+    >
+      {/* Header */}
+      <View style={styles.header}>
+        <Text
+          style={[typography.h1, { color: colors.textPrimary, fontSize: 32 }]}
+        >
+          Attendance
+        </Text>
+        <Text
+          style={[
+            typography.body,
+            { color: colors.textSecondary, marginTop: 8 },
+          ]}
+        >
+          {activeCheckIn
+            ? "You're crushing it today!"
+            : history.length === 0
+              ? "Ready to start your fitness journey?"
+              : "Track your gym visits and build streaks!"}
+        </Text>
+      </View>
+
+      {/* Check In/Out Section */}
+      <View style={styles.section}>
+        {activeCheckIn ? (
+          <MinimalCard variant="bordered" style={styles.activeCard}>
+            <View style={styles.activeHeader}>
+              <View style={styles.activeHeaderLeft}>
+                <IconContainer
+                  variant="colored"
+                  backgroundColor={`${colors.success}20`}
+                  size="lg"
+                >
+                  <Ionicons
+                    name="checkmark-circle"
+                    size={28}
+                    color={colors.success}
+                  />
+                </IconContainer>
+                <View style={{ marginLeft: 12 }}>
+                  <Text style={[typography.h3, { color: colors.textPrimary }]}>
+                    ✅ Currently Checked In
+                  </Text>
+                  <Text
+                    style={[
+                      typography.caption,
+                      { color: colors.textTertiary, marginTop: 2 },
+                    ]}
+                  >
+                    Since{" "}
+                    {new Date(activeCheckIn.checkInTime).toLocaleTimeString(
+                      [],
+                      {
+                        hour: "2-digit",
+                        minute: "2-digit",
+                      },
+                    )}
+                  </Text>
+                </View>
+              </View>
+            </View>
+            <MinimalButton
+              title="Check Out"
+              onPress={handleCheckOut}
+              variant="danger"
+              size="lg"
+              style={{ marginTop: 16 }}
+            />
+          </MinimalCard>
+        ) : (
+          <MinimalButton
+            title="💪 Check In"
+            onPress={handleCheckIn}
+            variant="primary"
+            size="lg"
+          />
+        )}
+      </View>
+
+      {/* Attendance Calendar */}
+      <View style={styles.section}>
+        <SectionHeader title="📅 Calendar" />
+        <MinimalCard variant="default" style={{ borderRadius: 20 }}>
+          <AttendanceCalendar attendanceRecords={history} />
+        </MinimalCard>
+      </View>
+
+      {/* Recent History */}
+      <View style={styles.section}>
+        <SectionHeader title="📊 Recent History" />
+        {history.length === 0 ? (
+          <MinimalCard variant="default" style={{ borderRadius: 20 }}>
+            <View style={styles.emptyState}>
+              <Text style={{ fontSize: 64 }}>📍</Text>
+              <Text
+                style={[
+                  typography.bodyEmphasis,
+                  { color: colors.textPrimary, marginTop: 16 },
+                ]}
+              >
+                No attendance history yet
+              </Text>
+              <Text
+                style={[
+                  typography.body,
+                  {
+                    color: colors.textSecondary,
+                    marginTop: 8,
+                    textAlign: "center",
+                  },
+                ]}
+              >
+                Check in to start building your streak! 🔥
+              </Text>
+            </View>
+          </MinimalCard>
+        ) : (
+          <View style={styles.historyList}>
+            {history.slice(0, 10).map((record, index) => {
+              const checkIn = new Date(record.checkInTime);
+              const checkOut = record.checkOutTime
+                ? new Date(record.checkOutTime)
+                : null;
+              const duration = checkOut
+                ? Math.round((checkOut.getTime() - checkIn.getTime()) / 60000)
+                : null;
+
+              return (
+                <MinimalCard
+                  key={index}
+                  variant="bordered"
+                  style={{ borderRadius: 16 }}
+                >
+                  <View style={styles.historyItem}>
+                    <View style={styles.historyLeft}>
+                      <IconContainer
+                        variant="colored"
+                        backgroundColor={
+                          checkOut ? `${colors.success}20` : `${colors.info}20`
+                        }
+                      >
+                        <Ionicons
+                          name={checkOut ? "checkmark-done" : "time"}
+                          size={20}
+                          color={checkOut ? colors.success : colors.info}
+                        />
+                      </IconContainer>
+                      <View style={{ marginLeft: 12, flex: 1 }}>
+                        <Text
+                          style={[typography.h3, { color: colors.textPrimary }]}
+                        >
+                          {checkIn.toLocaleDateString()}
+                        </Text>
+                        <Text
+                          style={[
+                            typography.caption,
+                            { color: colors.textTertiary, marginTop: 2 },
+                          ]}
+                        >
+                          {checkIn.toLocaleTimeString([], {
+                            hour: "2-digit",
+                            minute: "2-digit",
+                          })}
+                          {checkOut &&
+                            ` - ${checkOut.toLocaleTimeString([], {
+                              hour: "2-digit",
+                              minute: "2-digit",
+                            })}`}
+                        </Text>
+                      </View>
+                    </View>
+                    {duration && (
+                      <Badge
+                        label={`${duration}m`}
+                        variant="neutral"
+                        size="sm"
+                      />
+                    )}
+                  </View>
+                </MinimalCard>
+              );
+            })}
+          </View>
+        )}
+      </View>
+
+      {/* Bottom Spacer */}
+      <View style={{ height: 100 }} />
+    </ScrollView>
+  );
+}
+
+const styles = StyleSheet.create({
+  container: {
+    flex: 1,
+  },
+  centered: {
+    flex: 1,
+    justifyContent: "center",
+    alignItems: "center",
+  },
+  content: {
+    paddingBottom: 20,
+  },
+  header: {
+    paddingHorizontal: 24,
+    paddingTop: 60,
+    paddingBottom: 24,
+  },
+  section: {
+    paddingHorizontal: 24,
+    marginBottom: 24,
+  },
+  activeCard: {
+    padding: 20,
+    borderRadius: 20,
+  },
+  activeHeader: {
+    flexDirection: "row",
+    justifyContent: "space-between",
+    alignItems: "center",
+  },
+  activeHeaderLeft: {
+    flexDirection: "row",
+    alignItems: "center",
+    flex: 1,
+  },
+  emptyState: {
+    alignItems: "center",
+    paddingVertical: 40,
+    paddingHorizontal: 20,
+  },
+  historyList: {
+    gap: 12,
+  },
+  historyItem: {
+    flexDirection: "row",
+    justifyContent: "space-between",
+    alignItems: "center",
+  },
+  historyLeft: {
+    flexDirection: "row",
+    alignItems: "center",
+    flex: 1,
+  },
+});

apps/mobile/src/app/(tabs)/index.tsx

@@ -10,7 +10,6 @@ import {
   Alert,
   AppState,
 } from "react-native";
-import * as Location from "expo-location";
 import { useAuth, useUser } from "@clerk/clerk-expo";
 import { useState, useCallback, useEffect, useRef, useMemo } from "react";
 import { useFocusEffect } from "@react-navigation/native";
@@ -30,7 +29,6 @@ import { ActivityRing } from "../../components/ActivityRing";
 import { useMembership } from "../../hooks/useMembership";
 import { attendanceApi, type Attendance } from "../../api/attendance";
 import { useDailySteps } from "../../hooks/useDailySteps";
-import { syncAutoWorkoutGeofenceWithToken } from "../../services/autoWorkoutGeofence";
 import {
   checkInsToActivities,
   completedGoalsToActivities,
@@ -238,40 +236,11 @@ export default function HomeScreen() {
         return;
       }
 
-      await syncAutoWorkoutGeofenceWithToken(token, {
-        requestPermissions: true,
-      });
-
-      const permission = await Location.requestForegroundPermissionsAsync();
-      if (permission.status !== "granted") {
-        Alert.alert(
-          "Location required",
-          "Location access is required to check in and check out.",
-        );
-        return;
-      }
-
-      const position = await Location.getCurrentPositionAsync({
-        accuracy: Location.Accuracy.Balanced,
-      });
-      const locationPayload = {
-        latitude: position.coords.latitude,
-        longitude: position.coords.longitude,
-        accuracy: position.coords.accuracy ?? 999,
-      };
-
       if (activeWorkoutSession) {
-        const fallbackRequested = locationPayload.accuracy > 50;
+        await attendanceApi.checkOut(token);
-        await attendanceApi.checkOut(token, locationPayload, fallbackRequested);
         Alert.alert("Workout logged", "Session ended successfully.");
       } else {
-        const fallbackRequested = locationPayload.accuracy > 50;
+        await attendanceApi.checkIn("gym", token);
-        await attendanceApi.checkIn(
-          "gym",
-          token,
-          locationPayload,
-          fallbackRequested,
-        );
         Alert.alert("Workout started", "Session started successfully.");
       }
 

apps/mobile/src/app/(tabs)/profile.tsx

@@ -21,7 +21,6 @@ import { IconContainer } from "../../components/IconContainer";
 import { fitnessProfileApi, FitnessProfile } from "../../api/fitnessProfile";
 import { gymsApi, type Gym } from "../../api/gyms";
 import { useMembership } from "../../hooks/useMembership";
-import { syncAutoWorkoutGeofenceWithToken } from "../../services/autoWorkoutGeofence";
 import log from "../../utils/logger";
 
 export default function ProfileScreen() {
@@ -116,12 +115,6 @@ export default function ProfileScreen() {
         "Success",
         selectedGymId ? "Gym selected successfully" : "Proceeding without gym",
       );
-
-      if (token) {
-        await syncAutoWorkoutGeofenceWithToken(token, {
-          requestPermissions: true,
-        });
-      }
     } catch (err) {
       log.error("Failed to update gym selection", err);
       Alert.alert("Error", "Failed to update gym selection");

apps/mobile/src/app/_layout.tsx

@@ -13,7 +13,6 @@ import { RecommendationsProvider } from "../contexts/RecommendationsContext";
 import { NotificationsProvider } from "../contexts/NotificationsContext";
 import { MembershipProvider } from "../contexts/MembershipContext";
 import { queryClient } from "../lib/query-client";
-import { useAutoWorkoutGeofence } from "../hooks/useAutoWorkoutGeofence";
 import log from "../utils/logger";
 
 // Wrapper to use notification permissions hook after ClerkLoaded
@@ -23,7 +22,6 @@ function AppContent() {
     useNotificationPermissions,
   } = require("../hooks/useNotificationPermissions");
   useNotificationPermissions();
-  useAutoWorkoutGeofence();
 
   return (
     <Stack>

apps/mobile/src/components/AttendanceCalendar.tsx

@@ -0,0 +1,303 @@
+import React, { useState, useEffect } from "react";
+import { View, Text, StyleSheet, TouchableOpacity } from "react-native";
+import { LinearGradient } from "expo-linear-gradient";
+import { Ionicons } from "@expo/vector-icons";
+import { theme } from "../styles/theme";
+
+interface AttendanceRecord {
+  id: string;
+  checkInTime: string;
+  checkOutTime?: string | null;
+  duration?: number | null;
+}
+
+interface AttendanceCalendarProps {
+  attendanceRecords: AttendanceRecord[];
+}
+
+export function AttendanceCalendar({
+  attendanceRecords,
+}: AttendanceCalendarProps) {
+  const [currentMonth, setCurrentMonth] = useState(new Date());
+  const [calendarDays, setCalendarDays] = useState<
+    Array<{ date: Date | null; hasAttendance: boolean; isToday: boolean }>
+  >([]);
+
+  useEffect(() => {
+    generateCalendar(currentMonth);
+  }, [currentMonth, attendanceRecords]);
+
+  const generateCalendar = (month: Date) => {
+    const year = month.getFullYear();
+    const monthIndex = month.getMonth();
+
+    // Get first day of month and number of days
+    const firstDay = new Date(year, monthIndex, 1);
+    const lastDay = new Date(year, monthIndex + 1, 0);
+    const daysInMonth = lastDay.getDate();
+    const startingDayOfWeek = firstDay.getDay();
+
+    // Create attendance lookup set
+    const attendanceDates = new Set(
+      attendanceRecords.map((record) =>
+        new Date(record.checkInTime).toDateString(),
+      ),
+    );
+
+    const today = new Date().toDateString();
+
+    // Build calendar array
+    const days: Array<{
+      date: Date | null;
+      hasAttendance: boolean;
+      isToday: boolean;
+    }> = [];
+
+    // Add empty cells for days before month starts
+    for (let i = 0; i < startingDayOfWeek; i++) {
+      days.push({ date: null, hasAttendance: false, isToday: false });
+    }
+
+    // Add days of the month
+    for (let day = 1; day <= daysInMonth; day++) {
+      const date = new Date(year, monthIndex, day);
+      const dateString = date.toDateString();
+      days.push({
+        date,
+        hasAttendance: attendanceDates.has(dateString),
+        isToday: dateString === today,
+      });
+    }
+
+    setCalendarDays(days);
+  };
+
+  const goToPreviousMonth = () => {
+    setCurrentMonth(
+      new Date(currentMonth.getFullYear(), currentMonth.getMonth() - 1),
+    );
+  };
+
+  const goToNextMonth = () => {
+    setCurrentMonth(
+      new Date(currentMonth.getFullYear(), currentMonth.getMonth() + 1),
+    );
+  };
+
+  const monthName = currentMonth.toLocaleDateString("en-US", {
+    month: "long",
+    year: "numeric",
+  });
+
+  return (
+    <View style={styles.container}>
+      <LinearGradient
+        colors={[theme.colors.white, theme.colors.gray50]}
+        style={[styles.card, theme.shadows.medium]}
+      >
+        {/* Header */}
+        <View style={styles.header}>
+          <Text style={styles.title}>Attendance Calendar</Text>
+        </View>
+
+        {/* Month Navigation */}
+        <View style={styles.monthNav}>
+          <TouchableOpacity
+            onPress={goToPreviousMonth}
+            style={styles.navButton}
+          >
+            <Ionicons
+              name="chevron-back"
+              size={20}
+              color={theme.colors.primary}
+            />
+          </TouchableOpacity>
+          <Text style={styles.monthText}>{monthName}</Text>
+          <TouchableOpacity onPress={goToNextMonth} style={styles.navButton}>
+            <Ionicons
+              name="chevron-forward"
+              size={20}
+              color={theme.colors.primary}
+            />
+          </TouchableOpacity>
+        </View>
+
+        {/* Day Headers */}
+        <View style={styles.dayHeaders}>
+          {["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"].map((day) => (
+            <Text key={day} style={styles.dayHeader}>
+              {day}
+            </Text>
+          ))}
+        </View>
+
+        {/* Calendar Grid */}
+        <View style={styles.calendarGrid}>
+          {calendarDays.map((day, index) => (
+            <View key={index} style={styles.dayCell}>
+              {day.date ? (
+                <View
+                  style={[
+                    styles.dayContent,
+                    day.isToday && styles.todayContent,
+                    day.hasAttendance && styles.attendanceContent,
+                  ]}
+                >
+                  <Text
+                    style={[
+                      styles.dayText,
+                      day.isToday && styles.todayText,
+                      day.hasAttendance && styles.attendanceText,
+                    ]}
+                  >
+                    {day.date.getDate()}
+                  </Text>
+                  {day.hasAttendance && <View style={styles.attendanceDot} />}
+                </View>
+              ) : (
+                <View style={styles.emptyCell} />
+              )}
+            </View>
+          ))}
+        </View>
+
+        {/* Legend */}
+        <View style={styles.legend}>
+          <View style={styles.legendItem}>
+            <View style={styles.legendDotAttendance} />
+            <Text style={styles.legendText}>Attended</Text>
+          </View>
+          <View style={styles.legendItem}>
+            <View style={styles.legendDotToday} />
+            <Text style={styles.legendText}>Today</Text>
+          </View>
+        </View>
+      </LinearGradient>
+    </View>
+  );
+}
+
+const styles = StyleSheet.create({
+  container: {
+    paddingHorizontal: 20,
+    marginBottom: 20,
+  },
+  card: {
+    borderRadius: theme.borderRadius["2xl"],
+    padding: 20,
+  },
+  header: {
+    marginBottom: 16,
+  },
+  title: {
+    fontSize: theme.typography.fontSize.xl,
+    fontWeight: theme.typography.fontWeight.bold,
+    color: theme.colors.gray800,
+  },
+  monthNav: {
+    flexDirection: "row",
+    justifyContent: "space-between",
+    alignItems: "center",
+    marginBottom: 16,
+    paddingHorizontal: 8,
+  },
+  navButton: {
+    padding: 8,
+  },
+  monthText: {
+    fontSize: theme.typography.fontSize.lg,
+    fontWeight: theme.typography.fontWeight.semibold,
+    color: theme.colors.gray700,
+  },
+  dayHeaders: {
+    flexDirection: "row",
+    marginBottom: 8,
+  },
+  dayHeader: {
+    flex: 1,
+    textAlign: "center",
+    fontSize: theme.typography.fontSize.xs,
+    fontWeight: theme.typography.fontWeight.semibold,
+    color: theme.colors.gray500,
+  },
+  calendarGrid: {
+    flexDirection: "row",
+    flexWrap: "wrap",
+  },
+  dayCell: {
+    width: `${100 / 7}%`,
+    aspectRatio: 1,
+    padding: 2,
+  },
+  dayContent: {
+    flex: 1,
+    justifyContent: "center",
+    alignItems: "center",
+    borderRadius: theme.borderRadius.md,
+    position: "relative",
+  },
+  todayContent: {
+    backgroundColor: theme.colors.primaryLight,
+    borderWidth: 1,
+    borderColor: theme.colors.primary,
+  },
+  attendanceContent: {
+    backgroundColor: theme.colors.successLight,
+  },
+  emptyCell: {
+    flex: 1,
+  },
+  dayText: {
+    fontSize: theme.typography.fontSize.sm,
+    color: theme.colors.gray700,
+    fontWeight: theme.typography.fontWeight.medium,
+  },
+  todayText: {
+    color: theme.colors.white,
+    fontWeight: theme.typography.fontWeight.bold,
+  },
+  attendanceText: {
+    color: theme.colors.white,
+    fontWeight: theme.typography.fontWeight.bold,
+  },
+  attendanceDot: {
+    position: "absolute",
+    bottom: 2,
+    width: 4,
+    height: 4,
+    borderRadius: 2,
+    backgroundColor: theme.colors.white,
+  },
+  legend: {
+    flexDirection: "row",
+    justifyContent: "center",
+    gap: 20,
+    marginTop: 16,
+    paddingTop: 16,
+    borderTopWidth: 1,
+    borderTopColor: theme.colors.gray200,
+  },
+  legendItem: {
+    flexDirection: "row",
+    alignItems: "center",
+    gap: 6,
+  },
+  legendDotAttendance: {
+    width: 12,
+    height: 12,
+    borderRadius: 6,
+    backgroundColor: theme.colors.successLight,
+  },
+  legendDotToday: {
+    width: 12,
+    height: 12,
+    borderRadius: 6,
+    backgroundColor: theme.colors.primaryLight,
+    borderWidth: 1,
+    borderColor: theme.colors.primary,
+  },
+  legendText: {
+    fontSize: theme.typography.fontSize.xs,
+    color: theme.colors.gray600,
+  },
+});

apps/mobile/src/components/CustomTabBar.tsx

@@ -49,6 +49,8 @@ export function CustomTabBar({
               return focused ? "home" : "home-outline";
             case "goals":
               return focused ? "trophy" : "trophy-outline";
+            case "attendance":
+              return focused ? "calendar" : "calendar-outline";
             case "recommendations":
               return focused ? "sparkles" : "sparkles-outline";
             case "profile":
@@ -64,6 +66,8 @@ export function CustomTabBar({
               return "Home";
             case "goals":
               return "Goals";
+            case "attendance":
+              return "Attendance";
             case "recommendations":
               return "Plans";
             case "profile":

apps/mobile/src/contexts/StatisticsContext.tsx

@@ -4,7 +4,6 @@ import React, {
   useState,
   useCallback,
   useEffect,
-  useRef,
 } from "react";
 import { useUser, useAuth } from "@clerk/clerk-expo";
 import { getUserStatistics } from "../api/statistics";
@@ -37,9 +36,6 @@ export function StatisticsProvider({
   const [loading, setLoading] = useState(false);
   const [error, setError] = useState<Error | null>(null);
   const [lastFetchTime, setLastFetchTime] = useState<number>(0);
-  const statisticsRef = useRef<UserStatisticsResponse | null>(null);
-  const lastFetchTimeRef = useRef<number>(0);
-  const fetchInProgressRef = useRef(false);
 
   // Cache statistics for 30 seconds to avoid duplicate calls
   const CACHE_DURATION = 30000; // 30 seconds
@@ -47,49 +43,48 @@ export function StatisticsProvider({
   const refetchStatistics = useCallback(async () => {
     if (!user?.id) return;
 
-    if (fetchInProgressRef.current) {
-      return;
-    }
-
     // Check if we have recent cached data
     const now = Date.now();
-    if (
+    if (statistics && now - lastFetchTime < CACHE_DURATION) {
-      statisticsRef.current &&
+      log.debug("Using cached statistics", {
-      now - lastFetchTimeRef.current < CACHE_DURATION
+        age: now - lastFetchTime,
-    ) {
+        cacheRemaining: CACHE_DURATION - (now - lastFetchTime),
+      });
       return;
     }
 
     try {
-      fetchInProgressRef.current = true;
       setLoading(true);
       setError(null);
+      log.debug("Fetching fresh statistics", { userId: user.id });
 
       const token = await getToken();
       const stats = await getUserStatistics(user.id, token);
 
       setStatistics(stats);
-      statisticsRef.current = stats;
       setLastFetchTime(now);
-      lastFetchTimeRef.current = now;
+      log.debug("Statistics fetched and cached", {
+        userId: user.id,
+        hasWeeklyTrend: !!stats.weeklyTrend,
+        weeklyTrendLength: stats.weeklyTrend?.length || 0,
+        weeklyTrendSample: stats.weeklyTrend?.[0],
+        stats,
+      });
     } catch (err) {
       const error = err instanceof Error ? err : new Error(String(err));
       log.error("Failed to fetch statistics", error);
       setError(error);
     } finally {
       setLoading(false);
-      fetchInProgressRef.current = false;
     }
-  }, [user?.id, getToken]);
+  }, [user?.id, getToken, statistics, lastFetchTime]);
 
   const clearCache = useCallback(() => {
     setStatistics(null);
-    statisticsRef.current = null;
     setLoading(false);
     setLastFetchTime(0);
-    lastFetchTimeRef.current = 0;
     setError(null);
-    fetchInProgressRef.current = false;
+    log.debug("Statistics cache cleared");
   }, []);
 
   useEffect(() => {
@@ -105,25 +100,28 @@ export function StatisticsProvider({
     if (!user?.id) return;
 
     try {
-      fetchInProgressRef.current = true;
       setLoading(true);
       setError(null);
+      log.debug("Force fetching statistics", { userId: user.id });
 
       const token = await getToken();
       const stats = await getUserStatistics(user.id, token);
 
       setStatistics(stats);
-      statisticsRef.current = stats;
+      setLastFetchTime(Date.now());
-      const now = Date.now();
+      log.debug("Statistics force fetched and cached", {
-      setLastFetchTime(now);
+        userId: user.id,
-      lastFetchTimeRef.current = now;
+        hasWeeklyTrend: !!stats.weeklyTrend,
+        weeklyTrendLength: stats.weeklyTrend?.length || 0,
+        weeklyTrendSample: stats.weeklyTrend?.[0],
+        stats,
+      });
     } catch (err) {
       const error = err instanceof Error ? err : new Error(String(err));
       log.error("Failed to force fetch statistics", error);
       setError(error);
     } finally {
       setLoading(false);
-      fetchInProgressRef.current = false;
     }
   }, [user?.id, getToken]);
 

apps/mobile/src/hooks/useAutoWorkoutGeofence.ts

@@ -1,68 +0,0 @@
-import { useAuth } from "@clerk/clerk-expo";
-import { useCallback, useEffect } from "react";
-import { AppState } from "react-native";
-import {
-  disableAutoWorkoutGeofence,
-  syncAutoWorkoutGeofenceWithToken,
-} from "../services/autoWorkoutGeofence";
-import log from "../utils/logger";
-
-export function useAutoWorkoutGeofence() {
-  const { isSignedIn, getToken } = useAuth();
-
-  const syncGeofence = useCallback(async () => {
-    try {
-      if (!isSignedIn) {
-        await disableAutoWorkoutGeofence();
-        return;
-      }
-
-      const token = await getToken();
-      if (!token) {
-        await disableAutoWorkoutGeofence();
-        return;
-      }
-
-      await syncAutoWorkoutGeofenceWithToken(token, {
-        requestPermissions: true,
-      });
-    } catch (error) {
-      log.warn("Failed to sync auto workout geofence", {
-        error: error instanceof Error ? error.message : String(error),
-      });
-    }
-  }, [getToken, isSignedIn]);
-
-  useEffect(() => {
-    void syncGeofence();
-  }, [syncGeofence]);
-
-  useEffect(() => {
-    const appStateSubscription = AppState.addEventListener(
-      "change",
-      (state) => {
-        if (state === "active") {
-          void syncGeofence();
-        }
-      },
-    );
-
-    const interval = setInterval(
-      () => {
-        void syncGeofence();
-      },
-      5 * 60 * 1000,
-    );
-
-    return () => {
-      appStateSubscription.remove();
-      clearInterval(interval);
-    };
-  }, [syncGeofence]);
-
-  useEffect(() => {
-    if (!isSignedIn) {
-      void disableAutoWorkoutGeofence();
-    }
-  }, [isSignedIn]);
-}

apps/mobile/src/lib/background-auth-token.ts

@@ -1,19 +0,0 @@
-import * as SecureStore from "expo-secure-store";
-
-const BACKGROUND_AUTH_TOKEN_KEY = "fitai_background_auth_token";
-
-export async function saveBackgroundAuthToken(token: string): Promise<void> {
-  if (!looksLikeJwt(token)) {
-    return;
-  }
-
-  await SecureStore.setItemAsync(BACKGROUND_AUTH_TOKEN_KEY, token);
-}
-
-export async function getBackgroundAuthToken(): Promise<string | null> {
-  return SecureStore.getItemAsync(BACKGROUND_AUTH_TOKEN_KEY);
-}
-
-function looksLikeJwt(token: string): boolean {
-  return token.split(".").length === 3;
-}

apps/mobile/src/services/autoWorkoutGeofence.ts

@@ -1,296 +0,0 @@
-import * as Location from "expo-location";
-import * as TaskManager from "expo-task-manager";
-import { apiClient } from "../api/client";
-import { userGymApi } from "../api/userGym";
-import { API_ENDPOINTS } from "../config/api";
-import { saveBackgroundAuthToken } from "../lib/background-auth-token";
-import { getBackgroundAuthToken } from "../lib/background-auth-token";
-import log from "../utils/logger";
-
-const AUTO_WORKOUT_GEOFENCE_TASK = "fitai-auto-workout-geofence";
-const DEFAULT_RADIUS_METERS = 30;
-const MAX_ACCEPTABLE_ACCURACY_METERS = 50;
-const ACTION_COOLDOWN_MS = 90_000;
-
-let lastActionAt = 0;
-
-interface GeofenceRegion {
-  identifier: string;
-  latitude: number;
-  longitude: number;
-  radius: number;
-  notifyOnEnter: boolean;
-  notifyOnExit: boolean;
-}
-
-if (!TaskManager.isTaskDefined(AUTO_WORKOUT_GEOFENCE_TASK)) {
-  TaskManager.defineTask(
-    AUTO_WORKOUT_GEOFENCE_TASK,
-    async ({ data, error }: TaskManager.TaskManagerTaskBody) => {
-      if (error) {
-        log.error("Auto workout geofence task failed", error);
-        return;
-      }
-
-      const event = data as
-        | {
-            eventType?: Location.GeofencingEventType;
-            region?: GeofenceRegion;
-          }
-        | undefined;
-
-      const eventType = event?.eventType;
-      if (
-        eventType !== Location.GeofencingEventType.Enter &&
-        eventType !== Location.GeofencingEventType.Exit
-      ) {
-        return;
-      }
-
-      const now = Date.now();
-      if (now - lastActionAt < ACTION_COOLDOWN_MS) {
-        return;
-      }
-      lastActionAt = now;
-
-      try {
-        const token = await getBackgroundAuthToken();
-        if (!token) {
-          log.warn("Skipping geofence auto-workout due to missing auth token");
-          return;
-        }
-
-        const location = await Location.getCurrentPositionAsync({
-          accuracy: Location.Accuracy.Balanced,
-        });
-
-        const accuracy = location.coords.accuracy ?? 999;
-        if (accuracy > MAX_ACCEPTABLE_ACCURACY_METERS) {
-          log.warn("Skipping geofence auto-workout due to poor GPS accuracy", {
-            accuracy,
-          });
-          return;
-        }
-
-        const headers = { Authorization: `Bearer ${token}` };
-        const locationPayload = {
-          latitude: location.coords.latitude,
-          longitude: location.coords.longitude,
-          accuracy,
-        };
-
-        const historyRes = await apiClient.get(
-          API_ENDPOINTS.ATTENDANCE.HISTORY,
-          {
-            headers,
-          },
-        );
-        const history = Array.isArray(historyRes.data)
-          ? (historyRes.data as Array<{ id: string; checkOutTime?: string }>)
-          : [];
-        const activeSession = history.find((item) => !item.checkOutTime);
-
-        if (eventType === Location.GeofencingEventType.Enter) {
-          if (activeSession) {
-            return;
-          }
-
-          await apiClient.post(
-            API_ENDPOINTS.ATTENDANCE.CHECK_IN,
-            { type: "gym", location: locationPayload },
-            { headers },
-          );
-          log.info("Auto-started workout after geofence enter");
-          return;
-        }
-
-        if (!activeSession) {
-          return;
-        }
-
-        await apiClient.post(
-          API_ENDPOINTS.ATTENDANCE.CHECK_OUT,
-          {
-            location: locationPayload,
-            fallbackRequested: accuracy > MAX_ACCEPTABLE_ACCURACY_METERS,
-          },
-          { headers },
-        );
-        log.info("Auto-ended workout after geofence exit");
-      } catch (taskError: unknown) {
-        if (
-          isApiError(taskError, 400, "Already checked in") ||
-          isApiError(taskError, 404, "No active check-in found")
-        ) {
-          return;
-        }
-
-        log.error("Auto workout geofence action failed", taskError);
-      }
-    },
-  );
-}
-
-export async function configureAutoWorkoutGeofence(params: {
-  latitude: number;
-  longitude: number;
-  radiusMeters?: number | null;
-}): Promise<void> {
-  const started = await Location.hasStartedGeofencingAsync(
-    AUTO_WORKOUT_GEOFENCE_TASK,
-  );
-
-  const region: GeofenceRegion = {
-    identifier: "user-gym",
-    latitude: params.latitude,
-    longitude: params.longitude,
-    radius: params.radiusMeters ?? DEFAULT_RADIUS_METERS,
-    notifyOnEnter: true,
-    notifyOnExit: true,
-  };
-
-  if (started) {
-    try {
-      await Location.stopGeofencingAsync(AUTO_WORKOUT_GEOFENCE_TASK);
-    } catch (error) {
-      if (!isTaskNotFoundError(error)) {
-        throw error;
-      }
-
-      log.warn("Geofence task was not found while stopping before restart", {
-        task: AUTO_WORKOUT_GEOFENCE_TASK,
-      });
-    }
-  }
-
-  await Location.startGeofencingAsync(AUTO_WORKOUT_GEOFENCE_TASK, [region]);
-}
-
-export async function disableAutoWorkoutGeofence(): Promise<void> {
-  try {
-    const started = await Location.hasStartedGeofencingAsync(
-      AUTO_WORKOUT_GEOFENCE_TASK,
-    );
-
-    if (!started) {
-      return;
-    }
-
-    await Location.stopGeofencingAsync(AUTO_WORKOUT_GEOFENCE_TASK);
-  } catch (error) {
-    if (!isTaskNotFoundError(error)) {
-      throw error;
-    }
-
-    log.warn("Geofence task was not found while disabling", {
-      task: AUTO_WORKOUT_GEOFENCE_TASK,
-    });
-  }
-}
-
-export async function syncAutoWorkoutGeofenceWithToken(
-  token: string,
-  options?: { requestPermissions?: boolean },
-): Promise<void> {
-  const shouldRequestPermissions = options?.requestPermissions ?? false;
-
-  await saveBackgroundAuthToken(token);
-
-  const foregroundPermission = await Location.getForegroundPermissionsAsync();
-  const foregroundStatus =
-    foregroundPermission.status === "granted"
-      ? foregroundPermission.status
-      : shouldRequestPermissions
-        ? (await Location.requestForegroundPermissionsAsync()).status
-        : foregroundPermission.status;
-
-  if (foregroundStatus !== "granted") {
-    log.info("Auto workout geofence disabled: foreground location not granted");
-    await disableAutoWorkoutGeofence();
-    return;
-  }
-
-  const backgroundPermission = await Location.getBackgroundPermissionsAsync();
-  const backgroundStatus =
-    backgroundPermission.status === "granted"
-      ? backgroundPermission.status
-      : shouldRequestPermissions
-        ? (await Location.requestBackgroundPermissionsAsync()).status
-        : backgroundPermission.status;
-
-  if (backgroundStatus !== "granted") {
-    log.info("Auto workout geofence disabled: background location not granted");
-    await disableAutoWorkoutGeofence();
-    return;
-  }
-
-  const currentGym = await userGymApi.getCurrentGym(token);
-  const gym = currentGym.gym;
-
-  if (
-    !gym ||
-    gym.geofenceEnabled === false ||
-    gym.latitude === null ||
-    gym.longitude === null
-  ) {
-    log.info("Auto workout geofence disabled: missing/disabled gym geofence");
-    await disableAutoWorkoutGeofence();
-    return;
-  }
-
-  await configureAutoWorkoutGeofence({
-    latitude: gym.latitude,
-    longitude: gym.longitude,
-    radiusMeters: gym.geofenceRadiusMeters ?? DEFAULT_RADIUS_METERS,
-  });
-}
-
-function isApiError(
-  error: unknown,
-  status: number,
-  expectedMessage: string,
-): boolean {
-  if (!error || typeof error !== "object") {
-    return false;
-  }
-
-  const maybe = error as {
-    response?: {
-      status?: number;
-      data?: unknown;
-    };
-  };
-
-  if (maybe.response?.status !== status) {
-    return false;
-  }
-
-  const data = maybe.response.data;
-  if (typeof data === "string") {
-    return data === expectedMessage;
-  }
-
-  if (data && typeof data === "object") {
-    const errorField = (data as { error?: unknown }).error;
-    if (typeof errorField === "string") {
-      return errorField.includes(expectedMessage);
-    }
-  }
-
-  return false;
-}
-
-function isTaskNotFoundError(error: unknown): boolean {
-  if (!error || typeof error !== "object") {
-    return false;
-  }
-
-  const message =
-    "message" in error && typeof error.message === "string"
-      ? error.message
-      : String(error);
-
-  return (
-    message.includes("TaskNotFoundException") || message.includes("not found")
-  );
-}

packages/database/src/schema.ts

@@ -48,12 +48,6 @@ export const gyms = sqliteTable(
     id: text("id").primaryKey(),
     name: text("name").notNull(),
     location: text("location"),
-    latitude: real("latitude"),
-    longitude: real("longitude"),
-    geofenceRadiusMeters: real("geofence_radius_meters").notNull().default(30),
-    geofenceEnabled: integer("geofence_enabled", { mode: "boolean" })
-      .notNull()
-      .default(true),
     status: text("status", { enum: ["active", "inactive"] })
       .notNull()
       .default("active"),

packages/shared/src/types/index.ts

@@ -137,10 +137,6 @@ export interface Gym {
   id: string;
   name: string;
   location?: string;
-  latitude?: number;
-  longitude?: number;
-  geofenceRadiusMeters?: number;
-  geofenceEnabled?: boolean;
   status: GymStatus;
   adminUserId: string;
 }