Initialize project with basic setting

Author: B-HS

.github/workflows/deploy.yml

@@ -0,0 +1,69 @@
+name: Deploy to Lightsail
+
+on:
+    push:
+        branches:
+            - prod
+
+jobs:
+    deploy:
+        runs-on: ubuntu-latest
+
+        steps:
+            - name: Checkout
+              uses: actions/checkout@v4
+
+            - name: Setup Bun
+              uses: oven-sh/setup-bun@v2
+
+            - name: Install dependencies
+              run: bun install --frozen-lockfile
+
+            - name: Create .env file
+              run: |
+                  echo "${{ secrets.ENV_TEXT }}" > .env
+                  cp .env apps/web/.env
+                  cp .env apps/api/.env
+
+            - name: Typecheck API
+              run: bun run typecheck
+
+            - name: Build web app
+              run: bun run build
+
+            - name: Build Docker image
+              run: docker build -t calendar-app:latest .
+
+            - name: Save Docker image
+              run: docker save calendar-app:latest | gzip > calendar-app.tar.gz
+
+            - name: Create target directory
+              uses: appleboy/[email protected]
+              with:
+                  host: ${{ secrets.HOST }}
+                  username: ${{ secrets.USERNAME }}
+                  key: ${{ secrets.SSH_KEY }}
+                  script: mkdir -p ~/calendar-app
+
+            - name: Copy files to server
+              uses: appleboy/[email protected]
+              with:
+                  host: ${{ secrets.HOST }}
+                  username: ${{ secrets.USERNAME }}
+                  key: ${{ secrets.SSH_KEY }}
+                  source: calendar-app.tar.gz,compose.yml,.env
+                  target: ~/calendar-app
+                  timeout: 600s
+
+            - name: Deploy
+              uses: appleboy/[email protected]
+              with:
+                  host: ${{ secrets.HOST }}
+                  username: ${{ secrets.USERNAME }}
+                  key: ${{ secrets.SSH_KEY }}
+                  script: |
+                      cd ~/calendar-app
+                      docker load < calendar-app.tar.gz
+                      docker compose down || true
+                      docker compose up -d
+                      rm calendar-app.tar.gz

.gitignore

@@ -0,0 +1,33 @@
+node_modules
+
+# Output
+.output
+.vercel
+.netlify
+.wrangler
+.svelte-kit
+build
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Env
+.env
+.env.*
+!.env.example
+!.env.test
+
+# Vite
+vite.config.js.timestamp-*
+vite.config.ts.timestamp-*
+
+# Paraglide
+apps/web/src/lib/paraglide
+apps/web/project.inlang/cache/
+
+# Bun
+bun.lockb
+
+# Docker
+*.tar.gz

Dockerfile

@@ -0,0 +1,23 @@
+FROM node:22-slim
+WORKDIR /app
+
+ENV NODE_ENV=production
+ENV PORT=3000
+ENV API_PORT=4000
+
+RUN npm install -g bun
+
+COPY apps/web/build ./apps/web/build
+COPY apps/web/package.json ./apps/web/
+
+COPY apps/api ./apps/api
+
+COPY package.json bun.lock ./
+RUN bun install --frozen-lockfile --production
+
+COPY start.sh ./
+RUN chmod +x start.sh
+
+EXPOSE 3000 4000
+
+CMD ["./start.sh"]

apps/api/auth.ts

@@ -0,0 +1,38 @@
+import { betterAuth } from 'better-auth'
+import { drizzleAdapter } from 'better-auth/adapters/drizzle'
+import { db } from '@db/index'
+import * as schema from '@db/schema'
+
+const BETTER_AUTH_SECRET = process.env.BETTER_AUTH_SECRET
+const GOOGLE_CLIENT_ID = process.env.GOOGLE_CLIENT_ID
+const GOOGLE_CLIENT_SECRET = process.env.GOOGLE_CLIENT_SECRET
+
+if (!BETTER_AUTH_SECRET) throw new Error('BETTER_AUTH_SECRET is not set')
+if (!GOOGLE_CLIENT_ID) throw new Error('GOOGLE_CLIENT_ID is not set')
+if (!GOOGLE_CLIENT_SECRET) throw new Error('GOOGLE_CLIENT_SECRET is not set')
+
+const BETTER_AUTH_URL = process.env.BETTER_AUTH_URL
+const FRONTEND_URL = process.env.FRONTEND_URL || 'http://localhost:3000'
+
+if (!BETTER_AUTH_URL) throw new Error('BETTER_AUTH_URL is not set')
+
+export const auth = betterAuth({
+    baseURL: BETTER_AUTH_URL,
+    secret: BETTER_AUTH_SECRET,
+    database: drizzleAdapter(db, {
+        provider: 'mysql',
+        schema,
+    }),
+    trustedOrigins: [FRONTEND_URL, BETTER_AUTH_URL],
+    emailAndPassword: {
+        enabled: true,
+    },
+    socialProviders: {
+        google: {
+            clientId: GOOGLE_CLIENT_ID,
+            clientSecret: GOOGLE_CLIENT_SECRET,
+        },
+    },
+})
+
+export type AuthSession = typeof auth.$Infer.Session

apps/api/db/index.ts

@@ -0,0 +1,23 @@
+import { drizzle } from 'drizzle-orm/mysql2'
+import mysql from 'mysql2/promise'
+import * as schema from './schema'
+
+export type Database = ReturnType<typeof createDb>
+
+export const createDb = (pool: mysql.Pool) => drizzle(pool, { schema, mode: 'default' })
+
+export const createPool = (url: string) =>
+    mysql.createPool({
+        uri: url,
+        timezone: '+00:00',
+    })
+
+const poolConnection = mysql.createPool({
+    host: process.env.DATABASE_HOST,
+    port: parseInt(process.env.DATABASE_PORT!),
+    user: process.env.DATABASE_USERNAME,
+    database: process.env.DATABASE_NAME,
+    password: process.env.DATABASE_PASSWORD,
+})
+
+export const db = createDb(poolConnection)

apps/api/db/schema.ts

@@ -0,0 +1,118 @@
+import { mysqlTable, varchar, text, boolean, timestamp, datetime, tinyint, json, mysqlEnum } from 'drizzle-orm/mysql-core'
+
+export const user = mysqlTable('user', {
+    id: varchar('id', { length: 36 }).primaryKey(),
+    name: varchar('name', { length: 255 }).notNull(),
+    email: varchar('email', { length: 255 }).notNull().unique(),
+    emailVerified: boolean('email_verified').notNull().default(false),
+    image: text('image'),
+    timezone: varchar('timezone', { length: 64 }).notNull().default('Asia/Seoul'),
+    createdAt: timestamp('created_at').notNull().defaultNow(),
+    updatedAt: timestamp('updated_at').notNull().defaultNow().onUpdateNow(),
+})
+
+export const session = mysqlTable('session', {
+    id: varchar('id', { length: 36 }).primaryKey(),
+    userId: varchar('user_id', { length: 36 })
+        .notNull()
+        .references(() => user.id, { onDelete: 'cascade' }),
+    token: varchar('token', { length: 255 }).notNull().unique(),
+    expiresAt: timestamp('expires_at').notNull(),
+    ipAddress: varchar('ip_address', { length: 45 }),
+    userAgent: text('user_agent'),
+    createdAt: timestamp('created_at').notNull().defaultNow(),
+    updatedAt: timestamp('updated_at').notNull().defaultNow().onUpdateNow(),
+})
+
+export const account = mysqlTable('account', {
+    id: varchar('id', { length: 36 }).primaryKey(),
+    userId: varchar('user_id', { length: 36 })
+        .notNull()
+        .references(() => user.id, { onDelete: 'cascade' }),
+    accountId: varchar('account_id', { length: 255 }).notNull(),
+    providerId: varchar('provider_id', { length: 255 }).notNull(),
+    accessToken: text('access_token'),
+    refreshToken: text('refresh_token'),
+    accessTokenExpiresAt: timestamp('access_token_expires_at'),
+    refreshTokenExpiresAt: timestamp('refresh_token_expires_at'),
+    scope: text('scope'),
+    idToken: text('id_token'),
+    password: text('password'),
+    createdAt: timestamp('created_at').notNull().defaultNow(),
+    updatedAt: timestamp('updated_at').notNull().defaultNow().onUpdateNow(),
+})
+
+export const verification = mysqlTable('verification', {
+    id: varchar('id', { length: 36 }).primaryKey(),
+    identifier: varchar('identifier', { length: 255 }).notNull(),
+    value: text('value').notNull(),
+    expiresAt: timestamp('expires_at').notNull(),
+    createdAt: timestamp('created_at').notNull().defaultNow(),
+    updatedAt: timestamp('updated_at').notNull().defaultNow().onUpdateNow(),
+})
+
+export type RRuleType = {
+    freq: 'DAILY' | 'WEEKLY' | 'MONTHLY' | 'YEARLY'
+    interval?: number
+    count?: number
+    until?: string
+    byDay?: string[]
+    byMonth?: number[]
+    byMonthDay?: number[]
+} | null
+
+export const calendarEvent = mysqlTable('calendar_event', {
+    id: varchar('id', { length: 36 }).primaryKey(),
+    userId: varchar('user_id', { length: 36 })
+        .notNull()
+        .references(() => user.id, { onDelete: 'cascade' }),
+    uid: varchar('uid', { length: 255 }).notNull().unique(),
+    summary: varchar('summary', { length: 500 }).notNull(),
+    description: text('description'),
+    location: varchar('location', { length: 500 }),
+    dtstart: datetime('dtstart').notNull(),
+    dtend: datetime('dtend').notNull(),
+    isAllDay: boolean('is_all_day').notNull().default(false),
+    rrule: json('rrule').$type<RRuleType>(),
+    exdate: json('exdate').$type<string[]>(),
+    status: mysqlEnum('status', ['TENTATIVE', 'CONFIRMED', 'CANCELLED']).default('CONFIRMED'),
+    transp: mysqlEnum('transp', ['TRANSPARENT', 'OPAQUE']).default('OPAQUE'),
+    priority: tinyint('priority'),
+    categories: json('categories').$type<string[]>(),
+    color: varchar('color', { length: 50 }),
+    sequence: tinyint('sequence').notNull().default(0),
+    dtstamp: datetime('dtstamp').notNull(),
+    createdAt: timestamp('created_at').notNull().defaultNow(),
+    updatedAt: timestamp('updated_at').notNull().defaultNow().onUpdateNow(),
+})
+
+export const deletedCalendarEvent = mysqlTable('deleted_calendar_event', {
+    id: varchar('id', { length: 36 }).primaryKey(),
+    userId: varchar('user_id', { length: 36 })
+        .notNull()
+        .references(() => user.id, { onDelete: 'cascade' }),
+    uid: varchar('uid', { length: 255 }).notNull(),
+    deletedAt: timestamp('deleted_at').notNull().defaultNow(),
+    syncToken: varchar('sync_token', { length: 64 }).notNull(),
+})
+
+export const calendarSubscription = mysqlTable('calendar_subscription', {
+    id: varchar('id', { length: 36 }).primaryKey(),
+    userId: varchar('user_id', { length: 36 })
+        .notNull()
+        .references(() => user.id, { onDelete: 'cascade' }),
+    token: varchar('token', { length: 64 }).notNull().unique(),
+    icsToken: varchar('ics_token', { length: 64 }).notNull().unique(),
+    name: varchar('name', { length: 255 }),
+    isActive: boolean('is_active').notNull().default(true),
+    ctag: varchar('ctag', { length: 64 }).notNull().default('0'),
+    lastAccessedAt: datetime('last_accessed_at'),
+    createdAt: timestamp('created_at').notNull().defaultNow(),
+    updatedAt: timestamp('updated_at').notNull().defaultNow().onUpdateNow(),
+})
+
+export type User = typeof user.$inferSelect
+export type Session = typeof session.$inferSelect
+export type Account = typeof account.$inferSelect
+export type CalendarEventRow = typeof calendarEvent.$inferSelect
+export type CalendarSubscriptionRow = typeof calendarSubscription.$inferSelect

apps/api/drizzle.config.ts

@@ -0,0 +1,14 @@
+import { defineConfig } from 'drizzle-kit'
+
+export default defineConfig({
+    schema: './db/schema.ts',
+    out: './drizzle',
+    dialect: 'mysql',
+    dbCredentials: {
+        host: process.env.DATABASE_HOST!,
+        port: parseInt(process.env.DATABASE_PORT!),
+        database: process.env.DATABASE_NAME!,
+        user: process.env.DATABASE_USERNAME!,
+        password: process.env.DATABASE_PASSWORD!,
+    },
+})

apps/api/middleware/auth.ts

@@ -0,0 +1,24 @@
+import { createMiddleware } from 'hono/factory'
+import { auth } from '../auth'
+import type { CalendarService, CalendarSubscription } from '@service/calendar'
+import type { CaldavService } from '@service/caldav'
+import type { AuthSession } from '../auth'
+
+export type AppEnv = {
+    Variables: {
+        session: AuthSession
+        calendarService: CalendarService
+        caldavService: CaldavService
+        caldavSubscription: CalendarSubscription
+        caldavUserId: string
+    }
+}
+
+export const authMiddleware = createMiddleware<AppEnv>(async (c, next) => {
+    const session = await auth.api.getSession({ headers: c.req.raw.headers })
+    if (!session?.user) {
+        return c.json({ error: 'Unauthorized' }, 401)
+    }
+    c.set('session', session)
+    await next()
+})

apps/api/middleware/index.ts

@@ -0,0 +1,32 @@
+import type { OpenAPIHono } from '@hono/zod-openapi'
+import { cors } from 'hono/cors'
+import type { AppEnv } from './auth'
+import { authMiddleware } from './auth'
+import { createServiceMiddleware } from './service'
+import type { CalendarService } from '@service/calendar'
+import type { CaldavService } from '@service/caldav'
+
+export type { AppEnv } from './auth'
+export { authMiddleware } from './auth'
+export { createServiceMiddleware } from './service'
+
+type InitMiddlewareDeps = {
+    calendarService: CalendarService
+    caldavService: CaldavService
+}
+
+export const initMiddleware = (app: OpenAPIHono<AppEnv>, deps: InitMiddlewareDeps) => {
+    app.use(
+        '/api/*',
+        cors({
+            origin: (origin) => origin,
+            credentials: true,
+        }),
+    )
+    app.use('*', createServiceMiddleware(deps.calendarService, deps.caldavService))
+
+    app.use('/api/events/*', authMiddleware)
+    app.use('/api/events', authMiddleware)
+    app.use('/api/calendar/subscription/*', authMiddleware)
+    app.use('/api/calendar/subscription', authMiddleware)
+}

apps/api/middleware/service.ts

@@ -0,0 +1,11 @@
+import { createMiddleware } from 'hono/factory'
+import type { AppEnv } from './auth'
+import type { CalendarService } from '@service/calendar'
+import type { CaldavService } from '@service/caldav'
+
+export const createServiceMiddleware = (calendarService: CalendarService, caldavService: CaldavService) =>
+    createMiddleware<AppEnv>(async (c, next) => {
+        c.set('calendarService', calendarService)
+        c.set('caldavService', caldavService)
+        await next()
+    })