tina4-python 3.13.51__tar.gz → 3.13.53__tar.gz

{tina4_python-3.13.51 → tina4_python-3.13.53}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tina4-python
-Version: 3.13.51
+Version: 3.13.53
 Summary: Tina4 Python v3 — Zero-dependency, lightweight web framework
 Author-email: Andre van Zuydam <andrevanzuydam@gmail.com>
 License: MIT

{tina4_python-3.13.51 → tina4_python-3.13.53}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "tina4-python"
-version = "3.13.51"
+version = "3.13.53"
 description = "Tina4 Python v3 — Zero-dependency, lightweight web framework"
 authors = [
     {name = "Andre van Zuydam", email = "andrevanzuydam@gmail.com"}

{tina4_python-3.13.51 → tina4_python-3.13.53}/tina4_python/CLAUDE.md

@@ -901,7 +901,9 @@ User.query().where("name = ?", ["Alice"]).to_mongo()
 ```
 
 ### Available field types
-`IntegerField`, `StringField`, `TextField`, `DateTimeField`, `NumericField`, `BlobField`, `BooleanField`, `FloatField`, `ForeignKeyField`
+`IntegerField`, `StringField`, `TextField`, `DateTimeField`, `NumericField`, `BlobField`, `BooleanField`, `FloatField`, `JSONField`, `ForeignKeyField`
+
+`JSONField()` stores a `dict`/`list` as JSON. You work with a plain Python object; the ORM serializes to a JSON string on save and parses it back on load, so `model.field` is always a `dict`/`list`. Engine-aware column: `JSONB` (PostgreSQL), `JSON` (MySQL), `NVARCHAR(MAX)` (MSSQL), `TEXT` (SQLite), `BLOB SUB_TYPE TEXT` (Firebird). Use it for a JSON column inside a relational row; use DocStore for whole-document storage with Mongo-style queries.
 
 Import from `tina4_python` or `tina4_python.orm.fields`.
 

{tina4_python-3.13.51 → tina4_python-3.13.53}/tina4_python/__init__.py

@@ -36,7 +36,7 @@ from tina4_python.database import Database  # noqa: E402, F401
 from tina4_python.orm import (  # noqa: E402, F401
     ORM, bind_database, Field,
     IntegerField, StringField, BooleanField, FloatField,
-    DateTimeField, TextField, BlobField, NumericField,
+    DateTimeField, TextField, BlobField, NumericField, JSONField,
     ForeignKeyField,
     IntField, StrField, BoolField,  # short aliases
     has_many, has_one, belongs_to,  # relationship descriptors

{tina4_python-3.13.51 → tina4_python-3.13.53}/tina4_python/core/server.py

@@ -276,6 +276,12 @@ Router.add("GET", _HEALTH_PATH, _health_handler)
 if _HEALTH_PATH != "/health":
     Router.add("GET", "/health", _health_handler)
 
+# Frond live blocks: re-render a registered {% live %} fragment on demand.
+# Always on (production too) - the poll/sse client fetches this; auth re-applies
+# through the normal middleware chain on every refresh.
+from tina4_python.frond import live_endpoint as _live_endpoint
+Router.add("GET", "/__frond/live/{name}", _live_endpoint)
+
 
 def _render_error_page(status_code: int, path: str, request_id: str, error_message: str = "") -> str | None:
     """Render a styled error page using Frond engine.

{tina4_python-3.13.51 → tina4_python-3.13.53}/tina4_python/database/connection.py

@@ -110,6 +110,7 @@ except ImportError:
 from tina4_python.database.postgres import PostgreSQLAdapter
 register_driver("postgresql", PostgreSQLAdapter)
 register_driver("postgres", PostgreSQLAdapter)
+register_driver("pgsql", PostgreSQLAdapter)  # PDO / Laravel / Doctrine scheme name (issue #58)
 
 # Register MySQL (mysql-connector-python — optional)
 from tina4_python.database.mysql import MySQLAdapter

{tina4_python-3.13.51 → tina4_python-3.13.53}/tina4_python/frond/FROND.md

@@ -383,6 +383,85 @@ Macros don't inherit parent context — pass everything explicitly via parameter
 
 ---
 
+## Live Blocks
+
+A live block renders on the server, then keeps itself fresh. The first paint ships with the
+page, so there is no loading flash. After that, the block re-fetches its own HTML and swaps
+it in place. You write server-side Frond and the block stays current, with no hand-written
+JavaScript.
+
+```twig
+{% live "cart" poll 5 %}
+    <strong>{{ count }}</strong> items - {{ total | number_format(2) }}
+{% endlive %}
+```
+
+That block paints once with the page, then re-renders every 5 seconds. `frond.js` (already
+loaded from `/js/frond.js`) finds the marker, calls `GET /__frond/live/cart`, and morphs the
+returned HTML into place. A focused input and its caret survive the swap.
+
+### Transports
+
+Pick how the block refreshes:
+
+```twig
+{% live "cart" poll 5 %}...{% endlive %}          {# re-fetch every 5 seconds #}
+{% live "feed" sse %}...{% endlive %}             {# Server-Sent Events stream #}
+{% live "chat" ws "/ws/chat" %}...{% endlive %}   {# WebSocket on /ws/chat #}
+```
+
+`poll N` pulls every `N` seconds. `sse` and `ws` push: the server decides when to send. All
+three render the same server-side body. Only the delivery changes.
+
+### The data source
+
+A live block needs data on every refresh, not just the first paint. Register a provider by
+name with `@live_source`. It runs on each refresh with the live request, so the block
+re-renders against fresh data and re-applies auth every time. An unauthenticated caller never
+sees another user's numbers.
+
+```python
+from tina4_python.frond import live_source
+
+@live_source("cart")
+def cart_data(request):
+    user = request.session.get("user_id")
+    return {"count": cart_count(user), "total": cart_total(user)}
+```
+
+The provider feeds the always-on endpoint `GET /__frond/live/{name}`. There is no route to
+write. The block name is the route.
+
+### Pushing updates
+
+A `ws` block can update the moment data changes, without waiting for the next poll. Call
+`push_live(name, data)`. It re-renders the block and broadcasts the new HTML to every client
+connected on the block's WebSocket path.
+
+```python
+from tina4_python.frond import push_live
+
+# after an order lands:
+push_live("cart", {"count": 3, "total": 59.97})
+```
+
+### Same-origin only
+
+A block can point at your own route with `src` instead of the auto endpoint:
+
+```twig
+{% live "cart" poll 5 src "/fragments/cart" %}...{% endlive %}
+```
+
+`src` must be a same-origin path. An absolute URL is rejected at render time, so a live block
+never fetches from a host you did not write. Nested live blocks are rejected too.
+
+The marker element is byte-identical across Python, PHP, Ruby, and Node, so the shared
+`frond.js` drives every backend the same way. Write the block once. It renders anywhere
+Tina4 runs.
+
+---
+
 ## Comments
 
 ```twig

tina4_python-3.13.53/tina4_python/frond/__init__.py

@@ -0,0 +1,85 @@
+# Tina4 Frond — Zero-dependency template engine.
+"""
+Twig-like template engine built from scratch.
+
+    from tina4_python.frond import Frond
+
+    engine = Frond(template_dir="src/templates")
+    output = engine.render("page.html", {"name": "World"})
+"""
+import inspect
+
+from tina4_python.frond.engine import Frond
+
+
+async def live_endpoint(name, request, response):
+    """GET /__frond/live/{name} - re-render a registered {% live %} fragment.
+
+    Resolves the @live_source provider for <name>, runs it with the LIVE request
+    so auth and session scoping re-apply on every refresh (a live "my cart"
+    cannot leak another user's data), renders the registered fragment, and
+    returns the HTML. 404 when the name is unknown or its fragment has not been
+    registered yet (the page carrying the block has not rendered).
+    """
+    provider = Frond._class_live_sources.get(name)
+    if name not in Frond._class_live_fragments and provider is None:
+        return response("live block not found: " + str(name), 404)
+    context = {}
+    if provider is not None:
+        result = provider(request)
+        if inspect.isawaitable(result):
+            result = await result
+        context = result or {}
+    html = Frond.render_live(name, context)
+    if html is None:
+        return response("live fragment not registered yet: " + str(name), 404)
+    return response(html)
+
+
+async def push_live(name, data=None):
+    """Re-render the '<name>' live fragment and push it to connected clients.
+
+    Renders via Frond.render_live(name, data) and broadcasts a {type, name, html}
+    envelope over WebSocket: to the ws path the block declared (data-ws), or to a
+    room named <name> if the block declared none. Apps call this after a state
+    change (a new chat message, an order update). Returns the rendered HTML, or
+    None when the fragment is not registered (its page has not rendered).
+    """
+    html = Frond.render_live(name, data or {})
+    if html is None:
+        return None
+    import json
+    envelope = json.dumps({"type": "live", "name": name, "html": html})
+    try:
+        from tina4_python.core.server import _ws_manager
+        ws_path = Frond._class_live_ws_paths.get(name)
+        if ws_path:
+            await _ws_manager.broadcast(envelope, path=ws_path)
+        else:
+            await _ws_manager.broadcast_to_room(name, envelope)
+    except Exception as exc:
+        try:
+            from tina4_python.debug import Log
+            Log.error("push_live(" + str(name) + ") broadcast failed: " + str(exc))
+        except Exception:
+            pass
+    return html
+
+
+def live_source(name: str):
+    """Register a data provider for a {% live %} block.
+
+    The decorated function receives the request and returns the context dict
+    used to re-render the fragment on refresh:
+
+        @live_source("notifications")
+        async def notifications(request):
+            return {"items": Notification.where("user_id = ?", [request.session["uid"]])}
+    """
+    def _wrap(fn):
+        Frond._class_live_sources[name] = fn
+        return fn
+    return _wrap
+
+
+__all__ = ["Frond", "live_source", "live_endpoint", "push_live"]

{tina4_python-3.13.51 → tina4_python-3.13.53}/tina4_python/frond/engine.py

@@ -117,6 +117,15 @@ _FILTER_CMP_RE = re.compile(r"(\w+)\s*(!=|==|>=|<=|>|<)\s*(.+)")
 _FOR_RE = re.compile(r"for\s+(\w+)(?:\s*,\s*(\w+))?\s+in\s+(.+)")
 _SET_RE = re.compile(r"set\s+(\w+)\s*=\s*(.+)", re.DOTALL)
 _INCLUDE_RE = re.compile(r'include\s+["\'](.+?)["\'](?:\s+with\s+(.+))?')
+_LIVE_RE = re.compile(r'live\s+["\'](?P<name>[^"\']+)["\'](?P<rest>.*)$', re.DOTALL)
+_LIVE_WS_RE = re.compile(r'ws\s+["\']([^"\']+)["\']')
+_LIVE_SRC_RE = re.compile(r'src\s+["\']([^"\']+)["\']')
+
+
+def _live_attr(value) -> str:
+    """Escape a value for use inside an HTML attribute on a live marker."""
+    return (str(value).replace("&", "&amp;").replace('"', "&quot;")
+            .replace("<", "&lt;").replace(">", "&gt;"))
 _MACRO_RE = re.compile(r"macro\s+(\w+)\s*\(([^)]*)\)")
 _FROM_IMPORT_RE = re.compile(r'from\s+["\'](.+?)["\']\s+import\s+(.+)')
 _IMPORT_AS_RE = re.compile(r'import\s+["\'](.+?)["\']\s+as\s+(\w+)')
@@ -1309,6 +1318,11 @@ class Frond:
     _class_globals: dict = {}
     _class_filters: dict = {}
     _class_tests: dict = {}
+    # Live blocks: name -> body template source (registered when a {% live %}
+    # block renders); name -> data provider (registered via @live_source).
+    _class_live_fragments: dict = {}
+    _class_live_sources: dict = {}
+    _class_live_ws_paths: dict = {}
 
     @classmethod
     def clear_registry(cls):
@@ -1320,6 +1334,9 @@ class Frond:
         cls._class_globals.clear()
         cls._class_filters.clear()
         cls._class_tests.clear()
+        cls._class_live_fragments.clear()
+        cls._class_live_sources.clear()
+        cls._class_live_ws_paths.clear()
 
     def __init__(self, template_dir: str = "src/templates"):
         self.template_dir = Path(template_dir)
@@ -1766,6 +1783,11 @@ class Frond:
                     output.append(result)
                     i = skip
 
+                elif tag == "live":
+                    result, skip = self._handle_live(tokens, i, context)
+                    output.append(result)
+                    i = skip
+
                 elif tag in ("block", "endblock", "extends"):
                     i += 1  # Already handled
 
@@ -2396,6 +2418,93 @@ class Frond:
         self._fragment_cache[cache_key] = (rendered, time.time() + ttl)
         return rendered, i
 
+    def _handle_live(self, tokens: list, start: int, context: dict) -> tuple[str, int]:
+        """Handle {% live "name" poll N | sse | ws "path" [src "url"] %}...{% endlive %}.
+
+        Server-rendered live region. The body renders once for first paint, is
+        registered under <name> so the /__frond/live/<name> endpoint (or a
+        @live_source provider) can re-render it, and is wrapped in a marker
+        element that frond.js wires to the chosen transport (poll / sse / ws).
+        """
+        content, _, _ = _strip_tag(tokens[start][1])
+        m = _LIVE_RE.match(content)
+        if not m:
+            raise ValueError('live: expected {% live "name" poll N | sse | ws "path" %}')
+        name = m.group("name")
+        rest = (m.group("rest") or "").strip()
+        parts = rest.split()
+        mode = parts[0] if parts else ""
+
+        src = None
+        sm = _LIVE_SRC_RE.search(rest)
+        if sm:
+            src = sm.group(1)
+        if src and (src.startswith("http://") or src.startswith("https://") or src.startswith("//")):
+            raise ValueError("live: src must be a same-origin path, not an absolute URL")
+
+        interval = None
+        ws_path = None
+        if mode == "poll":
+            if len(parts) < 2 or not parts[1].isdigit():
+                raise ValueError('live: poll requires seconds, e.g. {% live "x" poll 5 %}')
+            interval = int(parts[1])
+        elif mode == "sse":
+            pass
+        elif mode == "ws":
+            wm = _LIVE_WS_RE.search(rest)
+            if not wm:
+                raise ValueError('live: ws requires a path, e.g. {% live "x" ws "/ws/x" %}')
+            ws_path = wm.group(1)
+        else:
+            raise ValueError(f'live: unknown transport "{mode}" (use poll N, sse, or ws "path")')
+
+        # Collect body tokens up to {% endlive %}. Nested live is unsupported.
+        body_tokens = []
+        i = start + 1
+        while i < len(tokens):
+            if tokens[i][0] == BLOCK:
+                tag_content, _, _ = _strip_tag(tokens[i][1])
+                tag = tag_content.split()[0] if tag_content.split() else ""
+                if tag == "live":
+                    raise ValueError("live: nested live blocks are not supported")
+                if tag == "endlive":
+                    i += 1
+                    break
+                body_tokens.append(tokens[i])
+            else:
+                body_tokens.append(tokens[i])
+            i += 1
+
+        # Register the body source so the auto endpoint can re-render it.
+        Frond._class_live_fragments[name] = "".join(raw for (_t, raw) in body_tokens)
+
+        endpoint = src or ("/__frond/live/" + name)
+        attrs = [f'data-frond-live="{_live_attr(name)}"', f'id="live-{_live_attr(name)}"']
+        if mode == "poll":
+            attrs += ['data-mode="poll"', f'data-interval="{interval}"',
+                      f'data-src="{_live_attr(endpoint)}"']
+        elif mode == "sse":
+            attrs += ['data-mode="sse"', f'data-src="{_live_attr(endpoint)}"']
+        elif mode == "ws":
+            Frond._class_live_ws_paths[name] = ws_path
+            attrs += ['data-mode="ws"', f'data-ws="{_live_attr(ws_path)}"']
+
+        first_paint = self._render_tokens(list(body_tokens), context)
+        return f'<div {" ".join(attrs)}>{first_paint}</div>', i
+
+    @classmethod
+    def render_live(cls, name: str, data: dict = None):
+        """Re-render a registered {% live %} fragment by name.
+
+        Returns the rendered HTML fragment, or None if no fragment is registered
+        under that name yet (the page carrying the block has not rendered). The
+        /__frond/live/<name> endpoint calls this after resolving the provider data.
+        """
+        source = cls._class_live_fragments.get(name)
+        if source is None:
+            return None
+        return cls().render_string(source, data or {})
+
     def _handle_spaceless(self, tokens: list, start: int, context: dict) -> tuple[str, int]:
         """Handle {% spaceless %}...{% endspaceless %}.
 

{tina4_python-3.13.51 → tina4_python-3.13.53}/tina4_python/graphql/__init__.py

@@ -382,7 +382,8 @@ class Schema:
                 gql_type = "Float"
             elif ftype == "BooleanField":
                 gql_type = "Boolean"
-            elif ftype in ("StringField", "TextField", "DateTimeField"):
+            elif ftype in ("StringField", "TextField", "DateTimeField", "JSONField"):
+                # JSONField serializes to a JSON string in the GraphQL payload.
                 gql_type = "String"
             else:
                 gql_type = "String"

{tina4_python-3.13.51 → tina4_python-3.13.53}/tina4_python/orm/__init__.py

@@ -19,7 +19,7 @@ Active Record ORM with SQL-first paradigm.
 from tina4_python.orm.fields import (
     Field,
     IntegerField, StringField, BooleanField, FloatField,
-    DateTimeField, TextField, BlobField, NumericField,
+    DateTimeField, TextField, BlobField, NumericField, JSONField,
     ForeignKeyField,
     IntField, StrField, BoolField,  # short aliases
     has_many, has_one, belongs_to,  # relationship descriptors
@@ -31,7 +31,7 @@ __all__ = [
     "Field",
     # Verbose (preferred)
     "IntegerField", "StringField", "BooleanField", "FloatField",
-    "DateTimeField", "TextField", "BlobField", "NumericField",
+    "DateTimeField", "TextField", "BlobField", "NumericField", "JSONField",
     "ForeignKeyField",
     # Short aliases (backwards compat)
     "IntField", "StrField", "BoolField",

{tina4_python-3.13.51 → tina4_python-3.13.53}/tina4_python/orm/fields.py

@@ -9,6 +9,8 @@ Fields define column types, constraints, and defaults for ORM models.
         role = Field(str, choices=["admin", "user", "guest"])
         active = Field(bool, default=True)
 """
+import copy as _copy
+import json as _json
 import re as _re
 from datetime import datetime
 
@@ -165,6 +167,16 @@ class Field:
 
         return value
 
+    def to_db(self, value):
+        """Serialize an in-memory value to the form the driver should store.
+
+        Identity by default — the value already round-trips through the driver
+        as-is. Overridden by fields whose Python representation differs from
+        their column representation (e.g. ``JSONField`` stores a JSON string).
+        Called by ``ORM.save()`` when building the row for INSERT/UPDATE.
+        """
+        return value
+
     def __repr__(self):
         parts = [self.field_type.__name__]
         if self.primary_key:
@@ -212,6 +224,80 @@ def BlobField(**kwargs):
 def NumericField(**kwargs):
     return _make_field(float, "NumericField", **kwargs)
 
+class JSONField(Field):
+    """A column that stores a JSON document (a ``dict`` or a ``list``).
+
+    You work with a plain Python ``dict``/``list``; the ORM serializes it to a
+    JSON string on save and parses it back on load. The column DDL is
+    engine-aware (see :meth:`ORM.create_table`): ``JSONB`` on PostgreSQL,
+    ``JSON`` on MySQL, ``NVARCHAR(MAX)`` on MSSQL, ``TEXT`` on SQLite/ODBC,
+    ``BLOB SUB_TYPE TEXT`` on Firebird.
+
+    Read normalization: a native-JSON driver (PostgreSQL JSONB, MySQL JSON) may
+    hand back an already-parsed object, while a string-backed engine (SQLite)
+    hands back a JSON string. :meth:`validate` normalizes both to a Python
+    object, so ``model.data`` is always a ``dict``/``list`` regardless of engine.
+
+    Usage::
+
+        class Event(ORM):
+            id      = IntegerField(primary_key=True, auto_increment=True)
+            payload = JSONField()
+
+        Event({"payload": {"type": "click", "tags": ["a", "b"]}}).save()
+        e = Event.find(1)
+        e.payload["type"]   # "click"  — a real dict, not a string
+    """
+
+    def __init__(self, **kwargs):
+        super().__init__(dict, **kwargs)
+        self.kind = "JSONField"
+
+    def _resolve_default(self):
+        # Deep-copy a mutable JSON default (``default={}`` / ``default=[]``) so
+        # separate instances never alias the same object — the classic
+        # shared-default footgun. This runs on BOTH the __init__ default path
+        # (which calls _resolve_default directly) and the validate() None path.
+        d = super()._resolve_default()
+        return _copy.deepcopy(d) if isinstance(d, (dict, list)) else d
+
+    def validate(self, value):
+        # None -> required check + default (mirrors base Field).
+        if value is None:
+            if self.required and self.default is None:
+                raise ValueError(f"Field '{self.name}' is required")
+            return self._resolve_default()
+
+        # A driver returns a JSON string (SQLite/TEXT) or an already-parsed
+        # dict/list (PostgreSQL JSONB, MySQL JSON). Normalize to a Python object.
+        if isinstance(value, (bytes, bytearray)):
+            value = value.decode("utf-8")
+        if isinstance(value, str):
+            try:
+                value = _json.loads(value)
+            except (ValueError, TypeError) as e:
+                raise ValueError(f"Field '{self.name}': value is not valid JSON") from e
+        if not isinstance(value, (dict, list)):
+            raise ValueError(
+                f"Field '{self.name}': expected a dict or list, got {type(value).__name__}"
+            )
+        if self.validator is not None:
+            self.validator(value)
+        return value
+
+    def to_db(self, value):
+        # Serialize to a JSON string for the driver. A TEXT column stores it
+        # verbatim; a native JSON column (JSONB/JSON) casts the string literal.
+        if value is None:
+            return None
+        if isinstance(value, str):
+            return value  # already serialized (defensive)
+        try:
+            return _json.dumps(value)
+        except (TypeError, ValueError) as e:
+            raise ValueError(f"Field '{self.name}': value is not JSON-serializable") from e
+
+
 class ForeignKeyField(Field):
     """Integer field that references another model's primary key.
 

{tina4_python-3.13.51 → tina4_python-3.13.53}/tina4_python/orm/model.py

@@ -390,7 +390,9 @@ class ORM(metaclass=ORMMeta):
             if value is not None or not field.auto_increment:
                 # Use field_mapping for the column name, fall back to field.column
                 db_col = self.field_mapping.get(name, field.column)
-                data[db_col] = value
+                # Serialize to the column's storage form: identity for most
+                # fields, JSON string for JSONField (see Field.to_db).
+                data[db_col] = field.to_db(value)
 
         # v3.13.11 (issue #50): pick INSERT vs UPDATE on row existence
         # for non-auto-increment PKs. Auto-increment keeps the legacy
@@ -840,6 +842,23 @@ class ORM(metaclass=ORMMeta):
         else:
             datetime_sql = "DATETIME"
 
+        # JSONField -> the engine's native JSON type where it has one, else a
+        # text column. PostgreSQL JSONB (binary, indexable, canonical form);
+        # MySQL JSON; MSSQL has no JSON type so NVARCHAR(MAX) (its documented
+        # JSON storage); SQLite/ODBC TEXT; Firebird has no TEXT/JSON type so
+        # BLOB SUB_TYPE TEXT. The ORM stores a JSON string in every case, so a
+        # text-backed column round-trips identically to a native one.
+        if engine in ("postgres", "postgresql"):
+            json_sql = "JSONB"
+        elif engine == "mysql":
+            json_sql = "JSON"
+        elif engine == "mssql":
+            json_sql = "NVARCHAR(MAX)"
+        elif engine == "firebird":
+            json_sql = "BLOB SUB_TYPE TEXT"
+        else:
+            json_sql = "TEXT"
+
         # Don't recreate if table already exists
         if db.table_exists(table):
             return True
@@ -866,6 +885,8 @@ class ORM(metaclass=ORMMeta):
                 sql_type = datetime_sql
             elif kind == "BlobField":
                 sql_type = "BLOB"
+            elif kind == "JSONField":
+                sql_type = json_sql
             else:
                 # Fallback based on field_type
                 ft = field_obj.field_type
@@ -886,7 +907,7 @@ class ORM(metaclass=ORMMeta):
                 parts.append("AUTOINCREMENT")
             if field_obj.required and not field_obj.primary_key:
                 parts.append("NOT NULL")
-            if field_obj.default is not None and not field_obj.auto_increment:
+            if field_obj.default is not None and not field_obj.auto_increment and kind != "JSONField":
                 default_val = field_obj.default
                 if isinstance(default_val, str):
                     parts.append(f"DEFAULT '{default_val}'")