tatus

diff --git a/apps/api/.env.example b/apps/api/.env.example
deleted file mode 100644
index cf92664..0000000
--- a/apps/api/.env.example
+++ /dev/null
@@ -1,6 +0,0 @@
-# Environment
-ENVIRONMENT=development
-
-# Clerk Authentication
-CLERK_PUBLISHABLE_KEY=your_publishable_key
-CLERK_SECRET_KEY=your_secret_key 
\ No newline at end of file
diff --git a/apps/api/apps/clerk-sync/cloudflared.rpm b/apps/api/apps/clerk-sync/cloudflared.rpm
deleted file mode 100644
index e1713b1..0000000
Binary files a/apps/api/apps/clerk-sync/cloudflared.rpm and /dev/null differ
diff --git a/apps/api/drizzle.config.ts b/apps/api/drizzle.config.ts
index b129d35..30a41fb 100644
--- a/apps/api/drizzle.config.ts
+++ b/apps/api/drizzle.config.ts
@@ -1,13 +1,7 @@
 import type { Config } from 'drizzle-kit'
-import * as dotenv from 'dotenv'
-dotenv.config()
 
 export default {
-  schema: "./src/db/schema.ts",
-  out: "./drizzle/migrations",
-  driver: "turso",
-  dbCredentials: {
-    url: process.env.TURSO_DATABASE_URL!,
-    authToken: process.env.TURSO_AUTH_TOKEN
-  }
+  schema: './src/db/schema/*',
+  out: './drizzle',
+  driver: 'turso'
 } satisfies Config
diff --git a/apps/api/drizzle/meta/0000_snapshot.json b/apps/api/drizzle/meta/0000_snapshot.json
deleted file mode 100644
index a45dee7..0000000
--- a/apps/api/drizzle/meta/0000_snapshot.json
+++ /dev/null
@@ -1,74 +0,0 @@
-{
-  "version": "5",
-  "dialect": "sqlite",
-  "id": "00000000-0000-0000-0000-000000000000",
-  "prevId": "00000000-0000-0000-0000-000000000000",
-  "tables": {
-    "users": {
-      "name": "users",
-      "columns": {
-        "id": {
-          "name": "id",
-          "type": "text",
-          "primaryKey": true,
-          "notNull": true
-        },
-        "clerk_id": {
-          "name": "clerk_id",
-          "type": "text",
-          "unique": true
-        },
-        "email": {
-          "name": "email",
-          "type": "text",
-          "notNull": true
-        },
-        "first_name": {
-          "name": "first_name",
-          "type": "text",
-          "notNull": true
-        },
-        "last_name": {
-          "name": "last_name",
-          "type": "text",
-          "notNull": true
-        },
-        "phone_number": {
-          "name": "phone_number",
-          "type": "text"
-        },
-        "role": {
-          "name": "role",
-          "type": "text",
-          "notNull": true
-        },
-        "status": {
-          "name": "status",
-          "type": "text",
-          "notNull": true,
-          "default": "'invited'"
-        },
-        "created_at": {
-          "name": "created_at",
-          "type": "text",
-          "notNull": true
-        },
-        "updated_at": {
-          "name": "updated_at",
-          "type": "text",
-          "notNull": true
-        }
-      },
-      "indexes": {},
-      "foreignKeys": {},
-      "compositePrimaryKeys": {},
-      "uniqueConstraints": {}
-    }
-  },
-  "enums": {},
-  "_meta": {
-    "schemas": {},
-    "tables": {},
-    "columns": {}
-  }
-}
\ No newline at end of file
diff --git a/apps/api/drizzle/meta/0001_snapshot.json b/apps/api/drizzle/meta/0001_snapshot.json
deleted file mode 100644
index 5305f78..0000000
--- a/apps/api/drizzle/meta/0001_snapshot.json
+++ /dev/null
@@ -1,140 +0,0 @@
-{
-  "version": "5",
-  "dialect": "sqlite",
-  "id": "708e59b7-4367-4bac-9b0c-2a772d235694",
-  "prevId": "1ebfc2db-36d1-4417-87b2-73a8b4c083b3",
-  "tables": {
-    "migrations": {
-      "name": "migrations",
-      "columns": {
-        "id": {
-          "name": "id",
-          "type": "integer",
-          "primaryKey": true,
-          "notNull": true,
-          "autoincrement": true
-        },
-        "name": {
-          "name": "name",
-          "type": "text",
-          "primaryKey": false,
-          "notNull": true,
-          "autoincrement": false
-        },
-        "applied_at": {
-          "name": "applied_at",
-          "type": "text",
-          "primaryKey": false,
-          "notNull": true,
-          "autoincrement": false
-        }
-      },
-      "indexes": {
-        "migrations_name_unique": {
-          "name": "migrations_name_unique",
-          "columns": [
-            "name"
-          ],
-          "isUnique": true
-        }
-      },
-      "foreignKeys": {},
-      "compositePrimaryKeys": {},
-      "uniqueConstraints": {}
-    },
-    "users": {
-      "name": "users",
-      "columns": {
-        "id": {
-          "name": "id",
-          "type": "text",
-          "primaryKey": true,
-          "notNull": true,
-          "autoincrement": false
-        },
-        "clerk_id": {
-          "name": "clerk_id",
-          "type": "text",
-          "primaryKey": false,
-          "notNull": false,
-          "autoincrement": false
-        },
-        "email": {
-          "name": "email",
-          "type": "text",
-          "primaryKey": false,
-          "notNull": true,
-          "autoincrement": false
-        },
-        "first_name": {
-          "name": "first_name",
-          "type": "text",
-          "primaryKey": false,
-          "notNull": true,
-          "autoincrement": false
-        },
-        "last_name": {
-          "name": "last_name",
-          "type": "text",
-          "primaryKey": false,
-          "notNull": true,
-          "autoincrement": false
-        },
-        "role": {
-          "name": "role",
-          "type": "text",
-          "primaryKey": false,
-          "notNull": true,
-          "autoincrement": false
-        },
-        "status": {
-          "name": "status",
-          "type": "text",
-          "primaryKey": false,
-          "notNull": true,
-          "autoincrement": false,
-          "default": "'invited'"
-        },
-        "phone_number": {
-          "name": "phone_number",
-          "type": "text",
-          "primaryKey": false,
-          "notNull": false,
-          "autoincrement": false
-        },
-        "created_at": {
-          "name": "created_at",
-          "type": "text",
-          "primaryKey": false,
-          "notNull": true,
-          "autoincrement": false
-        },
-        "updated_at": {
-          "name": "updated_at",
-          "type": "text",
-          "primaryKey": false,
-          "notNull": true,
-          "autoincrement": false
-        }
-      },
-      "indexes": {
-        "users_clerk_id_unique": {
-          "name": "users_clerk_id_unique",
-          "columns": [
-            "clerk_id"
-          ],
-          "isUnique": true
-        }
-      },
-      "foreignKeys": {},
-      "compositePrimaryKeys": {},
-      "uniqueConstraints": {}
-    }
-  },
-  "enums": {},
-  "_meta": {
-    "schemas": {},
-    "tables": {},
-    "columns": {}
-  }
-}
\ No newline at end of file
diff --git a/apps/api/drizzle/meta/_journal.json b/apps/api/drizzle/meta/_journal.json
deleted file mode 100644
index 3972bd1..0000000
--- a/apps/api/drizzle/meta/_journal.json
+++ /dev/null
@@ -1,20 +0,0 @@
-{
-  "version": "5",
-  "dialect": "sqlite",
-  "entries": [
-    {
-      "idx": 0,
-      "version": "5",
-      "when": 1735842325099,
-      "tag": "0000_medical_wraith",
-      "breakpoints": true
-    },
-    {
-      "idx": 1,
-      "version": "5",
-      "when": 1735855301121,
-      "tag": "0001_flashy_angel",
-      "breakpoints": true
-    }
-  ]
-}
\ No newline at end of file
diff --git a/apps/api/drizzle/migrations/meta/_journal.json b/apps/api/drizzle/migrations/meta/_journal.json
index e158b44..9218098 100644
--- a/apps/api/drizzle/migrations/meta/_journal.json
+++ b/apps/api/drizzle/migrations/meta/_journal.json
@@ -8,6 +8,41 @@
       "when": 1735937423353,
       "tag": "0000_massive_enchantress",
       "breakpoints": true
+    },
+    {
+      "idx": 1,
+      "version": "5",
+      "when": 1736356333278,
+      "tag": "0001_gray_morgan_stark",
+      "breakpoints": true
+    },
+    {
+      "idx": 2,
+      "version": "5",
+      "when": 1736356401556,
+      "tag": "0002_useful_proudstar",
+      "breakpoints": true
+    },
+    {
+      "idx": 3,
+      "version": "5",
+      "when": 1736356565993,
+      "tag": "0003_dashing_black_queen",
+      "breakpoints": true
+    },
+    {
+      "idx": 4,
+      "version": "5",
+      "when": 1736361797914,
+      "tag": "0004_nebulous_the_hand",
+      "breakpoints": true
+    },
+    {
+      "idx": 5,
+      "version": "5",
+      "when": 1736444808745,
+      "tag": "0005_lean_rockslide",
+      "breakpoints": true
     }
   ]
 }
\ No newline at end of file
diff --git a/apps/api/migrate-data.sh b/apps/api/migrate-data.sh
deleted file mode 100644
index 370280b..0000000
--- a/apps/api/migrate-data.sh
+++ /dev/null
@@ -1,7 +0,0 @@
-#!/bin/bash
-
-# Delete existing data from both tables
-echo "DELETE FROM users; DELETE FROM d1_migrations;" | turso db shell libsql://edgestack-elevraben.aws-us-east-1.turso.io
-
-# Extract and import only INSERT statements, excluding sqlite_sequence
-grep "^INSERT" d1-data.sql | grep -v "sqlite_sequence" | turso db shell libsql://edgestack-elevraben.aws-us-east-1.turso.io 
\ No newline at end of file
diff --git a/apps/api/package.json b/apps/api/package.json
index 1381694..180c0d8 100644
--- a/apps/api/package.json
+++ b/apps/api/package.json
@@ -5,30 +5,30 @@
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "scripts": {
-    "dev": "wrangler dev src/index.ts --env development --local",
-    "deploy": "wrangler deploy src/index.ts",
+    "dev": "wrangler dev --env development --local",
+    "deploy": "wrangler deploy",
     "build": "tsc --project tsconfig.build.json",
-    "db:generate": "drizzle-kit generate:sqlite",
-    "db:migrate": "drizzle-kit push:sqlite",
-    "db:push": "wrangler d1 execute admin-db --local --file=./drizzle/0000_chilly_surge.sql",
-    "db:studio": "drizzle-kit studio"
+    "db:generate": "drizzle-kit generate",
+    "db:migrate": "drizzle-kit migrate",
+    "db:studio": "drizzle-kit studio",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "typecheck": "tsc --noEmit"
   },
   "dependencies": {
     "@admin-cloudflare/api-types": "workspace:*",
     "@clerk/backend": "^1.21.4",
     "@clerk/clerk-sdk-node": "^5.1.4",
     "@hono/clerk-auth": "^2.0.0",
+    "@hono/swagger-ui": "0.2.1",
     "@hono/zod-openapi": "^0.18.3",
     "@hono/zod-validator": "^0.1.11",
     "@libsql/client": "^0.14.0",
-    "dotenv": "^16.4.7",
-    "dotenv-expand": "^12.0.1",
     "drizzle-orm": "^0.29.3",
     "drizzle-zod": "^0.5.1",
     "hono": "^4.6.15",
     "hono-pino": "^0.7.0",
     "pino": "^9.6.0",
-    "pino-pretty": "^13.0.0",
     "svix": "^1.45.1",
     "uuid": "^9.0.1",
     "web": "link:@libsql/client/web",
@@ -37,9 +37,10 @@
   "devDependencies": {
     "@cloudflare/workers-types": "^4.20231218.0",
     "@types/uuid": "^9.0.7",
-    "drizzle-kit": "^0.20.9",
+    "drizzle-kit": "^0.20.18",
+    "pino-pretty": "^13.0.0",
     "tsx": "^4.19.2",
     "typescript": "^5.0.0",
-    "wrangler": "^3.99.0"
+    "wrangler": "^3.100.0"
   }
 }
diff --git a/apps/api/src/.env.example b/apps/api/src/.env.example
deleted file mode 100644
index 5254925..0000000
--- a/apps/api/src/.env.example
+++ /dev/null
@@ -1,12 +0,0 @@
-# Environment
-NODE_ENV=development
-LOG_LEVEL=debug
-API_VERSION=1.0.0
-
-# Database
-DATABASE_URL=
-DATABASE_AUTH_TOKEN=
-
-# Authentication
-CLERK_PUBLISHABLE_KEY=
-CLERK_SECRET_KEY= 
\ No newline at end of file
diff --git a/apps/api/src/db/config.ts b/apps/api/src/db/config.ts
index e0ebdb5..b11f234 100644
--- a/apps/api/src/db/config.ts
+++ b/apps/api/src/db/config.ts
@@ -1,16 +1,49 @@
 import { createClient } from '@libsql/client'
-import { drizzle } from 'drizzle-orm/libsql'
-import * as schema from './schema'
-import type { RuntimeEnv } from '../env'
+import type { Client } from '@libsql/client'
+import type { HonoContext } from '../types'
 
-export function getDatabaseClient(env: RuntimeEnv) {
-  const client = createClient({
-    url: env.TURSO_DATABASE_URL,
-    authToken: env.TURSO_AUTH_TOKEN,
-  })
+export async function createDatabase(context: HonoContext): Promise<Client> {
+  if (!context.env.TURSO_DATABASE_URL) {
+    throw new Error('TURSO_DATABASE_URL is required')
+  }
+  if (!context.env.TURSO_AUTH_TOKEN) {
+    throw new Error('TURSO_AUTH_TOKEN is required')
+  }
 
-  return drizzle(client, { schema })
-}
+  try {
+    // Try libSQL protocol first
+    const libsqlUrl = context.env.TURSO_DATABASE_URL
+    console.log('Trying libSQL connection:', {
+      url: libsqlUrl.split('://')[0] + '://' + libsqlUrl.split('://')[1]?.split('.')[0] + '...'
+    })
+    
+    try {
+      const libsqlClient = createClient({ 
+        url: libsqlUrl,
+        authToken: context.env.TURSO_AUTH_TOKEN
+      })
+      await libsqlClient.execute('SELECT 1')
+      console.log('libSQL connection successful')
+      return libsqlClient
+    } catch (libsqlError) {
+      console.log('libSQL connection failed:', libsqlError)
 
-// Export database type
-export type Database = ReturnType<typeof getDatabaseClient> 
\ No newline at end of file
+      // Try HTTP protocol
+      const httpUrl = libsqlUrl.replace('libsql://', 'https://')
+      console.log('Trying HTTP connection:', {
+        url: httpUrl.split('://')[0] + '://' + httpUrl.split('://')[1]?.split('.')[0] + '...'
+      })
+
+      const httpClient = createClient({ 
+        url: httpUrl,
+        authToken: context.env.TURSO_AUTH_TOKEN
+      })
+      await httpClient.execute('SELECT 1')
+      console.log('HTTP connection successful')
+      return httpClient
+    }
+  } catch (error) {
+    console.error('Failed to create database client:', error)
+    throw error
+  }
+} 
\ No newline at end of file
diff --git a/apps/api/src/db/index.ts b/apps/api/src/db/index.ts
index c6b191d..298abdf 100644
--- a/apps/api/src/db/index.ts
+++ b/apps/api/src/db/index.ts
@@ -1,13 +1,2 @@
-import type { Hono } from 'hono'
-import type { RuntimeEnv } from '../env'
-
-// Re-export database type
-export type { Database } from './config'
-
-// Export context type with updated database
-export type AppContext = {
-  Bindings: RuntimeEnv
-  Variables: {
-    userId: string
-  }
-}
+export * from './services'
+export * from './config'
diff --git a/apps/api/src/db/migrations/index.ts b/apps/api/src/db/migrations/index.ts
index 6bd0438..4889ac3 100644
--- a/apps/api/src/db/migrations/index.ts
+++ b/apps/api/src/db/migrations/index.ts
@@ -1,43 +1,47 @@
+import { LibSQLDatabase } from 'drizzle-orm/libsql'
+import { sql } from 'drizzle-orm'
 import * as createUsers from './0001_create_users'
+import * as createOrganizations from './0002_organizations'
 
 // List of migrations in order
 const migrations = [
   createUsers,
+  createOrganizations,
 ] as const
 
 // Migration metadata table
 const MIGRATION_TABLE = 'migrations'
 
 // Initialize migrations table
-async function initMigrationTable(db: D1Database) {
-  await db.prepare(`
+async function initMigrationTable(db: LibSQLDatabase) {
+  await db.run(sql`
     CREATE TABLE IF NOT EXISTS ${MIGRATION_TABLE} (
       id INTEGER PRIMARY KEY AUTOINCREMENT,
       name TEXT NOT NULL UNIQUE,
       applied_at TEXT NOT NULL
     )
-  `).run()
+  `)
 }
 
 // Get applied migrations
-async function getAppliedMigrations(db: D1Database): Promise<string[]> {
-  const result = await db.prepare(`
-    SELECT name FROM ${MIGRATION_TABLE} ORDER BY id ASC
-  `).all<{ name: string }>()
+async function getAppliedMigrations(db: LibSQLDatabase): Promise<string[]> {
+  const result = await db.select({ name: sql<string>`name` })
+    .from(sql.raw(MIGRATION_TABLE))
+    .orderBy(sql`id ASC`)
   
-  return result.results?.map(row => row.name) || []
+  return result.map(row => row.name)
 }
 
 // Apply a single migration
-async function applyMigration(db: D1Database, migration: typeof migrations[number], name: string) {
+async function applyMigration(db: LibSQLDatabase, migration: typeof migrations[number], name: string) {
   console.log(`Applying migration: ${name}`)
   
   try {
     await migration.up(db)
-    await db.prepare(`
+    await db.run(sql`
       INSERT INTO ${MIGRATION_TABLE} (name, applied_at)
-      VALUES (?, ?)
-    `).bind(name, new Date().toISOString()).run()
+      VALUES (${name}, ${new Date().toISOString()})
+    `)
     
     console.log(`Successfully applied migration: ${name}`)
   } catch (error) {
@@ -47,15 +51,15 @@ async function applyMigration(db: D1Database, migration: typeof migrations[numbe
 }
 
 // Revert a single migration
-async function revertMigration(db: D1Database, migration: typeof migrations[number], name: string) {
+async function revertMigration(db: LibSQLDatabase, migration: typeof migrations[number], name: string) {
   console.log(`Reverting migration: ${name}`)
   
   try {
     await migration.down(db)
-    await db.prepare(`
+    await db.run(sql`
       DELETE FROM ${MIGRATION_TABLE}
-      WHERE name = ?
-    `).bind(name).run()
+      WHERE name = ${name}
+    `)
     
     console.log(`Successfully reverted migration: ${name}`)
   } catch (error) {
@@ -65,7 +69,7 @@ async function revertMigration(db: D1Database, migration: typeof migrations[numb
 }
 
 // Run all pending migrations
-export async function migrate(db: D1Database) {
+export async function migrate(db: LibSQLDatabase) {
   console.log('Starting migrations...')
   
   // Initialize migrations table
@@ -88,7 +92,7 @@ export async function migrate(db: D1Database) {
 }
 
 // Revert all migrations
-export async function revertAll(db: D1Database) {
+export async function revertAll(db: LibSQLDatabase) {
   console.log('Reverting all migrations...')
   
   // Get applied migrations
diff --git a/apps/api/src/db/schema.ts b/apps/api/src/db/schema.ts
deleted file mode 100644
index bce4fb5..0000000
--- a/apps/api/src/db/schema.ts
+++ /dev/null
@@ -1,65 +0,0 @@
-import { sqliteTable, text, integer } from 'drizzle-orm/sqlite-core'
-import { sql } from 'drizzle-orm'
-import { createInsertSchema, createSelectSchema } from 'drizzle-zod'
-import { z } from 'zod'
-import { getCurrentTimestamp } from './utils'
-
-// Define user roles and status as string literals
-export const UserRole = {
-  SUPERADMIN: 'superadmin',
-  ADMIN: 'admin',
-  MANAGER: 'manager',
-  CASHIER: 'cashier',
-} as const
-
-export type UserRoleType = typeof UserRole[keyof typeof UserRole]
-
-export const UserStatus = {
-  ACTIVE: 'active',
-  INACTIVE: 'inactive',
-  INVITED: 'invited',
-  SUSPENDED: 'suspended',
-} as const
-
-export type UserStatusType = typeof UserStatus[keyof typeof UserStatus]
-
-// Create the users table
-export const users = sqliteTable('users', {
-  id: text('id').primaryKey(),
-  clerkId: text('clerk_id').unique(),
-  email: text('email').notNull(),
-  firstName: text('first_name').notNull(),
-  lastName: text('last_name').notNull(),
-  role: text('role', { enum: ['superadmin', 'admin', 'manager', 'cashier'] }).notNull().default('cashier'),
-  status: text('status', { enum: ['active', 'inactive', 'invited', 'suspended'] }).notNull().default('active'),
-  syncStatus: text('sync_status', { enum: ['synced', 'pending', 'failed'] }).notNull().default('pending'),
-  lastSyncAttempt: text('last_sync_attempt'),
-  syncError: text('sync_error'),
-  createdAt: text('created_at').notNull().default(sql`CURRENT_TIMESTAMP`),
-  updatedAt: text('updated_at').notNull().default(sql`CURRENT_TIMESTAMP`),
-})
-
-// Migrations table
-export const migrations = sqliteTable('migrations', {
-  id: integer('id').primaryKey({ autoIncrement: true }),
-  name: text('name').notNull().unique(),
-  appliedAt: text('applied_at').notNull(),
-})
-
-// Create Zod schemas for validation
-export const insertUserSchema = createInsertSchema(users, {
-  email: z.string().email(),
-  firstName: z.string().min(2),
-  lastName: z.string().min(2),
-  role: z.enum(['superadmin', 'admin', 'manager', 'cashier'] as const),
-  status: z.enum(['active', 'inactive', 'invited', 'suspended'] as const),
-})
-
-export const selectUserSchema = createSelectSchema(users)
-
-export const updateUserSchema = insertUserSchema.partial()
-
-// Types
-export type User = typeof users.$inferSelect
-export type NewUser = typeof users.$inferInsert
-export type Migration = typeof migrations.$inferSelect
diff --git a/apps/api/src/db/seed.ts b/apps/api/src/db/seed.ts
deleted file mode 100644
index 0519ecb..0000000
--- a/apps/api/src/db/seed.ts
+++ /dev/null
@@ -1 +0,0 @@
- 
\ No newline at end of file
diff --git a/apps/api/src/db/utils.ts b/apps/api/src/db/utils.ts
index 4d15491..d982846 100644
--- a/apps/api/src/db/utils.ts
+++ b/apps/api/src/db/utils.ts
@@ -1,6 +1,6 @@
 import { eq, and, desc, asc, sql, type SQL } from 'drizzle-orm'
 import type { Context } from 'hono'
-import type { AppContext } from '.'
+import type { AppContext } from '../types'
 import type { SQLiteTableWithColumns } from 'drizzle-orm/sqlite-core'
 
 // Pagination types
@@ -114,8 +114,5 @@ export function getCurrentTimestamp(): string {
 
 // Helper to get database instance from context
 export function getDBFromContext(c: Context<AppContext>) {
-  if (!c.env.db) {
-    throw new Error('Turso database instance not found')
-  }
   return c.env.db
 } 
\ No newline at end of file
diff --git a/apps/api/src/env.ts b/apps/api/src/env.ts
index d17ba34..e29cbeb 100644
--- a/apps/api/src/env.ts
+++ b/apps/api/src/env.ts
@@ -1,17 +1,52 @@
-import type { LibSQLDatabase } from 'drizzle-orm/libsql'
-import type { User } from '@clerk/backend'
-import type { MiddlewareHandler } from 'hono'
-import * as schema from './db/schema'
+import { z } from 'zod'
+import type { Bindings } from './types'
+import type { Logger } from './lib/logger'
+import type { Client } from '@libsql/client'
 
-export interface RuntimeEnv {
-  ENVIRONMENT: string
-  CLERK_PUBLISHABLE_KEY: string
-  CLERK_SECRET_KEY: string
-  TURSO_DATABASE_URL: string
-  TURSO_AUTH_TOKEN: string
-  WEBHOOK_SECRET: string
-  CLERK_WEBHOOK_SECRET: string
-  db: LibSQLDatabase<typeof schema>
-  logger: MiddlewareHandler
-  clerk: { users: { getUser: (id: string) => Promise<User> } }
+const envSchema = z.object({
+  // Database
+  TURSO_DATABASE_URL: z.string(),
+  TURSO_AUTH_TOKEN: z.string(),
+  TURSO_ORG_GROUP: z.string(),
+  TURSO_ORG_TOKEN: z.string(),
+
+  // Clerk
+  CLERK_SECRET_KEY: z.string(),
+  CLERK_WEBHOOK_SECRET: z.string(),
+
+  // Cloudflare (only required in production)
+  CLOUDFLARE_API_TOKEN: z.string().optional(),
+  CLOUDFLARE_ACCOUNT_ID: z.string().optional(),
+
+  // Misc
+  ENVIRONMENT: z.enum(['development', 'production', 'test']).default('development'),
+}).transform(env => {
+  // In production, ensure Cloudflare credentials are present
+  if (env.ENVIRONMENT === 'production') {
+    if (!env.CLOUDFLARE_API_TOKEN || !env.CLOUDFLARE_ACCOUNT_ID) {
+      throw new Error('Cloudflare credentials are required in production')
+    }
+  }
+  return env
+})
+
+export type EnvSchema = z.infer<typeof envSchema>
+export type RuntimeEnv = EnvSchema & { db: Client, logger: Logger }
+
+export function loadEnv(env: Record<string, string | undefined>): EnvSchema {
+  const result = envSchema.safeParse(env)
+  if (!result.success) {
+    const formatted = JSON.stringify(result.error.format(), null, 4)
+    throw new Error(`Invalid environment variables: ${formatted}`)
+  }
+  
+  return result.data
+}
+
+// Helper to create full environment with runtime bindings
+export function createEnv(env: EnvSchema, runtime: { db: Client, logger: Logger }): Bindings {
+  return {
+    ...env,
+    ...runtime
+  }
 } 
\ No newline at end of file
diff --git a/apps/api/src/index.ts b/apps/api/src/index.ts
index 594034b..a0646d4 100644
--- a/apps/api/src/index.ts
+++ b/apps/api/src/index.ts
@@ -1,36 +1,125 @@
 import { Hono } from 'hono'
 import { cors } from 'hono/cors'
-import { logger } from 'hono-pino'
-import { clerkMiddleware } from '@hono/clerk-auth'
+import { prettyJSON } from 'hono/pretty-json'
+import { secureHeaders } from 'hono/secure-headers'
+import { swaggerUI } from '@hono/swagger-ui/dist'
+import webhooksRouter from './routes/webhooks/clerk'
+import organizationsRouter from './routes/organizations'
 import { errorHandler } from './middleware/error'
-import { authMiddleware } from './middleware/auth'
-import usersRouter from './routes/users'
-import testRouter from './routes/test'
-import webhooks from './routes/webhooks/clerk'
-import type { AppContext } from './db'
-import { getDatabaseClient } from './db/config'
+import type { AppBindings, Variables } from './types'
+import pino from 'pino'
+import { loadEnv, createEnv } from './env'
+import { createDatabase } from './db/config'
+import { OpenAPIHono } from '@hono/zod-openapi'
 
-const app = new Hono<AppContext>()
+// Create app with proper typing
+const app = new OpenAPIHono<{ Bindings: AppBindings; Variables: Variables }>()
 
-// Add middleware (order is important)
+// Global middleware
+app.use('*', prettyJSON())
+app.use('*', secureHeaders())
 app.use('*', cors())
-app.use('*', logger())
-app.use('*', async (c, next) => {
-  // Initialize database
-  c.env.db = getDatabaseClient(c.env)
-  await next()
+app.use('*', errorHandler)
+
+// OpenAPI documentation
+app.doc('/api/docs', {
+  openapi: '3.0.0',
+  info: {
+    title: 'Admin API',
+    version: '1.0.0',
+    description: 'API for managing organizations, users, and webhooks'
+  },
+  servers: [
+    {
+      url: '/api',
+      description: 'API server'
+    }
+  ]
 })
 
-// Mount webhook routes before auth middleware
-app.route('/api/webhooks/clerk', webhooks)
+// Serve Swagger UI
+app.get('/api/swagger', swaggerUI({ url: '/api/docs' }))
 
-// Add auth middleware
-app.use('*', clerkMiddleware())
-app.use('*', authMiddleware)
-app.use('*', errorHandler)
+// Initialize environment and database
+app.use('*', async (c, next) => {
+  try {
+    // Load environment variables from bindings
+    const envVars: Record<string, string | undefined> = {
+      TURSO_DATABASE_URL: c.env.TURSO_DATABASE_URL,
+      TURSO_AUTH_TOKEN: c.env.TURSO_AUTH_TOKEN,
+      TURSO_ORG_GROUP: c.env.TURSO_ORG_GROUP,
+      TURSO_ORG_TOKEN: c.env.TURSO_ORG_TOKEN,
+      CLERK_SECRET_KEY: c.env.CLERK_SECRET_KEY,
+      CLERK_WEBHOOK_SECRET: c.env.CLERK_WEBHOOK_SECRET,
+      CLOUDFLARE_API_TOKEN: c.env.CLOUDFLARE_API_TOKEN,
+      CLOUDFLARE_ACCOUNT_ID: c.env.CLOUDFLARE_ACCOUNT_ID,
+      ENVIRONMENT: c.env.ENVIRONMENT
+    }
+
+    console.log('Environment variables loaded:', {
+      TURSO_DATABASE_URL: envVars.TURSO_DATABASE_URL?.substring(0, 20) + '...',
+      TURSO_AUTH_TOKEN: envVars.TURSO_AUTH_TOKEN?.substring(0, 5) + '...',
+      TURSO_ORG_GROUP: envVars.TURSO_ORG_GROUP,
+      TURSO_ORG_TOKEN: envVars.TURSO_ORG_TOKEN?.substring(0, 5) + '...'
+    })
+
+    const envSchema = loadEnv(envVars)
+    
+    // Configure logger
+    const pinoLogger = pino({
+      level: envSchema.ENVIRONMENT === 'development' ? 'debug' : 'info',
+      transport: {
+        target: 'pino-pretty'
+      }
+    })
 
-// Mount authenticated routes
-app.route('/api/users', usersRouter)
-app.route('/api/test', testRouter)
+    // Set environment first
+    const env: AppBindings = {
+      ...envSchema,
+      db: undefined!,
+      logger: pinoLogger
+    }
+    c.env = env
+
+    // Then create database with updated context
+    console.log('Creating database connection with:', {
+      url: c.env.TURSO_DATABASE_URL?.substring(0, 20) + '...',
+      hasAuthToken: !!c.env.TURSO_AUTH_TOKEN
+    })
+    const db = await createDatabase(c)
+    c.env.db = db
+    console.log('Database connection created')
+
+    await next()
+  } catch (error) {
+    console.error('Failed to initialize environment:', error)
+    throw error
+  }
+})
+
+// Mount routes
+app.route('/api/organizations', organizationsRouter)
+app.route('/api/webhooks/clerk', webhooksRouter)
+
+// Health check endpoint
+app.get('/api/health', async (c) => {
+  try {
+    console.log('Testing database connection...')
+    await c.env.db.execute('SELECT 1')
+    console.log('Database query successful')
+    return c.json({ status: 'healthy', database: 'connected' })
+  } catch (error) {
+    console.error('Database health check failed:', {
+      error: error instanceof Error ? error.message : 'Unknown error',
+      stack: error instanceof Error ? error.stack : undefined
+    })
+    c.status(500)
+    return c.json({ 
+      status: 'unhealthy', 
+      database: 'disconnected',
+      error: error instanceof Error ? error.message : 'Unknown error'
+    })
+  }
+})
 
 export default app
diff --git a/apps/api/src/lib/clerk.ts b/apps/api/src/lib/clerk.ts
index 2a15cfc..1db019c 100644
--- a/apps/api/src/lib/clerk.ts
+++ b/apps/api/src/lib/clerk.ts
@@ -1,135 +1,117 @@
-import type { User } from '../db/schema'
-import { eq } from 'drizzle-orm'
-import { users } from '../db/schema'
-import type { LibSQLDatabase } from 'drizzle-orm/libsql'
-import type { Context } from 'hono'
-import type { AppContext } from '../db'
-import type * as schema from '../db/schema'
+import type { User } from '../db/schema/users'
+import { generateId } from './utils'
+import { getCurrentTimestamp } from '../db/utils'
+import type { HonoContext } from '../types'
+import { createDatabase } from '../db/config'
 
-interface CreateClerkUserParams {
-  email: string
-  firstName: string
-  lastName: string
-  password?: string
-}
-
-export async function createClerkUser(c: Context<AppContext>, params: CreateClerkUserParams) {
-  try {
-    const clerk = c.get('clerk')
-    const user = await clerk.users.createUser({
-      emailAddress: [params.email],
-      firstName: params.firstName,
-      lastName: params.lastName,
-      password: params.password,
-      skipPasswordRequirement: true,
-      skipPasswordChecks: true,
-    })
-    return user
-  } catch (error) {
-    console.error('Failed to create Clerk user:', error)
-    throw error
+export interface ClerkWebhookEvent {
+  data: {
+    id: string
+    first_name?: string
+    last_name?: string
+    email_addresses?: Array<{
+      email_address: string
+      id: string
+    }>
+    created_at: number
+    updated_at: number
+    public_metadata?: Record<string, unknown>
   }
+  object: 'event'
+  type: string
 }
 
-export async function listClerkUsers(c: Context<AppContext>) {
-  try {
-    const clerk = c.get('clerk')
-    const PAGE_SIZE = 10
-    let allUsers: Array<Awaited<ReturnType<typeof clerk.users.getUser>>> = []
-    let pageNumber = 0
-    let hasMore = true
-
-    console.log('Starting to fetch all Clerk users...')
-    
-    while (hasMore) {
-      console.log(`Fetching page ${pageNumber + 1} of Clerk users...`)
-      const response = await clerk.users.getUserList({
-        limit: PAGE_SIZE,
-        offset: pageNumber * PAGE_SIZE,
-      })
-      
-      if (response.data.length === 0) {
-        hasMore = false
-      } else {
-        allUsers = [...allUsers, ...response.data]
-        pageNumber++
-        console.log(`Fetched ${response.data.length} users (total: ${allUsers.length})`)
-        
-        // If we got fewer users than the page size, we've reached the end
-        if (response.data.length < PAGE_SIZE) {
-          hasMore = false
-        }
-      }
-    }
-
-    console.log(`Completed fetching all Clerk users. Total: ${allUsers.length}`)
-    return { data: allUsers }
-  } catch (error) {
-    console.error('Failed to list Clerk users:', error)
-    throw error
+function rowToUser(row: Record<string, any>): User {
+  return {
+    id: row.id,
+    clerkId: row.clerk_id,
+    email: row.email,
+    firstName: row.first_name,
+    lastName: row.last_name,
+    imageUrl: row.image_url,
+    role: row.role,
+    status: row.status,
+    syncStatus: row.sync_status,
+    lastSyncAttempt: row.last_sync_attempt,
+    syncError: row.sync_error,
+    metadata: row.metadata,
+    createdAt: row.created_at,
+    updatedAt: row.updated_at
   }
 }
 
-export async function syncUserToClerk(
-  c: Context<AppContext>, 
-  db: LibSQLDatabase<typeof schema>,
-  dbUser: User
-) {
-  try {
-    // Skip if already synced
-    if (dbUser.clerkId) {
-      console.log(`User ${dbUser.id} already synced with Clerk ID ${dbUser.clerkId}`)
-      return dbUser
-    }
+export async function syncUser(
+  context: HonoContext,
+  event: ClerkWebhookEvent
+): Promise<User> {
+  const data = event.data
+  const email = data.email_addresses?.[0]?.email_address
 
-    // Get list of Clerk users to check for existing user
-    const { data: clerkUsers } = await listClerkUsers(c)
-    const existingClerkUser = clerkUsers.find(
-      clerkUser => clerkUser.emailAddresses.some(
-        emailObj => emailObj.emailAddress === dbUser.email
-      )
-    )
+  if (!email) {
+    throw new Error('User has no email address')
+  }
 
-    if (!existingClerkUser) {
-      throw new Error('No matching Clerk user found. Cannot create new users due to quota limit.')
-    }
+  const db = await createDatabase(context)
 
-    // Use existing Clerk user
-    console.log(`Found existing Clerk user for ${dbUser.email}`)
-    const clerkUserId = existingClerkUser.id
+  // Check if user exists
+  const existingResult = await db.execute({
+    sql: 'SELECT * FROM users WHERE clerk_id = ? LIMIT 1',
+    args: [data.id]
+  })
+  const existingUser = existingResult.rows[0] ? rowToUser(existingResult.rows[0] as Record<string, any>) : undefined
 
-    // Update D1 user with Clerk ID
-    const updatedUser = await db
-      .update(users)
-      .set({ clerkId: clerkUserId })
-      .where(eq(users.id, dbUser.id))
-      .returning()
-      .get()
+  if (existingUser) {
+    // Update user
+    const result = await db.execute({
+      sql: `
+        UPDATE users 
+        SET 
+          first_name = ?,
+          last_name = ?,
+          email = ?,
+          sync_status = 'synced',
+          last_sync_attempt = ?,
+          updated_at = ?
+        WHERE id = ?
+        RETURNING *
+      `,
+      args: [
+        data.first_name || existingUser.firstName,
+        data.last_name || existingUser.lastName,
+        email,
+        getCurrentTimestamp(),
+        getCurrentTimestamp(),
+        existingUser.id
+      ]
+    })
 
-    console.log(`Synced user ${dbUser.id} with Clerk ID ${clerkUserId}`)
-    return updatedUser
-  } catch (error) {
-    console.error(`Failed to sync user ${dbUser.id} to Clerk:`, error)
-    throw error
+    return rowToUser(result.rows[0] as Record<string, any>)
   }
-}
 
-export async function getClerkUser(c: Context<AppContext>, clerkId: string) {
-  try {
-    const clerk = c.get('clerk')
-    return await clerk.users.getUser(clerkId)
-  } catch (error) {
-    console.error('Failed to get Clerk user:', error)
-    throw error
-  }
-}
+  // Create new user
+  const result = await db.execute({
+    sql: `
+      INSERT INTO users (
+        id, clerk_id, first_name, last_name, email,
+        role, status, sync_status, last_sync_attempt,
+        created_at, updated_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      RETURNING *
+    `,
+    args: [
+      generateId(),
+      data.id,
+      data.first_name || '',
+      data.last_name || '',
+      email,
+      'cashier',
+      'active',
+      'synced',
+      getCurrentTimestamp(),
+      getCurrentTimestamp(),
+      getCurrentTimestamp()
+    ]
+  })
 
-export async function deleteClerkUser(c: Context<AppContext>, clerkId: string) {
-  try {
-    const clerk = c.get('clerk')
-    await clerk.users.deleteUser(clerkId)
-  } catch (error) {
-    console.error('Failed to delete Clerk user:', error)
-    throw error
-  }
+  return rowToUser(result.rows[0] as Record<string, any>)
 } 
\ No newline at end of file
diff --git a/apps/api/src/lib/create-app.ts b/apps/api/src/lib/create-app.ts
index 973d272..bae1172 100644
--- a/apps/api/src/lib/create-app.ts
+++ b/apps/api/src/lib/create-app.ts
@@ -3,14 +3,14 @@ import { cors } from 'hono/cors'
 import { prettyJSON } from 'hono/pretty-json'
 import { timing } from 'hono/timing'
 import type { Context, Next } from 'hono'
-import type { Bindings } from '../db'
+import type { RuntimeEnv } from '../env'
 import { errorHandler } from '../middleware/error'
 import { logging, requestTiming } from '../middleware/logging'
 import { authMiddleware } from '../middleware/auth'
 import { versionMiddleware } from '../middleware/version'
 
 export const createApp = () => {
-  const app = new OpenAPIHono<{ Bindings: Bindings }>()
+  const app = new OpenAPIHono<{ Bindings: RuntimeEnv }>()
 
   // Add global middleware
   app.use('*', cors())
@@ -22,7 +22,7 @@ export const createApp = () => {
   
   // Debug middleware to log all requests
   app.use('*', async (c, next) => {
-    console.log('📥 Incoming request:', {
+    c.env.logger.debug('📥 Incoming request', {
       method: c.req.method,
       path: c.req.path,
       headers: Object.fromEntries(c.req.raw.headers.entries())
@@ -38,7 +38,7 @@ export const createApp = () => {
 
   // Not found handler
   app.notFound((c) => {
-    console.log('❌ Route not found:', c.req.path)
+    c.env.logger.warn('❌ Route not found', { path: c.req.path })
     return c.json({
       error: {
         code: 'NOT_FOUND',
diff --git a/apps/api/src/lib/create-router.ts b/apps/api/src/lib/create-router.ts
index 32cf949..f8cf8f3 100644
--- a/apps/api/src/lib/create-router.ts
+++ b/apps/api/src/lib/create-router.ts
@@ -1,16 +1,6 @@
+import type { AppContext } from '../types'
 import { OpenAPIHono } from '@hono/zod-openapi'
-import type { AppContext } from '../db'
 
-export const createRouter = (version: string = 'v1') => {
-  const router = new OpenAPIHono<AppContext>()
-  
-  // Add version-specific middleware here if needed
-  router.use('*', async (c, next) => {
-    await next()
-    c.header('X-API-Route-Version', version)
-  })
+const router = new OpenAPIHono<AppContext>()
 
-  return router
-}
-
-export type Router = ReturnType<typeof createRouter> 
\ No newline at end of file
+export default router 
\ No newline at end of file
diff --git a/apps/api/src/lib/errors.ts b/apps/api/src/lib/errors.ts
index e844c28..f961ccc 100644
--- a/apps/api/src/lib/errors.ts
+++ b/apps/api/src/lib/errors.ts
@@ -30,6 +30,17 @@ export class BadRequestError extends APIError {
   }
 }
 
+export class DatabaseError extends Error {
+  constructor(
+    message: string,
+    public details: unknown = null,
+    public code: string = 'DATABASE_ERROR'
+  ) {
+    super(message)
+    this.name = 'DatabaseError'
+  }
+}
+
 // Error factories
 export const notFound = (resource: string) => {
   throw new NotFoundError(resource)
diff --git a/apps/api/src/lib/logger.ts b/apps/api/src/lib/logger.ts
index caef284..8a6001f 100644
--- a/apps/api/src/lib/logger.ts
+++ b/apps/api/src/lib/logger.ts
@@ -1,8 +1,8 @@
 export interface Logger {
-  debug(message: string, context?: Record<string, unknown>): void
-  info(message: string, context?: Record<string, unknown>): void
-  warn(message: string, context?: Record<string, unknown>): void
   error(message: string, context?: Record<string, unknown>): void
+  warn(message: string, context?: Record<string, unknown>): void
+  info(message: string, context?: Record<string, unknown>): void
+  debug(message: string, context?: Record<string, unknown>): void
 }
 
 export class ConsoleLogger implements Logger {
diff --git a/apps/api/src/lib/response.ts b/apps/api/src/lib/response.ts
index 1f03385..b5379b4 100644
--- a/apps/api/src/lib/response.ts
+++ b/apps/api/src/lib/response.ts
@@ -1,11 +1,9 @@
 import type { Context } from 'hono'
-import type { AppContext } from '../db'
+import type { AppContext } from '../types'
 
-export type APIResponse<T> = {
+export interface APIResponse<T> {
   data: T
-  meta: {
-    timestamp: string
-  }
+  meta?: Record<string, unknown>
 }
 
 export const wrapResponse = <T>(c: Context<AppContext>, data: T): APIResponse<T> => ({
@@ -15,22 +13,16 @@ export const wrapResponse = <T>(c: Context<AppContext>, data: T): APIResponse<T>
   }
 })
 
-export const wrapPaginatedResponse = <T>(
+export const wrapError = (
   c: Context<AppContext>,
-  data: T[],
-  total: number,
-  nextCursor?: string
-): APIResponse<{
-  items: T[]
-  total: number
-  nextCursor?: string
-}> => ({
+  error: Error,
+  status: number = 500
+): APIResponse<{ message: string }> => ({
   data: {
-    items: data,
-    total,
-    nextCursor
+    message: error.message
   },
   meta: {
-    timestamp: new Date().toISOString()
+    timestamp: new Date().toISOString(),
+    status
   }
 }) 
\ No newline at end of file
diff --git a/apps/api/src/lib/utils.ts b/apps/api/src/lib/utils.ts
index 4e5f60a..ed88250 100644
--- a/apps/api/src/lib/utils.ts
+++ b/apps/api/src/lib/utils.ts
@@ -10,4 +10,18 @@ export function generateId(): string {
     result += chars[bytes[i] % chars.length]
   }
   return result
+}
+
+/**
+ * Generate a URL-friendly slug from a string
+ * @param str The string to convert to a slug
+ * @returns A URL-friendly slug
+ */
+export function generateSlug(str: string): string {
+  return str
+    .toLowerCase()
+    .trim()
+    .replace(/[^\w\s-]/g, '') // Remove all non-word chars
+    .replace(/[\s_-]+/g, '-') // Replace spaces and _ with -
+    .replace(/^-+|-+$/g, '') // Remove leading/trailing -
 } 
\ No newline at end of file
diff --git a/apps/api/src/middleware/auth.ts b/apps/api/src/middleware/auth.ts
index faef2ec..41f8c69 100644
--- a/apps/api/src/middleware/auth.ts
+++ b/apps/api/src/middleware/auth.ts
@@ -1,6 +1,6 @@
 import { getAuth } from '@hono/clerk-auth'
 import { Context, Next } from 'hono'
-import { AppContext } from '../db'
+import type { AppContext, OrganizationContext } from '../types'
 
 // Middleware to handle session checks and logging
 export const authMiddleware = async (c: Context<AppContext>, next: Next) => {
@@ -13,12 +13,20 @@ export const authMiddleware = async (c: Context<AppContext>, next: Next) => {
       }, 401)
     }
 
+    // Set user ID in variables
     c.set('userId', auth.userId)
+
+    // Set organization context if present in session
+    if (auth.orgId) {
+      c.set('organizationId', auth.orgId)
+    }
+
     await next()
-  } catch (err) {
-    return c.json({
-      error: 'Unauthorized', 
-      message: err instanceof Error ? err.message : 'Authentication failed'
+    return
+  } catch (error) {
+    return c.json({ 
+      error: 'Unauthorized',
+      message: 'Failed to authenticate request'
     }, 401)
   }
 } 
\ No newline at end of file
diff --git a/apps/api/src/middleware/error.ts b/apps/api/src/middleware/error.ts
index 745f841..a976f70 100644
--- a/apps/api/src/middleware/error.ts
+++ b/apps/api/src/middleware/error.ts
@@ -1,117 +1,95 @@
-import { Context, Next } from 'hono'
-import { HTTPException } from 'hono/http-exception'
-import { ZodError } from 'zod'
-import type { AppContext } from '../db'
+import type { Next } from 'hono'
+import { DatabaseError, APIError } from '../lib/errors'
+import type { HonoContext } from '../types'
+import { generateId } from '../lib/utils'
+import { ErrorCode } from '../schemas/errors'
 
-// Valid HTTP status codes for responses
-type StatusCode = 200 | 201 | 400 | 401 | 403 | 404 | 500
+interface ErrorResponse {
+  code: keyof typeof ErrorCode
+  message: string
+  details?: unknown
+  requestId?: string
+  statusCode: number
+}
 
-export class APIError extends Error {
-  constructor(
-    message: string,
-    public statusCode: StatusCode = 500,
-    public code: string = 'INTERNAL_SERVER_ERROR',
-    public details?: unknown
-  ) {
-    super(message)
-    this.name = 'APIError'
+function formatError(error: unknown): ErrorResponse {
+  if (error instanceof APIError) {
+    return {
+      code: error.code as keyof typeof ErrorCode,
+      message: error.message,
+      details: error.details,
+      statusCode: error.statusCode
+    }
   }
-}
 
-type ErrorResponse = {
-  error: {
-    code: string
-    message: string
-    details?: unknown
-    stack?: string
+  if (error instanceof DatabaseError) {
+    return {
+      code: 'INTERNAL_SERVER_ERROR',
+      message: 'Database operation failed',
+      details: {
+        error: error.message,
+        code: error.code,
+        details: error.details
+      },
+      statusCode: 500
+    }
   }
-  meta: {
-    timestamp: string
+
+  // Default error response
+  return {
+    code: 'INTERNAL_SERVER_ERROR',
+    message: error instanceof Error ? error.message : 'An unexpected error occurred',
+    statusCode: 500
   }
 }
 
-export const errorHandler = async (c: Context<AppContext>, next: Next) => {
-  const requestId = crypto.randomUUID().split('-')[0]
+export const errorHandler = async (c: HonoContext, next: Next) => {
+  const requestId = generateId()
+  // Store requestId in a header instead of context
+  c.header('X-Request-ID', requestId)
 
   try {
     await next()
+    return
   } catch (error) {
-    c.env.logger.error('Request error', { requestId, error })
-
-    const response: ErrorResponse = {
-      error: {
-        code: 'INTERNAL_SERVER_ERROR',
-        message: 'An unexpected error occurred',
-        ...(c.env.ENVIRONMENT === 'development' && { stack: (error as Error).stack })
-      },
-      meta: {
-        timestamp: new Date().toISOString()
-      }
-    }
-
-    // Handle different types of errors
-    if (error instanceof APIError) {
-      c.env.logger.error('API error', { 
-        requestId,
-        code: error.code,
-        message: error.message,
-        details: error.details
-      })
-      response.error = {
-        code: error.code,
-        message: error.message,
-        details: error.details,
-        ...(c.env.ENVIRONMENT === 'development' && { stack: error.stack })
-      }
-      return c.json(response, error.statusCode as StatusCode)
-    }
-
-    if (error instanceof HTTPException) {
-      c.env.logger.error('HTTP error', {
-        requestId,
-        status: error.status,
-        message: error.message
-      })
-      response.error = {
-        code: 'HTTP_ERROR',
-        message: error.message,
-        ...(c.env.ENVIRONMENT === 'development' && { stack: error.stack })
-      }
-      return c.json(response, error.status as StatusCode)
-    }
-
-    if (error instanceof ZodError) {
-      c.env.logger.error('Validation error', {
-        requestId,
-        details: error.format()
-      })
-      response.error = {
-        code: 'VALIDATION_ERROR',
-        message: 'Invalid request data',
-        details: error.format(),
-        ...(c.env.ENVIRONMENT === 'development' && { stack: error.stack })
-      }
-      return c.json(response, 400)
-    }
-
-    // Default error response
-    return c.json(response, 500)
+    const formattedError = formatError(error)
+    return c.json({
+      ...formattedError,
+      requestId
+    }, formattedError.statusCode as 400 | 401 | 403 | 404 | 500)
   }
 }
 
-// Common error creators
+// Error creators - these now return APIError instances
 export const notFound = (resource: string) => {
-  throw new APIError(`${resource} not found`, 404, 'NOT_FOUND')
+  throw new APIError(
+    `${resource} not found`,
+    'NOT_FOUND',
+    404
+  )
 }
 
 export const unauthorized = (message = 'Unauthorized') => {
-  throw new APIError(message, 401, 'UNAUTHORIZED')
+  throw new APIError(
+    message,
+    'UNAUTHORIZED',
+    401
+  )
 }
 
 export const forbidden = (message = 'Forbidden') => {
-  throw new APIError(message, 403, 'FORBIDDEN')
+  throw new APIError(
+    message,
+    'FORBIDDEN',
+    403
+  )
 }
 
 export const badRequest = (message: string, details?: unknown) => {
-  throw new APIError(message, 400, 'BAD_REQUEST', details)
+  throw new APIError(
+    message,
+    'BAD_REQUEST',
+    400,
+    details
+  )
 } 
\ No newline at end of file
diff --git a/apps/api/src/middleware/logging.ts b/apps/api/src/middleware/logging.ts
index 2886c0c..54f54ad 100644
--- a/apps/api/src/middleware/logging.ts
+++ b/apps/api/src/middleware/logging.ts
@@ -1,16 +1,27 @@
-import { Context, MiddlewareHandler } from 'hono'
-import { logger } from 'hono/logger'
-import { AppContext } from '../db'
+import type { Next } from 'hono'
+import type { HonoContext } from '../types'
 
-export const logging = (): MiddlewareHandler<AppContext> => {
-  return logger()
+export const logging = () => {
+  return async (c: HonoContext, next: Next) => {
+    const start = Date.now()
+    await next()
+    const ms = Date.now() - start
+
+    c.env.logger.info('Request completed', {
+      method: c.req.method,
+      path: c.req.path,
+      status: c.res?.status,
+      duration: `${ms}ms`
+    })
+  }
 }
 
-export const requestTiming = (): MiddlewareHandler<AppContext> => {
-  return async (c, next) => {
+export const requestTiming = () => {
+  return async (c: HonoContext, next: Next) => {
     const start = Date.now()
     await next()
-    const end = Date.now()
-    c.res.headers.set('X-Response-Time', `${end - start}ms`)
+    const ms = Date.now() - start
+
+    c.header('X-Response-Time', `${ms}ms`)
   }
 } 
\ No newline at end of file
diff --git a/apps/api/src/middleware/version.ts b/apps/api/src/middleware/version.ts
index e70d55e..04656b3 100644
--- a/apps/api/src/middleware/version.ts
+++ b/apps/api/src/middleware/version.ts
@@ -1,17 +1,10 @@
 import type { Context, Next } from 'hono'
-import type { AppContext } from '../db'
-import type { PinoLogger } from 'hono-pino'
-
-type VersionContext = AppContext & {
-  Variables: {
-    logger: PinoLogger
-  }
-}
+import type { AppContext } from '../types'
 
 // Version middleware
-export const versionMiddleware = async (c: Context<VersionContext>, next: Next) => {
+export const versionMiddleware = async (c: Context<AppContext>, next: Next) => {
   const path = c.req.path
-  const logger = c.var.logger
+  const logger = c.env.logger
   const requestId = crypto.randomUUID().split('-')[0]
 
   logger.debug('Version middleware called', { requestId, path })
diff --git a/apps/api/src/routes/index.ts b/apps/api/src/routes/index.ts
index e2f157f..e6b809a 100644
--- a/apps/api/src/routes/index.ts
+++ b/apps/api/src/routes/index.ts
@@ -1,11 +1,19 @@
 import { Hono } from 'hono'
+import type { AppContext } from '../types'
 import users from './users'
-import type { AppContext } from '../db'
 
 const app = new Hono<AppContext>()
 
 // Mount feature routes
 app.route('/users', users)
 
-export type AppType = typeof app
-export default app 
\ No newline at end of file
+app.get('/health', async (c) => {
+  try {
+    await c.env.db.execute('SELECT 1')
+    return c.json({ status: 'healthy', database: 'connected' })
+  } catch (error) {
+    return c.json({ status: 'unhealthy', database: 'disconnected', error: String(error) }, 500)
+  }
+})
+
+export type AppType = typeof app 
\ No newline at end of file
diff --git a/apps/api/src/routes/test.ts b/apps/api/src/routes/test.ts
deleted file mode 100644
index 7086a47..0000000
--- a/apps/api/src/routes/test.ts
+++ /dev/null
@@ -1,29 +0,0 @@
-import { Hono } from 'hono'
-import { sql } from 'drizzle-orm'
-import { wrapResponse } from '../lib/response'
-import type { AppContext } from '../db'
-import { users } from '../db/schema'
-
-const app = new Hono<AppContext>()
-
-const routes = app
-  .get('/', async (c) => {
-    try {
-      // Simple query to test connection
-      const result = await c.env.db
-        .select({ count: sql`count(*)` })
-        .from(users)
-        .get()
-      
-      return c.json(wrapResponse(c, { 
-        message: 'Database connection successful',
-        result 
-      }))
-    } catch (error) {
-      c.env.logger.error('Database connection test failed:', error)
-      throw error
-    }
-  })
-
-export type TestType = typeof routes
-export default app 
\ No newline at end of file
diff --git a/apps/api/src/routes/users.ts b/apps/api/src/routes/users.ts
index 97f4c56..b553b3b 100644
--- a/apps/api/src/routes/users.ts
+++ b/apps/api/src/routes/users.ts
@@ -1,264 +1,387 @@
-import { Hono } from 'hono'
-import { zValidator } from '@hono/zod-validator'
+import { OpenAPIHono } from '@hono/zod-openapi'
+import type { Context } from 'hono'
 import { z } from 'zod'
-import { eq } from 'drizzle-orm'
-import { users } from '../db/schema'
-import { wrapResponse } from '../lib/response'
-import type { AppContext } from '../db'
-import type { LibSQLDatabase } from 'drizzle-orm/libsql'
-import { notFound } from '../middleware/error'
-import { getCurrentTimestamp } from '../db/utils'
-import { createClerkUser, listClerkUsers } from '../lib/clerk'
+import { requireOrganizationRole } from '../middleware/organization'
 import { generateId } from '../lib/utils'
+import { getCurrentTimestamp } from '../db/utils'
+import type { AppContext } from '../types'
+import { notFound } from '../middleware/error'
+import { syncUser } from '../lib/clerk'
+import type { ClerkWebhookEvent } from '../lib/clerk'
+import { UserService } from '../db/services'
+import type { CreateUserInput, UpdateUserInput } from '../db/services/users'
+import { selectUserSchema, insertUserSchema, updateUserSchema } from '../db/schema/users'
+import { errorSchema, errorResponses } from '../schemas/errors'
+import { createRoute } from '@hono/zod-openapi'
 
-const app = new Hono<AppContext>()
+const app = new OpenAPIHono<AppContext>()
 
-const routes = app
-  .get('/', async (c) => {
-    try {
-      const db = c.env.db
-      const items = await db
-        .select()
-        .from(users)
-        .all()
-      return c.json(wrapResponse(c, { users: items }))
-    } catch (error) {
-      c.env.logger.error('Failed to fetch users:', error)
-      throw error
-    }
+// Response schemas
+const listUsersResponseSchema = z.object({
+  users: z.array(selectUserSchema),
+  total: z.number()
+}).openapi('ListUsersResponse')
+
+const deleteUserResponseSchema = z.object({
+  success: z.boolean()
+}).openapi('DeleteUserResponse')
+
+// Query/Path parameter schemas
+const listUsersQuerySchema = z.object({
+  cursor: z.string().optional().openapi({
+    param: {
+      name: 'cursor',
+      in: 'query'
+    },
+    example: 'next_12345',
+    description: 'Cursor for pagination'
+  }),
+  limit: z.number().optional().openapi({
+    param: {
+      name: 'limit',
+      in: 'query'
+    },
+    example: 10,
+    description: 'Number of items to return'
   })
-  .post('/', async (c) => {
-    try {
-      const data = await c.req.json()
-      const db = c.env.db
-      const user = await db.insert(users).values(data).returning().get()
-      return c.json(wrapResponse(c, user))
-    } catch (error) {
-      c.env.logger.error('Failed to create user:', error)
-      throw error
-    }
+}).openapi('ListUsersQuery')
+
+const userIdParamSchema = z.object({
+  id: z.string().openapi({
+    param: {
+      name: 'id',
+      in: 'path'
+    },
+    example: 'usr_123',
+    description: 'User ID'
   })
-  .get('/:id', async (c) => {
-    try {
-      const id = c.req.param('id')
-      const db = c.env.db
-      const user = await db.select().from(users).where(eq(users.id, id)).get()
-      if (!user) {
-        throw notFound('User')
+}).openapi('UserIdParam')
+
+// Route definitions
+const listUsersRoute = createRoute({
+  method: 'get',
+  path: '/',
+  tags: ['Users'],
+  summary: 'List users',
+  description: 'Retrieve a paginated list of users',
+  request: {
+    query: listUsersQuerySchema
+  },
+  responses: {
+    200: {
+      content: {
+        'application/json': {
+          schema: listUsersResponseSchema
+        }
+      },
+