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

package/queries/block-2.ts

@@ -1,339 +0,0 @@
-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/db-types.ts

@@ -1,15 +0,0 @@
-// db-types.ts
-export type DBBase = {
-  id: number;
-  created_at: string;
-  updated_at: string;
-  name: string;
-  label: string;
-  type: string;
-  sort_order: number;
-  value: string | null;
-  options: any | null;
-  status: string;
-  parent_id: number | null;
-  depth: number;
-};

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]);
-}