Model-config web apps: describe the app in configuration instead of writing code. Built on Polars and DuckDB.
parser.py · 13.4 KB · 369 lines
| 1 | #!/usr/bin/env python3 |
| 2 | """ |
| 3 | DBBasic YAML Parser - The Model-Config Revolution |
| 4 | |
| 5 | Rails generators gave us 20% of an app. This gives us 100%. |
| 6 | The difference? Real-time, service-oriented, and complete coverage. |
| 7 | """ |
| 8 | |
| 9 | import yaml |
| 10 | import json |
| 11 | from typing import Dict, List, Any, Optional |
| 12 | from dataclasses import dataclass, field |
| 13 | from pathlib import Path |
| 14 | import polars as pl |
| 15 | import duckdb |
| 16 | |
| 17 | @dataclass |
| 18 | class TableDef: |
| 19 | """Table definition from config""" |
| 20 | name: str |
| 21 | fields: List[str] |
| 22 | indexes: List[str] = field(default_factory=list) |
| 23 | relations: Dict[str, str] = field(default_factory=dict) |
| 24 | computed: Dict[str, str] = field(default_factory=dict) |
| 25 | workflow: Optional[Dict] = None |
| 26 | |
| 27 | @dataclass |
| 28 | class ViewDef: |
| 29 | """View/query definition""" |
| 30 | name: str |
| 31 | query: str |
| 32 | type: str = "table" |
| 33 | refresh: Optional[int] = None |
| 34 | |
| 35 | @dataclass |
| 36 | class FormDef: |
| 37 | """Form definition""" |
| 38 | name: str |
| 39 | fields: Any # Can be 'auto' or list of fields |
| 40 | validation: Dict[str, str] = field(default_factory=dict) |
| 41 | actions: Dict[str, str] = field(default_factory=dict) |
| 42 | |
| 43 | @dataclass |
| 44 | class AgentDef: |
| 45 | """Autonomous agent definition""" |
| 46 | name: str |
| 47 | task: str |
| 48 | schedule: Optional[str] = None |
| 49 | trigger: Optional[str] = None |
| 50 | output: Optional[str] = None |
| 51 | |
| 52 | class DBBasicYAMLParser: |
| 53 | """ |
| 54 | The parser that turns config into applications. |
| 55 | This is where Rails stopped and DBBasic continues. |
| 56 | """ |
| 57 | |
| 58 | def __init__(self): |
| 59 | self.config = {} |
| 60 | self.tables: Dict[str, TableDef] = {} |
| 61 | self.views: Dict[str, ViewDef] = {} |
| 62 | self.forms: Dict[str, FormDef] = {} |
| 63 | self.agents: Dict[str, AgentDef] = {} |
| 64 | self.workflows = {} |
| 65 | self.permissions = {} |
| 66 | self.integrations = {} |
| 67 | |
| 68 | def load_file(self, path: str) -> Dict: |
| 69 | """Load a .dbbasic YAML file""" |
| 70 | with open(path, 'r') as f: |
| 71 | self.config = yaml.safe_load(f) |
| 72 | self._parse_all() |
| 73 | return self.config |
| 74 | |
| 75 | def load_string(self, yaml_str: str) -> Dict: |
| 76 | """Load config from YAML string""" |
| 77 | self.config = yaml.safe_load(yaml_str) |
| 78 | self._parse_all() |
| 79 | return self.config |
| 80 | |
| 81 | def _parse_all(self): |
| 82 | """Parse all sections of the config""" |
| 83 | if 'model' in self.config: |
| 84 | self._parse_model() |
| 85 | if 'views' in self.config: |
| 86 | self._parse_views() |
| 87 | if 'forms' in self.config: |
| 88 | self._parse_forms() |
| 89 | if 'agents' in self.config: |
| 90 | self._parse_agents() |
| 91 | if 'workflows' in self.config: |
| 92 | self.workflows = self.config['workflows'] |
| 93 | if 'permissions' in self.config: |
| 94 | self.permissions = self.config['permissions'] |
| 95 | if 'integrations' in self.config: |
| 96 | self.integrations = self.config['integrations'] |
| 97 | |
| 98 | def _parse_model(self): |
| 99 | """Parse model section - the data structure""" |
| 100 | model = self.config['model'] |
| 101 | |
| 102 | for table_name, table_def in model.items(): |
| 103 | if isinstance(table_def, list): |
| 104 | # Simple format: users: [id, name, email] |
| 105 | self.tables[table_name] = TableDef( |
| 106 | name=table_name, |
| 107 | fields=table_def |
| 108 | ) |
| 109 | else: |
| 110 | # Complex format with metadata |
| 111 | self.tables[table_name] = TableDef( |
| 112 | name=table_name, |
| 113 | fields=table_def.get('fields', []), |
| 114 | indexes=table_def.get('indexes', []), |
| 115 | relations=table_def.get('relations', {}), |
| 116 | computed=table_def.get('computed', {}), |
| 117 | workflow=table_def.get('workflow') |
| 118 | ) |
| 119 | |
| 120 | def _parse_views(self): |
| 121 | """Parse views section - the queries""" |
| 122 | views = self.config['views'] |
| 123 | |
| 124 | for view_name, view_def in views.items(): |
| 125 | if isinstance(view_def, str): |
| 126 | # Simple: dashboard: "SELECT * FROM orders" |
| 127 | self.views[view_name] = ViewDef( |
| 128 | name=view_name, |
| 129 | query=view_def |
| 130 | ) |
| 131 | elif isinstance(view_def, dict): |
| 132 | # Complex with metadata |
| 133 | if isinstance(view_def, dict) and len(view_def) == 1: |
| 134 | # Nested views like executive: {revenue_mtd: "..."} |
| 135 | for sub_name, sub_query in view_def.items(): |
| 136 | full_name = f"{view_name}_{sub_name}" |
| 137 | self.views[full_name] = ViewDef( |
| 138 | name=full_name, |
| 139 | query=sub_query |
| 140 | ) |
| 141 | else: |
| 142 | self.views[view_name] = ViewDef( |
| 143 | name=view_name, |
| 144 | query=view_def.get('query', ''), |
| 145 | type=view_def.get('type', 'table'), |
| 146 | refresh=view_def.get('refresh') |
| 147 | ) |
| 148 | |
| 149 | def _parse_forms(self): |
| 150 | """Parse forms section""" |
| 151 | forms = self.config['forms'] |
| 152 | |
| 153 | for form_name, form_def in forms.items(): |
| 154 | if form_def == 'auto': |
| 155 | # Auto-generate from table |
| 156 | self.forms[form_name] = FormDef( |
| 157 | name=form_name, |
| 158 | fields='auto' |
| 159 | ) |
| 160 | else: |
| 161 | self.forms[form_name] = FormDef( |
| 162 | name=form_name, |
| 163 | fields=form_def.get('fields', []), |
| 164 | validation=form_def.get('validation', {}), |
| 165 | actions=form_def.get('actions', {}) |
| 166 | ) |
| 167 | |
| 168 | def _parse_agents(self): |
| 169 | """Parse agents section - autonomous operations""" |
| 170 | agents = self.config['agents'] |
| 171 | |
| 172 | for agent_name, agent_def in agents.items(): |
| 173 | self.agents[agent_name] = AgentDef( |
| 174 | name=agent_name, |
| 175 | schedule=agent_def.get('schedule'), |
| 176 | trigger=agent_def.get('trigger'), |
| 177 | task=agent_def.get('task', agent_def.get('action', '')), |
| 178 | output=agent_def.get('output') |
| 179 | ) |
| 180 | |
| 181 | def generate_sql_schema(self) -> str: |
| 182 | """Generate SQL CREATE statements""" |
| 183 | sql = [] |
| 184 | |
| 185 | for table in self.tables.values(): |
| 186 | columns = [] |
| 187 | for field_name in table.fields: |
| 188 | field_type = self._infer_sql_type(field_name) |
| 189 | columns.append(f" {field_name} {field_type}") |
| 190 | |
| 191 | # Add foreign keys |
| 192 | for fk_field, reference in table.relations.items(): |
| 193 | columns.append(f" FOREIGN KEY ({fk_field}) REFERENCES {reference}") |
| 194 | |
| 195 | create_sql = f"CREATE TABLE {table.name} (\n" |
| 196 | create_sql += ",\n".join(columns) |
| 197 | create_sql += "\n);" |
| 198 | sql.append(create_sql) |
| 199 | |
| 200 | # Add indexes |
| 201 | for idx_field in table.indexes: |
| 202 | sql.append(f"CREATE INDEX idx_{table.name}_{idx_field} ON {table.name}({idx_field});") |
| 203 | |
| 204 | # Add views |
| 205 | for view in self.views.values(): |
| 206 | sql.append(f"CREATE VIEW {view.name} AS\n{view.query};") |
| 207 | |
| 208 | return "\n\n".join(sql) |
| 209 | |
| 210 | def _infer_sql_type(self, field_name: str) -> str: |
| 211 | """Infer SQL type from field name""" |
| 212 | fn = field_name.lower() |
| 213 | |
| 214 | if fn == 'id' or fn.endswith('_id'): |
| 215 | return 'INTEGER PRIMARY KEY' if fn == 'id' else 'INTEGER' |
| 216 | elif 'email' in fn: |
| 217 | return 'VARCHAR(255)' |
| 218 | elif 'name' in fn or 'title' in fn or 'sku' in fn: |
| 219 | return 'VARCHAR(200)' |
| 220 | elif 'description' in fn or 'content' in fn or 'notes' in fn: |
| 221 | return 'TEXT' |
| 222 | elif 'price' in fn or 'amount' in fn or 'total' in fn or 'revenue' in fn: |
| 223 | return 'DECIMAL(10,2)' |
| 224 | elif 'stock' in fn or 'count' in fn or 'quantity' in fn: |
| 225 | return 'INTEGER' |
| 226 | elif 'created' in fn or 'updated' in fn or 'date' in fn: |
| 227 | return 'TIMESTAMP DEFAULT CURRENT_TIMESTAMP' |
| 228 | elif 'status' in fn or 'state' in fn or 'stage' in fn: |
| 229 | return 'VARCHAR(50)' |
| 230 | elif 'phone' in fn: |
| 231 | return 'VARCHAR(20)' |
| 232 | elif 'industry' in fn or 'category' in fn or 'type' in fn: |
| 233 | return 'VARCHAR(100)' |
| 234 | else: |
| 235 | return 'VARCHAR(255)' |
| 236 | |
| 237 | def generate_fastapi_routes(self) -> str: |
| 238 | """Generate FastAPI route code""" |
| 239 | code = [] |
| 240 | code.append("# Auto-generated FastAPI routes from DBBasic config") |
| 241 | code.append("from fastapi import FastAPI, HTTPException") |
| 242 | code.append("from typing import List, Optional") |
| 243 | code.append("") |
| 244 | code.append("# CRUD routes for each table") |
| 245 | |
| 246 | for table in self.tables.values(): |
| 247 | code.append(f"\n# {table.name.upper()} endpoints") |
| 248 | code.append(f"@app.get('/api/{table.name}')") |
| 249 | code.append(f"async def list_{table.name}():") |
| 250 | code.append(f" return engine.query('SELECT * FROM {table.name}')") |
| 251 | code.append("") |
| 252 | code.append(f"@app.get('/api/{table.name}/{{id}}')") |
| 253 | code.append(f"async def get_{table.name}(id: int):") |
| 254 | code.append(f" return engine.query('SELECT * FROM {table.name} WHERE id = ?', [id])") |
| 255 | code.append("") |
| 256 | code.append(f"@app.post('/api/{table.name}')") |
| 257 | code.append(f"async def create_{table.name}(data: dict):") |
| 258 | code.append(f" return engine.insert('{table.name}', data)") |
| 259 | code.append("") |
| 260 | code.append(f"@app.put('/api/{table.name}/{{id}}')") |
| 261 | code.append(f"async def update_{table.name}(id: int, data: dict):") |
| 262 | code.append(f" return engine.update('{table.name}', id, data)") |
| 263 | code.append("") |
| 264 | code.append(f"@app.delete('/api/{table.name}/{{id}}')") |
| 265 | code.append(f"async def delete_{table.name}(id: int):") |
| 266 | code.append(f" return engine.delete('{table.name}', id)") |
| 267 | |
| 268 | # View endpoints |
| 269 | code.append("\n# VIEW endpoints") |
| 270 | for view in self.views.values(): |
| 271 | code.append(f"@app.get('/api/views/{view.name}')") |
| 272 | code.append(f"async def view_{view.name}():") |
| 273 | code.append(f" return engine.query('''{view.query}''')") |
| 274 | code.append("") |
| 275 | |
| 276 | return "\n".join(code) |
| 277 | |
| 278 | def generate_html_form(self, form_name: str) -> str: |
| 279 | """Generate HTML form from config""" |
| 280 | if form_name not in self.forms: |
| 281 | return "" |
| 282 | |
| 283 | form = self.forms[form_name] |
| 284 | |
| 285 | if form.fields == 'auto': |
| 286 | # Auto-generate from table |
| 287 | table_name = form_name.replace('_form', '') |
| 288 | if table_name not in self.tables: |
| 289 | return "" |
| 290 | |
| 291 | table = self.tables[table_name] |
| 292 | html = [f'<form id="{form_name}" class="dbbasic-form">'] |
| 293 | html.append(f' <h2>{table_name.title()}</h2>') |
| 294 | |
| 295 | for field in table.fields: |
| 296 | if field == 'id': |
| 297 | continue |
| 298 | field_type = self._infer_input_type(field) |
| 299 | label = field.replace('_', ' ').title() |
| 300 | html.append(f' <div class="form-field">') |
| 301 | html.append(f' <label>{label}</label>') |
| 302 | if field_type == 'textarea': |
| 303 | html.append(f' <textarea name="{field}"></textarea>') |
| 304 | else: |
| 305 | html.append(f' <input type="{field_type}" name="{field}">') |
| 306 | html.append(f' </div>') |
| 307 | |
| 308 | html.append(' <button type="submit">Save</button>') |
| 309 | html.append('</form>') |
| 310 | return '\n'.join(html) |
| 311 | |
| 312 | # Manual form definition |
| 313 | html = [f'<form id="{form_name}">'] |
| 314 | for field in form.fields: |
| 315 | html.append(f' <div class="form-field">') |
| 316 | html.append(f' <label>{field}</label>') |
| 317 | html.append(f' <input name="{field}">') |
| 318 | html.append(f' </div>') |
| 319 | html.append(' <button type="submit">Submit</button>') |
| 320 | html.append('</form>') |
| 321 | return '\n'.join(html) |
| 322 | |
| 323 | def _infer_input_type(self, field_name: str) -> str: |
| 324 | """Infer HTML input type from field name""" |
| 325 | fn = field_name.lower() |
| 326 | |
| 327 | if 'email' in fn: |
| 328 | return 'email' |
| 329 | elif 'password' in fn: |
| 330 | return 'password' |
| 331 | elif 'phone' in fn or 'tel' in fn: |
| 332 | return 'tel' |
| 333 | elif 'url' in fn or 'link' in fn: |
| 334 | return 'url' |
| 335 | elif 'date' in fn or 'created' in fn or 'updated' in fn: |
| 336 | return 'date' |
| 337 | elif 'price' in fn or 'amount' in fn or 'stock' in fn or 'quantity' in fn: |
| 338 | return 'number' |
| 339 | elif 'description' in fn or 'notes' in fn or 'content' in fn: |
| 340 | return 'textarea' |
| 341 | else: |
| 342 | return 'text' |
| 343 | |
| 344 | def summary(self) -> str: |
| 345 | """Generate a summary of parsed config""" |
| 346 | lines = [] |
| 347 | lines.append(f"DBBasic Config Summary") |
| 348 | lines.append(f"=" * 40) |
| 349 | lines.append(f"Tables: {len(self.tables)}") |
| 350 | for t in self.tables.values(): |
| 351 | lines.append(f" - {t.name}: {len(t.fields)} fields") |
| 352 | |
| 353 | lines.append(f"\nViews: {len(self.views)}") |
| 354 | for v in self.views.values(): |
| 355 | lines.append(f" - {v.name}") |
| 356 | |
| 357 | lines.append(f"\nForms: {len(self.forms)}") |
| 358 | for f in self.forms.values(): |
| 359 | lines.append(f" - {f.name}") |
| 360 | |
| 361 | lines.append(f"\nAgents: {len(self.agents)}") |
| 362 | for a in self.agents.values(): |
| 363 | lines.append(f" - {a.name}: {a.task}") |
| 364 | |
| 365 | lines.append(f"\nWorkflows: {len(self.workflows)}") |
| 366 | lines.append(f"Permissions: {len(self.permissions)} rules") |
| 367 | lines.append(f"Integrations: {len(self.integrations)}") |
| 368 | |
| 369 | return "\n".join(lines) |