Val Town Code SearchReturn to Val Town

3import { setCookie, getCookie } from "https://esm.sh/hono@3.11.7/cookie";
4import { getUserByEmail, createUser } from "../database/queries.ts";
5import type { LoginRequest, SignupRequest, ApiResponse } from "../../shared/types.ts";
6import { validateEmail, validatePassword } from "../../shared/utils.ts";
7
31
32    if (!email || !password) {
33      return c.json<ApiResponse>({
34        success: false,
35        error: "Email and password are required"
38
39    if (!validateEmail(email)) {
40      return c.json<ApiResponse>({
41        success: false,
42        error: "Invalid email format"
46    const user = await getUserByEmail(email);
47    if (!user) {
48      return c.json<ApiResponse>({
49        success: false,
50        error: "Invalid credentials"
54    const isValidPassword = await verifyPassword(password, user.passwordHash);
55    if (!isValidPassword) {
56      return c.json<ApiResponse>({
57        success: false,
58        error: "Invalid credentials"
78    const { passwordHash, ...userWithoutPassword } = user;
79
80    return c.json<ApiResponse>({
81      success: true,
82      data: {
88  } catch (error) {
89    console.error("Login error:", error);
90    return c.json<ApiResponse>({
91      success: false,
92      error: "Internal server error"
102
103    if (!email || !password || !firstName || !lastName) {
104      return c.json<ApiResponse>({
105        success: false,
106        error: "All fields are required"
109
110    if (!validateEmail(email)) {
111      return c.json<ApiResponse>({
112        success: false,
113        error: "Invalid email format"
117    const passwordValidation = validatePassword(password);
118    if (!passwordValidation.isValid) {
119      return c.json<ApiResponse>({
120        success: false,
121        error: passwordValidation.errors.join(", ")
126    const existingUser = await getUserByEmail(email);
127    if (existingUser) {
128      return c.json<ApiResponse>({
129        success: false,
130        error: "User with this email already exists"
157    });
158
159    return c.json<ApiResponse>({
160      success: true,
161      data: {
167  } catch (error) {
168    console.error("Signup error:", error);
169    return c.json<ApiResponse>({
170      success: false,
171      error: "Internal server error"
183  });
184
185  return c.json<ApiResponse>({
186    success: true,
187    message: "Logged out successfully"
195    
196    if (!token) {
197      return c.json<ApiResponse>({
198        success: false,
199        error: "No authentication token provided"
205    
206    if (!user) {
207      return c.json<ApiResponse>({
208        success: false,
209        error: "User not found"
213    const { passwordHash, ...userWithoutPassword } = user;
214
215    return c.json<ApiResponse>({
216      success: true,
217      data: userWithoutPassword
219  } catch (error) {
220    console.error("Auth verification error:", error);
221    return c.json<ApiResponse>({
222      success: false,
223      error: "Invalid or expired token"
232    
233    if (!token) {
234      return c.json<ApiResponse>({
235        success: false,
236        error: "Authentication required"
243    await next();
244  } catch (error) {
245    return c.json<ApiResponse>({
246      success: false,
247      error: "Invalid or expired token"
255  
256  if (!user || !user.isAdmin) {
257    return c.json<ApiResponse>({
258      success: false,
259      error: "Admin access required"

112  const checkAuth = async () => {
113    try {
114      const response = await fetch('/api/auth/me', {
115        credentials: 'include'
116      });
129  const loadCart = async () => {
130    try {
131      const response = await fetch('/api/cart', {
132        credentials: 'include'
133      });

15await runMigrations();
16
17// API routes
18app.route("/api/jobs", jobsRouter);
19app.route("/api/chat", chatRouter);
20
21// Serve static files

1/** @jsxImportSource https://esm.sh/react@18.2.0 */
2import React, { useState, useEffect, useRef } from "https://esm.sh/react@18.2.0?deps=react@18.2.0";
3import type { ChatMessage, CreateChatMessageRequest, ApiResponse } from "../../shared/types.ts";
4
5export default function ChatRoom() {
19  const fetchMessages = async () => {
20    try {
21      const response = await fetch('/api/chat/messages');
22      const data: ApiResponse<ChatMessage[]> = await response.json();
23      
24      if (data.success && data.data) {
63      };
64
65      const response = await fetch('/api/chat/messages', {
66        method: 'POST',
67        headers: {
71      });
72
73      const data: ApiResponse<ChatMessage> = await response.json();
74
75      if (data.success) {

1/** @jsxImportSource https://esm.sh/react@18.2.0 */
2import React, { useState } from "https://esm.sh/react@18.2.0?deps=react@18.2.0";
3import type { CreateJobRequest, ApiResponse, Job } from "../../shared/types.ts";
4
5interface JobFormProps {
27
28    try {
29      const response = await fetch('/api/jobs', {
30        method: 'POST',
31        headers: {
35      });
36
37      const data: ApiResponse<Job> = await response.json();
38
39      if (data.success) {

2import React, { useState, useEffect } from "https://esm.sh/react@18.2.0?deps=react@18.2.0";
3import JobForm from "./JobForm.tsx";
4import type { Job, ApiResponse } from "../../shared/types.ts";
5
6export default function JobBoard() {
14    try {
15      setLoading(true);
16      const response = await fetch('/api/jobs');
17      const data: ApiResponse<Job[]> = await response.json();
18      
19      if (data.success && data.data) {
45
46    try {
47      const response = await fetch(`/api/jobs/${jobId}`, {
48        method: 'DELETE',
49      });
50      
51      const data: ApiResponse<{ deleted: boolean }> = await response.json();
52      
53      if (data.success) {

1import { Hono } from "https://esm.sh/hono@3.11.7";
2import { getRecentMessages, createMessage } from "../database/queries.ts";
3import type { CreateMessageRequest, ApiResponse } from "../../shared/types.ts";
4
5const chat = new Hono();
9  try {
10    const messages = await getRecentMessages();
11    const response: ApiResponse<typeof messages> = {
12      success: true,
13      data: messages
15    return c.json(response);
16  } catch (error) {
17    const response: ApiResponse<never> = {
18      success: false,
19      error: "Failed to fetch messages"
30    // Basic validation
31    if (!messageData.username || !messageData.message) {
32      const response: ApiResponse<never> = {
33        success: false,
34        error: "Username and message are required"
42
43    if (messageData.username.length > 50) {
44      const response: ApiResponse<never> = {
45        success: false,
46        error: "Username must be 50 characters or less"
50
51    if (messageData.message.length > 500) {
52      const response: ApiResponse<never> = {
53        success: false,
54        error: "Message must be 500 characters or less"
58
59    if (messageData.message.length === 0) {
60      const response: ApiResponse<never> = {
61        success: false,
62        error: "Message cannot be empty"
66
67    const newMessage = await createMessage(messageData);
68    const response: ApiResponse<typeof newMessage> = {
69      success: true,
70      data: newMessage
72    return c.json(response, 201);
73  } catch (error) {
74    const response: ApiResponse<never> = {
75      success: false,
76      error: "Failed to send message"

1import { Hono } from "https://esm.sh/hono@3.11.7";
2import { getAllJobs, createJob, deleteJob } from "../database/queries.ts";
3import type { CreateJobRequest, ApiResponse } from "../../shared/types.ts";
4
5const jobs = new Hono();
9  try {
10    const jobList = await getAllJobs();
11    const response: ApiResponse<typeof jobList> = {
12      success: true,
13      data: jobList
15    return c.json(response);
16  } catch (error) {
17    const response: ApiResponse<never> = {
18      success: false,
19      error: "Failed to fetch jobs"
31    if (!jobData.title || !jobData.company || !jobData.description || 
32        !jobData.location || !jobData.salary || !jobData.contact_email) {
33      const response: ApiResponse<never> = {
34        success: false,
35        error: "All fields are required"
39
40    const newJob = await createJob(jobData);
41    const response: ApiResponse<typeof newJob> = {
42      success: true,
43      data: newJob
45    return c.json(response, 201);
46  } catch (error) {
47    const response: ApiResponse<never> = {
48      success: false,
49      error: "Failed to create job"
58    const id = parseInt(c.req.param("id"));
59    if (isNaN(id)) {
60      const response: ApiResponse<never> = {
61        success: false,
62        error: "Invalid job ID"
67    const deleted = await deleteJob(id);
68    if (!deleted) {
69      const response: ApiResponse<never> = {
70        success: false,
71        error: "Job not found"
74    }
75
76    const response: ApiResponse<{ deleted: boolean }> = {
77      success: true,
78      data: { deleted: true }
80    return c.json(response);
81  } catch (error) {
82    const response: ApiResponse<never> = {
83      success: false,
84      error: "Failed to delete job"

1import { Hono } from "https://esm.sh/hono@3.11.7";
2import { getChatMessages, createChatMessage } from "../database/queries.ts";
3import type { CreateChatMessageRequest, ApiResponse } from "../../shared/types.ts";
4
5const chat = new Hono();
10    const limit = parseInt(c.req.query("limit") || "50");
11    const messages = await getChatMessages(limit);
12    return c.json({ success: true, data: messages } as ApiResponse<typeof messages>);
13  } catch (error) {
14    return c.json({ success: false, error: "Failed to fetch messages" } as ApiResponse<never>, 500);
15  }
16});
26        success: false, 
27        error: "Missing required fields: username, message" 
28      } as ApiResponse<never>, 400);
29    }
30
34        success: false, 
35        error: "Message too long. Maximum 500 characters." 
36      } as ApiResponse<never>, 400);
37    }
38
42        success: false, 
43        error: "Username too long. Maximum 50 characters." 
44      } as ApiResponse<never>, 400);
45    }
46
55        success: false, 
56        error: "Username and message cannot be empty" 
57      } as ApiResponse<never>, 400);
58    }
59
60    const newMessage = await createChatMessage(sanitizedMessage);
61    return c.json({ success: true, data: newMessage } as ApiResponse<typeof newMessage>, 201);
62  } catch (error) {
63    return c.json({ success: false, error: "Failed to create message" } as ApiResponse<never>, 500);
64  }
65});

33}
34
35export interface ApiResponse<T> {
36  success: boolean;
37  data?: T;