@alstar/studio 0.0.0-beta.10 → 0.0.0-beta.11

package/api/api-key.ts

@@ -8,66 +8,62 @@ import crypto from 'node:crypto'
 import { stripNewlines } from '../utils/strip-newlines.ts'
 import { sql } from '../utils/sql.ts'
 import Settings from '../components/Settings.ts'
+import { createHash } from '../utils/create-hash.ts'
 
-export default () => {
-  const app = new Hono<{ Bindings: HttpBindings }>()
+const app = new Hono<{ Bindings: HttpBindings }>()
 
-  app.post('/api-key', async (c) => {
-    return streamSSE(c, async (stream) => {
-      const formData = await c.req.formData()
-      const data = Object.fromEntries(formData.entries())
+app.post('/api-key', async (c) => {
+  return streamSSE(c, async (stream) => {
+    const formData = await c.req.formData()
+    const data = Object.fromEntries(formData.entries())
 
-      if (!data) return
+    if (!data) return
 
-      const apiKey = crypto.randomUUID()
-      const hash = crypto.createHash('sha256')
+    const apiKey = crypto.randomUUID()
 
-      hash.update(apiKey)
+    const hash = createHash(apiKey)
 
-      const digest = hash.digest().toString('base64')
+    const xs = (length: number) => '*'.repeat(length)
 
-      const xs = (length: number) => '*'.repeat(length)
-
-      db.insertInto('api_keys', {
-        name: data.name?.toString(),
-        value: digest,
-        hint: `${apiKey.substring(0, 8)}-${xs(4)}-${xs(4)}-${xs(4)}-${xs(12)}`,
-      })
+    db.insertInto('api_keys', {
+      name: data.name?.toString(),
+      value: hash,
+      hint: `${apiKey.substring(0, 8)}-${xs(4)}-${xs(4)}-${xs(4)}-${xs(12)}`,
+    })
 
-      await stream.writeSSE({
-        event: 'datastar-patch-signals',
-        data: `signals { apiKey: '${apiKey}', name: '' }`,
-      })
+    await stream.writeSSE({
+      event: 'datastar-patch-signals',
+      data: `signals { apiKey: '${apiKey}', name: '' }`,
+    })
 
-      await stream.writeSSE({
-        event: 'datastar-patch-elements',
-        data: `elements ${stripNewlines(Settings())}`,
-      })
+    await stream.writeSSE({
+      event: 'datastar-patch-elements',
+      data: `elements ${stripNewlines(Settings())}`,
     })
   })
+})
 
-  app.delete('/api-key', async (c) => {
-    return streamSSE(c, async (stream) => {
-      const formData = await c.req.formData()
+app.delete('/api-key', async (c) => {
+  return streamSSE(c, async (stream) => {
+    const formData = await c.req.formData()
 
-      const value = formData.get('value')?.toString()
+    const value = formData.get('value')?.toString()
 
-      if (!value) return
+    if (!value) return
 
-      db.database
-        .prepare(sql`
-          delete from api_keys
-          where
-            value = ?
-        `)
-        .run(value)
+    db.database
+      .prepare(sql`
+        delete from api_keys
+        where
+          value = ?
+      `)
+      .run(value)
 
-      await stream.writeSSE({
-        event: 'datastar-patch-elements',
-        data: `elements ${stripNewlines(Settings())}`,
-      })
+    await stream.writeSSE({
+      event: 'datastar-patch-elements',
+      data: `elements ${stripNewlines(Settings())}`,
     })
   })
+})
 
-  return app
-}
+export const apiKeyRoutes = app

package/api/auth.ts

@@ -0,0 +1,66 @@
+import { type HttpBindings } from '@hono/node-server'
+import { Hono } from 'hono'
+import { createHash } from '../utils/create-hash.ts'
+import { db } from '@alstar/db'
+import { streamSSE } from 'hono/streaming'
+import { sql } from '../utils/sql.ts'
+import { setCookie } from 'hono/cookie'
+
+const app = new Hono<{ Bindings: HttpBindings }>()
+
+app.post('/register', async (c) => {
+  return streamSSE(c, async (stream) => {
+    const formData = await c.req.formData()
+    const data = Object.fromEntries(formData.entries())
+
+    if (!data || !data.email || !data.password) return
+
+    const hash = createHash(data.password.toString())
+
+    db.insertInto('users', {
+      email: data.email?.toString(),
+      hash: hash,
+    })
+
+    await stream.writeSSE({
+      event: 'datastar-patch-signals',
+      data: `signals { status: 200, message: 'User "${data.email}" created successfully' }`,
+    })
+  })
+})
+
+app.post('/login', async (c) => {
+  const formData = await c.req.formData()
+  const data = Object.fromEntries(formData.entries())
+
+  if (!data || !data.email || !data.password) return
+
+  const user = db.database
+    .prepare(sql`
+      select
+        *
+      from
+        users
+      where
+        email = ?
+    `)
+    .get(data.email.toString())
+
+  if (!user) {
+    return c.json({ status: 404, message: 'No user with that email' })
+  }
+
+  const passwordHash = createHash(data.password.toString())
+
+  if (passwordHash !== user.hash) {
+    return c.json({ status: 401, message: 'Wrong password' })
+  }
+
+  setCookie(c, 'login', 'yes')
+
+  return c.redirect('/studio')
+
+  // return c.json({ status: 200, message: 'Logged in!' })
+})
+
+export const authRoutes = app

package/api/backup.ts

@@ -1,38 +1,40 @@
-import { type HttpBindings } from '@hono/node-server'
+import fsp from 'node:fs/promises'
+import { backup } from 'node:sqlite'
+
 import { Hono } from 'hono'
+import { type HttpBindings } from '@hono/node-server'
 import { streamSSE } from 'hono/streaming'
-import { DatabaseSync } from 'node:sqlite'
-
-import { stripNewlines } from '../utils/strip-newlines.ts'
 import { db } from '@alstar/db'
 
-export default () => {
-  const app = new Hono<{ Bindings: HttpBindings }>()
+const app = new Hono<{ Bindings: HttpBindings }>()
+
+app.post('/backup', async (c) => {
+  const date = new Date()
+  const name = `./backups/backup-${date.toISOString()}.db`
 
-  app.post('/backup', async (c) => {
-    // const totalPagesTransferred = await backup(db.database, './backups/backup.db', {
-    //   rate: 1, // Copy one page at a time.
-    //   progress: ({ totalPages, remainingPages }) => {
-    //     console.log('Backup in progress', { totalPages, remainingPages })
-    //   },
-    // })
+  try {
+    fsp.mkdir('./backups', { recursive: true })
 
-    // console.log('Backup completed', totalPagesTransferred)
+    await backup(db.database, name)
 
-    return c.html('good')
+    console.log('Backup')
 
-    // return streamSSE(c, async (stream) => {
-    //   await stream.writeSSE({
-    //     event: 'datastar-patch-signals',
-    //     data: `signals {}`,
-    //   })
+    return streamSSE(c, async (stream) => {
+      await stream.writeSSE({
+        event: 'datastar-patch-signals',
+        data: `signals { status: 200, message: '${name} created' }`,
+      })
+    })
+  } catch (error) {
+    console.log(error)
 
-    //   await stream.writeSSE({
-    //     event: 'datastar-patch-elements',
-    //     data: `elements ${stripNewlines(Settings())}`,
-    //   })
-    // })
-  })
+    return streamSSE(c, async (stream) => {
+      await stream.writeSSE({
+        event: 'datastar-patch-signals',
+        data: `signals { status: 500, message: '${name} failed' }`,
+      })
+    })
+  }
+})
 
-  return app
-}
+export const backupRoutes = app

package/api/block.ts

@@ -13,92 +13,64 @@ import {
 } from '../queries/block-with-children.ts'
 import AdminPanel from '../components/AdminPanel.ts'
 import { query } from '../queries/index.ts'
+import { studioStructure } from '../index.ts'
 
-export default (structure: Structure) => {
-  const app = new Hono<{ Bindings: HttpBindings }>()
+const app = new Hono<{ Bindings: HttpBindings }>()
 
-  app.post('/block', async (c) => {
-    return streamSSE(c, async (stream) => {
-      const formData = await c.req.formData()
-      const data = Object.fromEntries(formData.entries())
+app.post('/block', async (c) => {
+  return streamSSE(c, async (stream) => {
+    const formData = await c.req.formData()
+    const data = Object.fromEntries(formData.entries())
 
-      const row = structure[data.name?.toString()]
+    const row = studioStructure[data.name?.toString()]
 
-      if (!row) return
+    if (!row) return
 
-      db.insertInto('blocks', {
-        name: data.name?.toString(),
-        label: row.label,
-        type: row.type,
-      })
+    db.insertInto('blocks', {
+      name: data.name?.toString(),
+      label: row.label,
+      type: row.type,
+    })
 
-      await stream.writeSSE({
-        event: 'datastar-patch-elements',
-        data: `elements ${stripNewlines(AdminPanel())}`,
-      })
+    await stream.writeSSE({
+      event: 'datastar-patch-elements',
+      data: `elements ${stripNewlines(AdminPanel())}`,
     })
   })
+})
+
+app.post('/new-block', async (c) => {
+  return streamSSE(c, async (stream) => {
+    const formData = await c.req.formData()
+    const data = Object.fromEntries(formData)
+
+    db.insertInto('blocks', {
+      type: data.type.toString(),
+      name: data.name.toString(),
+      label: data.label.toString(),
+      parent_id: data.parent_id.toString(),
+      sort_order: data.sort_order.toString(),
+    })
 
-  app.post('/new-block', async (c) => {
-    return streamSSE(c, async (stream) => {
-      const formData = await c.req.formData()
-      const data = Object.fromEntries(formData)
-
-      db.insertInto('blocks', {
-        type: data.type.toString(),
-        name: data.name.toString(),
-        label: data.label.toString(),
-        parent_id: data.parent_id.toString(),
-        sort_order: data.sort_order.toString(),
-      })
-
-      await stream.writeSSE({
-        event: 'datastar-patch-elements',
-        data: `elements ${stripNewlines(Entry({ entryId: parseInt(data.entry_id.toString()) }))}`,
-      })
+    await stream.writeSSE({
+      event: 'datastar-patch-elements',
+      data: `elements ${stripNewlines(Entry({ entryId: parseInt(data.entry_id.toString()) }))}`,
     })
   })
+})
 
-  app.patch('/block', async (c) => {
-    return streamSSE(c, async (stream) => {
-      const formData = await c.req.formData()
-
-      const id = formData.get('id')?.toString()
-      const value = formData.get('value')?.toString()
-      const name = formData.get('name')?.toString()
-      const entryId = formData.get('entryId')?.toString()
-      const parentId = formData.get('parentId')?.toString()
-      // const sortOrder = formData.get('sort_order')?.toString()
+app.patch('/block', async (c) => {
+  return streamSSE(c, async (stream) => {
+    const formData = await c.req.formData()
 
-      if (!id || !value) return
+    const id = formData.get('id')?.toString()
+    const value = formData.get('value')?.toString()
+    const name = formData.get('name')?.toString()
+    const entryId = formData.get('entryId')?.toString()
+    const parentId = formData.get('parentId')?.toString()
+    // const sortOrder = formData.get('sort_order')?.toString()
 
-      const transaction = db.database.prepare(sql`
-        update blocks
-        set
-          value = ?
-        where
-          id = ?;
-      `)
-
-      transaction.run(value, id)
-
-      if (entryId === parentId && name?.toString() === 'title') {
-        const rootBlock = query.block({
-          id: parentId?.toString() || null,
-        })
-
-        if (rootBlock.type !== 'single') {
-          await stream.writeSSE({
-            event: 'datastar-patch-elements',
-            data: `elements <a href="/admin/entry/${entryId}" id="block_link_${entryId}">${value}</a>`,
-          })
-        }
-      }
-    })
-  })
-
-  app.patch('/value', async (c) => {
-    const body = await c.req.json()
+    if (!id || !value) return
 
     const transaction = db.database.prepare(sql`
       update blocks
@@ -108,56 +80,83 @@ export default (structure: Structure) => {
         id = ?;
     `)
 
-    transaction.run(body.value, body.id)
+    transaction.run(value, id)
+
+    if (entryId === parentId && name?.toString() === 'title') {
+      const rootBlock = query.block({
+        id: parentId?.toString() || null,
+      })
 
-    return c.json({ status: 200, message: 'success' })
+      if (rootBlock.type !== 'single') {
+        await stream.writeSSE({
+          event: 'datastar-patch-elements',
+          data: `elements <a href="/studio/entry/${entryId}" id="block_link_${entryId}">${value}</a>`,
+        })
+      }
+    }
   })
+})
 
-  app.delete('/block', async (c) => {
-    return streamSSE(c, async (stream) => {
-      const formData = await c.req.formData()
+app.patch('/value', async (c) => {
+  const body = await c.req.json()
 
-      const id = formData.get('id')?.toString()
-      const entryId = formData.get('entry_id')?.toString()
+  const transaction = db.database.prepare(sql`
+    update blocks
+    set
+      value = ?
+    where
+      id = ?;
+  `)
 
-      if (!id) return
+  transaction.run(body.value, body.id)
 
-      const transaction = db.database.prepare(deleteBlockWithChildren)
+  return c.json({ status: 200, message: 'success' })
+})
 
-      transaction.all(id)
+app.delete('/block', async (c) => {
+  return streamSSE(c, async (stream) => {
+    const formData = await c.req.formData()
 
-      if (entryId) {
-        await stream.writeSSE({
-          event: 'datastar-patch-elements',
-          data: `elements ${stripNewlines(Entry({ entryId: parseInt(entryId.toString()) }))}`,
-        })
-      } else {
-        await stream.writeSSE({
-          event: 'datastar-patch-elements',
-          data: `elements ${stripNewlines(AdminPanel())}`,
-        })
-      }
-    })
+    const id = formData.get('id')?.toString()
+    const entryId = formData.get('entry_id')?.toString()
+
+    if (!id) return
+
+    const transaction = db.database.prepare(deleteBlockWithChildren)
+
+    transaction.all(id)
+
+    if (entryId) {
+      await stream.writeSSE({
+        event: 'datastar-patch-elements',
+        data: `elements ${stripNewlines(Entry({ entryId: parseInt(entryId.toString()) }))}`,
+      })
+    } else {
+      await stream.writeSSE({
+        event: 'datastar-patch-elements',
+        data: `elements ${stripNewlines(AdminPanel())}`,
+      })
+    }
   })
+})
 
-  app.post('/sort-order', async (c) => {
-    const id = c.req.query('id')
-    const sortOrder = c.req.query('sort-order')
+app.post('/sort-order', async (c) => {
+  const id = c.req.query('id')
+  const sortOrder = c.req.query('sort-order')
 
-    if (!id || !sortOrder) return
+  if (!id || !sortOrder) return
 
-    const transaction = db.database.prepare(sql`
-      update blocks
-      set
-        sort_order = ?
-      where
-        id = ?
-    `)
+  const transaction = db.database.prepare(sql`
+    update blocks
+    set
+      sort_order = ?
+    where
+      id = ?
+  `)
 
-    transaction.run(sortOrder, id)
+  transaction.run(sortOrder, id)
 
-    return c.json({ status: 200, message: 'success' })
-  })
+  return c.json({ status: 200, message: 'success' })
+})
 
-  return app
-}
+export const blockRoutes = app

package/api/index.ts

@@ -1,13 +1,20 @@
-import block from './block.ts'
-import apiKey from './api-key.ts'
-import type { Structure } from '../types.ts'
-import backup from './backup.ts'
+import { Hono } from 'hono'
 
-export const api = (structure: Structure) => {
-  const app = block(structure)
+import { blockRoutes } from './block.ts'
+import { apiKeyRoutes } from './api-key.ts'
+import { backupRoutes } from './backup.ts'
+import { authRoutes } from './auth.ts'
+import { fieldRoutes } from '../components/fields/index.ts'
 
-  app.route('/', apiKey())
-  app.route('/', backup())
+const routes = new Hono()
 
-  return app
-}
+routes.route('/', blockRoutes)
+routes.route('/', apiKeyRoutes)
+routes.route('/', backupRoutes)
+routes.route('/auth', authRoutes)
+
+fieldRoutes.forEach((fieldRoute) => {
+  routes.route('/field', fieldRoute)
+})
+
+export const apiRoutes = routes

package/api/mcp.ts

@@ -1,53 +1,50 @@
 import { type HttpBindings } from '@hono/node-server'
-import { ServerSentEventGenerator } from '@starfederation/datastar-sdk'
 import { Hono } from 'hono'
 import { sql } from '../utils/sql.ts'
 import { db } from '@alstar/db'
 import { bearerAuth } from 'hono/bearer-auth'
 import crypto from 'node:crypto'
 
-export default () => {
-  const app = new Hono<{ Bindings: HttpBindings }>()
-
-  app.use(
-    '/*',
-    bearerAuth({
-      verifyToken: async (token, c) => {
-        const hash = crypto.createHash('sha256')
-
-        hash.update(token)
-
-        const digest = hash.digest().toString('base64')
-
-        const exists = db.database
-          .prepare(sql`
-            select
-              value
-            from
-              api_keys
-            where
-              value = ?
-          `)
-          .get(digest)
-
-        return !!exists
-      },
-    }),
-  )
-
-  app.get('/entry', async (c) => {
-    return c.json({
-      status: 'success',
-      message: 'Response from MCP server!',
-    })
+const app = new Hono<{ Bindings: HttpBindings }>()
+
+app.use(
+  '/*',
+  bearerAuth({
+    verifyToken: async (token, c) => {
+      const hash = crypto.createHash('sha256')
+
+      hash.update(token)
+
+      const digest = hash.digest().toString('base64')
+
+      const exists = db.database
+        .prepare(sql`
+          select
+            value
+          from
+            api_keys
+          where
+            value = ?
+        `)
+        .get(digest)
+
+      return !!exists
+    },
+  }),
+)
+
+app.get('/entry', async (c) => {
+  return c.json({
+    status: 'success',
+    message: 'Response from MCP server!',
   })
+})
 
-  app.post('/entry', async (c) => {
-    return c.json({
-      status: 'success',
-      message: 'New entry created!',
-    })
+app.post('/entry', async (c) => {
+  return c.json({
+    status: 'success',
+    message: 'New entry created!',
   })
+})
 
-  return app
-}
+export const mcpRoutes = app