@alstar/studio 0.0.0-beta.4 → 0.0.0-beta.6

package/queries/structure-types.ts

@@ -0,0 +1,97 @@
+// structure-types.ts
+import { type DBBase } from "./db-types.ts";
+
+/**
+ * Extract helpers
+ */
+type ArrayElement<T> = T extends readonly (infer U)[] ? U : never;
+
+/**
+ * Field definition shape inferred from defineField(...) (the runtime helper)
+ * We keep it generic as "any" shape but with the important properties present
+ */
+type FieldDef = {
+  readonly name: string;
+  readonly type: string;
+  readonly fields?: readonly any[]; // only present when type === 'blocks'
+};
+
+/**
+ * Block definition shape inferred from defineBlock(...) (the runtime helper)
+ */
+type BlockDef = {
+  readonly name: string;
+  readonly type: string;
+  readonly fields?: readonly FieldDef[];
+};
+
+/**
+ * Primitive field node (non-'blocks'): DBBase + kept fields but no children
+ */
+type PrimitiveFieldNode<TField extends FieldDef> =
+  DBBase & {
+    readonly name: TField["name"];
+    readonly type: TField["type"];
+    // no children (leaf), no nested fields
+    readonly children?: [];
+    readonly fields?: {}; // empty object for leaf
+  };
+
+/**
+ * For 'blocks' typed field, we need:
+ * - the block node representing the 'blocks' wrapper (has DBBase props)
+ * - its 'children' are an array of BlockNodes corresponding to nested block defs supplied in the field's 'fields' array
+ * - its 'fields' property is the mapping of its own child-field names (can be empty)
+ */
+type BlocksFieldNode<
+  TField extends FieldDef,
+  TFieldDefs extends readonly BlockDef[]
+> = DBBase & {
+  readonly name: TField["name"];      // e.g. "blocks" or "images"
+  readonly type: "blocks";            // literally 'blocks'
+  readonly children: BlockNodeFromBlockDefs<TFieldDefs>[]; // children are instances of the nested blocks
+  readonly fields: FieldsFromFieldDefs<TFieldDefs[number]["fields"]>; // the blocks-wrapper's own fields mapping (if any)
+};
+
+/**
+ * Build the 'fields' object for a set of FieldDef[].
+ * Maps each field name -> either PrimitiveFieldNode or BlocksFieldNode recursively.
+ */
+type FieldsFromFieldDefs<TDefs> =
+  // If no fields
+  TDefs extends readonly any[]
+    ? {
+        // For each field F in TDefs, map F['name'] -> node type
+        [F in ArrayElement<TDefs> as F extends { name: infer N extends string } ? N : never]:
+          F extends { type: "blocks"; fields: readonly BlockDef[] }
+            ? BlocksFieldNode<F, F["fields"]>
+            : PrimitiveFieldNode<F>;
+      }
+    : {};
+
+/**
+ * A Block node type for a particular BlockDef.
+ * - fields: mapping derived from the block's declared fields
+ * - children: by default [], because in our final shape all immediate children are placed under 'fields' of the parent.
+ *   BUT for nodes that are themselves 'blocks' wrappers (i.e. appear as a Block instance of a nested block def),
+ *   their 'children' will contain actual child blocks (these are handled via BlocksFieldNode above).
+ */
+export type BlockNode<T extends BlockDef> = DBBase & {
+  readonly name: T["name"];
+  readonly type: T["type"];
+  readonly fields: FieldsFromFieldDefs<T["fields"]>;
+  // for regular block nodes, children will usually be [] (top-level parent's children moved into fields)
+  readonly children: [];
+};
+
+/**
+ * Construct BlockNode unions for a set of block defs (used when blocks field has multiple block subdefs)
+ */
+type BlockNodeFromBlockDefs<TDefs extends readonly BlockDef[]> =
+  ArrayElement<TDefs> extends infer B ? (B extends BlockDef ? BlockNode<B> : never) : never;
+
+/**
+ * The top-level forest return type when you pass a structure: it's an array of BlockNode of any top-level BlockDef
+ */
+export type BlockTreeFromStructure<TStructure extends readonly BlockDef[]> =
+  BlockNodeFromBlockDefs<TStructure>;

package/schemas.ts

@@ -1,56 +1,5 @@
 import { sql } from './utils/sql.ts'
 
-// export const entriesTable = {
-//   tableName: 'entries',
-//   columns: sql`
-//     title TEXT not null, -- Title of the page
-//     slug TEXT not null unique, -- URL slug for the page
-//     meta_description TEXT -- Optional meta description for SEO
-//   `,
-// }
-
-// export const fieldTable = {
-//   tableName: 'fields',
-//   columns: sql`
-//     name TEXT not null, -- Name of the field (e.g., "content", "header", "image")
-//     type TEXT not null, -- Field type (e.g., "text", "image", "video")
-//     label TEXT not null, -- Field label (e.g., "Text", "Image", "Video")
-//     options TEXT -- Additional options or settings (can be a JSON string if needed)
-//   `,
-// }
-
-// export const entriesFieldsTable = {
-//   tableName: 'entry_fields',
-//   columns: sql`
-//     entry_id INTEGER not null, -- Foreign key to pages
-//     field_id INTEGER not null, -- Foreign key to fields
-//     position INTEGER, -- Optional: order of the field on the page
-//     content TEXT, -- Content of the field (e.g., text, image URL, etc.)
-//     foreign key (entry_id) references entries (id),
-//     foreign key (field_id) references fields (id)
-//   `,
-// }
-
-// export const entryTypeTable = {
-//   tableName: 'entry_types',
-//   columns: sql`
-//     name TEXT not null, -- Name of the field (e.g., "content", "header", "image")
-//     type TEXT not null, -- Field type (e.g., "text", "image", "video")
-//     label TEXT not null, -- Field label (e.g., "Text", "Image", "Video")
-//     options TEXT -- Additional options or settings (can be a JSON string if needed)
-//   `,
-// }
-
-// export const entryEntryTypeTable = {
-//   tableName: 'entry_entry_types',
-//   columns: sql`
-//     entry_id INTEGER not null, -- Foreign key to pages
-//     entry_type_id INTEGER not null, -- Foreign key to fields
-//     foreign key (entry_id) references entries (id),
-//     foreign key (entry_type_id) references entry_types (id)
-//   `,
-// }
-
 // -- Blocks
 export const blocksTable = {
   tableName: 'blocks',
@@ -58,10 +7,22 @@ export const blocksTable = {
     name TEXT not null,
     label TEXT not null,
     type TEXT not null,
-    sort_order INTEGER not null default 0,
     value TEXT,
     options JSON,
-    parent_block_id INTEGER,
-    foreign key (parent_block_id) references blocks (id)
+    status TEXT default 'enabled',
+    sort_order INTEGER not null default 0,
+    _depth INTEGER,
+    parent_id INTEGER,
+    foreign key (parent_id) references blocks (id)
+  `,
+}
+
+// -- API keys
+export const apiKeysTable = {
+  tableName: 'api_keys',
+  columns: sql`
+    name TEXT not null,
+    value TEXT,
+    hint TEXT
   `,
 }

package/types.ts

@@ -1,14 +1,94 @@
-import { type HonoOptions } from "hono/hono-base"
-import { type BlankEnv } from "hono/types"
+import { type HttpBindings } from '@hono/node-server'
+import { type Context } from 'hono'
+import { type HonoOptions } from 'hono/hono-base'
+import { type BlankInput, type BlankEnv } from 'hono/types'
+
+export type PrimitiveField = {
+  name: string
+  label: string
+  type: 'text' | 'slug' | 'markdown' | 'image'
+}
+
+export type BlockField = {
+  name: string
+  label: string
+  type: 'blocks'
+  children: Record<string, Field | Block>
+}
+
+export type Field = PrimitiveField | BlockField
 
 export type Block = {
   name: string
   label: string
   type: string
-  fields?: Block[]
+  fields: Record<string, Field | Block>
+}
+
+export type Structure = Record<string, BlockDef>
+
+// --- Field & block definitions ---
+type FieldType = 'text' | 'slug' | 'markdown' | 'blocks' | 'image';
+
+interface BaseField {
+  label: string;
+  type: FieldType;
+  description?: string
+}
+
+interface TextField extends BaseField {
+  type: 'text' | 'slug' | 'markdown';
 }
 
-export type Structure = Block[]
+interface ImageField extends BaseField {
+  type: 'image';
+}
+
+export interface BlocksField extends BaseField {
+  type: 'blocks';
+  children: Record<string, BlockDef | FieldDef>;
+}
+
+export type FieldDef = TextField | ImageField | BlocksField;
+
+export interface BlockDef {
+  label: string;
+  type: string;
+  fields: Record<string, FieldDef>;
+  description?: string
+}
+
+type DBDefaults = {
+  id: number
+  created_at: string
+  updated_at: string
+  name: string
+  label: string
+  // type: string
+  sort_order: number
+  value: string
+  options: string | null
+  status: 'enabled' | 'disabled'
+  parent_id: number | null
+  depth: number
+}
+
+export type DBBlockResult = {
+  id: number
+  created_at: string
+  updated_at: string
+  name: string
+  label: string
+  type: string
+  sort_order: number
+  value: string | null
+  options: any
+  status: string
+  parent_id: number | null
+  depth: number
+  children?: DBBlockResult[]
+  fields?: Record<string, DBBlockResult>
+}
 
 export type DBBlock = Block & {
   id: number
@@ -16,10 +96,20 @@ export type DBBlock = Block & {
   updated_at: string
   value: string | null
   sort_order: number | null
-  parent_block_id: number | null
+  parent_id: number | null
   options: number | null
 }
 
+export type BlockStatus = 'enabled' | 'disabled'
+
 export type StudioConfig = {
+  siteName: string
   honoConfig?: HonoOptions<BlankEnv>
+  structure: Structure
 }
+
+export type RequestContext = Context<
+  { Bindings: HttpBindings },
+  string,
+  BlankInput
+>

package/utils/buildBlocksTree.ts

@@ -6,7 +6,7 @@ type Block = {
   sort_order: number
   value: string | null
   options: any // JSON-parsed if necessary
-  parent_block_id: number | null
+  parent_id: number | null
   depth: number
   // ... you can add other fields if needed
 }
@@ -26,13 +26,13 @@ export function buildBlockTree(blocks: Block[]): BlockWithChildren {
   for (const block of blocks) {
     const current = blockMap.get(block.id)!
 
-    if (block.parent_block_id != null) {
-      const parent = blockMap.get(block.parent_block_id)
+    if (block.parent_id != null) {
+      const parent = blockMap.get(block.parent_id)
       if (parent) {
         parent.fields.push(current)
       } else {
         console.warn(
-          `Parent with id ${block.parent_block_id} not found for block ${block.id}`,
+          `Parent with id ${block.parent_id} not found for block ${block.id}`,
         )
       }
     } else {

package/utils/define.ts

@@ -1,13 +1,29 @@
-import { type Context } from 'hono'
 import * as types from '../types.ts'
-import { type HttpBindings } from '@hono/node-server'
-import { type BlankInput } from 'hono/types'
 import { type HtmlEscapedString } from './html.ts'
 
 export const defineConfig = (config: types.StudioConfig) => config
-export const defineStructure = (structure: types.Structure) => structure
+
+// export const defineStructure = (structure: types.Block[]) => structure
+// export const defineField = (field: types.Field) => field
+// export const defineBlock = (block: types.Block) => block
+
 export const defineEntry = (
   fn: (
-    c: Context<{ Bindings: HttpBindings }, string, BlankInput>,
+    c: types.RequestContext,
   ) => HtmlEscapedString | Promise<HtmlEscapedString>,
 ) => fn
+
+// --- Identity helpers (preserve literal types) ---
+export function defineField(field: types.FieldDef) {
+  return field
+}
+
+export function defineBlock(block: types.BlockDef) {
+  return block
+}
+
+export function defineStructure(
+  structure: Record<string, types.BlockDef>,
+) {
+  return structure
+}

package/utils/file-based-router.ts

@@ -9,7 +9,15 @@ export const fileBasedRouter = async (rootdir: string) => {
   const router = new Hono()
 
   const root = path.resolve(rootdir)
-  const dirs = await fs.readdir(root, { recursive: true })
+
+  let dirs
+
+  try {
+    dirs = await fs.readdir(root, { recursive: true })
+  } catch (error) {
+    return
+  }
+
   const files = dirs.filter((dir) => path.extname(dir))
 
   await Promise.all(

package/utils/get-config.ts

@@ -3,15 +3,6 @@ import path from 'node:path'
 
 const CONFIG_FILE_NAME = 'alstar.config.ts'
 
-async function fileExists(filepath: string) {
-  // does the file exist?
-  try {
-    await fs.stat(filepath)
-  } catch (error) {
-    return null
-  }
-}
-
 export const getConfig = async <P>(): Promise<P> => {
   const root = path.resolve('./')
 
@@ -24,3 +15,11 @@ export const getConfig = async <P>(): Promise<P> => {
 
   return config as P
 }
+
+async function fileExists(filepath: string) {
+  try {
+    return await fs.stat(filepath)
+  } catch (error) {
+    return null
+  }
+}

package/utils/get-or-create-row.ts

@@ -0,0 +1,28 @@
+import { db } from '@alstar/db'
+import { query } from '../queries/index.ts'
+import type { Block, FieldDef } from '../types.ts'
+
+export function getOrCreateRow(
+  parentId: string | number,
+  name: string,
+  field: Block | FieldDef,
+  sortOrder: number,
+) {
+  const data = query.block({
+    parent_id: parentId?.toString() || null,
+    name: name,
+    sort_order: sortOrder.toString(),
+  })
+
+  if (data) return data
+
+  const change = db.insertInto('blocks', {
+    name: name?.toString(),
+    label: field.label?.toString(),
+    type: field.type?.toString(),
+    sort_order: sortOrder,
+    parent_id: parentId,
+  })
+
+  return query.block({ id: change.lastInsertRowid.toString() })
+}

package/utils/startup-log.ts

@@ -0,0 +1,9 @@
+import packageJSON from '../package.json' with { type: 'json' }
+
+export default () => {
+  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:${3000} │`)
+  console.log('\x1b[32m%s\x1b[0m', '╰───────────────────────╯')
+}

package/components/AdminPanel/AdminPanel.css

@@ -1,59 +0,0 @@
-.admin-panel {
-  /* background: hsla(0, 0%, 0%, 0.1); */
-  padding: 40px;
-  padding-right: 0;
-
-  height: 100%;
-  min-height: inherit;
-
-  min-width: 200px;
-
-  > h1 {
-    padding-bottom: 1rem;
-
-    a {
-      display: flex;
-    }
-
-    svg {
-      height: 1.6rem;
-    }
-  }
-
-  form {
-    padding-bottom: 1rem;
-    
-    button {
-      margin: 10px 0px 20px;
-    }
-  }
-
-  #entries ul {
-    padding: 0;
-
-    > li {
-      margin-bottom: 0px;
-      border-radius: 8px;
-      display: flex;
-      justify-content: space-between;
-      align-items: stretch;
-      /* align-items: center; */
-      list-style: none;
-      margin-inline: -1rem;
-
-      a {
-        text-decoration: none;
-        width: 100%;
-        padding: 0.5rem 1rem;
-      }
-
-      button {
-        border-radius: 7px;
-
-        svg {
-          margin: 0.5rem 1rem;
-        }
-      }
-    }
-  }
-}

package/components/Field.ts

@@ -1,164 +0,0 @@
-import { html } from 'hono/html'
-import { type Block } from '../types.ts'
-import { type HtmlEscapedString } from 'hono/utils/html'
-import { query } from '../queries/index.ts'
-import { db } from '@alstar/db'
-import BlockComponent from './Block.ts'
-import {
-  buildStructurePath,
-  type StructurePath,
-} from '../utils/build-structure-path.ts'
-
-function getData(parentId: string | number, field: Block, sortOrder: number) {
-  const data = query.block({
-    parent: parentId?.toString() || null,
-    name: field.name,
-    sort_order: sortOrder.toString(),
-  })
-
-  if (!data) {
-    const change = db.insertInto('blocks', {
-      name: field.name?.toString(),
-      label: field.label?.toString(),
-      type: field.type?.toString(),
-      sort_order: sortOrder,
-      parent_block_id: parentId,
-    })
-
-    return query.block({ id: change.lastInsertRowid.toString() })
-  }
-
-  return data
-}
-
-const Field = (props: {
-  entryId: string | number
-  parentId: string | number
-  blockStructure: Block
-  sortOrder?: number
-  structurePath: StructurePath
-}): HtmlEscapedString | Promise<HtmlEscapedString> => {
-  const {
-    entryId,
-    parentId,
-    blockStructure,
-    sortOrder = 0,
-    structurePath,
-  } = props
-
-  const data = getData(parentId, blockStructure, sortOrder)
-
-  if (!data) return html`<p>No block</p>`
-
-  const fieldStructurePath = buildStructurePath(blockStructure, structurePath)
-
-  return html`
-    ${blockStructure.type === 'slug' &&
-    html`
-      <form
-        data-on-input="@patch('/admin/api/block', { contentType: 'form' })"
-      >
-        <label for="block-${data.id}">${blockStructure.label}</label>
-        <input
-          id="block-${data.id}"
-          name="value"
-          type="text"
-          value="${data.value}"
-        />
-
-        <input type="hidden" name="type" value="${blockStructure.type}" />
-        <input type="hidden" name="id" value="${data.id}" />
-        <input type="hidden" name="entryId" value="${entryId}" />
-        <input type="hidden" name="parentId" value="${parentId}" />
-        <input type="hidden" name="sort_order" value="${sortOrder}" />
-        <input
-          type="hidden"
-          name="path"
-          value="${fieldStructurePath.join('.')}"
-        />
-      </form>
-    `}
-    ${blockStructure.type === 'text' &&
-    html`
-      <form
-        data-on-input="@patch('/admin/api/block', { contentType: 'form' })"
-      >
-        <label for="block-${data.id}">${blockStructure.label}</label>
-        <input
-          id="block-${data.id}"
-          name="value"
-          type="text"
-          value="${data.value}"
-        />
-
-        <input type="hidden" name="type" value="${blockStructure.type}" />
-        <input type="hidden" name="id" value="${data.id}" />
-        <input type="hidden" name="entryId" value="${entryId}" />
-        <input type="hidden" name="parentId" value="${parentId}" />
-        <input type="hidden" name="sort_order" value="${sortOrder}" />
-        <input
-          type="hidden"
-          name="path"
-          value="${fieldStructurePath.join('.')}"
-        />
-      </form>
-    `}
-    ${blockStructure.type === 'image' &&
-    html`
-      <form
-        data-on-input="@patch('/admin/api/block', { contentType: 'form' })"
-      >
-        <label for="block-${data.id}">${blockStructure.label}</label>
-        <input
-          id="block-${data.id}"
-          name="value"
-          type="text"
-          value="${data.value}"
-        />
-
-        <input type="hidden" name="type" value="${blockStructure.type}" />
-        <input type="hidden" name="id" value="${data.id}" />
-        <input type="hidden" name="entryId" value="${entryId}" />
-        <input type="hidden" name="parentId" value="${parentId}" />
-        <input type="hidden" name="sort_order" value="${sortOrder}" />
-        <input
-          type="hidden"
-          name="path"
-          value="${fieldStructurePath.join('.')}"
-        />
-      </form>
-    `}
-    ${blockStructure.type === 'markdown' &&
-    html`
-      <form
-        data-on-input="@patch('/admin/api/block', { contentType: 'form' })"
-      >
-        <label for="block-${data.id}">${blockStructure.label}</label>
-
-        <textarea></textarea>
-
-        <!-- <input
-          id="block-${data.id}"
-          name="value"
-          type="text"
-          value="${data.value}"
-        /> -->
-
-        <input type="hidden" name="type" value="${blockStructure.type}" />
-        <input type="hidden" name="id" value="${data.id}" />
-        <input type="hidden" name="entryId" value="${entryId}" />
-        <input type="hidden" name="parentId" value="${parentId}" />
-        <input type="hidden" name="sort_order" value="${sortOrder}" />
-        <input
-          type="hidden"
-          name="path"
-          value="${fieldStructurePath.join('.')}"
-        />
-      </form>
-    `}
-    ${blockStructure.type === 'blocks' &&
-    BlockComponent(entryId, data.id, blockStructure, fieldStructurePath)}
-  `
-}
-
-export default Field