Val Town Code SearchReturn to Val Town

50    
51    /**
52     * Create the feedback in the database with the following fields:
53     * 
54     * Basic fields:

1/**
2 * Database migrations for productpanel
3 * Handles schema updates and migrations
4 */
63
64/**
65 * Check if a table exists in the database
66 */
67async function checkTableExists(tableName: string): Promise<boolean> {

1/**
2 * Database initialization for productpanel
3 * Creates required tables if they don't exist
4 */
8
9/**
10 * Initialize the database by creating required tables
11 * Only needs to be run once when the app starts
12 */
13export async function initializeDatabase() {
14  try {
15    // Create apps table
23    return { success: true };
24  } catch (error) {
25    console.error("Error initializing database:", error);
26    return { 
27      success: false, 
32
33/**
34 * Reset database (for development use only)
35 * Drops existing tables and recreates them
36 */
37export async function resetDatabase() {
38  try {
39    // Drop tables if they exist (reverse order due to foreign key)
42    
43    // Recreate tables
44    return await initializeDatabase();
45  } catch (error) {
46    console.error("Error resetting database:", error);
47    return { 
48      success: false, 

1/**
2 * Database schema for productpanel
3 * Contains table definitions for apps and feedback
4 */

27
28/**
29 * Validate an API key against the database
30 * @param apiKey The API key to validate
31 * @returns The app object if valid, null if invalid
36  }
37  
38  // Check if the API key exists in the database
39  const app = await getAppByApiKey(apiKey);
40  return app;

176  }
177  
178  // Return cleaned data mapped to our database field names
179  return {
180    valid: true,

3## 1. Project Overview
4
5**AppFeedback.val** is a personal service for collecting, storing, and viewing user feedback from your apps. Built exclusively on Val Town, the service will leverage TypeScript with Deno runtime and Val Town's built-in SQLite database for data storage. This project is designed for personal use, allowing you to collect feedback from one or more of your applications and view it in a consolidated dashboard.
6
7## 2. Technical Requirements
10- **Runtime:** Deno (Val Town's native runtime)
11- **Programming Language:** TypeScript
12- **Database:** Val Town's built-in SQLite database (limit: 10MB free, 1GB paid)
13- **Authentication:** Simple API key authentication for your apps to send feedback
14- **Frontend:** HTML/CSS/JS served directly from Val Town HTTP vals
61├── index.ts                 # Main entry point for the project
62├── db/
63│   ├── schema.ts            # Database schema definitions
64│   ├── init.ts              # Database initialization
65│   └── queries.ts           # Database query functions
66├── api/
67│   ├── submitFeedback.ts    # HTTP val for feedback submission

3## 🔍 Project Overview
4
5**AppFeedback.val** is a personal service built on Val Town for collecting and managing app feedback in a SQLite database. This service will be single-user (for personal use only) and implemented as a Val Town Project using TypeScript with the Deno runtime.
6
7> **Note:** The project has been created in Val Town with the name **"productpanel"**. Updates can be pushed to Val Town using the `vt` command line tool.
20   - [ ] Push updates to Val Town using the `vt` command
21
222. **Database Schema Design**
23   - [x] Create `db/schema.ts` with table definitions
24   - [x] Create `db/init.ts` for database initialization
25   - [x] Create `db/queries.ts` for database operation functions
26   - [x] Create `db/migrations.ts` for handling schema changes
27
35   - [x] Create `api/submitFeedback.ts` as an HTTP val for receiving feedback
36   - [x] Implement request validation in `utils/validation.ts`
37   - [x] Create database query functions in `db/queries.ts`
38
393. **App Management API**
81   - [ ] Test API endpoints with Deno's testing framework
82   - [ ] Test email notification delivery
83   - [ ] Verify database performance
84
85---
94├── db/
95│   ├── schema.ts           # Table definitions
96│   ├── init.ts             # Database initialization
97│   └── queries.ts          # Query functions
98├── api/
123
1242. **SQLite via Val Town**
125   - Use `std/sqlite` for database operations
126   - Implement parameterized queries for security
127   - Structure queries in `db/queries.ts` for reusability
1411. **Feedback Collection Flow**
142   - App sends POST request with feedback data + API key to submitFeedback endpoint
143   - Authentication middleware validates API key against database
144   - Validation middleware checks input data
145   - Database module stores feedback in SQLite
146   - Email module sends notification
147   - Response sent back to app
162
163- Set up Val Town Project structure
164- Design and implement database schema and operations
165- Test Deno runtime features and Val Town integration
166- Create API key generation and authentication utilities

6# AppFeedback.val Project Overview
7
8This is a personal service for collecting and managing app feedback built on Val Town using TypeScript. It leverages Val Town's SQLite database for storage, HTTP vals for API endpoints, and email functionality for notifications.
9
10## Key Project Documents
16AppFeedback.val is a single-user service that allows you to:
171. Collect feedback from your various applications
182. Store that feedback in a SQLite database
193. View and analyze feedback through a dashboard
204. Receive email notifications when new feedback is submitted
30├── db/
31│   ├── schema.ts           # Table definitions
32│   ├── init.ts             # Database initialization
33│   └── queries.ts          # Query functions
34├── api/

11
121. **Incremental Development**
13   - Start with database schema initialization
14   - Then build core API endpoints
15   - Finally develop the dashboard UI
312. **SQLite Usage**
32   - Use parameterized queries to prevent SQL injection
33   - Keep database schema simple to stay within size limits (10MB free, 1GB paid)
34   - Create new tables when modifying schema rather than using ALTER TABLE
35   - Consider occasional exports for backup
434. **Authentication**
44   - Generate strong API keys (at least 32 characters)
45   - Store API keys in the database, not as environment variables
46   - Use basic authentication for dashboard access
47   - Always validate API keys against the database
48
495. **UI Development**
113## Troubleshooting
114
115- **Database Issues**: Check SQLite query syntax and parameter types
116- **HTTP Val Errors**: Verify Request/Response format against Web API standards
117- **Authentication Problems**: Ensure API keys match and Authorization header is correctly formatted