baucli 1.0.1__py3-none-any.whl

baucli/apexlang.py

@@ -0,0 +1,317 @@
+"""APEXLang split-export reader for DOCAPEX ingestion.
+
+Builds the `POST /apex/sync` payload (contract of
+PKG_BAU_DOCAPEX_CORE.SYNC_APP) by PARSING THE APP DIRECTORY of a SQLcl
+split export (`application.apx` + `pages/p*.apx`) — no APEX dictionary
+access required. This is the canonical ingestion path: the split export
+is what teams version and what `apex-rebuild` operates on.
+
+Component ids
+=============
+The server upserts regions/items/processes/DAs keyed by numeric component
+ids. APEXLang blocks have names, not ids, so we derive a STABLE numeric id
+from sha256(page|kind|name|ordinal): the same block maps to the same id on
+every sync, which keeps the server's per-row hash change-detection working.
+
+Parsing model
+=============
+Same machinery proven by apex-rebuild: paren-balanced block scanning that
+skips ```fences``` and quoted strings, plus property lookups by indent
+depth. Only depth-1 blocks of the page are scanned (region / pageItem /
+process / dynamicAction are siblings in the MMD grammar).
+"""
+from __future__ import annotations
+
+import hashlib
+import json
+import re
+from datetime import datetime, timezone
+from pathlib import Path
+
+from baucli.apex_rebuild import find_matching_paren, _resolve_root_and_appdir
+
+_PAGE_HEAD = re.compile(r"^page\s+(\d+)\s*\(", re.MULTILINE)
+_APP_HEAD = re.compile(r"^app\s+([A-Za-z0-9_-]+)\s*\(", re.MULTILINE)
+_BLOCK = re.compile(
+    r"^([ \t]*)(region|pageItem|process|dynamicAction)[ \t]+"
+    r"([A-Za-z_][A-Za-z0-9_-]*)[ \t]*\(",
+    re.MULTILINE,
+)
+
+
+def _stable_id(*parts) -> int:
+    """Deterministic 48-bit id from the block identity — stable across
+    syncs so the server's hash diffing sees the same row."""
+    key = "|".join(str(p) for p in parts)
+    return int(hashlib.sha256(key.encode("utf-8")).hexdigest()[:12], 16)
+
+
+def _prop(body: str, key: str, indent: str) -> str | None:
+    """Scalar `key: value` at exactly the given indent."""
+    m = re.search(rf"^{re.escape(indent)}{re.escape(key)}\s*:\s*(.*?)\s*$",
+                  body, re.MULTILINE)
+    return m.group(1) if m else None
+
+
+def _nested(body: str, parent: str, key: str) -> str | None:
+    """`parent { ... key: value ... }` anywhere in the block body."""
+    m = re.search(rf"^([ \t]*){re.escape(parent)}\s*\{{(.*?)^\1\}}",
+                  body, re.MULTILINE | re.DOTALL)
+    if not m:
+        return None
+    kv = re.search(rf"^[ \t]*{re.escape(key)}\s*:\s*(.*?)\s*$",
+                   m.group(2), re.MULTILINE)
+    return kv.group(1) if kv else None
+
+
+def _fence(body: str) -> str | None:
+    """First ```fenced``` content in the block body (sql/plsql/html)."""
+    m = re.search(r"```[a-z]*\n(.*?)```", body, re.DOTALL)
+    return m.group(1).strip() if m else None
+
+
+def _blocks(page_body: str, page_indent: str = "    "):
+    """Depth-1 blocks (kind, name, body) of a page body."""
+    for m in _BLOCK.finditer(page_body):
+        if m.group(1) != page_indent:
+            continue  # nested (e.g. `action` inside dynamicAction)
+        op = page_body.find("(", m.end() - 1)
+        try:
+            end = find_matching_paren(page_body, op)
+        except ValueError:
+            continue
+        yield m.group(2), m.group(3), page_body[op + 1:end - 1]
+
+
+def _parse_page(path: Path, payload: dict) -> None:
+    src = path.read_text(encoding="utf-8", errors="replace")
+    hm = _PAGE_HEAD.search(src)
+    if not hm:
+        return
+    page_id = int(hm.group(1))
+    op = src.find("(", hm.end() - 1)
+    body = src[op + 1:find_matching_paren(src, op) - 1]
+
+    mode = _nested(body, "appearance", "pageMode") or "normal"
+    # Alvos `page: N` (colunas-link, botões redirect, branches) → usados por
+    # _infer_modal_launchers p/ descobrir qual página lança cada modal.
+    _targets = sorted({int(n) for n in re.findall(r"\bpage\s*:\s*(\d+)", body)})
+    payload["pages"].append({
+        "page_id": page_id,
+        "page_name": _prop(body, "name", "    "),
+        "page_title": _prop(body, "title", "    "),
+        "page_alias": _prop(body, "alias", "    "),
+        "page_mode": "Modal Dialog" if mode == "modalDialog" else "Normal",
+        "page_type": None,
+        "parent_page_id": None,
+        "authorization_scheme":
+            (_nested(body, "security", "authorizationScheme") or "")
+            .lstrip("@") or None,
+        "help_text": _nested(body, "help", "helpText"),
+        "_targets": _targets,
+    })
+
+    for kind, name, blk in _blocks(body):
+        if kind == "region":
+            # Source: fenced SQL/PLSQL, or the form/table reference.
+            source = _fence(blk)
+            if source is None:
+                source = (_nested(blk, "source", "tableName")
+                          or _nested(blk, "source", "table"))
+            payload["regions"].append({
+                "page_id": page_id,
+                "region_id": _stable_id(page_id, "region", name),
+                "region_name": _prop(blk, "name", "        ") or name,
+                "region_type": _prop(blk, "type", "        "),
+                "region_template":
+                    (_nested(blk, "appearance", "template") or "").lstrip("@/")
+                    or None,
+                "display_position": _nested(blk, "layout", "slot"),
+                "display_sequence":
+                    _num(_nested(blk, "layout", "sequence")),
+                "parent_region_id": None,
+                "region_source": source,
+            })
+        elif kind == "pageItem":
+            label = (_nested(blk, "label", "label")
+                     or _prop(blk, "label", "        "))
+            template = _nested(blk, "appearance", "template") or ""
+            required = ("Y" if ("required" in template
+                                or (_nested(blk, "validation",
+                                            "valueRequired") == "true"))
+                        else "N")
+            src_type = _nested(blk, "source", "type")
+            src_value = (_nested(blk, "source", "dbColumn")
+                         or _nested(blk, "source", "column")
+                         or _nested(blk, "source", "sqlQuery"))
+            if src_type is None and _nested(blk, "source", "formRegion"):
+                src_type = "formRegion"
+            # Vínculo item→região: layout { region: @nome } aponta o bloco da
+            # região; o id estável é o mesmo gerado para o bloco region, então
+            # o servidor resolve o FK BAU_DOCAPEX_REGIONS_ID no upsert.
+            region_ref = _nested(blk, "layout", "region")
+            payload["items"].append({
+                "page_id": page_id,
+                "region_id": (_stable_id(page_id, "region", region_ref.lstrip("@"))
+                              if region_ref else None),
+                "item_id": _stable_id(page_id, "item", name),
+                "item_name": name,
+                "item_type": _prop(blk, "type", "        "),
+                "label": (label or "")[:450] or None,
+                "display_sequence": _num(_nested(blk, "layout", "sequence")),
+                "data_type": _nested(blk, "source", "dataType"),
+                "is_required": required,
+                # VARCHAR2(4000) on the server is BYTES — UTF-8 text must
+                # stay well under it (4000 chars of accented text overflow).
+                "default_value": (_nested(blk, "default", "staticValue")
+                                  or "")[:1000] or None,
+                "source_type": src_type,
+                "source_value": (src_value or "")[:2000] or None,
+                "lov_name": None,
+                "help_text": _nested(blk, "help", "helpText"),
+            })
+        elif kind == "process":
+            payload["proc"].append({
+                "page_id": page_id,
+                "process_id": _stable_id(page_id, "process", name),
+                "process_name": _prop(blk, "name", "        ") or name,
+                "process_type": _prop(blk, "type", "        "),
+                "process_point":
+                    _nested(blk, "execution", "point") or "afterSubmit",
+                "display_sequence":
+                    _num(_nested(blk, "execution", "sequence")),
+                # Native form processes (autoRowFetch/autoRowProcessing)
+                # carry the table in source{tableName}, not a code fence.
+                "process_source": (_fence(blk)
+                                   or _nested(blk, "source", "tableName")),
+                "when_button_pressed":
+                    _nested(blk, "serverSideCondition", "value"),
+            })
+        elif kind == "dynamicAction":
+            actions = re.findall(
+                r"^[ \t]*action[ \t]+[A-Za-z_][\w-]*[ \t]*\(\s*\n"
+                r"[ \t]*action\s*:\s*(\S+)",
+                blk, re.MULTILINE)
+            payload["da"].append({
+                "page_id": page_id,
+                "region_id": None,
+                "da_id": _stable_id(page_id, "da", name),
+                "da_name": _prop(blk, "name", "        ") or name,
+                "event_name": _nested(blk, "when", "event"),
+                "selection_type": _nested(blk, "when", "selectionType"),
+                "selection_value":
+                    (_nested(blk, "when", "button")
+                     or _nested(blk, "when", "items")
+                     or "").lstrip("@") or None,
+                "condition_type": None,
+                "condition_value": None,
+                "actions_json": json.dumps(actions) if actions else None,
+            })
+
+
+def _num(v: str | None):
+    try:
+        return int(v) if v is not None else None
+    except (TypeError, ValueError):
+        return None
+
+
+def _application_id(app_root: Path, override: int | None) -> int | None:
+    """From --app-id, else the deployments/*.json manifest."""
+    if override:
+        return override
+    dep_dir = app_root / "deployments"
+    if dep_dir.is_dir():
+        for f in sorted(dep_dir.glob("*.json")):
+            try:
+                data = json.loads(f.read_text(encoding="utf-8"))
+                app_id = (data.get("app") or {}).get("id")
+                if app_id:
+                    return int(app_id)
+            except (OSError, ValueError):
+                continue
+    return None
+
+
+def extract_apexlang(project_root: Path, app_dir: str, schema: str,
+                     application_id: int | None = None,
+                     workspace: str | None = None) -> dict:
+    """Parse an APEXLang split export into the /apex/sync payload."""
+    root, eff_app_dir = _resolve_root_and_appdir(project_root, app_dir)
+    if root is None:
+        raise FileNotFoundError(
+            f"App directory '{app_dir}' has no pages/ folder under "
+            f"{project_root} or its parents.")
+    app_root = root / "apex" / eff_app_dir
+
+    app_id = _application_id(app_root, application_id)
+    if app_id is None:
+        raise ValueError(
+            "Could not determine the APEX application id: pass --app-id or "
+            "keep a deployments/*.json with {\"app\":{\"id\":N}} in the "
+            "export.")
+
+    app_name = None
+    app_alias = None
+    app_file = app_root / "application.apx"
+    if app_file.is_file():
+        src = app_file.read_text(encoding="utf-8", errors="replace")
+        am = _APP_HEAD.search(src)
+        if am:
+            app_alias = am.group(1)
+            op = src.find("(", am.end() - 1)
+            body = src[op + 1:find_matching_paren(src, op) - 1]
+            app_name = _prop(body, "name", "    ")
+
+    page_files = sorted((app_root / "pages").glob("*.apx"))
+    last_upd = max((f.stat().st_mtime for f in page_files), default=None)
+
+    payload = {
+        "schema": schema.upper(),
+        "app": {
+            "application_id": app_id,
+            "app_name": app_name or eff_app_dir,
+            "app_alias": app_alias,
+            "workspace_name": workspace,
+            "authentication_scheme": None,
+            "theme_name": None,
+            "build_status": None,
+            "app_version": None,
+            "page_count": len(page_files),
+            "last_updated_by": "APEXLANG",
+            "last_updated_on": (
+                datetime.fromtimestamp(last_upd, tz=timezone.utc)
+                .strftime("%Y-%m-%dT%H:%M:%S") if last_upd else None),
+        },
+        "pages": [], "regions": [], "items": [], "proc": [], "da": [],
+    }
+    for f in page_files:
+        _parse_page(f, payload)
+    _infer_modal_launchers(payload)
+    return payload
+
+
+def _infer_modal_launchers(payload: dict) -> None:
+    """Infere, p/ cada página modal (Modal Dialog), a página LANÇADORA — a
+    página Normal que a referencia via `page: N` (coluna-link / botão / branch).
+    Grava `launch_page` no dict da modal p/ o servidor registrar
+    `BAU_DOCAPEX_PAGES.SS_LAUNCH_PAGE` no sync (só preenche quando a coluna está
+    NULL — edições da p42 vencem). Não descobre modais abertas só por JS
+    (`apex.navigation.dialog`) sem `page: N` no export — essas seguem pela
+    auto-descoberta em runtime (harvest do link f?p). Limpa o campo transitório
+    `_targets`."""
+    pages = payload.get("pages", [])
+    by_id = {p["page_id"]: p for p in pages}
+    cands: dict[int, list[int]] = {}
+    for p in pages:
+        for t in (p.get("_targets") or []):
+            if t and t != p["page_id"]:
+                cands.setdefault(t, []).append(p["page_id"])
+    for p in pages:
+        if p.get("page_mode") == "Modal Dialog":
+            ls = cands.get(p["page_id"], [])
+            # prefere lançador Normal (evita modal→modal); desempate determinístico
+            normal = sorted(l for l in ls
+                            if by_id.get(l, {}).get("page_mode") != "Modal Dialog")
+            p["launch_page"] = normal[0] if normal else (sorted(ls)[0] if ls else None)
+        p.pop("_targets", None)