@gencow/core 0.1.23 → 0.1.25

package/src/auth.ts

@@ -5,20 +5,20 @@ import { sign, verify } from "hono/utils/jwt/jwt";
 // ─── Types ──────────────────────────────────────────────
 
 interface User {
-    id: string;
-    email: string;
-    name?: string;
+  id: string;
+  email: string;
+  name?: string;
 }
 
 interface AuthContext {
-    /** Get current user or null — Convex의 ctx.auth.getUserIdentity() */
-    getUserIdentity(): User | null;
-    /** Get current user or throw 401 — 편의 메서드 */
-    requireAuth(): User;
+  /** Get current user or null — Convex의 ctx.auth.getUserIdentity() */
+  getUserIdentity(): User | null;
+  /** Get current user or throw 401 — 편의 메서드 */
+  requireAuth(): User;
 }
 
 interface AuthConfig {
-    jwtSecret: string;
+  jwtSecret: string;
 }
 
 // ─── In-memory user store (POC용, 프로덕션에서는 Drizzle 테이블 사용) ──
@@ -28,12 +28,12 @@ const users = new Map<string, User & { passwordHash: string; createdAt: string }
 // ─── Simple password hashing (POC용) ────────────────────
 
 async function hashPassword(password: string): Promise<string> {
-    const encoder = new TextEncoder();
-    const data = encoder.encode(password);
-    const hash = await crypto.subtle.digest("SHA-256", data);
-    return Array.from(new Uint8Array(hash))
-        .map((b) => b.toString(16).padStart(2, "0"))
-        .join("");
+  const encoder = new TextEncoder();
+  const data = encoder.encode(password);
+  const hash = await crypto.subtle.digest("SHA-256", data);
+  return Array.from(new Uint8Array(hash))
+    .map((b) => b.toString(16).padStart(2, "0"))
+    .join("");
 }
 
 // ─── Auth middleware — Convex ctx.auth 패턴 재현 ─────────
@@ -48,108 +48,108 @@ async function hashPassword(password: string): Promise<string> {
  * const user = c.get('auth').requireAuth();
  */
 export function authMiddleware(config: AuthConfig) {
-    return async (c: Context, next: Next) => {
-        let currentUser: User | null = null;
-
-        // Extract JWT from Authorization header
-        const authHeader = c.req.header("Authorization");
-        if (authHeader?.startsWith("Bearer ")) {
-            const token = authHeader.slice(7);
-            try {
-                const payload = (await verify(token, config.jwtSecret, "HS256")) as any;
-                currentUser = {
-                    id: payload.sub as string,
-                    email: payload.email as string,
-                    name: payload.name as string | undefined,
-                };
-            } catch {
-                // Invalid token — continue as unauthenticated
-            }
-        }
-
-        const authContext: AuthContext = {
-            getUserIdentity: () => currentUser,
-            requireAuth: () => {
-                if (!currentUser) {
-                    throw new HTTPException(401, { message: "Authentication required" });
-                }
-                return currentUser;
-            },
+  return async (c: Context, next: Next) => {
+    let currentUser: User | null = null;
+
+    // Extract JWT from Authorization header
+    const authHeader = c.req.header("Authorization");
+    if (authHeader?.startsWith("Bearer ")) {
+      const token = authHeader.slice(7);
+      try {
+        const payload = (await verify(token, config.jwtSecret, "HS256")) as any;
+        currentUser = {
+          id: payload.sub as string,
+          email: payload.email as string,
+          name: payload.name as string | undefined,
         };
-
-        c.set("auth", authContext);
-        await next();
+      } catch {
+        // Invalid token — continue as unauthenticated
+      }
+    }
+
+    const authContext: AuthContext = {
+      getUserIdentity: () => currentUser,
+      requireAuth: () => {
+        if (!currentUser) {
+          throw new HTTPException(401, { message: "Authentication required" });
+        }
+        return currentUser;
+      },
     };
+
+    c.set("auth", authContext);
+    await next();
+  };
 }
 
 // ─── Auth routes — 회원가입/로그인/프로필 ────────────────
 
 export function authRoutes(config: AuthConfig) {
-    return {
-        /** POST /auth/signup — 회원가입 */
-        async signup(c: Context) {
-            const { email, password, name } = await c.req.json();
-
-            if (!email || !password) {
-                return c.json({ error: "Email and password required" }, 400);
-            }
-
-            if (users.has(email)) {
-                return c.json({ error: "User already exists" }, 409);
-            }
-
-            const id = crypto.randomUUID();
-            const passwordHash = await hashPassword(password);
-            users.set(email, { id, email, name, passwordHash, createdAt: new Date().toISOString() });
-
-            const token = await sign(
-                { sub: id, email, name, exp: Math.floor(Date.now() / 1000) + 86400 },
-                config.jwtSecret
-            );
-
-            return c.json({ token, user: { id, email, name } });
-        },
-
-        /** POST /auth/login — 로그인 */
-        async login(c: Context) {
-            const { email, password } = await c.req.json();
-
-            const user = users.get(email);
-            if (!user) {
-                return c.json({ error: "Invalid credentials" }, 401);
-            }
-
-            const hash = await hashPassword(password);
-            if (hash !== user.passwordHash) {
-                return c.json({ error: "Invalid credentials" }, 401);
-            }
-
-            const token = await sign(
-                {
-                    sub: user.id,
-                    email: user.email,
-                    name: user.name,
-                    exp: Math.floor(Date.now() / 1000) + 86400,
-                },
-                config.jwtSecret
-            );
-
-            return c.json({
-                token,
-                user: { id: user.id, email: user.email, name: user.name },
-            });
+  return {
+    /** POST /auth/signup — 회원가입 */
+    async signup(c: Context) {
+      const { email, password, name } = await c.req.json();
+
+      if (!email || !password) {
+        return c.json({ error: "Email and password required" }, 400);
+      }
+
+      if (users.has(email)) {
+        return c.json({ error: "User already exists" }, 409);
+      }
+
+      const id = crypto.randomUUID();
+      const passwordHash = await hashPassword(password);
+      users.set(email, { id, email, name, passwordHash, createdAt: new Date().toISOString() });
+
+      const token = await sign(
+        { sub: id, email, name, exp: Math.floor(Date.now() / 1000) + 86400 },
+        config.jwtSecret,
+      );
+
+      return c.json({ token, user: { id, email, name } });
+    },
+
+    /** POST /auth/login — 로그인 */
+    async login(c: Context) {
+      const { email, password } = await c.req.json();
+
+      const user = users.get(email);
+      if (!user) {
+        return c.json({ error: "Invalid credentials" }, 401);
+      }
+
+      const hash = await hashPassword(password);
+      if (hash !== user.passwordHash) {
+        return c.json({ error: "Invalid credentials" }, 401);
+      }
+
+      const token = await sign(
+        {
+          sub: user.id,
+          email: user.email,
+          name: user.name,
+          exp: Math.floor(Date.now() / 1000) + 86400,
         },
-
-        /** GET /auth/me — 현재 유저 정보 */
-        async me(c: Context) {
-            const auth: AuthContext = c.get("auth");
-            const user = auth.requireAuth();
-            return c.json(user);
-        },
-    };
+        config.jwtSecret,
+      );
+
+      return c.json({
+        token,
+        user: { id: user.id, email: user.email, name: user.name },
+      });
+    },
+
+    /** GET /auth/me — 현재 유저 정보 */
+    async me(c: Context) {
+      const auth: AuthContext = c.get("auth");
+      const user = auth.requireAuth();
+      return c.json(user);
+    },
+  };
 }
 
 /** Get all registered users (for admin dashboard) */
 export function getUsers(): (User & { createdAt: string })[] {
-    return Array.from(users.values()).map(({ passwordHash, ...user }) => user);
+  return Array.from(users.values()).map(({ passwordHash, ...user }) => user);
 }

package/src/crons.ts

@@ -19,50 +19,50 @@
 // ─── 타입 ───────────────────────────────────────────────
 
 export interface CronJobDef {
-    /** 크론 잡 이름 */
-    name: string;
-    /** cron 표현식 (예: "0 2 * * *") */
-    pattern: string;
-    /** 실행할 액션 또는 핸들러 */
-    action: string | (() => Promise<void>);
+  /** 크론 잡 이름 */
+  name: string;
+  /** cron 표현식 (예: "0 2 * * *") */
+  pattern: string;
+  /** 실행할 액션 또는 핸들러 */
+  action: string | (() => Promise<void>);
 }
 
 export interface IntervalOptions {
-    /** 분 단위 */
-    minutes?: number;
-    /** 시간 단위 */
-    hours?: number;
-    /** 초 단위 */
-    seconds?: number;
+  /** 분 단위 */
+  minutes?: number;
+  /** 시간 단위 */
+  hours?: number;
+  /** 초 단위 */
+  seconds?: number;
 }
 
 export interface DailyOptions {
-    /** 실행 시각 (0-23, 로컬 시간) */
-    hour: number;
-    /** 분 (0-59, 기본 0) */
-    minute?: number;
+  /** 실행 시각 (0-23, 로컬 시간) */
+  hour: number;
+  /** 분 (0-59, 기본 0) */
+  minute?: number;
 }
 
 export interface WeeklyOptions {
-    /** 요일 (0=일, 1=월, ..., 6=토) */
-    dayOfWeek: number;
-    /** 시각 (0-23) */
-    hour: number;
-    /** 분 (0-59, 기본 0) */
-    minute?: number;
+  /** 요일 (0=일, 1=월, ..., 6=토) */
+  dayOfWeek: number;
+  /** 시각 (0-23) */
+  hour: number;
+  /** 분 (0-59, 기본 0) */
+  minute?: number;
 }
 
 export interface CronJobsBuilder {
-    /** 일정 간격으로 실행 */
-    interval(name: string, options: IntervalOptions, action: string | (() => Promise<void>)): CronJobsBuilder;
-    /** 매일 특정 시각에 실행 */
-    daily(name: string, options: DailyOptions, action: string | (() => Promise<void>)): CronJobsBuilder;
-    /** 매주 특정 요일/시각에 실행 */
-    weekly(name: string, options: WeeklyOptions, action: string | (() => Promise<void>)): CronJobsBuilder;
-    /** cron 표현식으로 직접 지정 */
-    cron(name: string, pattern: string, action: string | (() => Promise<void>)): CronJobsBuilder;
-    /** 등록된 크론 잡 목록 (서버 내부에서 사용) */
-    getJobs(): CronJobDef[];
+  /** 일정 간격으로 실행 */
+  interval(name: string, options: IntervalOptions, action: string | (() => Promise<void>)): CronJobsBuilder;
+  /** 매일 특정 시각에 실행 */
+  daily(name: string, options: DailyOptions, action: string | (() => Promise<void>)): CronJobsBuilder;
+  /** 매주 특정 요일/시각에 실행 */
+  weekly(name: string, options: WeeklyOptions, action: string | (() => Promise<void>)): CronJobsBuilder;
+  /** cron 표현식으로 직접 지정 */
+  cron(name: string, pattern: string, action: string | (() => Promise<void>)): CronJobsBuilder;
+  /** 등록된 크론 잡 목록 (서버 내부에서 사용) */
+  getJobs(): CronJobDef[];
 }
 
 // ─── 빌더 구현 ──────────────────────────────────────────
@@ -78,54 +78,54 @@ export interface CronJobsBuilder {
  * export default crons;
  */
 export function cronJobs(): CronJobsBuilder {
-    const jobs: CronJobDef[] = [];
-
-    const builder: CronJobsBuilder = {
-        interval(name, options, action) {
-            const pattern = intervalToPattern(options);
-            jobs.push({ name, pattern, action });
-            return builder;
-        },
-
-        daily(name, options, action) {
-            const minute = options.minute ?? 0;
-            const pattern = `${minute} ${options.hour} * * *`;
-            jobs.push({ name, pattern, action });
-            return builder;
-        },
-
-        weekly(name, options, action) {
-            const minute = options.minute ?? 0;
-            const pattern = `${minute} ${options.hour} * * ${options.dayOfWeek}`;
-            jobs.push({ name, pattern, action });
-            return builder;
-        },
-
-        cron(name, pattern, action) {
-            jobs.push({ name, pattern, action });
-            return builder;
-        },
-
-        getJobs() {
-            return [...jobs];
-        },
-    };
-
-    return builder;
+  const jobs: CronJobDef[] = [];
+
+  const builder: CronJobsBuilder = {
+    interval(name, options, action) {
+      const pattern = intervalToPattern(options);
+      jobs.push({ name, pattern, action });
+      return builder;
+    },
+
+    daily(name, options, action) {
+      const minute = options.minute ?? 0;
+      const pattern = `${minute} ${options.hour} * * *`;
+      jobs.push({ name, pattern, action });
+      return builder;
+    },
+
+    weekly(name, options, action) {
+      const minute = options.minute ?? 0;
+      const pattern = `${minute} ${options.hour} * * ${options.dayOfWeek}`;
+      jobs.push({ name, pattern, action });
+      return builder;
+    },
+
+    cron(name, pattern, action) {
+      jobs.push({ name, pattern, action });
+      return builder;
+    },
+
+    getJobs() {
+      return [...jobs];
+    },
+  };
+
+  return builder;
 }
 
 // ─── 유틸리티 ───────────────────────────────────────────
 
 function intervalToPattern(options: IntervalOptions): string {
-    if (options.seconds) {
-        // node-cron은 초 단위 지원: "*/N * * * * *"
-        return `*/${options.seconds} * * * * *`;
-    }
-    if (options.minutes) {
-        return `*/${options.minutes} * * * *`;
-    }
-    if (options.hours) {
-        return `0 */${options.hours} * * *`;
-    }
-    throw new Error("interval: minutes, hours, 또는 seconds 중 하나를 지정하세요");
+  if (options.seconds) {
+    // node-cron은 초 단위 지원: "*/N * * * * *"
+    return `*/${options.seconds} * * * * *`;
+  }
+  if (options.minutes) {
+    return `*/${options.minutes} * * * *`;
+  }
+  if (options.hours) {
+    return `0 */${options.hours} * * *`;
+  }
+  throw new Error("interval: minutes, hours, 또는 seconds 중 하나를 지정하세요");
 }