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

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/readme.md

@@ -0,0 +1,205 @@
+# Alstar Studio
+
+Alstar Studio is a **fullstack framework** for building CMS-driven applications with **native Node.js** and **Hono**.
+
+
+## Installation
+
+Create a new project:
+
+```sh
+pnpm create @alstar
+```
+
+Follow the CLI prompts to set up a starter project in your chosen folder.
+
+
+## Development
+
+Start the dev server:
+
+```sh
+pnpm run dev
+```
+
+This runs a **Hono server**.
+
+The core app is created via `createStudio(structure)`, which returns the Hono app. This makes it possible to extend the server with plugins or custom settings:
+
+```ts
+const app = await createStudio(structure)
+// app.use(...) custom middleware
+```
+
+
+## Routing
+
+Pages are defined in the `/pages` directory.
+
+* Each `.ts` file becomes a route.
+* Dynamic routes are created with square brackets, e.g. `/pages/[slug].ts`.
+
+
+## CMS
+
+Access the CMS at:
+
+```
+/studio
+```
+
+### Defining Content Structure
+
+Pass a `Structure` object to `createStudio(structure)` to define the schema.
+
+Use the helpers:
+
+```ts
+import { 
+  defineBlock, 
+  defineField, 
+  defineStructure, 
+  defineBlockField 
+} from '@alstar/studio'
+```
+
+### Example: Schema Definition
+
+```ts
+const titleField = defineField({
+  label: 'Title',
+  type: 'text' | 'image' | 'markdown' | 'slug',
+  description: 'Page title'
+})
+
+const pageBuilder = defineBlockField({
+  label: 'Sections',
+  type: 'blocks',
+  children: {
+    hero: defineBlock({
+      label: 'Hero',
+      type: 'hero',
+      fields: { /* fields */ },
+    }),
+    gallery: defineBlock({
+      label: 'Gallery',
+      type: 'gallery',
+      fields: { /* fields */ },
+    }),
+  },
+})
+
+const entryBlock = defineBlock({
+  label: 'Entry',
+  type: 'entry',
+  fields: {
+    title: titleField,
+    builder: pageBuilder
+  }
+})
+
+export default defineStructure({
+  entry: entryBlock
+})
+```
+
+### Concepts
+
+* **Blocks** contain **fields**.
+* **Block fields** (`type: 'blocks'`) can nest multiple block types under `children`.
+* This enables **page builders** and reusable structures.
+
+All content is stored in a **SQLite database** (`studio.db`) and can be queried in the templates with the `query` module.
+
+
+## Frontend
+
+The framework encourages **server-side rendering** with Hono’s HTML helper (re-exported by the `@alstar/studio` package):
+
+```ts
+import { defineEntry, html } from '@alstar/studio'
+
+export default defineEntry((c) => {
+  const slug = c.req.param('slug')
+  
+  return html`
+    <h1>Hello World</h1>
+    <p>This page is: ${slug}</p>
+  `
+})
+```
+
+### Interactivity
+
+Even though the framework allows for having any library and tool for creating client-side behavior, it's recommended to use lightweight libraries such as:
+
+* [Datastar](https://data-star.dev/) (used internally by the Studio)
+* [Alpine.js](https://alpinejs.dev/)
+
+## Quickstart Example Project
+
+This example shows how to define a simple **page schema** and render it on the frontend.
+
+### 1. Define the CMS Schema (`./index.ts`)
+
+```ts
+import { createStudio, defineBlock, defineField, defineStructure } from '@alstar/studio'
+
+const page = defineBlock({
+  label: 'Page',
+  type: 'page',
+  fields: {
+    title: defineField({
+      label: 'Title',
+      type: 'text',
+    }),
+    slug: defineField({
+      label: 'Slug',
+      type: 'slug',
+    }),
+    body: defineField({
+      label: 'Body',
+      type: 'markdown',
+    }),
+  },
+})
+
+const structure = defineStructure({
+  page,
+})
+
+await createStudio(structure)
+```
+
+### 2. Create a Frontend Route (`/pages/[slug].ts`)
+
+```ts
+import { defineEntry, html, query } from '@alstar/studio'
+
+export default defineEntry(c) => {
+  const slug = c.req.param('slug')
+  const page = query.root({ type: 'slug', value: slug })
+
+  if (!page) return c.notFound()
+
+  return html`
+    <main>
+      <h1>${page.fields.title.value}</h1>
+      <article>${page.fields.body.value}</article>
+    </main>
+  `
+}
+```
+
+### 3. Run the Project
+
+```sh
+pnpm run dev
+```
+
+Visit:
+
+* **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,55 +1,14 @@
 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)
-//   `,
-// }
+// -- API keys
+export const usersTable = {
+  tableName: 'users',
+  columns: sql`
+    email TEXT not null,
+    hash TEXT
+  `,
+}
 
-// 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 = {
@@ -58,10 +17,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,142 @@
-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'
+import {
+  BlockFieldInstance,
+  BlockInstance,
+  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
+  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 = Block[]
+export type Structure = Record<string, BlockDefStructure>
+// export type Structure = Record<string, BlockDefStructure>
+
+// --- Field & block definitions ---
+type FieldType = 'text' | 'slug' | 'markdown' | 'image'
+
+interface BaseField {
+  label: string
+  type: FieldType
+  description?: string
+}
+
+interface TextField extends BaseField {
+  type: 'text' | 'slug' | 'markdown'
+}
+
+interface TextFieldStructure extends TextField {
+  instanceOf: typeof FieldInstance
+}
+
+interface ImageField extends BaseField {
+  type: 'image'
+}
+
+interface ImageFieldStructure extends ImageField {
+  instanceOf: typeof FieldInstance
+}
+
+export interface BlocksFieldDef {
+  label: string
+  type: 'blocks'
+  description?: string
+  children: Record<string, BlockDefStructure | FieldDefStructure>
+}
+
+export interface BlocksFieldDefStructure extends BlocksFieldDef {
+  instanceOf: typeof BlockFieldInstance
+}
+
+export type FieldDef = TextField | ImageField
+export type FieldDefStructure = TextFieldStructure | ImageFieldStructure
+
+export interface BlockDef {
+  label: string
+  type: string
+  fields: Record<string, FieldDefStructure | BlocksFieldDefStructure>
+  description?: string
+}
+
+export interface BlockDefStructure extends BlockDef {
+  instanceOf: typeof BlockInstance
+}
+
+// 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
+// }
+
+type BaseDBResult = {
+  id: number
+  created_at: string
+  updated_at: string
+  name: string
+  label: string
+  sort_order: number
+  value: string | null
+  options: any
+  status: 'enabled' | 'disabled'
+  parent_id: number | null
+  depth: number
+}
+
+export type DBPrimitiveFieldResult = BaseDBResult & {
+  type: FieldDef
+}
+
+export type DBBlockFieldResult = BaseDBResult & {
+  type: 'blocks'
+  children: DBBlockResult[]
+}
+
+export type DBBlockResult = BaseDBResult & {
+  type: string
+  fields: Record<string, DBFieldResult>
+}
+
+export type DBFieldResult = DBPrimitiveFieldResult & DBBlockFieldResult
 
 export type DBBlock = Block & {
   id: number
@@ -16,10 +144,21 @@ 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>
+  port?: number
+  structure: Structure
 }
+
+export type RequestContext = Context<
+  { Bindings: HttpBindings },
+  string,
+  BlankInput
+>

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/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/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')
+}