Val Town Code SearchReturn to Val Town

39  const handleLogout = async () => {
40    try {
41      await fetch('/api/auth/logout', {
42        method: 'POST',
43        credentials: 'include'
174                >
175                  <img
176                    src={`https://ui-avatars.com/api/?name=${encodeURIComponent(user.firstName + ' ' + user.lastName)}&background=6366f1&color=fff&size=32`}
177                    alt={user.firstName}
178                    className="h-8 w-8 rounded-full"

8  clearCart 
9} from "../database/queries.ts";
10import type { CartUpdateRequest, ApiResponse } from "../../shared/types.ts";
11import { generateId } from "../../shared/utils.ts";
12
43    const total = subtotal + tax + shipping;
44
45    return c.json<ApiResponse>({
46      success: true,
47      data: {
58  } catch (error) {
59    console.error("Get cart error:", error);
60    return c.json<ApiResponse>({
61      success: false,
62      error: "Failed to fetch cart"
72
73    if (!productId || !quantity || quantity < 1) {
74      return c.json<ApiResponse>({
75        success: false,
76        error: "Invalid product ID or quantity"
83    const cartItem = await addToCart(productId, quantity, user?.userId, sessionId);
84
85    return c.json<ApiResponse>({
86      success: true,
87      data: cartItem,
90  } catch (error) {
91    console.error("Add to cart error:", error);
92    return c.json<ApiResponse>({
93      success: false,
94      error: "Failed to add item to cart"
105
106    if (isNaN(itemId) || quantity < 0) {
107      return c.json<ApiResponse>({
108        success: false,
109        error: "Invalid item ID or quantity"
113    await updateCartItem(itemId, quantity);
114
115    return c.json<ApiResponse>({
116      success: true,
117      message: quantity === 0 ? "Item removed from cart" : "Cart updated"
119  } catch (error) {
120    console.error("Update cart error:", error);
121    return c.json<ApiResponse>({
122      success: false,
123      error: "Failed to update cart"
132
133    if (isNaN(itemId)) {
134      return c.json<ApiResponse>({
135        success: false,
136        error: "Invalid item ID"
140    await removeFromCart(itemId);
141
142    return c.json<ApiResponse>({
143      success: true,
144      message: "Item removed from cart"
146  } catch (error) {
147    console.error("Remove from cart error:", error);
148    return c.json<ApiResponse>({
149      success: false,
150      error: "Failed to remove item from cart"
161    await clearCart(user?.userId, sessionId);
162
163    return c.json<ApiResponse>({
164      success: true,
165      message: "Cart cleared"
167  } catch (error) {
168    console.error("Clear cart error:", error);
169    return c.json<ApiResponse>({
170      success: false,
171      error: "Failed to clear cart"

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"