tova 0.1.1 → 0.2.2

package/src/codegen/base-codegen.js

@@ -157,6 +157,14 @@ export class BaseCodegen {
       case 'TypeAlias': result = this.genTypeAlias(node); break;
       case 'DeferStatement': result = this.genDeferStatement(node); break;
       case 'ExternDeclaration': result = `${this.i()}// extern: ${node.name}`; break;
+      // Config declarations handled at block level — emit nothing in statement context
+      case 'AiConfigDeclaration': result = ''; break;
+      case 'DataBlock': result = ''; break;
+      case 'SourceDeclaration': result = ''; break;
+      case 'PipelineDeclaration': result = ''; break;
+      case 'ValidateBlock': result = ''; break;
+      case 'RefreshPolicy': result = ''; break;
+      case 'RefinementType': result = this.genRefinementType(node); break;
       default:
         result = `${this.i()}${this.genExpression(node)};`;
     }
@@ -213,6 +221,10 @@ export class BaseCodegen {
       case 'AwaitExpression': return `(await ${this.genExpression(node.argument)})`;
       case 'YieldExpression': return node.delegate ? `(yield* ${this.genExpression(node.argument)})` : `(yield ${this.genExpression(node.argument)})`;
       case 'TupleExpression': return `[${node.elements.map(e => this.genExpression(e)).join(', ')}]`;
+      // Column expressions (for table operations)
+      case 'ColumnExpression': return this.genColumnExpression(node);
+      case 'ColumnAssignment': return this.genColumnAssignment(node);
+      case 'NegatedColumnExpression': return `{ __exclude: ${JSON.stringify(node.name)} }`;
       default:
         throw new Error(`Codegen: unknown expression type '${node.type}'`);
     }
@@ -754,6 +766,20 @@ export class BaseCodegen {
       if (node.callee.name === 'Ok' || node.callee.name === 'Err' || node.callee.name === 'Some') {
         this._needsResultOption = true;
       }
+
+      // Inline string/collection builtins to direct method calls
+      const inlined = this._tryInlineBuiltin(node);
+      if (inlined !== null) return inlined;
+    }
+
+    // Check for table operation calls with column expressions
+    const hasColumnExprs = node.arguments.some(a => this._containsColumnExpr(a));
+    if (hasColumnExprs || (node.callee.type === 'Identifier' && ['agg', 'table_agg'].includes(node.callee.name))) {
+      const tableArgs = this._genTableCallArgs(node);
+      if (tableArgs) {
+        const callee = this.genExpression(node.callee);
+        return `${callee}(${tableArgs.join(', ')})`;
+      }
     }
 
     const callee = this.genExpression(node.callee);
@@ -783,6 +809,85 @@ export class BaseCodegen {
     return `${callee}(${args})`;
   }
 
+  // Inline known builtins to direct method calls, eliminating wrapper overhead.
+  // Returns the inlined code string, or null if not inlineable.
+  _tryInlineBuiltin(node) {
+    const name = node.callee.name;
+    const args = node.arguments;
+
+    switch (name) {
+      // String methods: fn(str, ...) → str.method(...)
+      case 'split':
+        if (args.length === 2)
+          return `${this.genExpression(args[0])}.split(${this.genExpression(args[1])})`;
+        break;
+      case 'join':
+        if (args.length === 2)
+          return `${this.genExpression(args[0])}.join(${this.genExpression(args[1])})`;
+        if (args.length === 1)
+          return `${this.genExpression(args[0])}.join('')`;
+        break;
+      case 'replace':
+        if (args.length === 3)
+          return `${this.genExpression(args[0])}.replaceAll(${this.genExpression(args[1])}, ${this.genExpression(args[2])})`;
+        break;
+      case 'contains':
+        if (args.length === 2)
+          return `${this.genExpression(args[0])}.includes(${this.genExpression(args[1])})`;
+        break;
+      case 'upper':
+        if (args.length === 1)
+          return `${this.genExpression(args[0])}.toUpperCase()`;
+        break;
+      case 'lower':
+        if (args.length === 1)
+          return `${this.genExpression(args[0])}.toLowerCase()`;
+        break;
+      case 'trim':
+        if (args.length === 1)
+          return `${this.genExpression(args[0])}.trim()`;
+        break;
+      case 'trim_start':
+        if (args.length === 1)
+          return `${this.genExpression(args[0])}.trimStart()`;
+        break;
+      case 'trim_end':
+        if (args.length === 1)
+          return `${this.genExpression(args[0])}.trimEnd()`;
+        break;
+      case 'repeat':
+        if (args.length === 2)
+          return `${this.genExpression(args[0])}.repeat(${this.genExpression(args[1])})`;
+        break;
+      case 'starts_with':
+        if (args.length === 2)
+          return `${this.genExpression(args[0])}.startsWith(${this.genExpression(args[1])})`;
+        break;
+      case 'ends_with':
+        if (args.length === 2)
+          return `${this.genExpression(args[0])}.endsWith(${this.genExpression(args[1])})`;
+        break;
+      case 'pad_start':
+        if (args.length >= 2)
+          return `${this.genExpression(args[0])}.padStart(${this.genExpression(args[1])}${args[2] ? ', ' + this.genExpression(args[2]) : ''})`;
+        break;
+      case 'pad_end':
+        if (args.length >= 2)
+          return `${this.genExpression(args[0])}.padEnd(${this.genExpression(args[1])}${args[2] ? ', ' + this.genExpression(args[2]) : ''})`;
+        break;
+      case 'includes':
+        if (args.length === 2)
+          return `${this.genExpression(args[0])}.includes(${this.genExpression(args[1])})`;
+        break;
+      case 'char_at':
+        if (args.length === 2)
+          return `${this.genExpression(args[0])}[${this.genExpression(args[1])}]`;
+        break;
+    }
+
+    return null;
+  }
+
   genMemberExpression(node) {
     const obj = this.genExpression(node.object);
     if (node.computed) {
@@ -814,6 +919,20 @@ export class BaseCodegen {
 
     // If right is a call expression, check for placeholder _ or insert as first arg
     if (right.type === 'CallExpression') {
+      // Check for table operations with column expressions
+      const hasColumnExprs = right.arguments.some(a => this._containsColumnExpr(a));
+      if (hasColumnExprs || (right.callee.type === 'Identifier' && ['agg', 'table_agg'].includes(right.callee.name))) {
+        const tableArgs = this._genTableCallArgs(right);
+        if (tableArgs) {
+          const callee = this.genExpression(right.callee);
+          // Track builtin usage
+          if (right.callee.type === 'Identifier' && BUILTIN_NAMES.has(right.callee.name)) {
+            this._usedBuiltins.add(right.callee.name);
+          }
+          return `${callee}(${[left, ...tableArgs].join(', ')})`;
+        }
+      }
+
       const placeholderCount = right.arguments.filter(a => a.type === 'Identifier' && a.name === '_').length;
       if (placeholderCount > 0) {
         const callee = this.genExpression(right.callee);
@@ -849,6 +968,250 @@ export class BaseCodegen {
     return `(${this.genExpression(right)})(${left})`;
   }
 
+  // ─── Column expressions ──────────────────────────────────
+
+  // Context flag for whether we're inside a select() call argument list
+  _columnAsString = false;
+
+  genColumnExpression(node) {
+    // Inside select(), column expressions compile to string names
+    if (this._columnAsString) {
+      return JSON.stringify(node.name);
+    }
+    // Default: compile to row lambda
+    return `(__row) => __row.${node.name}`;
+  }
+
+  genColumnAssignment(node) {
+    // Compile to object entry for derive(): { colName: (row) => expr }
+    // The expression inside the assignment may reference other columns
+    const expr = this._genColumnBody(node.expression);
+    return `${JSON.stringify(node.target)}: (__row) => ${expr}`;
+  }
+
+  // Generate an expression body that wraps column references as __row.col
+  _genColumnBody(node) {
+    if (!node) return 'undefined';
+    if (node.type === 'ColumnExpression') {
+      return `__row.${node.name}`;
+    }
+    if (node.type === 'BinaryExpression') {
+      return `(${this._genColumnBody(node.left)} ${node.operator} ${this._genColumnBody(node.right)})`;
+    }
+    if (node.type === 'LogicalExpression') {
+      const op = node.operator === 'and' ? '&&' : node.operator === 'or' ? '||' : node.operator;
+      return `(${this._genColumnBody(node.left)} ${op} ${this._genColumnBody(node.right)})`;
+    }
+    if (node.type === 'UnaryExpression') {
+      return `${node.operator}${this._genColumnBody(node.operand)}`;
+    }
+    if (node.type === 'CallExpression') {
+      // Check if callee is a builtin used as pipe target
+      const callee = this.genExpression(node.callee);
+      const args = node.arguments.map(a => this._genColumnBody(a)).join(', ');
+      return `${callee}(${args})`;
+    }
+    if (node.type === 'PipeExpression') {
+      const left = this._genColumnBody(node.left);
+      const right = node.right;
+      if (right.type === 'CallExpression') {
+        const callee = this.genExpression(right.callee);
+        const args = [left, ...right.arguments.map(a => this._genColumnBody(a))].join(', ');
+        return `${callee}(${args})`;
+      }
+      if (right.type === 'Identifier') {
+        return `${right.name}(${left})`;
+      }
+      return `(${this._genColumnBody(right)})(${left})`;
+    }
+    if (node.type === 'TemplateLiteral') {
+      // Template literal with column references
+      const parts = node.parts.map(p => {
+        if (p.type === 'text') return p.value;
+        return `\${${this._genColumnBody(p.value)}}`;
+      });
+      return '`' + parts.join('') + '`';
+    }
+    if (node.type === 'ConditionalExpression' || node.type === 'IfExpression') {
+      const cond = this._genColumnBody(node.condition);
+      const cons = this._genColumnBody(node.consequent);
+      const alt = node.alternate || node.elseBody;
+      const altCode = alt ? this._genColumnBody(alt) : 'undefined';
+      return `(${cond} ? ${cons} : ${altCode})`;
+    }
+    if (node.type === 'MatchExpression') {
+      // Match on column value
+      const subject = this._genColumnBody(node.subject);
+      const tmp = `__match_${this._uid()}`;
+      let code = `((__m) => { `;
+      for (const arm of node.arms) {
+        if (arm.pattern.type === 'WildcardPattern') {
+          const body = this._genColumnBody(arm.body);
+          code += `return ${body}; `;
+        } else if (arm.pattern.type === 'RangePattern') {
+          const start = this.genExpression(arm.pattern.start);
+          const end = this.genExpression(arm.pattern.end);
+          const op = arm.pattern.inclusive ? '<=' : '<';
+          code += `if (__m >= ${start} && __m ${op} ${end}) return ${this._genColumnBody(arm.body)}; `;
+        } else {
+          const pat = this.genExpression(arm.pattern.value || arm.pattern);
+          code += `if (__m === ${pat}) return ${this._genColumnBody(arm.body)}; `;
+        }
+      }
+      code += `})(${subject})`;
+      return code;
+    }
+    if (node.type === 'MemberExpression') {
+      const obj = this._genColumnBody(node.object);
+      if (node.computed) {
+        return `${obj}[${this._genColumnBody(node.property)}]`;
+      }
+      return `${obj}.${node.property}`;
+    }
+    // Fallback to normal expression generation for constants, strings, etc.
+    return this.genExpression(node);
+  }
+
+  // Override genCallExpression to handle table operations with column expressions
+  _genTableCallArgs(node) {
+    const calleeName = node.callee.type === 'Identifier' ? node.callee.name : null;
+
+    // select() — column expressions should compile to strings
+    if (calleeName === 'select' || calleeName === 'table_select') {
+      this._columnAsString = true;
+      const args = node.arguments.map(a => this.genExpression(a));
+      this._columnAsString = false;
+      return args;
+    }
+
+    // where() — column expressions compile to row lambdas
+    if (calleeName === 'where' || calleeName === 'table_where') {
+      return node.arguments.map(a => {
+        if (this._containsColumnExpr(a)) {
+          return `(__row) => ${this._genColumnBody(a)}`;
+        }
+        return this.genExpression(a);
+      });
+    }
+
+    // sort_by() — column expression compiles to row lambda
+    if (calleeName === 'sort_by' || calleeName === 'table_sort_by') {
+      return node.arguments.map(a => {
+        if (this._containsColumnExpr(a)) {
+          return `(__row) => ${this._genColumnBody(a)}`;
+        }
+        return this.genExpression(a);
+      });
+    }
+
+    // group_by() — column expression compiles to row lambda
+    if (calleeName === 'group_by' || calleeName === 'table_group_by') {
+      return node.arguments.map(a => {
+        if (this._containsColumnExpr(a)) {
+          return `(__row) => ${this._genColumnBody(a)}`;
+        }
+        return this.genExpression(a);
+      });
+    }
+
+    // derive() — column assignments compile to { name: (row) => expr }
+    if (calleeName === 'derive' || calleeName === 'table_derive') {
+      const parts = [];
+      for (const a of node.arguments) {
+        if (a.type === 'ColumnAssignment') {
+          parts.push(this.genColumnAssignment(a));
+        } else {
+          parts.push(this.genExpression(a));
+        }
+      }
+      // Wrap column assignments in an object
+      const hasAssignments = node.arguments.some(a => a.type === 'ColumnAssignment');
+      if (hasAssignments) {
+        return [`{ ${parts.join(', ')} }`];
+      }
+      return parts;
+    }
+
+    // agg() — named arguments with aggregation functions
+    if (calleeName === 'agg' || calleeName === 'table_agg') {
+      const parts = [];
+      for (const a of node.arguments) {
+        if (a.type === 'NamedArgument') {
+          // Named agg: total: sum(.amount) → total: agg_sum((__row) => __row.amount)
+          const val = a.value;
+          if (val.type === 'CallExpression' && val.callee.type === 'Identifier') {
+            const aggName = val.callee.name;
+            const aggFn = `agg_${aggName}`;
+            if (['sum', 'count', 'mean', 'median', 'min', 'max'].includes(aggName)) {
+              this._usedBuiltins.add(aggFn);
+              if (val.arguments.length === 0) {
+                // count() with no args
+                parts.push(`${a.name}: ${aggFn}()`);
+              } else {
+                const inner = val.arguments[0];
+                if (this._containsColumnExpr(inner)) {
+                  parts.push(`${a.name}: ${aggFn}((__row) => ${this._genColumnBody(inner)})`);
+                } else {
+                  parts.push(`${a.name}: ${aggFn}(${this.genExpression(inner)})`);
+                }
+              }
+              continue;
+            }
+          }
+          parts.push(`${a.name}: ${this.genExpression(a.value)}`);
+        } else {
+          parts.push(this.genExpression(a));
+        }
+      }
+      const hasNamed = node.arguments.some(a => a.type === 'NamedArgument');
+      if (hasNamed) {
+        return [`{ ${parts.join(', ')} }`];
+      }
+      return parts;
+    }
+
+    // drop_nil/fill_nil — column expression compiles to string or lambda
+    if (calleeName === 'drop_nil' || calleeName === 'fill_nil') {
+      return node.arguments.map(a => {
+        if (a.type === 'ColumnExpression') {
+          return JSON.stringify(a.name);
+        }
+        return this.genExpression(a);
+      });
+    }
+
+    // join() — handle left/right column expressions
+    if (calleeName === 'join' || calleeName === 'table_join') {
+      return node.arguments.map(a => {
+        if (a.type === 'NamedArgument') {
+          if ((a.name === 'left' || a.name === 'right') && a.value.type === 'ColumnExpression') {
+            return this.genExpression(a); // NamedArgument genExpression handles it
+          }
+        }
+        return this.genExpression(a);
+      });
+    }
+
+    return null; // No special handling needed
+  }
+
+  _containsColumnExpr(node) {
+    if (!node) return false;
+    if (node.type === 'ColumnExpression' || node.type === 'ColumnAssignment' || node.type === 'NegatedColumnExpression') return true;
+    for (const key of Object.keys(node)) {
+      if (key === 'loc' || key === 'type') continue;
+      const val = node[key];
+      if (Array.isArray(val)) {
+        for (const item of val) {
+          if (item && typeof item === 'object' && this._containsColumnExpr(item)) return true;
+        }
+      } else if (val && typeof val === 'object' && val.type) {
+        if (this._containsColumnExpr(val)) return true;
+      }
+    }
+    return false;
+  }
+
   genLambdaExpression(node) {
     const params = this.genParams(node.params);
     const hasPropagate = this._containsPropagate(node.body);
@@ -1323,6 +1686,14 @@ export class BaseCodegen {
     return `${this.i()}/* ${exportStr}type alias: ${node.name} = ${typeStr} */`;
   }
 
+  genRefinementType(node) {
+    // Refinement types compile to validator functions
+    // type Email = String where { it |> contains("@") }
+    // → function __validate_Email(it) { return it.includes("@"); }
+    const predExpr = this.genExpression(node.predicate);
+    return `${this.i()}function __validate_${node.name}(it) {\n${this.i()}  if (!(${predExpr})) throw new Error("Refinement type ${node.name} validation failed");\n${this.i()}  return it;\n${this.i()}}`;
+  }
+
   genDeferStatement(node) {
     // Defer is handled by genBlockBody which collects defers and wraps in try/finally.
     // If called outside genBlockBody (e.g., via genBlockStatements), generate a no-op comment.

package/src/codegen/client-codegen.js

@@ -172,24 +172,48 @@ export class ClientCodegen extends BaseCodegen {
     return `${asyncPrefix}(${params}) => ${this.genExpression(node.body)}`;
   }
 
-  generate(clientBlocks, sharedCode) {
+  generate(clientBlocks, sharedCode, sharedBuiltins = null) {
+    this._sharedBuiltins = sharedBuiltins || new Set();
     const lines = [];
 
     // Runtime imports
     lines.push(`import { createSignal, createEffect, createComputed, mount, hydrate, tova_el, tova_fragment, tova_keyed, tova_inject_css, batch, onMount, onUnmount, onCleanup, createRef, createContext, provide, inject, createErrorBoundary, ErrorBoundary, createRoot, watch, untrack, Dynamic, Portal, lazy } from './runtime/reactivity.js';`);
     lines.push(`import { rpc } from './runtime/rpc.js';`);
-    lines.push('');
 
-    // Shared code
+    // Hoist import lines from shared code to the top of the module
+    let sharedRest = sharedCode;
     if (sharedCode.trim()) {
+      const sharedLines = sharedCode.split('\n');
+      const importLines = [];
+      const nonImportLines = [];
+      for (const line of sharedLines) {
+        if (/^\s*import\s+/.test(line)) {
+          importLines.push(line);
+        } else {
+          nonImportLines.push(line);
+        }
+      }
+      if (importLines.length > 0) {
+        for (const imp of importLines) {
+          lines.push(imp);
+        }
+      }
+      sharedRest = nonImportLines.join('\n');
+    }
+
+    lines.push('');
+
+    // Shared code (non-import lines)
+    if (sharedRest.trim()) {
       lines.push('// ── Shared ──');
-      lines.push(sharedCode);
+      lines.push(sharedRest);
       lines.push('');
     }
 
-    // Stdlib core functions (available in all Tova code)
+    // Stdlib placeholder — filled after all client code is generated so tree-shaking sees all usages
+    const stdlibPlaceholderIdx = lines.length;
     lines.push('// ── Stdlib ──');
-    lines.push(this.getStdlibCore());
+    lines.push('__STDLIB_PLACEHOLDER__');
     lines.push('');
 
     // Server RPC proxy
@@ -206,6 +230,7 @@ export class ClientCodegen extends BaseCodegen {
     const effects = [];
     const components = [];
     const stores = [];
+    const imports = [];
     const other = [];
 
     for (const block of clientBlocks) {
@@ -216,11 +241,23 @@ export class ClientCodegen extends BaseCodegen {
           case 'EffectDeclaration': effects.push(stmt); break;
           case 'ComponentDeclaration': components.push(stmt); break;
           case 'StoreDeclaration': stores.push(stmt); break;
+          case 'ImportDeclaration': imports.push(stmt); break;
+          case 'ImportDefault': imports.push(stmt); break;
+          case 'ImportWildcard': imports.push(stmt); break;
           default: other.push(stmt); break;
         }
       }
     }
 
+    // Generate client block imports (hoisted after runtime imports)
+    if (imports.length > 0) {
+      lines.push('// ── Client Imports ──');
+      for (const stmt of imports) {
+        lines.push(this.generateStatement(stmt));
+      }
+      lines.push('');
+    }
+
     // Register state names for setter transforms
     for (const s of states) {
       this.stateNames.add(s.name);
@@ -301,14 +338,23 @@ export class ClientCodegen extends BaseCodegen {
     }
 
     // Auto-mount the App component if it exists
+    // Auto-detect SSR: if the container already has children, hydrate instead of mount
     const hasApp = components.some(c => c.name === 'App');
     if (hasApp) {
       lines.push('// ── Mount ──');
       lines.push('document.addEventListener("DOMContentLoaded", () => {');
-      lines.push('  mount(App, document.getElementById("app") || document.body);');
+      lines.push('  const container = document.getElementById("app") || document.body;');
+      lines.push('  if (container.children.length > 0) {');
+      lines.push('    hydrate(App, container);');
+      lines.push('  } else {');
+      lines.push('    mount(App, container);');
+      lines.push('  }');
       lines.push('});');
     }
 
+    // Replace stdlib placeholder now that all client code has been generated
+    lines[stdlibPlaceholderIdx + 1] = this.getStdlibCore();
+
     return lines.join('\n');
   }
 
@@ -751,7 +797,7 @@ export class ClientCodegen extends BaseCodegen {
           propsStr = `{${propParts.join(', ')}}`;
         }
       }
-      return `${node.tag}(${propsStr})`;
+      return `(() => { const __v = ${node.tag}(${propsStr}); if (__v && __v.__tova) __v._componentName = "${node.tag}"; return __v; })()`;
     }
 
     const tag = JSON.stringify(node.tag);
@@ -860,8 +906,14 @@ export class ClientCodegen extends BaseCodegen {
 
   getStdlibCore() {
     const parts = [];
-    // Only include used builtin functions (tree-shaking)
-    const selectiveStdlib = buildSelectiveStdlib(this._usedBuiltins);
+    // Only include builtins used in client blocks that aren't already in shared code
+    const clientOnly = new Set();
+    for (const name of this._usedBuiltins) {
+      if (!this._sharedBuiltins || !this._sharedBuiltins.has(name)) {
+        clientOnly.add(name);
+      }
+    }
+    const selectiveStdlib = buildSelectiveStdlib(clientOnly);
     if (selectiveStdlib) parts.push(selectiveStdlib);
     // Include Result/Option if Ok/Err/Some/None are used
     if (this._needsResultOption) parts.push(RESULT_OPTION);