File size: 10,920 Bytes
3998487
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2e77cd4
 
 
 
 
 
3998487
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
4df2e4a
 
 
 
3998487
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
"""chart_system.py β€” a SAVED CONFIGURABLE-INTERFACE RECORD (wave 47, instruction 18, W47-T30).

⭐ **OWNER RULING R7 IS WHY THIS FILE EXISTS.** Verbatim: *"every interface like chart, swap etc.
that we need to configure should act like route with the right side navigation to choose the
specific view we want to see. So its not pegged on a per view basis."* Time-series state hides
today inside `ws["views"][vid]["config"]["display"]` β€” one copy per view, owned by nobody, listed
nowhere, and lost the moment the view it rode on is changed or deleted. That is precisely what the
ruling rejects.

⭐ **CONTRACT C6:** *"a saved chart is a record, not a view setting. It carries its own id, name and
owner and is listed independently of `ws["views"]`, so a second consumer can reuse the type
unchanged."*

β›”β›” **THIS FILE MUST NEVER INTERPRET `config`, AND THAT IS THE WHOLE REUSABILITY CONTRACT.** A
record carries a `kind` (this wave's only shipped consumer writes `"timeseries"`) and an OPAQUE
`config` dict stored verbatim. There is deliberately NO allowlist of kinds and NO knowledge of a
single config key: a second consumer ("swap", a map preset, a pivot) stores its own `kind` and its
own config shape with ZERO change to this file. An `if kind == "timeseries"` here β€” or a field
named after the time-series β€” breaks C6 while passing every gate.

β›” **INDEPENDENT STORAGE IS THE NEGATIVE CONTROL, not a detail.** Charts live in their own
dedicated store bucket, `loopable_chart_system`. The view documents live in the personal source
strata of per-topic table workspace buckets (`customer_table_workspace`,
`product_table_workspace`, a `ut_*` key); the reserved `__shared__` member is for field annotations,
not Views. Nothing in this module reads or writes a workspace document, a `views` map, or anything
named `ws[...]`, so deleting a view cannot delete a chart: they are different keys in the store and
there is no code path between them.

⭐ **THE SHAPE OF THIS MODULE MIRRORS `core/route_system.py` DELIBERATELY** β€” a dedicated
module-level `STORE_KEY`, a projected `_store` read, a read-modify-write `_persist` under the
store's own lock, server-minted ids, and a duck-typed `st` (only `get` / `get_projection` /
`update` are ever used). Like that module this one imports ONLY stdlib and NOTHING from
`platform/core/`, so it can never drag a topic, a permission model or a connector into a record
type that is meant to outlive all three. The small duplication of `_now` / `_store` / `_persist` is
correct here rather than a smell: there is no shared lower-level helper to reuse, and importing
`route_system` would couple charts to routes for four lines of code.

⚠ NAME IS NOT UNIQUE. `id` is the only match key, exactly as for a Route. Two charts may share a
name on one database and neither is lost.

⚠ PERMISSION IS NOT DECIDED HERE. Visibility is a per-database question and its one chokepoint is
`deps.Session.require(<database>)` in `aios-web/api/routes_charts.py`, the same predicate the nav
uses. This module stores `database` as a DATABASE KEY (`customer_data`, `product_data`, a `ut_*`
table key) β€” never the React client's separate `SurfaceScope` vocabulary ("customer", "product"),
which is a different string space and a separately booked defect.
"""
import copy
import json
import re
import uuid
from datetime import datetime, timezone

#: The DEDICATED bucket. Not inside any workspace document β€” that separation is what makes C6's
#: "listed independently of ws['views']" a fact about storage rather than a promise about code.
STORE_KEY = "loopable_chart_system"

#: A DEFAULT, never a constraint: any slug is accepted. β›” Never a retired kind: S68-T44 retired
#: `timeseries` and its boot purge deletes every chart of that kind (and every stored kind-less
#: one), so a kind-less chart written AFTER the purge must not be re-stamped as Time-series.
DEFAULT_KIND = "chart"

_MAX_NAME = 120
_MAX_KIND = 40
_MAX_DATABASE = 200
_MAX_ID = 80
_MAX_STAMP = 120
#: A client may not park an unbounded blob in the tenant store. A BYTE CAP is not interpretation:
#: it never looks at a key, only at the serialized length.
MAX_CONFIG_BYTES = 64 * 1024

_KIND_CLEAN = re.compile(r"[^a-z0-9_]+")


def _now():
    return datetime.now(timezone.utc).replace(microsecond=0).isoformat()


def _store(st):
    """The bucket, projected when the runtime offers a projection (never the whole store)."""
    try:
        projected = getattr(st, "get_projection", None)
        if callable(projected):
            return dict(projected(STORE_KEY, drop=()) or {})
        return dict(st.get(STORE_KEY) or {})
    except Exception:
        return {}


def _persist(st, mutate):
    """Read-modify-write under the store's own lock, mirroring `route_system._persist`."""
    result = {}

    def apply(current):
        state = copy.deepcopy(current) if isinstance(current, dict) else {}
        state.setdefault("charts", [])
        next_state, value = mutate(state)
        result["value"] = copy.deepcopy(value)
        return next_state

    st.update(STORE_KEY, apply, flush="sync")
    return result.get("value")


def _text(raw, limit):
    return str(raw if raw is not None else "").strip()[:limit]


def _slug_kind(raw):
    """A kind is SANITIZED, never validated against a list. See the module note."""
    slug = _KIND_CLEAN.sub("_", str(raw or "").strip().lower())[:_MAX_KIND].strip("_")
    return slug or DEFAULT_KIND


def _config(raw):
    """`(value, ok)` for an OPAQUE config: JSON-safe and under the byte cap, or refused.

    Strictly JSON-serializable with no `default=` coercion, because the store persists JSON and a
    value that only stringifies would be a write that fails later, somewhere else. Nothing here
    inspects a key, and nothing may start to.
    """
    if raw is None:
        return {}, True
    if not isinstance(raw, dict):
        return {}, False
    try:
        blob = json.dumps(raw)
    except (TypeError, ValueError):
        return {}, False
    if len(blob.encode("utf-8")) > MAX_CONFIG_BYTES:
        return {}, False
    return copy.deepcopy(raw), True


def _record(raw, *, created_by="", tenant_id="", prior=None):
    """Normalize one chart, or None when it is not a chart.

    β›” `database`, `createdBy`, `createdAt`, `tenantId` and `id` are all PRIOR-WINS on update.
    An update that could move a chart to another database would be a permission escape: the caller
    passed the wall for the database the chart is on, not for the one being named.
    """
    raw = raw if isinstance(raw, dict) else {}
    prior = prior if isinstance(prior, dict) else None

    name = _text(raw.get("name"), _MAX_NAME)
    if not name and prior is not None:
        name = _text(prior.get("name"), _MAX_NAME)
    if not name:
        return None

    database = _text(prior.get("database") if prior is not None else raw.get("database"),
                     _MAX_DATABASE)
    if not database:
        return None

    kind_src = raw.get("kind")
    if kind_src in (None, "") and prior is not None:
        kind_src = prior.get("kind")
    kind = _slug_kind(kind_src)

    if "config" in raw:
        config, ok = _config(raw.get("config"))
        if not ok:
            return None
    elif prior is not None:
        config = copy.deepcopy(prior.get("config") or {})
    else:
        config = {}

    now = _now()
    if prior is not None:
        chart_id = _text(prior.get("id"), _MAX_ID)
        owner = _text(prior.get("createdBy"), _MAX_STAMP).lower()
        tenant = _text(prior.get("tenantId"), _MAX_STAMP)
        created_at = _text(prior.get("createdAt"), 40) or now
    else:
        chart_id = "chart_" + uuid.uuid4().hex
        owner = _text(created_by, _MAX_STAMP).lower()
        tenant = _text(tenant_id, _MAX_STAMP)
        created_at = now

    return {"id": chart_id,
            "tenantId": tenant,
            "kind": kind,
            "database": database,
            "name": name,
            "config": config,
            "createdBy": owner,
            "createdAt": created_at,
            "updatedAt": now}


def _tenant_ok(chart, tenant_id):
    if not tenant_id:
        return True
    stamped = str(chart.get("tenantId") or "")
    return not stamped or stamped == str(tenant_id)


def list_charts(st, *, database=None, tenant_id=None):
    """Every saved chart in this store, optionally narrowed to one database key.

    Sorted by name then id so a navigator renders stably; NAME IS NOT UNIQUE, so id breaks ties.
    """
    charts = [c for c in (_store(st).get("charts") or []) if isinstance(c, dict)]
    charts = [c for c in charts if _tenant_ok(c, tenant_id)]
    want = str(database or "").strip()
    if want:
        charts = [c for c in charts if str(c.get("database") or "") == want]
    return sorted(charts, key=lambda c: (str(c.get("name") or "").lower(), str(c.get("id") or "")))


def get_chart(st, chart_id, *, tenant_id=None):
    """One chart by id, or None. The caller still owes the per-database wall."""
    wanted = str(chart_id or "").strip()
    if not wanted:
        return None
    for chart in list_charts(st, tenant_id=tenant_id):
        if str(chart.get("id") or "") == wanted:
            return chart
    return None


def put_chart(st, raw, *, tenant_id, created_by):
    """Create (no `id`) or update (`id` of an existing chart). None when the input is not a chart.

    An `id` naming a chart that does not exist is refused rather than created, so an upsert
    primitive cannot become a way to choose your own id.
    """
    incoming = dict(raw) if isinstance(raw, dict) else {}
    wanted = str(incoming.get("id") or "").strip()
    prior = get_chart(st, wanted, tenant_id=tenant_id) if wanted else None
    if wanted and prior is None:
        return None
    record = _record(incoming, created_by=created_by, tenant_id=tenant_id, prior=prior)
    if record is None:
        return None

    def mutate(state):
        charts = [c for c in (state.get("charts") or []) if isinstance(c, dict)]
        replaced = False
        for index, chart in enumerate(charts):
            if str(chart.get("id") or "") == record["id"]:
                charts[index] = record
                replaced = True
                break
        if not replaced:
            charts.append(record)
        state["charts"] = charts
        return state, record

    return _persist(st, mutate)


def delete_chart(st, chart_id):
    """True when a chart was removed. Touches nothing but this module's own bucket."""
    wanted = str(chart_id or "").strip()
    if not wanted:
        return False

    def mutate(state):
        charts = [c for c in (state.get("charts") or []) if isinstance(c, dict)]
        keep = [c for c in charts if str(c.get("id") or "") != wanted]
        state["charts"] = keep
        return state, len(keep) != len(charts)

    return bool(_persist(st, mutate))