Val Town Code SearchReturn to Val Town

1# Database
2
3This app uses [Val Town SQLite](https://docs.val.town/std/sqlite/) to manage data. Every Val Town account comes with a free SQLite database, hosted on [Turso](https://turso.tech/). This folder is broken up into two files:
4
5* `migrations.ts` - code to set up the database tables the app needs
6* `queries.ts` - functions to run queries against those tables, which are imported and used in the main Hono server in `/backend/index.ts`
7
8## Migrations
9
10In `backend/database/migrations.ts`, this app creates a new SQLite table `reactHonoStarter_messages` to store messages. 
11
12This "migration" runs once on every app startup because it's imported in `index.ts`. You can comment this line out for a slight (30ms) performance improvement on cold starts. It's left in so that users who fork this project will have the migration run correctly.
13
14SQLite has much more limited support for altering existing tables as compared to other databases. Often it's easier to create new tables with the schema you want, and then copy the data over. Happily LLMs are quite good at those sort of database operations, but please reach out in the [Val Town Discord](https://discord.com/invite/dHv45uN5RY) if you need help.
15
16## Queries
17
18The queries file is where running the migrations happen in this app. It'd also be reasonable for that to happen in index.ts, or as is said above, for that line to be commented out, and only run when actual changes are made to your database schema.
19
20The queries file exports functions to get and write data. It relies on shared types and data imported from the `/shared` directory.

374];
375
376// Insert memories into the database
377async function insertDemoMemories() {
378  try {
415    await insertDemoMemories();
416
417    console.log("Demo database successfully populated!");
418    return "Demo database successfully populated!";
419  } catch (error) {
420    console.error("Error populating demo database:", error);
421    throw error;
422  }

6import { Hono } from "npm:hono";
7import { type Memory } from "../shared/types.ts";
8import { createMemory, deleteMemory, getAllMemories, updateMemory } from "./database/queries.ts";
9
10const app = new Hono();

208```
209├── backend/
210│   ├── database/
211│   │   ├── migrations.ts    # Schema definitions
212│   │   ├── queries.ts       # DB query functions
270- Handle API calls properly with proper error catching
271
272### Database Patterns
273- Run migrations on startup or comment out for performance
274- Change table names when modifying schemas rather than altering

33
34const notion = new Client({ auth: process.env.NOTION_SECRET! });
35const dbID = process.env.NOTION_DATABASE_ID!;
36
37export default async function syncLetterboxd() {
69      const page = await notion.pages.create({
70        parent: {
71          database_id: dbID,
72        },
73
108
109async function existsByGUID(guid: string) {
110  const res = await notion.databases.query(
111    {
112      database_id: dbID,
113      page_size: 1,
114      filter: {

6
7- `auth.ts` - Authentication middleware
8- `example-database-page.ts` - Handles `/example/database/page` endpoint
9- `example-guest-welcome.ts` - Handles `/example/guest/welcome` endpoint
10- `glancer.ts` - Handles `/glancer` and `/glancer/:id` endpoints

30    // if the block associated to this blob no longer exists in notion
31    // the blob should be deleted; the block id is in lastRun.id
32    // and can be either a callout block or a child_database
33    const block = await notion.blocks.retrieve({ block_id: lastRun?.id });
34    // console.log(block);

7});
8
9export async function createDatabasePagesParallel(databaseId: string, pages: []) {
10  const creations = pages.map((page) =>
11    notion.pages.create({
12      parent: { database_id: databaseId },
13      properties: {
14        "Website": {
42}
43
44// delete all database rows
45export async function deleteAllDatabasePagesParallel(databaseId: string) {
46  const pageIds = await notion.databases.query({
47    database_id: databaseId,
48  });
49  // Step 2: Delete all pages in parallel
59}
60
61export async function getDatabaseId(databaseTitle: string) {
62  // getDatabaseId(databaseTitle)
63  const database = await notion.databases
64    .query({ filter: { property: "title", title: { equals: databaseTitle } } });
65  return database.results[0].id;
66}
67
68export async function getDatabaseTitle(databaseId: string) {
69  // getDatabaseTitle(databaseId)
70  const database = await notion.databases.retrieve({ database_id: databaseId });
71  // console.log(database.title[0].plain_text);
72  return database.title[0].plain_text;
73}
74
75export async function getDatabaseParentPageId(databaseId: string) {
76  let currentBlockId = databaseId;
77
78  while (true) {
121}
122
123export async function findChildDatabaseBlocks(rootBlockId: string, blockIdentifier: string) {
124  const matchingBlocks = [];
125
140      // }
141      if (
142        block.type === "child_database" && block.child_database?.title && (!block.archived || !block.in_trash)
143      ) {
144        const databaseTitle = await helpers.slugify(block.child_database?.title.toLowerCase()) || "";
145        const identifier = await helpers.slugify(blockIdentifier?.toLowerCase());
146
147        if (databaseTitle === identifier) {
148          console.log(databaseTitle, identifier);
149          matchingBlocks.push(block);
150        }

20  const data = payload?.data;
21  const pageId = data?.id;
22  const databaseId = data?.parent?.database_id;
23
24  // this endpoint is for a specific database page and is triggered by a button in that database page
25
26  // the button that calls this endpoint sends a payload with the id of the database page, and the id of the parent database
27  // (e.g., pageId and databaseId from the payload)
28
29  // different than other endpoints, this one does not get called by a reset button or the cron reset
30  // instead, the reset button and the reset cron target the database, not the page
31  // so, we don't have a reset call coming in with the x-blob-key custom header to this enpoint
32  // nor do we have a x-container-title header that holds the title of the target object coming from the button payload
33
34  // both the reset button and the reset cron delete all database pages, and then add back fresh pages
35  // the endpoint for that is /example-database-pages (note the "s" at the end)
36
37  // different than other endpoints, we get the id of the block to modify (ie, the database page) from the button payload
38  // so, we don't need to do the things we do at other endpoints to get the id of target block
39  // (e.g., search the blob cache, or traverse notion page objects)
40
41  // but, we do need to set the blob for the resets
42  // and for that we'll need the id of the page in which this database lives
43  // and an identifier for the database
44
45  // can that idenfifier be the databaseId rather than the database title?
46  // the reset button sends the database title to the .../pages endpoint in order to find the id of the database
47  // but the matching there will traverse the notion page database objects looking for a title match
48  // which has nothing to do with the database title in the blob
49
50  // note: if you're wondering why none of the notion buttons have hard-coded ids for the targeting
53  // as is, i can clone a page with examples for a guest and everything will work without anyone needing to edit button settings
54
55  // when a user adds a favicon to a database page, we need to capture in the blob cache that a page in this database has been updated
56  // so that resets know which database to reset
57  // but the payload of the favicon button in this page does _not_ send the id of the page in which the database lives
58  // nor does it send the database title
59  // so we'll need to get those to make the blob key
60
67    for (const item of items) {
68      const blobData = await blob.getJSON(item.key);
69      if (blobData?.id === databaseId) {
70        // console.log(item.key, blobData);
71        blobData.key = item.key;
82
83  // blob for cache
84  // get the parent page id of this child_database
85  // this is the user's page and we need it for the blob key
86  const parentPageId = blobject?.user
87    ? blobject?.user?.page_id
88    : await notionHelpers.getDatabaseParentPageId(databaseId);
89
90  // we also need the database title
91  // even though we have the database id and it's tempting to use it here
92  // we need the title in the blob key so that the reset button can work
93  // b/c the reset button can only send the title in the x-container-title header
94  // with no other way to tie the button to the database
95
96  // const databaseTitle = blobject?.key
97  //   ? (blobject?.key).split("--").pop()
98  //   : await notionHelpers.getDatabaseTitle(databaseId);
99  const databaseTitle = await notionHelpers.getDatabaseTitle(databaseId);
100
101  console.log("databaseTitle:", databaseTitle);
102
103  // store webhook data in blob storage for resets
105    "slug": slug,
106    "clientPageId": parentPageId,
107    // "containerId": databaseId, // slugify databaseTitle here?
108    "containerId": await helpers.slugify(databaseTitle),
109  });
110  await blob.setJSON(blobKey, {
113      page_id: parentPageId,
114    },
115    id: databaseId,
116    date: new Date(),
117    content: askingFor,

16  const slug = await c.req.url.replace("https://", "");
17  const askingFor = c.req.headers.get("x-asking-for") || "default"; // val.town or default
18  const containerTitle = c.req.headers.get("x-container-title") || "good web sites"; // should map to the database title
19  const payload = await c.req.json();
20  const pageId = payload?.data?.id;
38
39  // when the reset button is clicked, it sends the x-container-title header
40  // we use this header to a) find a blob or b) if no blob, find a database with a title that matches it
41  // a) find a blob
42  // b) find a database with a title that matches it
43
44  // blob
64  // console.log("blockId:", blockId);
65
66  const databaseId = blobject?.id || (await notionHelpers.findChildDatabaseBlocks(pageId, containerTitle))[0].id;
67  // console.log("databaseId:", databaseId);
68
69  // actions
70  await notionHelpers.deleteAllDatabasePagesParallel(databaseId);
71  // add back pages; fresh start for the next person to add favicons
72  // create new database pages from default object
73  await notionHelpers.createDatabasePagesParallel(databaseId, defaults);
74  // store webhook data in blob storage for resets
75  await blob.setJSON(blobKey, {
78      page_id: pageId,
79    },
80    id: databaseId,
81    date: new Date(),
82    content: askingFor,