+
);
}
diff --git a/src/app/export/page.tsx b/src/app/export/page.tsx
index ef88390..78479a5 100644
--- a/src/app/export/page.tsx
+++ b/src/app/export/page.tsx
@@ -1,6 +1,7 @@
"use client";
import { useState } from "react";
+import { AppShell } from "@/components/AppShell";
import { Download, FileJson, FileText, Loader2 } from "lucide-react";
import { APP_NAME } from "@/lib/constants";
@@ -42,7 +43,7 @@ export default function ExportPage() {
};
return (
-
+
{APP_NAME}
Export
@@ -97,6 +98,6 @@ export default function ExportPage() {
+
+ {/* Account info */}
+ {user && (
+
+
Account
+
{user.email}
+ {user.name &&
{user.name}
}
+
+
+ )}
+
{/* Notifications - disabled in MVP */}
@@ -68,6 +91,6 @@ export default function SettingsPage() {
A calm, private gratitude log.
-
);
}
diff --git a/src/app/timeline/page.tsx b/src/app/timeline/page.tsx
index b66092b..4fa1ad4 100644
--- a/src/app/timeline/page.tsx
+++ b/src/app/timeline/page.tsx
@@ -1,6 +1,7 @@
"use client";
-import { useState, useEffect, useCallback } from "react";
+import { useState, useEffect } from "react";
+import { AppShell } from "@/components/AppShell";
import { WeeklyReflection } from "@/components/WeeklyReflection";
import { FilterPanel } from "@/components/FilterPanel";
import { EntryRow } from "@/components/EntryRow";
@@ -56,7 +57,7 @@ export default function TimelinePage() {
}, [entries, filters]);
return (
-
+
{APP_NAME}
Timeline
@@ -88,6 +89,6 @@ export default function TimelinePage() {
)}
)}
-
+
);
}
diff --git a/src/components/AppShell.tsx b/src/components/AppShell.tsx
new file mode 100644
index 0000000..b24b7f0
--- /dev/null
+++ b/src/components/AppShell.tsx
@@ -0,0 +1,19 @@
+"use client";
+
+import { useAuth } from "./AuthProvider";
+import { Navigation } from "./Navigation";
+
+export function AppShell({ children }: { children: React.ReactNode }) {
+ const { user } = useAuth();
+
+ if (!user) {
+ return <>{children};
+ }
+
+ return (
+ <>
+
{children}
+
+
+ );
+}
diff --git a/src/components/AuthProvider.tsx b/src/components/AuthProvider.tsx
new file mode 100644
index 0000000..532df51
--- /dev/null
+++ b/src/components/AuthProvider.tsx
@@ -0,0 +1,88 @@
+"use client";
+
+import { createContext, useContext, useState, useEffect, useCallback } from "react";
+import { useRouter, usePathname } from "next/navigation";
+
+interface User {
+ id: string;
+ email: string;
+ name: string | null;
+}
+
+interface AuthContextType {
+ user: User | null;
+ isLoading: boolean;
+ logout: () => Promise
;
+ refresh: () => Promise;
+}
+
+const AuthContext = createContext({
+ user: null,
+ isLoading: true,
+ logout: async () => {},
+ refresh: async () => {},
+});
+
+export function useAuth() {
+ return useContext(AuthContext);
+}
+
+const PUBLIC_PATHS = ["/login", "/register"];
+
+export function AuthProvider({ children }: { children: React.ReactNode }) {
+ const [user, setUser] = useState(null);
+ const [isLoading, setIsLoading] = useState(true);
+ const router = useRouter();
+ const pathname = usePathname();
+
+ const fetchUser = useCallback(async () => {
+ try {
+ const res = await fetch("/api/auth/me");
+ const data = await res.json();
+ setUser(data.user);
+ return data.user;
+ } catch {
+ setUser(null);
+ return null;
+ } finally {
+ setIsLoading(false);
+ }
+ }, []);
+
+ useEffect(() => {
+ fetchUser().then((user) => {
+ if (!user && !PUBLIC_PATHS.includes(pathname)) {
+ router.push("/login");
+ }
+ });
+ }, [fetchUser, pathname, router]);
+
+ const logout = async () => {
+ try {
+ await fetch("/api/auth/logout", { method: "POST" });
+ setUser(null);
+ router.push("/login");
+ } catch {
+ // Ignore errors
+ }
+ };
+
+ const refresh = async () => {
+ await fetchUser();
+ };
+
+ // Show nothing while checking auth on protected pages
+ if (isLoading && !PUBLIC_PATHS.includes(pathname)) {
+ return (
+
+ );
+ }
+
+ return (
+
+ {children}
+
+ );
+}
diff --git a/src/lib/auth.ts b/src/lib/auth.ts
new file mode 100644
index 0000000..a8c5231
--- /dev/null
+++ b/src/lib/auth.ts
@@ -0,0 +1,160 @@
+import { cookies } from "next/headers";
+import { db, schema } from "./db";
+import { eq, and, gt } from "drizzle-orm";
+import { v4 as uuidv4 } from "uuid";
+import bcrypt from "bcryptjs";
+
+const SESSION_COOKIE = "qt_session";
+const SESSION_DURATION_MS = 30 * 24 * 60 * 60 * 1000; // 30 days
+
+export interface AuthUser {
+ id: string;
+ email: string;
+ name: string | null;
+}
+
+export async function hashPassword(password: string): Promise {
+ return bcrypt.hash(password, 10);
+}
+
+export async function verifyPassword(
+ password: string,
+ hash: string
+): Promise {
+ return bcrypt.compare(password, hash);
+}
+
+export async function createSession(userId: string): Promise {
+ const sessionId = uuidv4();
+ const now = Date.now();
+
+ await db.insert(schema.sessions).values({
+ id: sessionId,
+ userId,
+ expiresAt: now + SESSION_DURATION_MS,
+ createdAt: now,
+ });
+
+ return sessionId;
+}
+
+export async function setSessionCookie(sessionId: string) {
+ const cookieStore = await cookies();
+ cookieStore.set(SESSION_COOKIE, sessionId, {
+ httpOnly: true,
+ secure: process.env.NODE_ENV === "production",
+ sameSite: "lax",
+ maxAge: SESSION_DURATION_MS / 1000,
+ path: "/",
+ });
+}
+
+export async function clearSessionCookie() {
+ const cookieStore = await cookies();
+ cookieStore.delete(SESSION_COOKIE);
+}
+
+export async function getSession(): Promise {
+ const cookieStore = await cookies();
+ const sessionId = cookieStore.get(SESSION_COOKIE)?.value;
+
+ if (!sessionId) return null;
+
+ const now = Date.now();
+
+ const result = await db
+ .select({
+ sessionId: schema.sessions.id,
+ userId: schema.users.id,
+ email: schema.users.email,
+ name: schema.users.name,
+ expiresAt: schema.sessions.expiresAt,
+ })
+ .from(schema.sessions)
+ .innerJoin(schema.users, eq(schema.sessions.userId, schema.users.id))
+ .where(
+ and(eq(schema.sessions.id, sessionId), gt(schema.sessions.expiresAt, now))
+ )
+ .limit(1);
+
+ if (result.length === 0) return null;
+
+ return {
+ id: result[0].userId,
+ email: result[0].email,
+ name: result[0].name,
+ };
+}
+
+export async function deleteSession(sessionId: string) {
+ await db.delete(schema.sessions).where(eq(schema.sessions.id, sessionId));
+}
+
+export async function registerUser(
+ email: string,
+ password: string,
+ name?: string
+): Promise<{ user?: AuthUser; error?: string }> {
+ const existing = await db
+ .select()
+ .from(schema.users)
+ .where(eq(schema.users.email, email.toLowerCase()))
+ .limit(1);
+
+ if (existing.length > 0) {
+ return { error: "Email already registered" };
+ }
+
+ const userId = uuidv4();
+ const passwordHash = await hashPassword(password);
+ const now = Date.now();
+
+ await db.insert(schema.users).values({
+ id: userId,
+ email: email.toLowerCase(),
+ passwordHash,
+ name: name || null,
+ createdAt: now,
+ });
+
+ return {
+ user: {
+ id: userId,
+ email: email.toLowerCase(),
+ name: name || null,
+ },
+ };
+}
+
+export async function loginUser(
+ email: string,
+ password: string
+): Promise<{ user?: AuthUser; sessionId?: string; error?: string }> {
+ const users = await db
+ .select()
+ .from(schema.users)
+ .where(eq(schema.users.email, email.toLowerCase()))
+ .limit(1);
+
+ if (users.length === 0) {
+ return { error: "Invalid email or password" };
+ }
+
+ const user = users[0];
+ const valid = await verifyPassword(password, user.passwordHash);
+
+ if (!valid) {
+ return { error: "Invalid email or password" };
+ }
+
+ const sessionId = await createSession(user.id);
+
+ return {
+ user: {
+ id: user.id,
+ email: user.email,
+ name: user.name,
+ },
+ sessionId,
+ };
+}
diff --git a/src/lib/db/schema.ts b/src/lib/db/schema.ts
index 2543173..0ff6fa8 100644
--- a/src/lib/db/schema.ts
+++ b/src/lib/db/schema.ts
@@ -1,7 +1,27 @@
import { sqliteTable, text, integer, primaryKey } from "drizzle-orm/sqlite-core";
+export const users = sqliteTable("users", {
+ id: text("id").primaryKey(),
+ email: text("email").notNull().unique(),
+ passwordHash: text("password_hash").notNull(),
+ name: text("name"),
+ createdAt: integer("created_at").notNull(), // Unix ms
+});
+
+export const sessions = sqliteTable("sessions", {
+ id: text("id").primaryKey(),
+ userId: text("user_id")
+ .notNull()
+ .references(() => users.id, { onDelete: "cascade" }),
+ expiresAt: integer("expires_at").notNull(), // Unix ms
+ createdAt: integer("created_at").notNull(), // Unix ms
+});
+
export const entries = sqliteTable("entries", {
id: text("id").primaryKey(),
+ userId: text("user_id")
+ .notNull()
+ .references(() => users.id, { onDelete: "cascade" }),
date: text("date").notNull(), // YYYY-MM-DD local date
text: text("text").notNull(),
mood: integer("mood"), // 1-5, null if not set
@@ -12,7 +32,10 @@ export const entries = sqliteTable("entries", {
export const tags = sqliteTable("tags", {
id: text("id").primaryKey(),
- name: text("name").notNull().unique(), // Normalized lowercase
+ userId: text("user_id")
+ .notNull()
+ .references(() => users.id, { onDelete: "cascade" }),
+ name: text("name").notNull(), // Normalized lowercase
createdAt: integer("created_at").notNull(), // Unix ms
});
@@ -30,6 +53,12 @@ export const entryTags = sqliteTable(
);
// Types
+export type User = typeof users.$inferSelect;
+export type NewUser = typeof users.$inferInsert;
+
+export type Session = typeof sessions.$inferSelect;
+export type NewSession = typeof sessions.$inferInsert;
+
export type Entry = typeof entries.$inferSelect;
export type NewEntry = typeof entries.$inferInsert;