@alstar/studio 0.0.0-beta.16 → 0.0.0-beta.18

package/queries/getBlockTrees-2.ts

@@ -1,71 +0,0 @@
-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/getBlocks.ts

@@ -1,214 +0,0 @@
-import { DatabaseSync } from "node:sqlite";
-import { sql } from "../utils/sql.ts";
-
-// --- Field & block definitions ---
-type FieldType = 'text' | 'slug' | 'markdown' | 'blocks' | 'image';
-
-interface BaseField {
-  label: string;
-  type: FieldType;
-}
-
-interface TextField extends BaseField {
-  type: 'text' | 'slug' | 'markdown';
-}
-
-interface ImageField extends BaseField {
-  type: 'image';
-}
-
-interface BlocksField extends BaseField {
-  type: 'blocks';
-  children: Record<string, BlockDef>;
-}
-
-type FieldDef = TextField | ImageField | BlocksField;
-
-interface BlockDef {
-  label: string;
-  type: string;
-  fields: Record<string, FieldDef>;
-}
-
-// --- Identity helpers (preserve literal types) ---
-export function defineField<T extends FieldDef>(field: T) {
-  return field;
-}
-
-export function defineBlock<T extends BlockDef>(block: T) {
-  return block;
-}
-
-export function defineStructure<T extends Record<string, BlockDef>>(structure: T) {
-  return structure;
-}
-
-// --- Type mapping from structure to data ---
-type FieldToType<F extends FieldDef> =
-  F['type'] extends 'text' | 'slug' | 'markdown' ? string :
-  F['type'] extends 'image' ? string :
-  F['type'] extends 'blocks'
-    ? {
-        [K in keyof F['children']]: {
-          type: K;
-          data: BlockData<F['children'][K]>;
-        }
-      }[keyof F['children']][]
-    : never;
-
-type BlockData<B extends BlockDef> = {
-  [K in keyof B['fields']]: FieldToType<B['fields'][K]>;
-};
-
-type StructureData<S extends Record<string, BlockDef>> = {
-  [K in keyof S]: BlockData<S[K]>;
-};
-
-// This will be inferred after you define your structure
-export type CMSData<S extends Record<string, BlockDef>> = StructureData<S>;
-
-
-interface DBBase {
-  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;
-}
-
-export function buildTypedForest<
-  S extends Record<string, BlockDef>,
-  K extends keyof S
->(
-  rows: DBBase[],
-  rootDef: S[K]
-): CMSData<S>[K][] {
-  const map = new Map<number, DBBase & { children: DBBase[] }>();
-
-  // Initialize with children arrays
-  for (const r of rows) {
-    map.set(r.id, { ...r, children: [] });
-  }
-
-  // Link children to parents
-  const roots: (DBBase & { children: DBBase[] })[] = [];
-  for (const r of rows) {
-    const node = map.get(r.id)!;
-    if (r.parent_id === null) {
-      roots.push(node);
-    } else {
-      const parent = map.get(r.parent_id);
-      if (parent) parent.children.push(node);
-    }
-  }
-
-  // Recursive transformer: maps a DB row into typed data
-  function transformNode<D extends FieldDef | BlockDef>(
-    node: DBBase & DBBase['type'] extends 'blocks' ? { children: DBBase[] } : {},
-    def: D
-  ): any {
-    if ('fields' in def) {
-      // It's a BlockDef
-      const result: any = {};
-      for (const key in def.fields) {
-        const fieldDef = def.fields[key];
-        const childNode = node.children.find(c => c.name === key);
-        result[key] = childNode
-          ? transformNode(childNode, fieldDef)
-          : getDefaultValue(fieldDef);
-      }
-      return result;
-    } else {
-      // It's a FieldDef
-      if (def.type === 'text' || def.type === 'slug' || def.type === 'markdown') {
-        return node.value ?? '';
-      }
-      if (def.type === 'image') {
-        return node.value ?? '';
-      }
-      if (def.type === 'blocks') {
-        return node.children.map(child => {
-          const childDef = def.children[child.name as keyof typeof def.children];
-          return {
-            type: child.name as keyof typeof def.children,
-            data: transformNode(child, childDef)
-          };
-        });
-      }
-    }
-  }
-
-  // Provide safe defaults for missing fields
-  function getDefaultValue(fieldDef: FieldDef): any {
-    if (fieldDef.type === 'blocks') return [];
-    return '';
-  }
-
-  // Map all root nodes into typed data
-  return roots.map(root => transformNode(root, rootDef));
-}
-
-
-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 * from ancestors where parent_id is null
-      ),
-      descendants as (
-        select * 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 parent_id, sort_order
-  `;
-}
-
-export function queryTypedRoot<
-  S extends Record<string, BlockDef>,
-  K extends keyof S
->(
-  db: DatabaseSync,
-  structure: S,
-  blockType: K,
-  opts: { id?: number; depthLimit?: number }
-): CMSData<S>[K][] {
-  let filterSql: string;
-  if (opts.id !== undefined) {
-    filterSql = `id = ${opts.id}`;
-  } else {
-    filterSql = `type = '${String(structure[blockType].type)}'`;
-  }
-
-  const sql = rootQuery(filterSql, opts.depthLimit);
-  const rows = db.prepare(sql).all() as unknown as DBBase[];
-
-  return buildTypedForest(rows, structure[blockType]);
-}

package/queries/structure-types.ts

@@ -1,97 +0,0 @@
-// 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/utils/buildBlocksTree.ts

@@ -1,44 +0,0 @@
-type Block = {
-  id: number
-  name: string
-  label: string
-  type: string
-  sort_order: number
-  value: string | null
-  options: any // JSON-parsed if necessary
-  parent_id: number | null
-  depth: number
-  // ... you can add other fields if needed
-}
-
-type BlockWithChildren = Block & { fields: BlockWithChildren[] }
-
-export function buildBlockTree(blocks: Block[]): BlockWithChildren {
-  const blockMap = new Map<number, BlockWithChildren>()
-
-  // Initialize map with all blocks and empty `fields` array
-  for (const block of blocks) {
-    blockMap.set(block.id, { ...block, fields: [] })
-  }
-
-  const tree: BlockWithChildren[] = []
-
-  for (const block of blocks) {
-    const current = blockMap.get(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_id} not found for block ${block.id}`,
-        )
-      }
-    } else {
-      tree.push(current) // top-level (root) blocks
-    }
-  }
-
-  return tree[0]
-}