interface User {
id: string;
name: string;
role: "dev" | "mentor";
}
async function fetchUsers(): Promise<User[]> {
const res = await fetch("/api/users");
return res.json();
}
const mentors = users.filter(
(u) => u.role === "mentor"
);
export function createSession(
mentor: User,
topic: string
) {
return {
id: crypto.randomUUID(),
mentor,
topic,
startedAt: new Date(),
};
}
type Result<T> =
| { ok: true; data: T }
| { ok: false; error: string };
function parseConfig(raw: string): Result<Config> {
try {
const data = JSON.parse(raw);
return { ok: true, data };
} catch {
return { ok: false, error: "Invalid JSON" };
}
} interface User {
id: string;
name: string;
role: "dev" | "mentor";
}
async function fetchUsers(): Promise<User[]> {
const res = await fetch("/api/users");
return res.json();
}
const mentors = users.filter(
(u) => u.role === "mentor"
);
export function createSession(
mentor: User,
topic: string
) {
return {
id: crypto.randomUUID(),
mentor,
topic,
startedAt: new Date(),
};
}
type Result<T> =
| { ok: true; data: T }
| { ok: false; error: string };
function parseConfig(raw: string): Result<Config> {
try {
const data = JSON.parse(raw);
return { ok: true, data };
} catch {
return { ok: false, error: "Invalid JSON" };
}
}
const app = express();
app.use(cors({ origin: "*" }));
app.use(json());
app.get("/health", (req, res) => {
res.json({ status: "ok" });
});
const router = new Router();
router.post("/sessions", async (ctx) => {
const { mentorId, topic } = ctx.body;
const session = await db.sessions.create({
data: { mentorId, topic },
});
ctx.json(session);
});
export async function migrate() {
await db.$executeRaw`
CREATE TABLE IF NOT EXISTS sessions (
id UUID PRIMARY KEY,
mentor_id TEXT NOT NULL,
topic TEXT NOT NULL,
created_at TIMESTAMP DEFAULT NOW()
)
`;
}
function validateEmail(email: string) {
return /^[^@]+@[^@]+\.[^@]+$/.test(email);
}
class EventEmitter<T> {
private listeners: ((data: T) => void)[] = [];
on(fn: (data: T) => void) {
this.listeners.push(fn);
}
emit(data: T) {
this.listeners.forEach((fn) => fn(data));
}
} const app = express();
app.use(cors({ origin: "*" }));
app.use(json());
app.get("/health", (req, res) => {
res.json({ status: "ok" });
});
const router = new Router();
router.post("/sessions", async (ctx) => {
const { mentorId, topic } = ctx.body;
const session = await db.sessions.create({
data: { mentorId, topic },
});
ctx.json(session);
});
export async function migrate() {
await db.$executeRaw`
CREATE TABLE IF NOT EXISTS sessions (
id UUID PRIMARY KEY,
mentor_id TEXT NOT NULL,
topic TEXT NOT NULL,
created_at TIMESTAMP DEFAULT NOW()
)
`;
}
function validateEmail(email: string) {
return /^[^@]+@[^@]+\.[^@]+$/.test(email);
}
class EventEmitter<T> {
private listeners: ((data: T) => void)[] = [];
on(fn: (data: T) => void) {
this.listeners.push(fn);
}
emit(data: T) {
this.listeners.forEach((fn) => fn(data));
}
}
import { describe, it, expect } from "vitest";
describe("createSession", () => {
it("should create a valid session", () => {
const mentor = {
id: "1",
name: "Anna",
role: "mentor" as const,
};
const session = createSession(
mentor, "TypeScript"
);
expect(session.mentor).toBe(mentor);
expect(session.topic).toBe("TypeScript");
expect(session.id).toBeDefined();
});
});
const useDebounce = <T>(value: T, ms = 300) => {
const [debounced, setDebounced] = useState(value);
useEffect(() => {
const timer = setTimeout(
() => setDebounced(value), ms
);
return () => clearTimeout(timer);
}, [value, ms]);
return debounced;
};
async function* paginate<T>(
fetchPage: (cursor?: string) => Promise<{
data: T[];
next?: string;
}>
) {
let cursor: string | undefined;
do {
const page = await fetchPage(cursor);
yield* page.data;
cursor = page.next;
} while (cursor);
} import { describe, it, expect } from "vitest";
describe("createSession", () => {
it("should create a valid session", () => {
const mentor = {
id: "1",
name: "Anna",
role: "mentor" as const,
};
const session = createSession(
mentor, "TypeScript"
);
expect(session.mentor).toBe(mentor);
expect(session.topic).toBe("TypeScript");
expect(session.id).toBeDefined();
});
});
const useDebounce = <T>(value: T, ms = 300) => {
const [debounced, setDebounced] = useState(value);
useEffect(() => {
const timer = setTimeout(
() => setDebounced(value), ms
);
return () => clearTimeout(timer);
}, [value, ms]);
return debounced;
};
async function* paginate<T>(
fetchPage: (cursor?: string) => Promise<{
data: T[];
next?: string;
}>
) {
let cursor: string | undefined;
do {
const page = await fetchPage(cursor);
yield* page.data;
cursor = page.next;
} while (cursor);
}
const pipeline = [
tokenize,
parse,
transform,
generate,
];
function compose(...fns: Function[]) {
return (input: unknown) =>
fns.reduce((acc, fn) => fn(acc), input);
}
const process = compose(...pipeline);
interface Observable<T> {
subscribe(observer: Observer<T>): () => void;
pipe<R>(...ops: Operator[]): Observable<R>;
}
function fromEvent(
el: HTMLElement,
event: string
): Observable<Event> {
return {
subscribe(observer) {
el.addEventListener(event, observer.next);
return () =>
el.removeEventListener(event, observer.next);
},
pipe: (...ops) => ops.reduce(
(src, op) => op(src), this
),
};
}
const cache = new Map<string, unknown>();
async function memoize<T>(
key: string,
fn: () => Promise<T>
): Promise<T> {
if (cache.has(key)) return cache.get(key) as T;
const result = await fn();
cache.set(key, result);
return result;
} const pipeline = [
tokenize,
parse,
transform,
generate,
];
function compose(...fns: Function[]) {
return (input: unknown) =>
fns.reduce((acc, fn) => fn(acc), input);
}
const process = compose(...pipeline);
interface Observable<T> {
subscribe(observer: Observer<T>): () => void;
pipe<R>(...ops: Operator[]): Observable<R>;
}
function fromEvent(
el: HTMLElement,
event: string
): Observable<Event> {
return {
subscribe(observer) {
el.addEventListener(event, observer.next);
return () =>
el.removeEventListener(event, observer.next);
},
pipe: (...ops) => ops.reduce(
(src, op) => op(src), this
),
};
}
const cache = new Map<string, unknown>();
async function memoize<T>(
key: string,
fn: () => Promise<T>
): Promise<T> {
if (cache.has(key)) return cache.get(key) as T;
const result = await fn();
cache.set(key, result);
return result;
}
