askrobots / dbbasic Public

Model-config web apps: describe the app in configuration instead of writing code. Built on Polars and DuckDB.

0 downloads

dbbasic/core/parser.py
Download zip
Clone
Clone with git
git clone https://gitstable.com/git/askrobots/dbbasic.git
HTTPS
https://gitstable.com/git/askrobots/dbbasic.git
SSH
ssh://git@gitstable.com:2222/askrobots/dbbasic.git

Cloning needs no sign-in. Pushing over HTTPS asks for your username and an access token. SSH needs your key under SSH keys.

danq9 Add DBBasic crate engine logo and update README 0d628db 1 year, 2 months ago History
parser.py · 13.4 KB · 369 lines
1#!/usr/bin/env python3
2"""
3DBBasic YAML Parser - The Model-Config Revolution
4
5Rails generators gave us 20% of an app. This gives us 100%.
6The difference? Real-time, service-oriented, and complete coverage.
7"""
8
9import yaml
10import json
11from typing import Dict, List, Any, Optional
12from dataclasses import dataclass, field
13from pathlib import Path
14import polars as pl
15import duckdb
16
17@dataclass
18class 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
28class ViewDef:
29 """View/query definition"""
30 name: str
31 query: str
32 type: str = "table"
33 refresh: Optional[int] = None
34
35@dataclass
36class 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
44class 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
52class 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)