Search

This is a lightweight SQLite Admin interface to view and debug your SQLite data.


It's currently super limited (no pagination, editing data, data-type specific viewers), and is just a couple dozens lines of code over a couple different vals. Forks encouraged! Just comment on the val if you add any features that you want to share.

To use it on your own Val Town SQLite database, [fork it](https://www.val.town/v/stevekrouse/sqlite_admin/fork) to your account.

It uses [basic authentication](https://www.val.town/v/pomdtr/basicAuth) with your [Val Town API Token](https://www.val.town/settings/api) as the password (leave the username field blank).

const app = new Hono();

app.get("/", async (c) => c.html(await sqlite_admin_tables()));

app.get("/:table", async (c) => c.html(await sqlite_admin_table(c.req.param("table"))));

export default basicAuth(app.fetch);

import { cryptoFearAndGreedIndex } from "https://esm.town/v/chrispie/cryptoFearAndGreedIndex";

export async function pollCryptoFearAndGreedIndex() {

let index = await cryptoFearAndGreedIndex();

const date = Date.now();

if (index) {

cryptoFearAndGreedIndexDB.push({ date, index });

await set(

"cryptoFearAndGreedIndexDB",

cryptoFearAndGreedIndexDB,

import { sqlite } from "https://esm.town/v/std/sqlite";

export default async function() {

return sqlite.execute(`CREATE TABLE IF NOT EXISTS todos (

id INTEGER PRIMARY KEY AUTOINCREMENT,

created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,

text TEXT NOT NULL

How do you make a programmer laugh every morning?

A dad joke cron job!

1. [Fork this val](https://www.val.town/v/stevekrouse/dailyDadJoke/fork)

2. Click **Create fork**

export async function dailyDadJoke() {

let { setup, punchline } = await fetchJSON("https://official-joke-api.appspot.com/random_joke");

return email({

text: punchline,

export { default } from "https://esm.town/v/nbbaier/sqliteExplorerApp?v=81";


To authenticate, use an [API Token](https://www.val.town/settings/api).

import { createApp } from "https://jsr.io/@pomdtr/libsqlstudio/0.0.2/mod.ts";

const app = createApp();

export default passwordAuth(app.fetch, {

verifyPassword: verifyToken,

import { fetch } from "https://esm.town/v/std/fetch";

export async function wttrJson(location: string) {

// https://github.com/chubin/wttr.in#json-output

return (await fetch(`https://wttr.in/${location}?format=j1`)).json();

async function fetchRandomJoke() {

const response = await fetch(

"https://official-joke-api.appspot.com/random_joke",

return response.json();

const randomJoke = await fetchRandomJoke();

const setup = randomJoke.setup;

const punchline = randomJoke.punchline;

export const emailRandomJoke = email({

Handles email subscription signup+verification and sending.

1. Fork and run the sibling Vals to set up SQLite tables: [createSubscribers](https://www.val.town/v/petermillspaugh/createSubscribers), [createNewsletters](https://www.val.town/v/petermillspaugh/createNewsletters), [createEmailLogs](https://www.val.town/v/petermillspaugh/createEmailLogs)

2. Fork this Val and update for your use case (e.g. confirmation link, `sendEmail` args, form fields, etc.)

3. Add an HTML form to your frontend that calls `/send-verification`, or just use `/` to return a simple HTML form

export async function emailSubscription(req: Request) {

const app = new Hono();

app.post("/send-verification", async c => {

const formData = await c.req.formData();

export default async () => {

const URL = "https://healeycodes.com";

const [date, time] = new Date().toISOString().split("T");

let ok = true;

let reason: string;

try {

const res = await fetch(URL);

if (res.status !== 200) {

reason = `(status code: ${res.status})`;

ok = false;

import { blobSetJson } from "https://esm.town/v/andreterron/blobSetJson";

export const blobTest = await (async () => {

let key = "counter-never set";

const result = await blobGetJson(key);

// await blobSetJson(key, result ?? 0);

// const result1 = await blobGetJson(key);

// await blobSetJson(key, result + 1);

// const result2 = await blobGetJson(key);

return result;

export async function formulaEndpoint(req) {

if (req.method !== "GET") {

return new Response("Method Not Allowed", { status: 405 });

// PARSE URL

const params = new URLSearchParams(req.url.split("?")[1]);

// Extract the method and remove it from the parameters

const method = params.get("method");

params.delete("method");

// Initialize an object to store the variables

const vars = {};

export let getSeattleSubwayTweets = async (request: Request): Promise<Response> => {

let data = await fetch(

`https://api.apify.com/v2/acts/quacker~twitter-url-scraper/runs/last/dataset/items?token=apify_api_wi6mnWH8aJ5yiwv3ePmYV7BI31yTE13ameye`,

let jsonData = await data.json();

return Response.json(

jsonData

.map(({ full_text, url, created_at, user }) => ({

full_text,

url,

created_at,

export let elExampleVal = new Date();

export const testFilteringCommentsVal = (() => {

const innerAsyncFunction = async () => {

logMessage("debug", "Initialization of innerAsyncFunction");

const lastRunAt = new Date("2013-10-14T16:07:01.000Z");

// Construct the URL with the desired parameters

const url = ConstructReadTangleUrl({ post_id: "6525827c68f969000134e052" });

// Fetch the comments using the constructed URL

logMessage("info", "Fetching comments from the server");

const comments = await fetchComments(url);