@nitra/cursor 3.12.0 → 3.14.0

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Changelog
 
+## [3.14.0] - 2026-06-02
+
+### Changed
+
+- k8s hasura_configmap: base/dev ConfigMap Hasura-Deployment має містити HASURA_GRAPHQL_ENABLED_APIS="metadata,graphql,pgdump" (точний рядок). Кожен не-base overlay (k8s/<env>/, env≠base/dev), що успадковує Hasura-base, має у kustomization.yaml перевизначати цей ключ до "metadata,graphql" (без pgdump) патчем JSON6902/Strategic Merge на ConfigMap — нова cross-file перевірка validateHasuraOverlayEnabledApisOverride
+
+## [3.13.0] - 2026-06-02
+
+### Changed
+
+- k8s hasura_configmap: розширено перелік обов'язкових env у ConfigMap Hasura-Deployment — додатково до HASURA_GRAPHQL_ENABLE_REMOTE_SCHEMA_PERMISSIONS="true" тепер вимагаються HASURA_GRAPHQL_ENABLE_RELAY="false", HASURA_GRAPHQL_ENABLE_TELEMETRY="false", HASURA_GRAPHQL_ENABLED_LOG_TYPES="startup,http-log" (точний рядок) і HASURA_GRAPHQL_DISABLE_EVENTING (ключ обов'язковий, значення довільне, за замовчуванням "true")
+
 ## [3.12.0] - 2026-06-02
 
 ### Added

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nitra/cursor",
-  "version": "3.12.0",
+  "version": "3.14.0",
   "description": "CLI для завантаження cursor-правил (префікс n-) у локальний репозиторій",
   "keywords": [
     "cli",

package/rules/k8s/js/manifests.mjs

@@ -2349,47 +2349,18 @@ export function isHasuraDeploymentManifest(manifest) {
 }
 
 /**
- * Обов'язковий ключ у **`data`** ConfigMap для Hasura-Deployment (узгоджено з k8s.mdc).
- */
-export const HASURA_REMOTE_SCHEMA_PERMISSIONS_KEY = 'HASURA_GRAPHQL_ENABLE_REMOTE_SCHEMA_PERMISSIONS'
-
-/**
- * Чи значення поля `data.<key>` у ConfigMap читається як логічне **true**.
- * ConfigMap у Kubernetes тримає значення як рядки, але в YAML часто пишуть без лапок —
- * тому приймаємо і булевий **true**, і рядок **"true"** (без регістрової залежності).
- * @param {unknown} v значення з `data[HASURA_REMOTE_SCHEMA_PERMISSIONS_KEY]`
- * @returns {boolean} true, якщо значення — `true` або рядок `'true'`
- */
-function isConfigMapValueTrue(v) {
-  if (v === true) return true
-  if (typeof v === 'string' && v.trim().toLowerCase() === 'true') return true
-  return false
-}
-
-/**
- * Чи порушує ConfigMap вимогу щодо **`HASURA_GRAPHQL_ENABLE_REMOTE_SCHEMA_PERMISSIONS: "true"`** (k8s.mdc).
- * Перевірка застосовна, коли в тому ж каталозі є Hasura-Deployment (див. `isHasuraDeploymentManifest`).
- * @param {unknown} manifest корінь YAML-документа ConfigMap
- * @returns {string | null} текст порушення або null, якщо не ConfigMap / ключ є і значення `true`
- */
-export function hasuraConfigMapRemoteSchemaPermissionsViolation(manifest) {
-  if (manifest === null || manifest === undefined || typeof manifest !== 'object' || Array.isArray(manifest))
-    return null
-  const rec = /** @type {Record<string, unknown>} */ (manifest)
-  if (rec.kind !== 'ConfigMap') return null
-  const data = rec.data
-  if (data === null || data === undefined || typeof data !== 'object' || Array.isArray(data)) {
-    return `data.${HASURA_REMOTE_SCHEMA_PERMISSIONS_KEY}: додай ключ зі значенням "true" (Deployment з hasura/graphql-engine — див. k8s.mdc)`
-  }
-  const d = /** @type {Record<string, unknown>} */ (data)
-  if (!Object.hasOwn(d, HASURA_REMOTE_SCHEMA_PERMISSIONS_KEY)) {
-    return `data.${HASURA_REMOTE_SCHEMA_PERMISSIONS_KEY}: додай ключ зі значенням "true" (Deployment з hasura/graphql-engine — див. k8s.mdc)`
-  }
-  if (!isConfigMapValueTrue(d[HASURA_REMOTE_SCHEMA_PERMISSIONS_KEY])) {
-    return `data.${HASURA_REMOTE_SCHEMA_PERMISSIONS_KEY}: значення має бути "true" (зараз: ${JSON.stringify(d[HASURA_REMOTE_SCHEMA_PERMISSIONS_KEY])}) (див. k8s.mdc)`
-  }
-  return null
-}
+ * Обов'язкові env-ключі у **`data`** ConfigMap для Hasura-Deployment (узгоджено з
+ * rego-пакетом `k8s.hasura_configmap` та k8s.mdc). Лише для людиночитного pass-повідомлення —
+ * авторитетна пер-документна валідація (наявність ключів і значення) живе в rego.
+ */
+export const HASURA_REQUIRED_ENV_KEYS = [
+  'HASURA_GRAPHQL_ENABLE_REMOTE_SCHEMA_PERMISSIONS',
+  'HASURA_GRAPHQL_ENABLE_RELAY',
+  'HASURA_GRAPHQL_ENABLE_TELEMETRY',
+  'HASURA_GRAPHQL_ENABLED_LOG_TYPES',
+  'HASURA_GRAPHQL_ENABLED_APIS',
+  'HASURA_GRAPHQL_DISABLE_EVENTING'
+]
 
 const K8S_YAML_EXT_RE = /\.ya?ml$/iu
 
@@ -3676,7 +3647,10 @@ async function validateConfigMapNameMatchesDeployment(root, yamlFilesAbs, fail,
 
 /**
  * Для кожного `k8s/base/configmap.yaml`, у каталозі якого поруч є Hasura-Deployment,
- * вимагає у `data` ключ **`HASURA_GRAPHQL_ENABLE_REMOTE_SCHEMA_PERMISSIONS`** зі значенням **`"true"`** (k8s.mdc).
+ * вимагає у `data` обов'язкові env-ключі (`HASURA_REQUIRED_ENV_KEYS`) з очікуваними
+ * значеннями (`HASURA_GRAPHQL_ENABLE_REMOTE_SCHEMA_PERMISSIONS="true"`,
+ * `HASURA_GRAPHQL_ENABLE_RELAY="false"`, `HASURA_GRAPHQL_ENABLE_TELEMETRY="false"`,
+ * `HASURA_GRAPHQL_ENABLED_LOG_TYPES="startup,http-log"`, `HASURA_GRAPHQL_DISABLE_EVENTING` — будь-яке) (k8s.mdc).
  * @param {string} root корінь репозиторію
  * @param {string[]} yamlFilesAbs yaml під k8s
  * @param {(msg: string) => void} fail callback при помилці
@@ -3688,8 +3662,8 @@ async function validateHasuraConfigMapRemoteSchemaPermissions(root, yamlFilesAbs
     return CONFIGMAP_BASE_PATH_RE.test(`/${rel}`) || rel === 'k8s/base/configmap.yaml'
   })
   // JS gating: відберемо ConfigMap-файли, у каталозі яких поруч є Hasura-Deployment.
-  // Per-document валідація `data.HASURA_GRAPHQL_ENABLE_REMOTE_SCHEMA_PERMISSIONS == "true"`
-  // — у rego-пакеті `k8s.hasura_configmap`.
+  // Per-document валідація обов'язкових `data.HASURA_GRAPHQL_*` env — у rego-пакеті
+  // `k8s.hasura_configmap`.
   const paired = []
   for (const cmAbs of cmFiles) {
     const deployment = await findDeploymentDocInDir(dirname(cmAbs))
@@ -3708,7 +3682,7 @@ async function validateHasuraConfigMapRemoteSchemaPermissions(root, yamlFilesAbs
     fail(`${rel}: ${v.message}`)
   }
   if (violations.length === 0) {
-    passFn(`Hasura-ConfigMap (${paired.length}) відповідає ${HASURA_REMOTE_SCHEMA_PERMISSIONS_KEY}="true" (rego)`)
+    passFn(`Hasura-ConfigMap (${paired.length}) містить обов'язкові env [${HASURA_REQUIRED_ENV_KEYS.join(', ')}] (rego)`)
   }
 }
 
@@ -4956,6 +4930,130 @@ async function validateProdKustomizationOverrides(root, yamlFilesAbs, fail, pass
   }
 }
 
+/** Очікуване `HASURA_GRAPHQL_ENABLED_APIS` у non-base/dev overlay (без `pgdump` — він лише для base/dev). */
+const HASURA_OVERLAY_ENABLED_APIS = 'metadata,graphql'
+
+/** JSON-Pointer ключа `HASURA_GRAPHQL_ENABLED_APIS` у `data` ConfigMap (для JSON6902-патчів). */
+const HASURA_ENABLED_APIS_DATA_POINTER = '/data/HASURA_GRAPHQL_ENABLED_APIS'
+
+/**
+ * Чи дерево kustomization (`resources` / `bases` / `components` / `crds`, рекурсивно) містить
+ * **Hasura-Deployment** у шарі base (образ `hasura/graphql-engine`). Маркер того, що overlay успадковує
+ * Hasura-ConfigMap з pgdump-значенням `ENABLED_APIS` і має його перевизначити.
+ * @param {string} kustAbs kustomization.yaml
+ * @param {string} rootNorm нормалізований корінь репо
+ * @returns {Promise<boolean>} true, якщо в успадкованому base є Hasura-Deployment
+ */
+export async function kustomizationTreeHasHasuraDeployment(kustAbs, rootNorm) {
+  const visited = new Set()
+  const paths = await collectYamlAbsPathsFromKustomizationTree(kustAbs, rootNorm, visited)
+  const rootResolved = resolve(rootNorm)
+  for (const abs of paths) {
+    const rel = (relative(rootResolved, abs) || '').replaceAll('\\', '/')
+    if (!isK8sYamlUnderBaseDirectory(rel)) continue
+    const roots = await readK8sYamlDocumentRootsForInventory(abs)
+    if (roots.some(o => isHasuraDeploymentManifest(o))) return true
+  }
+  return false
+}
+
+/**
+ * Значення, яке inline-`patch` присвоює `data.HASURA_GRAPHQL_ENABLED_APIS`. Підтримка двох форматів:
+ * **JSON6902** (`op` add/replace на `/data/HASURA_GRAPHQL_ENABLED_APIS`) і **Strategic Merge**
+ * (`data.HASURA_GRAPHQL_ENABLED_APIS`). Зовнішні patch-файли (`patches[].path`) не охоплені — Plan B trade-off.
+ * @param {string} patchText вміст поля `patch`
+ * @returns {string | null} присвоєне значення (рядок) або null, якщо patch не чіпає цей ключ
+ */
+export function enabledApisValueFromPatchText(patchText) {
+  const t = typeof patchText === 'string' ? patchText.trim() : ''
+  if (t === '') return null
+  let parsed
+  try {
+    for (const d of parseAllDocuments(t)) {
+      if (d.errors.length === 0) {
+        parsed = d.toJSON()
+        break
+      }
+    }
+  } catch {
+    return null
+  }
+  if (Array.isArray(parsed)) {
+    for (const item of parsed) {
+      if (item === null || typeof item !== 'object' || Array.isArray(item)) continue
+      const rec = /** @type {Record<string, unknown>} */ (item)
+      const op = typeof rec.op === 'string' ? rec.op.trim().toLowerCase() : ''
+      const path = typeof rec.path === 'string' ? normalizeJsonPatchPath(rec.path) : ''
+      if ((op === 'add' || op === 'replace') && path === HASURA_ENABLED_APIS_DATA_POINTER) {
+        return typeof rec.value === 'string' ? rec.value : JSON.stringify(rec.value)
+      }
+    }
+    return null
+  }
+  if (parsed === null || typeof parsed !== 'object') return null
+  const data = /** @type {Record<string, unknown>} */ (parsed).data
+  if (data === null || typeof data !== 'object' || Array.isArray(data)) return null
+  const d = /** @type {Record<string, unknown>} */ (data)
+  if (!Object.hasOwn(d, 'HASURA_GRAPHQL_ENABLED_APIS')) return null
+  const v = d.HASURA_GRAPHQL_ENABLED_APIS
+  return typeof v === 'string' ? v : JSON.stringify(v)
+}
+
+/**
+ * Значення, яке `patches[]` kustomization присвоюють `data.HASURA_GRAPHQL_ENABLED_APIS` на цілі **ConfigMap**.
+ * Повертає значення першого patch-а, що чіпає цей ключ, або null, якщо такого немає.
+ * @param {Record<string, unknown>} kust об'єкт kustomization.yaml
+ * @returns {string | null} присвоєне значення або null
+ */
+export function hasuraEnabledApisOverrideValue(kust) {
+  const patches = kust.patches
+  if (!Array.isArray(patches)) return null
+  for (const p of patches) {
+    if (p === null || typeof p !== 'object' || Array.isArray(p)) continue
+    const pr = /** @type {Record<string, unknown>} */ (p)
+    if (typeof pr.patch !== 'string') continue
+    if (resolvePatchTargetKind(pr) !== 'ConfigMap') continue
+    const v = enabledApisValueFromPatchText(pr.patch)
+    if (v !== null) return v
+  }
+  return null
+}
+
+/**
+ * Для кожного **non-base/dev** overlay `kustomization.yaml`, що успадковує Hasura-base (Deployment з
+ * `hasura/graphql-engine`), вимагає у `patches[]` перевизначення **`data.HASURA_GRAPHQL_ENABLED_APIS`**
+ * до **`"metadata,graphql"`** (pgdump лишається строго для base/dev) (k8s.mdc). `kind: Component`
+ * пропускається (env-неутральне джерело, не overlay).
+ * @param {string} root корінь репозиторію
+ * @param {string[]} yamlFilesAbs yaml під k8s
+ * @param {(msg: string) => void} fail callback при помилці
+ * @param {(msg: string) => void} passFn callback при успіху
+ */
+async function validateHasuraOverlayEnabledApisOverride(root, yamlFilesAbs, fail, passFn) {
+  const rootNorm = resolve(root)
+  const kustFiles = yamlFilesAbs.filter(abs => basename(abs) === 'kustomization.yaml')
+  for (const kustAbs of kustFiles) {
+    const rel = (relative(rootNorm, kustAbs) || kustAbs).replaceAll('\\', '/')
+    const segment = k8sEnvSegmentFromRelPath(rel)
+    if (segment === null || segment === 'base' || segment === 'dev') continue
+    const kust = await readFirstYamlObject(kustAbs)
+    if (kust === null || kust.kind === 'Component') continue
+    if (!(await kustomizationTreeHasHasuraDeployment(kustAbs, rootNorm))) continue
+    const value = hasuraEnabledApisOverrideValue(kust)
+    if (value === HASURA_OVERLAY_ENABLED_APIS) {
+      passFn(`${rel}: overlay '${segment}' перевизначає HASURA_GRAPHQL_ENABLED_APIS="${HASURA_OVERLAY_ENABLED_APIS}" (k8s.mdc)`)
+    } else if (value === null) {
+      fail(
+        `${rel}: overlay '${segment}' має у patches[] перевизначати data.HASURA_GRAPHQL_ENABLED_APIS до "${HASURA_OVERLAY_ENABLED_APIS}" (pgdump лише для base/dev) (k8s.mdc)`
+      )
+    } else {
+      fail(
+        `${rel}: overlay '${segment}' patch data.HASURA_GRAPHQL_ENABLED_APIS має бути "${HASURA_OVERLAY_ENABLED_APIS}" (зараз: ${JSON.stringify(value)}) (k8s.mdc)`
+      )
+    }
+  }
+}
+
 /**
  * Шукає HPA за `scaleTargetRef.name` серед документів.
  * @param {Record<string, unknown>[]} hpaDocs масив HPA-документів
@@ -6653,5 +6751,7 @@ export async function check(cwd = process.cwd()) {
 
   await validateProdKustomizationOverrides(root, yamlFiles, fail, pass)
 
+  await validateHasuraOverlayEnabledApisOverride(root, yamlFiles, fail, pass)
+
   return reporter.getExitCode()
 }

package/rules/k8s/k8s.mdc

@@ -297,11 +297,40 @@ spec:
 
 ## ConfigMap для Hasura-Deployment
 
-Якщо в `k8s/base/` поруч із **`configmap.yaml`** є **Deployment** з образом **`hasura/graphql-engine`**, у `data` ConfigMap **обов'язково** має бути ключ **`HASURA_GRAPHQL_ENABLE_REMOTE_SCHEMA_PERMISSIONS`** зі значенням **`"true"`**. Точні умови перевірки — **`rules/k8s/fix.mjs`**.
+Якщо в `k8s/base/` поруч із **`configmap.yaml`** є **Deployment** з образом **`hasura/graphql-engine`**, у `data` ConfigMap **обов'язково** мають бути env-ключі:
+
+- **`HASURA_GRAPHQL_ENABLE_REMOTE_SCHEMA_PERMISSIONS`** зі значенням **`"true"`**;
+- **`HASURA_GRAPHQL_ENABLE_RELAY`** зі значенням **`"false"`**;
+- **`HASURA_GRAPHQL_ENABLE_TELEMETRY`** зі значенням **`"false"`**;
+- **`HASURA_GRAPHQL_ENABLED_LOG_TYPES`** зі значенням **`"startup,http-log"`** (точний рядок);
+- **`HASURA_GRAPHQL_ENABLED_APIS`** зі значенням **`"metadata,graphql,pgdump"`** (точний рядок) — **значення для base/dev**;
+- **`HASURA_GRAPHQL_DISABLE_EVENTING`** — ключ обов'язковий, значення довільне (за замовчуванням **`"true"`**).
+
+Точні умови перевірки — rego-пакет **`k8s.hasura_configmap`** (cross-file прив'язка ConfigMap↔Deployment — у `rules/k8s/js/manifests.mjs`).
 
 ```yaml
 data:
   HASURA_GRAPHQL_ENABLE_REMOTE_SCHEMA_PERMISSIONS: 'true'
+  HASURA_GRAPHQL_ENABLE_RELAY: 'false'
+  HASURA_GRAPHQL_ENABLE_TELEMETRY: 'false'
+  HASURA_GRAPHQL_ENABLED_LOG_TYPES: 'startup,http-log'
+  HASURA_GRAPHQL_ENABLED_APIS: 'metadata,graphql,pgdump'
+  HASURA_GRAPHQL_DISABLE_EVENTING: 'true'
+```
+
+### `HASURA_GRAPHQL_ENABLED_APIS` поза base/dev
+
+`pgdump` дозволено **лише** для **base**/**dev**. Кожен **не-base** overlay (`k8s/<env>/`, де `<env>` ≠ `base`/`dev`), що успадковує Hasura-base, **зобов'язаний** у своєму **`kustomization.yaml`** перевизначити `HASURA_GRAPHQL_ENABLED_APIS` до **`"metadata,graphql"`** (без `pgdump`) — патчем JSON6902 або Strategic Merge на ціль **ConfigMap**. Перевірка — cross-file у `rules/k8s/js/manifests.mjs` (`validateHasuraOverlayEnabledApisOverride`); `kind: Component` пропускається.
+
+```yaml title="k8s/prod/kustomization.yaml"
+patches:
+  - target:
+      kind: ConfigMap
+      name: db-h
+    patch: |
+      - op: replace
+        path: /data/HASURA_GRAPHQL_ENABLED_APIS
+        value: metadata,graphql
 ```
 
 ## Kustomize: структура каталогів (`base` / overlays)

package/rules/k8s/policy/hasura_configmap/hasura_configmap.rego

@@ -1,18 +1,33 @@
 # Порт перевірки ConfigMap для Hasura-Deployment з
 # `npm/scripts/rules/k8s/fix.mjs` (k8s.mdc): у ConfigMap, що сусідствує з
-# Hasura-Deployment, у `data` обов'язково має бути ключ
-# `HASURA_GRAPHQL_ENABLE_REMOTE_SCHEMA_PERMISSIONS` зі значенням `"true"`.
+# Hasura-Deployment, у `data` обов'язково мають бути env-ключі зі списку
+# `required_env` з очікуваними значеннями:
+#   "HASURA_GRAPHQL_ENABLE_REMOTE_SCHEMA_PERMISSIONS" → "true"
+#   "HASURA_GRAPHQL_ENABLE_RELAY"                      → "false"
+#   "HASURA_GRAPHQL_ENABLE_TELEMETRY"                  → "false"
+#   "HASURA_GRAPHQL_ENABLED_LOG_TYPES"                 → "startup,http-log" (точний рядок)
+#   "HASURA_GRAPHQL_ENABLED_APIS"                       → "metadata,graphql,pgdump" (точний рядок;
+#       це значення для base/dev. Не-base overlay-и мають зводити його до "metadata,graphql"
+#       патчем у kustomization.yaml — перевіряє JS `validateHasuraOverlayEnabledApisOverride`)
+#   "HASURA_GRAPHQL_DISABLE_EVENTING"                  → null (ключ обов'язковий,
+#       значення довільне; за замовчуванням рекомендовано "true")
+#
+# Семантика очікуваного значення у `required_env`:
+#   "true"  — має читатись як логічне true (boolean true або рядок "true", case-insensitive);
+#   "false" — має читатись як логічне false (boolean false або рядок "false", case-insensitive);
+#   null    — ключ обов'язковий, значення довільне (за замовчуванням "true");
+#   інший рядок — значення має точно дорівнювати рядку (exact match).
 #
 # Запуск (локально, лише для ConfigMap у каталозі з Hasura-Deployment):
 #   conftest test path/to/k8s/.../configmap.yaml \
 #     -p npm/policy/k8s/hasura_configmap \
 #     --namespace k8s.hasura_configmap
 #
-# Прив'язка ConfigMap-Deployment cross-file — у JS (`rules/k8s/fix.mjs`:
+# Прив'язка ConfigMap-Deployment cross-file — у JS (`rules/k8s/js/manifests.mjs`:
 # `validateHasuraConfigMapRemoteSchemaPermissions` шукає Hasura-Deployment
 # у тому ж dir-у і викликає conftest з цією намеспейс лише для відповідних
-# ConfigMap-ів). JS authoritative (`hasuraConfigMapRemoteSchemaPermissionsViolation`,
-# константа `HASURA_REMOTE_SCHEMA_PERMISSIONS_KEY`).
+# ConfigMap-ів). Rego authoritative для пер-документної валідації; JS лишає
+# лише cross-file orchestration.
 #
 # Структура каталогу збігається зі шляхом пакету (regal: directory-package-mismatch).
 # Конвенція проєкту — `import rego.v1` + multi-value `deny contains msg if { … }`.
@@ -20,45 +35,83 @@ package k8s.hasura_configmap
 
 import rego.v1
 
-# Обов'язковий ключ у `data` (узгоджено з `rules/k8s/fix.mjs`).
-required_key := "HASURA_GRAPHQL_ENABLE_REMOTE_SCHEMA_PERMISSIONS"
+# Обов'язкові env-ключі у `data` (узгоджено з `rules/k8s/js/manifests.mjs` та k8s.mdc).
+# Значення — очікуваний стан ключа (семантика — у шапці файлу).
+required_env := {
+	"HASURA_GRAPHQL_ENABLE_REMOTE_SCHEMA_PERMISSIONS": "true",
+	"HASURA_GRAPHQL_ENABLE_RELAY": "false",
+	"HASURA_GRAPHQL_ENABLE_TELEMETRY": "false",
+	"HASURA_GRAPHQL_ENABLED_LOG_TYPES": "startup,http-log",
+	"HASURA_GRAPHQL_ENABLED_APIS": "metadata,graphql,pgdump",
+	"HASURA_GRAPHQL_DISABLE_EVENTING": null,
+}
+
+# Множина "boolean-подібних" очікувань — для них значення читається як логічне,
+# а не звіряється точним рядком.
+bool_expected := {"true", "false"}
+
+# Підказка про очікуване значення для повідомлення про відсутній ключ.
+expected_hint(null) := "(значення довільне, за замовчуванням \"true\")"
 
-key_missing_template := concat(" ", [
-	"data.%s: додай ключ зі значенням \"true\"",
-	"(Deployment з hasura/graphql-engine — k8s.mdc)",
-])
+expected_hint(expected) := sprintf("зі значенням \"%s\"", [expected]) if is_string(expected)
 
-key_value_wrong_template := concat(" ", ["data.%s: значення має бути \"true\" (зараз: %v) (k8s.mdc)"])
+key_value_wrong_template := concat(" ", ["data.%s: значення має бути \"%s\" (зараз: %v) (k8s.mdc)"])
+
+# Ключ відсутній: `data` не об'єкт або в ньому немає обов'язкового ключа.
+deny contains msg if {
+	input.kind == "ConfigMap"
+	some key, expected in required_env
+	not key_present(key)
+	msg := sprintf(
+		"data.%s: додай ключ %s (Deployment з hasura/graphql-engine — k8s.mdc)",
+		[key, expected_hint(expected)],
+	)
+}
 
+# Очікуване "true", а значення не читається як логічне true.
 deny contains msg if {
 	input.kind == "ConfigMap"
-	not is_object(object.get(input, "data", null))
-	msg := sprintf(key_missing_template, [required_key])
+	d := object.get(input, "data", null)
+	is_object(d)
+	some key, expected in required_env
+	expected == "true"
+	key in object.keys(d)
+	not is_value_true(d[key])
+	msg := sprintf(key_value_wrong_template, [key, "true", d[key]])
 }
 
+# Очікуване "false", а значення не читається як логічне false.
 deny contains msg if {
 	input.kind == "ConfigMap"
 	d := object.get(input, "data", null)
 	is_object(d)
-	not key_present(d)
-	msg := sprintf(key_missing_template, [required_key])
+	some key, expected in required_env
+	expected == "false"
+	key in object.keys(d)
+	not is_value_false(d[key])
+	msg := sprintf(key_value_wrong_template, [key, "false", d[key]])
 }
 
+# Очікуване — точний рядок (не "true"/"false"/null), а значення не збігається.
 deny contains msg if {
 	input.kind == "ConfigMap"
 	d := object.get(input, "data", null)
 	is_object(d)
-	key_present(d)
-	value := d[required_key]
-	not is_value_true(value)
-	msg := sprintf(key_value_wrong_template, [required_key, value])
+	some key, expected in required_env
+	is_string(expected)
+	not expected in bool_expected
+	key in object.keys(d)
+	d[key] != expected
+	msg := sprintf(key_value_wrong_template, [key, expected, d[key]])
 }
 
-key_present(d) if {
-	required_key in object.keys(d)
+key_present(key) if {
+	d := object.get(input, "data", null)
+	is_object(d)
+	key in object.keys(d)
 }
 
-# Значення вважається "true", якщо це boolean true або рядок "true"
+# Значення вважається "true"/"false", якщо це відповідний boolean або рядок
 # (case-insensitive). ConfigMap у Kubernetes тримає рядки, але YAML без лапок
 # дає boolean — приймаємо обидва варіанти.
 is_value_true(true)
@@ -67,3 +120,10 @@ is_value_true(v) if {
 	is_string(v)
 	lower(trim_space(v)) == "true"
 }
+
+is_value_false(false)
+
+is_value_false(v) if {
+	is_string(v)
+	lower(trim_space(v)) == "false"
+}