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

package/queries/block-2.ts

@@ -0,0 +1,339 @@
+import { db } from '@alstar/db'
+import { sql } from '../utils/sql.ts'
+import { type DBBlockResult } from '../types.ts'
+
+function buildForest(blocks: DBBlockResult[]): DBBlockResult[] {
+  const map = new Map<number, DBBlockResult>()
+  const roots: DBBlockResult[] = []
+
+  for (const block of blocks) {
+    block.children = []
+    map.set(block.id, block)
+  }
+
+  for (const block of blocks) {
+    if (block.parent_id === null) {
+      roots.push(block)
+    } else {
+      const parent = map.get(block.parent_id)
+      if (parent) parent.children!.push(block)
+    }
+  }
+
+  // Sort children by sort_order recursively
+  const sortChildren = (node: DBBlockResult) => {
+    node.children!.sort((a, b) => a.sort_order - b.sort_order)
+    node.children!.forEach(sortChildren)
+  }
+  roots.forEach(sortChildren)
+
+  return roots
+}
+
+function buildTree(blocks: DBBlockResult[]): DBBlockResult {
+  const map = new Map<number, DBBlockResult>()
+  const roots: DBBlockResult[] = []
+
+  for (const block of blocks) {
+    block.children = []
+    map.set(block.id, block)
+  }
+
+  for (const block of blocks) {
+    if (block.parent_id === null) {
+      roots.push(block)
+    } else {
+      const parent = map.get(block.parent_id)
+      if (parent) parent.children!.push(block)
+    }
+  }
+
+  // Sort children by sort_order recursively
+  const sortChildren = (node: DBBlockResult) => {
+    node.children!.sort((a, b) => a.sort_order - b.sort_order)
+    node.children!.forEach(sortChildren)
+  }
+  roots.forEach(sortChildren)
+
+  return roots[0]
+}
+
+function transformBlocksTree(
+  block: DBBlockResult,
+  isBlocksChild?: boolean,
+): DBBlockResult {
+  const fields: Record<string, DBBlockResult> = {}
+  let hasFields = false
+
+  for (const child of block.children ?? []) {
+    const transformedChild = transformBlocksTree(
+      child,
+      child.type === 'blocks',
+    )
+
+    if (!isBlocksChild) {
+      hasFields = true
+      fields[transformedChild.name] = transformedChild
+    }
+  }
+
+  if(hasFields) {
+    block.fields = fields
+  }
+  
+  if (!isBlocksChild) {
+    delete block.children
+  } else {
+    delete block.fields
+  }
+
+  return block
+}
+
+function transformForest(blocks: DBBlockResult[]): DBBlockResult[] {
+  return blocks.map((block) => transformBlocksTree(block))
+}
+
+function rootQuery(filterSql: string, depthLimit?: number) {
+  const depthLimitClause =
+    depthLimit !== undefined ? `WHERE d.depth + 1 <= ${depthLimit}` : ''
+
+  return sql`
+    with recursive
+      ancestors as (
+        select
+          id,
+          created_at,
+          updated_at,
+          name,
+          label,
+          type,
+          sort_order,
+          value,
+          options,
+          status,
+          parent_id,
+          0 as depth
+        from
+          blocks
+        where
+          ${filterSql}
+        union all
+        select
+          b.id,
+          b.created_at,
+          b.updated_at,
+          b.name,
+          b.label,
+          b.type,
+          b.sort_order,
+          b.value,
+          b.options,
+          b.status,
+          b.parent_id,
+          a.depth + 1
+        from
+          blocks b
+          inner join ancestors a on b.id = a.parent_id
+      ),
+      roots as (
+        select
+          id,
+          created_at,
+          updated_at,
+          name,
+          label,
+          type,
+          sort_order,
+          value,
+          options,
+          status,
+          parent_id,
+          0 as depth
+        from
+          ancestors
+        where
+          parent_id is null
+      ),
+      descendants as (
+        select
+          id,
+          created_at,
+          updated_at,
+          name,
+          label,
+          type,
+          sort_order,
+          value,
+          options,
+          status,
+          parent_id,
+          depth
+        from
+          roots
+        union all
+        select
+          b.id,
+          b.created_at,
+          b.updated_at,
+          b.name,
+          b.label,
+          b.type,
+          b.sort_order,
+          b.value,
+          b.options,
+          b.status,
+          b.parent_id,
+          d.depth + 1
+        from
+          blocks b
+          inner join descendants d on b.parent_id = d.id ${depthLimitClause}
+      )
+    select
+      *
+    from
+      descendants
+    order by
+      sort_order,
+      id;
+  `
+}
+
+function buildFilterSql(params: Record<string, any>) {
+  const entries = Object.entries(params)
+  const filterSql = entries
+    .map(([key, value]) =>
+      value === null ? `${key} is null` : `${key} = :${key}`,
+    )
+    .join(' and ')
+
+  let sqlParams: Record<keyof typeof params, any> = {}
+
+  for (const param in params) {
+    if (params[param] !== null) {
+      sqlParams[param] = params[param]
+    }
+  }
+
+  return { filterSql, sqlParams }
+}
+
+export function roots(
+  params: Record<string, any>,
+  options?: {
+    depth?: number
+  },
+): DBBlockResult[] | [] {
+  const { filterSql, sqlParams } = buildFilterSql(params)
+
+  const query = rootQuery(filterSql, options?.depth)
+  const rows = db.database
+    .prepare(query)
+    .all(sqlParams) as unknown as DBBlockResult[]
+
+  if (!rows.length) return []
+
+  const forest = buildForest(rows)
+
+  return transformForest(forest)
+}
+
+type DBRow = {
+  id: number
+  created_at: string
+  updated_at: string
+  name: string
+  label: string
+  type: string
+  sort_order: number
+  value: string | null
+  options: string | null
+  status: 'enabled' | 'disabled'
+  parent_id: number | null
+  depth: number
+}
+
+type TODO = any
+
+function buildTree2(items: DBRow[]): TODO | null {
+  const map = new Map<number, TODO>();
+
+  // First pass: clone items into map
+  for (const item of items) {
+    map.set(item.id, { ...item });
+  }
+
+  let root: TODO | null = null;
+
+  // Second pass: assign children to parents
+  for (const item of map.values()) {
+    if (item.parent_id === null) {
+      root = item; // Root node
+    } else {
+      const parent = map.get(item.parent_id);
+      if (parent) {
+        if(parent.type === 'blocks') {
+          if (!parent.children) parent.children = [];
+          parent.children.push(item);
+        } else {
+          if (!parent.fields) parent.fields = {};
+          parent.fields[item.name] = item;
+        }
+      }
+    }
+  }
+
+  return root;
+}
+
+export function root(
+  params: Record<string, any>,
+  options?: { depth?: number },
+): DBBlockResult | null {
+  const { filterSql, sqlParams } = buildFilterSql(params)
+
+  const query = rootQuery(filterSql, options?.depth)
+  const rows = db.database
+    .prepare(query)
+    .all(sqlParams) as unknown as DBRow[]
+
+  if (!rows.length) return null
+
+  // const tree = buildTree(rows)
+
+  const tree = buildTree2(rows)
+
+  return tree // transformBlocksTree(tree)
+}
+
+export function block(params: Record<string, any>) {
+  const { filterSql, sqlParams } = buildFilterSql(params)
+
+  const query = sql`
+    select
+      *
+    from
+      blocks
+    where
+      ${filterSql}
+  `
+
+  return db.database.prepare(query).get(sqlParams) as unknown as DBBlockResult
+}
+
+export function blocks(params: Record<string, any>) {
+  const { filterSql, sqlParams } = buildFilterSql(params)
+
+  const query = sql`
+    select
+      *
+    from
+      blocks
+    where
+      ${filterSql}
+    order by
+     sort_order
+  `
+
+  return db.database.prepare(query).all(sqlParams) as unknown as DBBlockResult[]
+}

package/queries/getBlockTrees-2.ts

@@ -0,0 +1,71 @@
+import { structure } from "../index.ts";
+
+export const defineField = <
+  F extends Record<string, any> | undefined = undefined,
+  C extends Record<string, any> | undefined = undefined
+>(config: {
+  type: string;
+  label: string;
+  fields?: F;
+  children?: C;
+}) =>
+  ({
+    kind: 'field',
+    type: config.type,
+    label: config.label,
+    fields: (config.fields ?? {}) as F,
+    children: (config.children ?? {}) as C,
+  } as const);
+
+export const defineBlock = <
+  F extends Record<string, any> = {},
+  C extends Record<string, any> = {}
+>(config: {
+  type: string;
+  label: string;
+  fields?: F;
+  children?: C;
+}) =>
+  ({
+    kind: 'block',
+    type: config.type,
+    label: config.label,
+    fields: (config.fields ?? {}) as F,
+    children: (config.children ?? {}) as C,
+  } as const);
+
+  type InferBlock<T> =
+  // A Block has fields + children
+  T extends { kind: 'block'; fields: infer F; children: infer C }
+    ? {
+        fields: { [K in keyof F]: InferBlock<F[K]> };
+        children: { [K in keyof C]: InferBlock<C[K]> }[keyof C][];
+      }
+    // A Field without children
+    : T extends { kind: 'field'; children: infer C; fields: infer F }
+      ? keyof C extends never
+        ? { value: string | null; type: string; label: string }
+        // A Field with children (like "blocks")
+        : {
+            fields: { [K in keyof F]: InferBlock<F[K]> };
+            children: { [K in keyof C]: InferBlock<C[K]> }[keyof C][];
+            type: string;
+            label: string;
+          }
+      : never;
+
+// Top-level inference for the structure object
+type InferStructure<S> = {
+  [K in keyof S]: InferBlock<S[K]>;
+};
+
+  type AppStructure = typeof structure;
+type AppBlocks = InferStructure<AppStructure>;
+
+// Example: AppBlocks["page"] is the typed shape for a page block
+export function getBlockTrees<T extends keyof AppBlocks>(
+  rootType: T
+): AppBlocks[T][] {
+  // Your SQL + builder code goes here
+  return [] as any;
+}

package/queries/index.ts

@@ -1,2 +1,2 @@
-export * as query from './block.ts'
+export * as query from './block-2.ts'
 export { getBlockTrees } from './getBlockTrees.ts'

package/readme.md

@@ -45,7 +45,7 @@ Pages are defined in the `/pages` directory.
 Access the CMS at:
 
 ```
-/admin
+/studio
 ```
 
 ### Defining Content Structure
@@ -199,7 +199,7 @@ pnpm run dev
 
 Visit:
 
-* **CMS admin**: `http://localhost:3000/admin`
+* **CMS admin**: `http://localhost:3000/studio`
 * **Frontend page**: `http://localhost:3000/my-first-page`
 
 Create a new page in the CMS, set its slug field to `my-first-page`, and the frontend will render it automatically.

package/schema.sql

@@ -0,0 +1,18 @@
+CREATE TABLE blocks (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        created_at DATE DEFAULT (datetime('now')),
+        updated_at DATE DEFAULT (datetime('now')),
+        
+    name TEXT not null,
+    label TEXT not null,
+    type TEXT not null,
+    sort_order INTEGER not null default 0,
+    value TEXT,
+    options JSON,
+    status TEXT default 'enabled',
+    parent_id INTEGER,
+    _depth INTEGER,
+    foreign key (parent_id) references blocks (id)
+  
+      );
+CREATE TABLE sqlite_sequence(name,seq);

package/schemas.ts

@@ -1,5 +1,15 @@
 import { sql } from './utils/sql.ts'
 
+// -- API keys
+export const usersTable = {
+  tableName: 'users',
+  columns: sql`
+    email TEXT not null,
+    hash TEXT
+  `,
+}
+
+
 // -- Blocks
 export const blocksTable = {
   tableName: 'blocks',
@@ -11,7 +21,7 @@ export const blocksTable = {
     options JSON,
     status TEXT default 'enabled',
     sort_order INTEGER not null default 0,
-    _depth INTEGER,
+    -- _depth INTEGER,
     parent_id INTEGER,
     foreign key (parent_id) references blocks (id)
   `,

package/types.ts

@@ -8,6 +8,16 @@ import {
   FieldInstance,
 } from './utils/define.ts'
 
+// DeepReadonly utility type
+export type DeepReadonly<T> =
+  T extends (...args: any[]) => any   // functions stay as-is
+    ? T
+    : T extends any[]        // arrays/tuples
+      ? { [K in keyof T]: DeepReadonly<T[K]> }
+      : T extends object              // objects
+        ? { [K in keyof T]: DeepReadonly<T[K]> }
+        : T;                          // primitives
+
 export type PrimitiveField = {
   name: string
   label: string
@@ -31,6 +41,7 @@ export type Block = {
 }
 
 export type Structure = Record<string, BlockDefStructure>
+// export type Structure = Record<string, BlockDefStructure>
 
 // --- Field & block definitions ---
 type FieldType = 'text' | 'slug' | 'markdown' | 'image'

package/utils/auth.ts

@@ -0,0 +1,54 @@
+import { db } from '@alstar/db'
+import { type MiddlewareHandler } from 'hono'
+import { getCookie, setCookie } from 'hono/cookie'
+import { HTTPException } from 'hono/http-exception'
+import { sql } from './sql.ts'
+
+const middleware: MiddlewareHandler = async (c, next) => {
+  const url = new URL(c.req.url)
+  const user = db.database
+    .prepare(sql`
+      select
+        email
+      from
+        users
+    `)
+    .get()
+
+  const cookie = getCookie(c, 'login')
+
+  if (
+    !user &&
+    url.pathname !== '/studio/register' &&
+    url.pathname !== '/studio/api/auth/register'
+  ) {
+    return c.redirect('/studio/register')
+  }
+
+  if (
+    user &&
+    !cookie &&
+    url.pathname !== '/studio/login' &&
+    url.pathname !== '/studio/api/auth/login'
+  ) {
+    return c.redirect('/studio/login')
+  }
+
+  // console.log(cookie)
+
+  // deleteCookie(c, 'cookie_name')
+
+  // const allCookies = getCookie(c)
+
+  await next()
+
+  // const authorized = false
+
+  // if(!authorized) {
+  //   throw new HTTPException(401, { message: 'Custom error message' })
+  // } else {
+  //   await next()
+  // }
+}
+
+export default middleware

package/utils/create-hash.ts

@@ -0,0 +1,9 @@
+import crypto from 'node:crypto'
+
+export const createHash = (str: string) => {
+  const hash = crypto.createHash('sha256')
+  
+  hash.update(str)
+  
+  return hash.digest().toString('base64')
+}

package/utils/define.ts

@@ -34,8 +34,6 @@ export function defineBlock(block: types.BlockDef): types.BlockDefStructure {
   return { ...block, instanceOf: BlockInstance }
 }
 
-export function defineStructure(
-  structure: Record<string, types.BlockDefStructure>,
-) {
+export function defineStructure(structure: types.Structure) {
   return structure
 }

package/utils/renderSSE.ts

@@ -0,0 +1,27 @@
+import path from 'node:path'
+import { stripNewlines } from './strip-newlines.ts'
+import { type SSEStreamingApi } from 'hono/streaming'
+import { type Context } from 'hono'
+
+export const renderSSE = async (stream: SSEStreamingApi, c: Context) => {
+  const componentPath = c.req.header('render')
+  const props = c.req.header('props')
+
+  if (componentPath) {
+    try {
+      const partialToRender = await import(
+        path.join('../', 'components', componentPath + '.ts')
+      )
+
+      const propsJSON = props ? JSON.parse(props) : undefined
+      const component = await partialToRender.default(propsJSON)
+
+      await stream.writeSSE({
+        event: 'datastar-patch-elements',
+        data: `elements ${stripNewlines(component)}`,
+      })
+    } catch (error) {
+      console.log(error)
+    }
+  }
+}

package/utils/slugify.ts

@@ -1,4 +1,6 @@
-export function slugify(str: string) {
+export function slugify(str?: string | null) {
+  if (!str) return ''
+
   return String(str)
     .normalize('NFKD') // split accented characters into their base characters and diacritical marks
     .replace(/[\u0300-\u036f]/g, '') // remove all the accents, which happen to be all in the \u03xx UNICODE block.

package/utils/startup-log.ts

@@ -1,10 +1,19 @@
 import packageJSON from '../package.json' with { type: 'json' }
 
 export default ({ port, refresherPort }: { port: number, refresherPort: number }) => {
-  console.log('\x1b[32m%s\x1b[0m', '╭───────────────────────╮')
-  console.log('\x1b[32m%s\x1b[0m', '│ Alstar Studio         │')
-  console.log('\x1b[32m%s\x1b[0m', `│ ${packageJSON.version}${' '.repeat(22 - packageJSON.version.length)}│`)
-  console.log('\x1b[32m%s\x1b[0m', `│ http://localhost:${port} │`)
-  console.log('\x1b[32m%s\x1b[0m', `│ Refresher port:  ${refresherPort} │`)
-  console.log('\x1b[32m%s\x1b[0m', '╰───────────────────────╯')
+  console.log('\x1b[32m%s\x1b[0m', '╭───────────────╮')
+  console.log('\x1b[32m%s\x1b[0m', '│ Alstar Studio │')
+  console.log('\x1b[32m%s\x1b[0m', '╰───────────────╯')
+  console.log(' ')
+  console.log('\x1b[32m%s\x1b[0m', `Version:`)
+  console.log(packageJSON.version)
+  console.log(' ')
+  console.log('\x1b[32m%s\x1b[0m', `App:`)
+  console.log(`http://localhost:${port}`)
+  console.log(' ')
+  console.log('\x1b[32m%s\x1b[0m', `Studio:`)
+  console.log(`http://localhost:${port}/studio`)
+  console.log(' ')
+  console.log('\x1b[32m%s\x1b[0m', `Refresher:`)
+  console.log(`http://localhost:${refresherPort}`)  
 }

package/components/Backup.ts

@@ -1,10 +0,0 @@
-import { html } from 'hono/html'
-
-export default () => {
-  return html`<article>
-      <header>Backup</header>
-      <form data-on-submit="@post('/admin/api/backup', { contentType: 'form' })">
-        <button type="submit">Backup database</button>
-      </form>
-    </article>`
-}

package/utils/build-structure-path.ts

@@ -1,43 +0,0 @@
-import { type Block } from '../types.ts'
-import { structure } from '../index.ts'
-
-export type StructurePath = (string | number)[]
-
-function getTargetPath(
-  target: Block,
-  path: StructurePath,
-): number | string | undefined {
-  if (!path.length) {
-    return structure.findIndex((block) => block.name === target.name)
-  }
-
-  let sub = structure
-
-  path.forEach((key: number | string) => {
-    if (sub) {
-      // @ts-ignore
-      sub = sub[key]
-    }
-  })
-
-  if (Array.isArray(sub)) {
-    return sub.findIndex((block) => block.name === target.name)
-  }
-
-  return
-}
-
-export const buildStructurePath = (
-  target: Block | undefined,
-  path: StructurePath = [],
-) => {
-  if (!target) return path
-
-  const targetPlacement = getTargetPath(target, path)
-
-  if (targetPlacement !== undefined) {
-    path.push(targetPlacement)
-  }
-
-  return path
-}