emdash 0.0.0-b → 0.0.2

package/src/database/repositories/user.ts

@@ -0,0 +1,258 @@
+import type { Kysely, Selectable, Updateable } from "kysely";
+import { ulid } from "ulidx";
+
+import type { Database, UserTable } from "../types.js";
+import { encodeCursor, decodeCursor, type FindManyResult } from "./types.js";
+
+type UserRow = Selectable<UserTable>;
+
+/**
+ * Valid role levels matching the database schema.
+ * 10=subscriber, 20=contributor, 30=author, 40=editor, 50=admin
+ */
+export type UserRole = 10 | 20 | 30 | 40 | 50;
+
+/** String role names for convenience APIs */
+export type UserRoleName = "subscriber" | "contributor" | "author" | "editor" | "admin";
+
+export interface User {
+	id: string;
+	email: string;
+	name: string | null;
+	role: UserRole;
+	avatarUrl: string | null;
+	emailVerified: boolean;
+	data: Record<string, unknown> | null;
+	createdAt: string;
+}
+
+export interface CreateUserInput {
+	email: string;
+	name?: string;
+	role?: UserRole | UserRoleName;
+	avatarUrl?: string;
+	data?: Record<string, unknown>;
+}
+
+export interface UpdateUserInput {
+	name?: string;
+	role?: UserRole | UserRoleName;
+	avatarUrl?: string | null;
+	data?: Record<string, unknown>;
+}
+
+/**
+ * User repository for CRUD operations
+ */
+export class UserRepository {
+	constructor(private db: Kysely<Database>) {}
+
+	/**
+	 * Create a new user
+	 */
+	async create(input: CreateUserInput): Promise<User> {
+		const id = ulid();
+
+		const row: Omit<UserTable, "created_at" | "updated_at" | "disabled"> = {
+			id,
+			email: input.email.toLowerCase(),
+			name: input.name ?? null,
+			role: UserRepository.resolveRole(input.role ?? 10),
+			avatar_url: input.avatarUrl ?? null,
+			email_verified: 0,
+			data: input.data ? JSON.stringify(input.data) : null,
+		};
+
+		await this.db.insertInto("users").values(row).execute();
+
+		const user = await this.findById(id);
+		if (!user) {
+			throw new Error("Failed to create user");
+		}
+		return user;
+	}
+
+	/**
+	 * Find user by ID
+	 */
+	async findById(id: string): Promise<User | null> {
+		const row = await this.db
+			.selectFrom("users")
+			.selectAll()
+			.where("id", "=", id)
+			.executeTakeFirst();
+
+		return row ? this.rowToUser(row) : null;
+	}
+
+	/**
+	 * Find user by email (case-insensitive)
+	 */
+	async findByEmail(email: string): Promise<User | null> {
+		const row = await this.db
+			.selectFrom("users")
+			.selectAll()
+			.where("email", "=", email.toLowerCase())
+			.executeTakeFirst();
+
+		return row ? this.rowToUser(row) : null;
+	}
+
+	/**
+	 * List all users with cursor-based pagination
+	 */
+	async findMany(
+		options: {
+			role?: UserRole | UserRoleName;
+			limit?: number;
+			cursor?: string;
+		} = {},
+	): Promise<FindManyResult<User>> {
+		const limit = Math.min(Math.max(1, options.limit || 50), 100);
+
+		let query = this.db
+			.selectFrom("users")
+			.selectAll()
+			.orderBy("created_at", "desc")
+			.orderBy("id", "desc")
+			.limit(limit + 1);
+
+		if (options.role !== undefined) {
+			query = query.where("role", "=", UserRepository.resolveRole(options.role));
+		}
+
+		if (options.cursor) {
+			const decoded = decodeCursor(options.cursor);
+			if (decoded) {
+				query = query.where((eb) =>
+					eb.or([
+						eb("created_at", "<", decoded.orderValue),
+						eb.and([eb("created_at", "=", decoded.orderValue), eb("id", "<", decoded.id)]),
+					]),
+				);
+			}
+		}
+
+		const rows = await query.execute();
+		const items = rows.slice(0, limit).map((row) => this.rowToUser(row));
+		const result: FindManyResult<User> = { items };
+
+		if (rows.length > limit && items.length > 0) {
+			const last = items.at(-1)!;
+			result.nextCursor = encodeCursor(last.createdAt, last.id);
+		}
+
+		return result;
+	}
+
+	/**
+	 * Update a user
+	 */
+	async update(id: string, input: UpdateUserInput): Promise<User | null> {
+		const existing = await this.findById(id);
+		if (!existing) return null;
+
+		const updates: Updateable<UserTable> = {};
+		if (input.name !== undefined) updates.name = input.name;
+		if (input.role !== undefined) updates.role = UserRepository.resolveRole(input.role);
+		if (input.avatarUrl !== undefined) updates.avatar_url = input.avatarUrl;
+		if (input.data !== undefined) updates.data = JSON.stringify(input.data);
+
+		if (Object.keys(updates).length > 0) {
+			await this.db.updateTable("users").set(updates).where("id", "=", id).execute();
+		}
+
+		return this.findById(id);
+	}
+
+	/**
+	 * Delete a user
+	 */
+	async delete(id: string): Promise<boolean> {
+		const result = await this.db.deleteFrom("users").where("id", "=", id).executeTakeFirst();
+
+		return (result.numDeletedRows ?? 0) > 0;
+	}
+
+	/**
+	 * Count users
+	 */
+	async count(role?: UserRole | UserRoleName): Promise<number> {
+		let query = this.db.selectFrom("users").select((eb) => eb.fn.count("id").as("count"));
+
+		if (role !== undefined) {
+			query = query.where("role", "=", UserRepository.resolveRole(role));
+		}
+
+		const result = await query.executeTakeFirst();
+		return Number(result?.count || 0);
+	}
+
+	/**
+	 * Check if email exists
+	 */
+	async emailExists(email: string): Promise<boolean> {
+		const row = await this.db
+			.selectFrom("users")
+			.select("id")
+			.where("email", "=", email.toLowerCase())
+			.executeTakeFirst();
+
+		return !!row;
+	}
+
+	/**
+	 * Convert database row to User object
+	 */
+	private rowToUser(row: UserRow): User {
+		return {
+			id: row.id,
+			email: row.email,
+			name: row.name,
+			role: UserRepository.toRole(row.role),
+			avatarUrl: row.avatar_url,
+			emailVerified: row.email_verified === 1,
+			data: row.data ? JSON.parse(row.data) : null,
+			createdAt: row.created_at,
+		};
+	}
+
+	/** Map of role name strings to numeric levels */
+	private static readonly ROLE_NAME_TO_LEVEL: Record<UserRoleName, UserRole> = {
+		subscriber: 10,
+		contributor: 20,
+		author: 30,
+		editor: 40,
+		admin: 50,
+	};
+
+	/** Valid numeric role levels */
+	private static readonly VALID_LEVELS = new Set<number>([10, 20, 30, 40, 50]);
+
+	/**
+	 * Resolve a role name or number to a valid numeric UserRole.
+	 * Accepts both string names ("admin") and numeric levels (50).
+	 */
+	static resolveRole(role: UserRole | UserRoleName): UserRole {
+		if (typeof role === "string") {
+			const level = UserRepository.ROLE_NAME_TO_LEVEL[role];
+			if (level === undefined) {
+				throw new Error(`Invalid role name: ${role}`);
+			}
+			return level;
+		}
+		if (!UserRepository.VALID_LEVELS.has(role)) {
+			throw new Error(`Invalid role level: ${role}`);
+		}
+		return role;
+	}
+
+	/**
+	 * Convert a raw DB integer to a typed UserRole.
+	 * Falls back to subscriber (10) for unknown values.
+	 */
+	private static toRole(level: number): UserRole {
+		if (UserRepository.VALID_LEVELS.has(level)) return level as UserRole;
+		return 10;
+	}
+}

package/src/database/transaction.ts

@@ -0,0 +1,54 @@
+/**
+ * Transaction utility for D1 compatibility
+ *
+ * D1 (via kysely-d1) does not support transactions. On workerd, the error
+ * from beginTransaction() crosses request contexts and can hang the worker.
+ *
+ * This utility provides a drop-in replacement that runs the callback directly
+ * against the db instance when transactions are unavailable. D1 is single-writer
+ * so atomicity is not a concern for individual statements — multi-statement
+ * atomicity is lost, but that's a known D1 limitation.
+ *
+ * Usage:
+ *   import { withTransaction } from "../database/transaction.js";
+ *   const result = await withTransaction(db, async (trx) => { ... });
+ */
+
+import type { Kysely, Transaction } from "kysely";
+
+/**
+ * Run a callback inside a transaction if supported, or directly if not.
+ *
+ * Probes the database once on first call to determine if transactions work.
+ * The result is cached for the lifetime of the process/worker.
+ */
+let transactionsSupported: boolean | null = null;
+const TRANSACTIONS_NOT_SUPPORTED_RE = /transactions are not supported/i;
+
+export async function withTransaction<DB, T>(
+	db: Kysely<DB>,
+	fn: (trx: Kysely<DB> | Transaction<DB>) => Promise<T>,
+): Promise<T> {
+	// Fast path: we already know transactions work
+	if (transactionsSupported === true) {
+		return db.transaction().execute(fn);
+	}
+
+	// Fast path: we already know they don't
+	if (transactionsSupported === false) {
+		return fn(db);
+	}
+
+	// First call: probe
+	try {
+		const result = await db.transaction().execute(fn);
+		transactionsSupported = true;
+		return result;
+	} catch (error) {
+		if (error instanceof Error && TRANSACTIONS_NOT_SUPPORTED_RE.test(error.message)) {
+			transactionsSupported = false;
+			return fn(db);
+		}
+		throw error;
+	}
+}