openehr-rails 0.7.0 → 0.7.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 065a9ba44f893adaea9e6c0ccf6f3c5f8a0af8c8c3897379cd008e5642e99a7a
-  data.tar.gz: 98f81ad0baf2b086e2193102c25804b3affcd2fa1ffb4c0730952d6a916e3a58
+  metadata.gz: cf0122af26f620b3082c006c5d469fdf3710c5dd1647b856c9024c8e4e3f7c66
+  data.tar.gz: b54d925956180cd9baffab027d42564ecd55864f839698952ed2bfbfdfb9356d
 SHA512:
-  metadata.gz: 42353942db8a02b901e3727a85446fe1995f3c953fd33f3da2dfea68d7018b533de95b97494db856593df77ccbacd8d57f0f4bb4cdcedee086da6c4e44035a04
-  data.tar.gz: 4fd7e793d2d77230e585dcf06204147926d3b36a86a576525614d19395930f80b4fe38bc0b534de5a0f6b26e98e0859d5c8275ce865a1efedf3aa942dc1d272e
+  metadata.gz: 90fadabcf5f3215e6c24f4c75f5bef98e38b831286e0f0da33d6d67ae6743937d7958d286384c85042830452e47fe08e22eca6dce72541ab7bfb5395cc029ef2
+  data.tar.gz: 700d4afc6e60805cc76c478035131d0aa62b5f0decc09d44c67f0ac1bb4e8181500de65ba56b40f2974a0e24259945fb26285a6b3eac0ebe3ca394656cdc1c56

data/CHANGELOG.md

@@ -7,6 +7,30 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.7.1] - 2026-09-25
+
+> **Upgrade note.** AQL now skips a stored composition that holds an RM type
+> `RmObjectBuilder` cannot rebuild, with a warning
+> (`openehr-rails AQL: skipping composition uid=...`), instead of failing every
+> query in the store. No host-app change is needed; if that line appears in
+> your log, the composition is a #45 case (SECTION / INSTRUCTION / ACTIVITY
+> read-back, next minor release).
+
+### Fixed
+- A single-leaf entry mapped to a resource other than `Observation` and without a
+  `TypeMap::ENTRY_ELEMENT_MAPS` row no longer produces `<Resource>.value[x]`, which
+  `Condition`/`ServiceRequest`/`Procedure`/`Encounter` do not have; it is skipped and
+  reported through `#skipped` like the multi-leaf case since 0.7.0 (#38). The
+  `UnsupportedProfileError` message now names both missing elements.
+- AQL no longer fails for the whole store when one stored composition cannot be
+  rebuilt as RM objects (a node type outside `RmObjectBuilder::TYPE_CLASSES`,
+  such as `SECTION`/`INSTRUCTION`, or an RM constructor rejecting stored data).
+  `DatasetAdapter` now warns (`Rails.logger` when present, else stderr), naming
+  the composition uid and the cause, and skips that composition; queries on the
+  rest of the store return their rows. `RmObjectBuilder` raises
+  `OpenehrRails::Rm::UnsupportedRmTypeError` (composition uid, node path,
+  rm_type) instead of an accidental `NoMethodError` (#44).
+
 ## [0.7.0] - 2026-09-10
 
 > **Upgrade note.** Regenerate `app/fhir/profiles/*.json`. `Condition.component`

data/docs/backlog.md

@@ -74,6 +74,15 @@ that verification is deferred to the next real release (>= 0.5.0), not simulated
 
 ## Release automation
 
+- **`release.yml` records no sha256 of the built `.gem`** (found at the 0.7.0
+  release, 2026-09-10, `docs/reports/fsh-generator-log.md` R14). The only digest in
+  the run log is `actions/upload-artifact`'s "SHA256 digest of uploaded artifact",
+  which hashes the uploaded archive, not the gem file, so `CLAUDE.md`'s "compare
+  against the value recorded for that run" cannot be followed literally; the
+  tag-rebuild cross-check is what pins the bytes today. Add a "Record sha256" step
+  after `rake build` (`sha256sum pkg/*.gem`), as openehr-ruby's `release.yml` has.
+  CI-only change; needs a PR, no Issue.
+
 **Done (2026-08-23, PR #28)** — kept below for the original rationale; see the CI
 status entry above for verification details.
 
@@ -122,6 +131,14 @@ status entry above for verification details.
 
 ## Fixture conventions
 
+- **`spec/templates/sample_blood_pressure.opt` does not parse** -- `OpenehrRails::Opt.parse`
+  raises `ArgumentError: invalid archetype id form` from
+  `OpenEHR::RM::Support::Identification::ArchetypeID` under openehr 2.4.2 *and* 2.4.3
+  (measured 2026-09-10 while checking fixtures for #38), and no spec, script or
+  generator references the file. Orphan fixture: either find which archetype id in
+  it is malformed and decide whether that is an openehr-ruby parser gap worth an
+  upstream Issue, or delete the file. Not touched in 0.7.0.
+
 - **Licensed terminology-code literals in spec expectations: keep minimal, cite the
   source fixture's file:line.** Adopted from Anlage's C2 firewall precedent (SNOMED
   CT is a licensed terminology; reproducing its codes verbatim in more places than

data/docs/design/multi-leaf-non-observation-plan.md

@@ -365,3 +365,34 @@ Still **minor**, on top of §8.5: `#skipped` and `UnsupportedProfileError` are
 new public API; the `category` anchor and the `comment` change the JSON facade's
 shape again for `EVALUATION` entries. `CHANGELOG.md` `[Unreleased]` updated in
 the same change.
+
+## 9.7 #38 (2026-09-10 ruling): the decision point widened to any leaf count
+
+The ruling on 9.5 allowed #38 to ride in 0.7.0 if it stayed on the same
+decision point, small, and green. It does: `TypeMap.assert_supported!` drops
+its `fields.size <= 1` early return, so *any* entry whose base resource is not
+`Observation` and which has no `ENTRY_ELEMENT_MAPS` row is skipped and
+reported -- a single leaf would have produced `<Resource>.value[x]`, which
+`Condition` / `ServiceRequest` / `Procedure` / `Encounter` lack just as they
+lack `component` (measured: 1 sushi Error on the 9.5 probe). The error message
+now names both missing elements and the leaf count in the singular where it is
+one. Resolution shape (a) bug.
+
+- **Fixture check before widening**: every OPT under `spec/templates/`,
+  `spec/generators/templates/` and `demo_assets/templates/` was listed with
+  `FieldExtractor#entries` -- all single-leaf entries are `OBSERVATION`
+  (`height.v2`, `body_weight.v2`, `heart_rate-pulse.v1`); the only
+  non-`Observation` entry is `problem_diagnosis.v1` (5 leaves, mapped). So no
+  fixture's output changes. (`spec/templates/sample_blood_pressure.opt` does not
+  parse at all -- `ArgumentError: invalid archetype id form` -- under openehr
+  2.4.2 *and* 2.4.3, and no spec references it; pre-existing, noted in
+  `docs/backlog.md`, not touched here.)
+- **Red**: 4 new examples (two per generator, synthetic single-leaf
+  `EVALUATION` entry `openEHR-EHR-EVALUATION.synthetic_single_leaf_test.v1`):
+  **40 examples, 4 failures** across the two spec files.
+- **Green**: the same files 40/0; `spec/openehr_rails/fhir/` 52/0; full suite
+  308/0. Regenerated FSH for `problem_list.opt` + `bmi_calculation.opt`
+  byte-identical to before and **0 Errors** under `sushi` 3.16.0 -- the pin.
+- **Semver**: 0.7.1 (0.7.0 shipped before PR #43 was merged; see log R13); a bug fix (patch) that changes no
+  fixture output, only what an unmapped single-leaf non-`Observation` entry
+  yields (invalid FHIR before, a `#skipped` entry now).

data/docs/design/rm-object-builder-section-instruction-plan.md

@@ -0,0 +1,134 @@
+# Plan: `RmObjectBuilder` reads back SECTION / INSTRUCTION / ACTIVITY
+
+- Status: **explore + plan, awaiting approval** (2026-09-25). No code written.
+- Issue: [#45](https://github.com/skoba/openehr-rails/issues/45) (anlage upstream candidate 15)
+- Log: `docs/reports/referral-upstream-log.md` R1
+- Prerequisite landed as its own fix: #44 / PR #50 (a failing `to_rm` no longer
+  fails the whole store; unknown types raise `UnsupportedRmTypeError`).
+
+## 1. Current behaviour (measured, `file:line` on `master` after PR #50)
+
+**Write side accepts the types.** `Rm::TypeMap::NODE_TYPES`
+(`lib/openehr_rails/rm/type_map.rb:9-26`) lists SECTION, INSTRUCTION, ACTION,
+ACTIVITY (and ITEM_SINGLE, ITEM_TABLE); the STI classes exist
+(`lib/openehr_rails/rm/nodes.rb:10,14,15,18`). `GraphBuilder#infer_type`
+(`lib/openehr_rails/rm/graph_builder.rb:111-122`) maps `activities` -> ACTIVITY and
+`protocol` / `description` -> ITEM_TREE for `_type`-less hashes. `build_children`
+(`:64-79`) persists Hash-valued attributes as child nodes or data-value rows and
+Array-valued ones as ordered children; **String-valued attributes are dropped** --
+so `ACTIVITY.action_archetype_id` never reaches the graph. `INSTRUCTION.narrative`
+(DV_TEXT), `ACTIVITY.timing` (DV_PARSABLE: `text_value` + `formalism`, `:180-181`)
+and `INSTRUCTION.expiry_time` (DV_DATE_TIME) are stored as data-value rows keyed by
+`rm_attribute_name`.
+
+**Read side does not.** `RmObjectBuilder::TYPE_CLASSES`
+(`lib/openehr_rails/rm/rm_object_builder.rb`, 10 entries) has none of them;
+`build_node` sets entry defaults only for Observation / Evaluation / AdminEntry,
+`data` only for `EntryNode`, and never `protocol`, `narrative`, `activities`,
+`description`. After PR #50 such a node raises `UnsupportedRmTypeError` and the
+composition is skipped from AQL with a warning; before it, the whole store failed
+(anlage referral-intake-log R6).
+
+**What the openehr gem (2.4.3) demands of the objects** (`openehr-ruby`
+`lib/openehr/rm/composition/content/`):
+
+| class | mandatory | optional / notes |
+|---|---|---|
+| `Navigation::Section` (`navigation.rb:12-27`) | -- | `items` must be nil or non-empty; `path_attribute :items` |
+| `Entry::Instruction` (`entry.rb:112-138`) | Entry: `language`, `encoding`, `subject`; `narrative` | `activities` nil or non-empty; `expiry_time`, `wf_definition`; CareEntry `protocol`, `guideline_id` (`entry.rb:69-78`); `path_attribute :activities, :protocol` |
+| `Entry::Activity` (`entry.rb:140-171`) | `description`, `action_archetype_id` (non-empty String) | `timing` optional since RM 1.1.0; `path_attribute :description` |
+| `Entry::Action` (`entry.rb:173-204`) | Entry attrs; `time`, `description`, `ism_transition` (with `current_state` validated against the openEHR terminology, `:236-275`) | out of scope here, see section 5 |
+
+`OpenEHR::RM::Composition::Composition` has `path_attribute :content, :context`,
+so objects built with the attributes above are navigable by the AQL engine's
+path evaluator without engine changes.
+
+## 2. Design -- phase A, no schema change
+
+1. `TYPE_CLASSES` gains `SECTION`, `INSTRUCTION`, `ACTIVITY`.
+2. `build_node` gains, per type (each in its own small private helper, because
+   `build_node` already sits at rubocop's AbcSize/complexity limits -- PR #50 had to
+   extract `node_class` for a one-line change):
+   - **Section**: `items` = children built in position order; `nil` when there
+     are none (the constructor rejects `[]`).
+   - **Instruction**: the same entry defaults as the other entries
+     (`language` / `encoding` / `subject`; extend the `is_a?` list);
+     `narrative` = the `narrative` data-value row as DvText, **defaulting to the
+     node's name** when the row is absent (an injected default, documented like
+     `language`); `activities` = children with `rm_attribute_name == 'activities'`,
+     `nil` when none; `expiry_time` when its row exists.
+   - **Activity**: `description` = the `description` child (ITEM_TREE) -- no
+     default: a missing description is an RM-conformance failure and surfaces
+     through #44's warning; `timing` = the `timing` row as
+     `OpenEHR::RM::DataTypes::Encapsulated::DvParsable` when present;
+     `action_archetype_id` = the injected default `'/.*/'` (the RM's "any ACTION
+     archetype" pattern) because the graph cannot carry it yet (section 5).
+   - **`protocol` for every CareEntry** (Observation, Evaluation, Instruction):
+     `attrs[:protocol] = build_node(protocol child)` when present. Same
+     mechanism, and it is where `jp_referral` keeps 紹介先/紹介元
+     (`service_request` `protocol[at0008]`, anlage memory of 2026-09-25) -- without
+     it the INSTRUCTION would be readable but its most-queried data not.
+3. `UnsupportedRmTypeError` keeps covering ACTION, ITEM_SINGLE, ITEM_TABLE.
+
+Injected defaults are listed in the class comment next to the existing ones.
+
+## 3. Spec plan (t-wada: red before green), resolution shape (b) enhancement
+
+- **Fixture**: a spec-level synthetic canonical hash (invented ids, stated in the
+  comment with this section as design authority; no real canonical JSON with
+  SECTION/INSTRUCTION exists in this repo -- anlage's is hand-mapped and outside):
+  COMPOSITION whose `content` is `[SECTION { items: [EVALUATION { data: ITEM_TREE {
+  items: [ELEMENT DV_TEXT] } }] }, INSTRUCTION { narrative, protocol: ITEM_TREE {
+  items: [ELEMENT DV_TEXT] }, activities: [ACTIVITY { description: ITEM_TREE {
+  items: [ELEMENT DV_TEXT] }, timing: DV_PARSABLE }] }]`, committed with
+  `CompositionCommitter`.
+- `rm_object_builder_spec.rb`: **red** today = `UnsupportedRmTypeError`; green =
+  `Section` with one `Evaluation` item; `Instruction` with the stored narrative,
+  one `Activity` whose `description.items.first.value` is the DvText,
+  `action_archetype_id == '/.*/'`, `protocol.items` present; entry defaults on the
+  Instruction.
+- `executor_spec.rb`: AQL through the new objects --
+  `SELECT i/activities[at0001]/description[at0009]/items[at0121]/value/value ...
+  CONTAINS INSTRUCTION i[<synthetic id>]` and
+  `SELECT i/protocol[at0008]/items[at0010]/value/value`, plus
+  `... CONTAINS SECTION s[<id>] CONTAINS EVALUATION ev[<id>]`. Whether the
+  engine's CONTAINS chain accepts SECTION/ACTIVITY is **unknown until measured**;
+  if it does not, that becomes an openehr-ruby item and the spec pins the `i/...`
+  path form only.
+- `dataset_adapter_spec.rb` / `executor_spec.rb` (#44): switch the "to_rm fails"
+  fixture from SECTION to ITEM_TABLE, which stays unsupported.
+- Regression pins: `bmi_calculation` / `problem_list` specs unchanged; full suite
+  green; `CanonicalSerializer` round-trip of the new fixture is checked and, if it
+  does not survive (`narrative` / `timing` rows), recorded as its own issue rather
+  than fixed here.
+
+## 4. Size and schedule
+
+Estimate: +3 map entries; ~50 lines of new helpers plus splitting `build_node`'s
+existing per-type `if` blocks into helpers (~80 lines moved, behaviour-neutral,
+needed to stay inside the rubocop limits); ~130 lines of specs across three files;
+no migration, no generator template change, no dependency change. **Small** by the
+ruling's criterion (same builder, one file of runtime code, existing test
+infrastructure). Recommendation: **implement before the freeze**, in one PR,
+`Fixes #45`, after this plan is approved.
+
+## 5. Out of scope (phase B, December unless pulled forward)
+
+- **Persisting `action_archetype_id`**, `narrative`, `timing` as columns instead
+  of injected defaults / data-value rows: needs a migration in
+  `lib/generators/**/templates/` (shipped product, host apps migrate) -- its own
+  issue and plan.
+- **ACTION**: `ism_transition` is persisted today as a generic CLUSTER node
+  (`infer_type` falls through), and rebuilding it needs codes valid against the
+  terminology; separate design.
+- **ITEM_SINGLE / ITEM_TABLE**: no consumer yet.
+
+## 6. Semver
+
+New read-side capability, observable through AQL and `to_rm`: **minor**. If it
+lands with #38 (PR #43) and #44 (PR #50), the next release is **0.8.0**, not 0.7.1
+-- to be decided at the inventory.
+
+## 7. Stop point
+
+Explore + plan only. Implementation starts on approval.

data/docs/reports/fsh-generator-log.md

@@ -923,3 +923,79 @@ retitled `[0.7.0] - 2026-09-10` with the Upgrade note, fresh empty
 `[Unreleased]`) -> tag `v0.7.0` -> `release.yml` -> artifact sha256 (R14) ->
 human `gem push` of that artifact -> confirmation by published checksum, the
 first application of the rule PR #42 added.
+
+## R14 -- v0.7.0 tagged, release.yml green, artifact sha256 recorded; gem push is the human's
+
+- Release prep on `master` after `acb1e3f`: `b1bfaa3` (lint), `2212955` (R13),
+  `aafbd2c` (Release: bump version to 0.7.0). Before the release commit: full
+  suite **304 examples, 0 failures**, `rubocop` **109 files, no offenses**,
+  `release:check OK` (no tag yet, so the tag check was silent by design).
+- Tag `v0.7.0` -> `aafbd2c`, pushed 2026-09-10. **Deviation noted**: this is a
+  lightweight tag; `v0.6.0` is an annotated tag object. Harmless for
+  `release.yml` (tag push) and `release:check` (`v0.7.0^{commit}`), but the
+  next release should use `git tag -a` to keep the series uniform.
+- `release.yml` run **34438238454**: all 12 jobs success (9 spec matrix, demo
+  smoke, application template smoke, Build gem artifact). `release:check OK`
+  inside the run, i.e. HEAD was the tag commit.
+- **Artifact**: downloaded with `gh run download 34438238454 -n gem -D pkg`:
+  `pkg/openehr-rails-0.7.0.gem`, 242176 bytes,
+  sha256 **`922ec940f15c8793ef6ee08568e4d7ea16f8a158da0d45936ff898e73cd1171a`**.
+- **Cross-check**: a fresh `gem build` in a scratch worktree at `v0.7.0`
+  (local ruby 4.0.6, not `pkg/`) produced the **same sha256** -- CI artifact and
+  tag rebuild are byte-identical, as for 0.5.0 and 0.6.0.
+- **Gap found in the comparison rule**: `CLAUDE.md` says to compare the
+  downloaded artifact "against the value recorded for that run", but
+  `release.yml` records no gem sha256 -- the only digest in the run log is
+  `actions/upload-artifact`'s `SHA256 digest of uploaded artifact`
+  (`671c8de1…238b`), which is the digest of the uploaded archive, **not of the
+  .gem**. The two are not comparable. The tag-rebuild cross-check above is what
+  actually pins the bytes today. Filed in `docs/backlog.md` "Release
+  automation": add a "Record sha256" step (as openehr-ruby's `release.yml`
+  has) so the rule can be followed literally.
+- **Handed to the human**: `gem push pkg/openehr-rails-0.7.0.gem` (the
+  downloaded CI artifact, never a local build), then confirm by checksum per
+  the rule PR #42 added: `https://rubygems.org/api/v1/gems/openehr-rails.json`
+  `sha` (or the compact index `checksum:`) must equal `922ec940…171a`; use
+  `versions/openehr-rails/latest.json` rather than `versions/openehr-rails.json`
+  while the latter lags. Then delete `pkg/openehr-rails-0.7.0.gem`. Result goes
+  in R15.
+- `master` is now past the tag by the docs commits that record this entry, so
+  `release:check` on `master` fails again by design until 0.7.1.
+
+## R15 -- 0.7.0 published; confirmed by checksum (first application of the PR #42 rule)
+
+Human `gem push` of the CI artifact `pkg/openehr-rails-0.7.0.gem` (R14). Confirmation
+2026-09-10, every source compared against the CI artifact's sha256
+`922ec940f15c8793ef6ee08568e4d7ea16f8a158da0d45936ff898e73cd1171a`:
+
+| source | value |
+|---|---|
+| `/api/v1/gems/openehr-rails.json` `sha` | `922ec940…171a`, version 0.7.0 |
+| compact index `https://index.rubygems.org/info/openehr-rails` | `checksum:922ec940…171a`, `created_at:2026-09-10T11:47:16Z` |
+| `/api/v1/versions/openehr-rails/latest.json` | `{"version":"0.7.0"}` |
+| `/api/v1/versions/openehr-rails.json` | 0.7.0, `sha` `922ec940…171a` (no lag observed this time) |
+| `gem list -r -e openehr-rails` | 0.7.0 |
+
+CI artifact, tag rebuild and published gem are one and the same bytes. The
+`pkg/` copy was deleted after the confirmation, leaving `pkg/` empty.
+
+### Tooling note (why two commits on the #43 branch fix single characters)
+
+The PowerShell -> `wsl` wrapper used to run this session's scripts carried a
+`sed -i "s/\r$//"`; the `\r` reached WSL as a plain `r`, so every script line
+ending in "r" lost that letter. Effects found and handled: `git checkout master`
+silently became `maste` (harmless, caught by the error), a backlog line on the
+#43 branch was committed as "script o" (restored in `566cddb`), and the
+`5fcc0ec` commit message reads "unde" for "under" (left as is). `master`'s
+tracked files were grepped for the same pattern: clean. The wrapper no longer
+runs sed.
+
+### State after 0.7.0
+
+- `master` = tag `v0.7.0` + docs (R14, R15). `release:check` fails on `master`
+  by design until the next release.
+- PR #43 (`fix/38-single-leaf-non-observation`, Fixes #38): rebased for 0.7.1,
+  CHANGELOG line under the new `[Unreleased]`, awaiting the human's merge.
+- Open follow-ups: `release.yml` "Record sha256" step (backlog, CI-only PR);
+  next tag annotated (`git tag -a`); `json < 3` pins until Rails ships the
+  `JSON.decode` fix (#40, backlog); reserves #35, #36, #37.

data/docs/reports/referral-upstream-log.md

@@ -0,0 +1,64 @@
+# Referral-v2 upstream batch log (anlage candidates 15-17 and siblings)
+
+Work on `openehr-rails` driven by `skoba/anlage`'s `jp_referral` v0.1 findings
+(`docs/upstream-candidates.md` items 15-17, 2026-09-25). R1〜.
+
+---
+
+## R1 -- filing, #44 fixed, #45 planned, #46-#49 filed (2026-09-25)
+
+### State on waking
+
+`master` = `6b0e357` (v0.7.0 + R14/R15 docs). PR #43 (#38, 0.7.1) still open and
+unmerged since 2026-09-10, CI green. Open issues before this batch: #35-#38.
+
+### 1. #44 -- AQL store-wide failure isolated per composition (PR #50)
+
+- Measured cause: `DatasetAdapter` materialises every head composition with
+  `to_rm` inside the lazy chain (`dataset_adapter.rb:35,37`); `RmObjectBuilder#build_node`
+  did `TYPE_CLASSES[rm_type]` -> nil -> `NoMethodError` for SECTION / INSTRUCTION /
+  ACTIVITY / ACTION / ITEM_SINGLE / ITEM_TABLE, all of which `GraphBuilder`
+  persists (`Rm::TypeMap::NODE_TYPES`).
+- Resolution shape (a) bug. **Red**: 23 examples, 3 failures (DatasetAdapter walk,
+  Executor end to end, `to_rm` directly) against a synthetic SECTION composition
+  committed beside a BmiCalculation record. **Green**: 23/0, full suite **307/0**
+  (304 + 3), rubocop clean (one extraction, `node_class`, to stay under
+  `build_node`'s AbcSize/complexity limits).
+- Behaviour: `DatasetAdapter#materialize` rescues, reports through `Rails.logger`
+  when present else `Kernel#warn` (spec env has no `Rails.logger`, so the specs
+  pin stderr), skips the composition. `OpenehrRails::Rm::UnsupportedRmTypeError`
+  (composition_uid, rm_type, path) replaces the accidental `NoMethodError`.
+- PR #50 (`dd157b6`, Fixes #44), CI run 36115865528. Semver patch; CHANGELOG
+  `[Unreleased]` Fixed.
+
+### 2. #45 -- SECTION / INSTRUCTION / ACTIVITY on the read side: explore + plan
+
+`docs/design/rm-object-builder-section-instruction-plan.md`. Verdict: **small**
+(phase A: 3 map entries, helper methods in one file, ~130 spec lines, no schema
+change) -> recommended before the freeze, awaiting approval. Phase B (persist
+`action_archetype_id`, ACTION, ITEM_SINGLE/TABLE) December. Note: minor, so a
+release carrying it is 0.8.0.
+
+### 3. Filed only
+
+- **#46** context (EVENT_CONTEXT) not persisted from canonical JSON (upstream 16).
+- **#47** FieldExtractor does not descend `activities` / `description` / `protocol`
+  (upstream 17; `DESCENDABLE_ATTRIBUTES = %w[data events items value]`,
+  `field_extractor.rb:47`).
+- **#48** DV_TEXT leaf on a CodeableConcept target -> `code only string` (invalid);
+  mapping row should carry the FHIR type.
+- **#49** 0-leaf entry gets an empty component-header profile instead of
+  skip-and-report (#38 sibling; #43 covers non-Observation 0-leaf once merged,
+  Observation 0-leaf not).
+
+### 4. 0.7.1 inventory (candidates, not yet a gate)
+
+| item | state | class |
+|---|---|---|
+| PR #43 (#38 single-leaf skip) | open, CI green, rebased on 0.7.0 | patch |
+| PR #50 (#44 isolation) | open, CI running | patch |
+| #45 phase A | plan awaiting approval | minor -> 0.8.0 |
+| #46 / #47 / #48 / #49 | filed | -- |
+
+Gate when the human has merged what should ride; version number decided from the
+merged content (0.7.1 if patch-only, 0.8.0 if #45 rides).

data/lib/openehr_rails/aql/dataset_adapter.rb

@@ -32,14 +32,32 @@ module OpenehrRails
 
       def ehr_records
         linked = @ehr_scope.find_each.lazy.map do |ehr|
-          { ehr_id: ehr.ehr_id, compositions: compositions_for(ehr_id: ehr.id).map(&:to_rm) }
+          { ehr_id: ehr.ehr_id, compositions: rm_compositions_for(ehr_id: ehr.id) }
         end
-        unlinked = [{ ehr_id: nil, compositions: compositions_for(ehr_id: nil).map(&:to_rm) }]
+        unlinked = [{ ehr_id: nil, compositions: rm_compositions_for(ehr_id: nil) }]
         linked + unlinked.lazy
       end
 
-      def compositions_for(ehr_id:)
-        @composition_scope.where(ehr_id: ehr_id).find_each.lazy
+      def rm_compositions_for(ehr_id:)
+        @composition_scope.where(ehr_id: ehr_id).find_each.lazy.filter_map { |composition| materialize(composition) }
+      end
+
+      # One composition whose graph cannot be rebuilt (a node type outside
+      # RmObjectBuilder::TYPE_CLASSES, or an RM constructor rejecting stored
+      # data) must not take every query in the store down with it (#44):
+      # warn, naming the composition and the cause, and leave it out. The
+      # rest of the EHR stays queryable; the warning is the report.
+      def materialize(composition)
+        composition.to_rm
+      rescue StandardError => e
+        report_skip("openehr-rails AQL: skipping composition uid=#{composition.uid} (id=#{composition.id}): " \
+                    "#{e.class}: #{e.message}")
+        nil
+      end
+
+      def report_skip(message)
+        logger = defined?(::Rails) && ::Rails.respond_to?(:logger) ? ::Rails.logger : nil
+        logger ? logger.warn(message) : warn(message)
       end
     end
   end

data/lib/openehr_rails/fhir/profile_generator.rb

@@ -10,7 +10,7 @@ module OpenehrRails
     # the entry's RM type selects the base FHIR resource, and the leaf
     # ELEMENTs constrain value[x] (single leaf), component slices (many, on
     # Observation) or the real elements named by TypeMap::ENTRY_ELEMENT_MAPS.
-    # Multi-leaf entries with neither are skipped and reported (#skipped).
+    # Entries with neither are skipped and reported (#skipped).
     class ProfileGenerator
       FHIR_VERSION = '5.0.0'
       ARCHETYPE_SYSTEM = 'http://openehr.org/ckm/archetypes'

data/lib/openehr_rails/fhir/type_map.rb

@@ -91,13 +91,13 @@ module OpenehrRails
       end
 
       # The one shared decision point for both generators (#33 ruling, plan
-      # section 9.3): an entry with more than one leaf whose base resource has no
-      # `component` element and which has no row in ENTRY_ELEMENT_MAPS cannot be
-      # profiled. Raises UnsupportedProfileError so the caller can skip and
-      # report it instead of emitting constraints on a path the resource lacks.
+      # section 9.3; widened to any leaf count by #38, section 9.7): an entry
+      # whose base resource is not Observation -- so it has neither `value[x]`
+      # for a single leaf nor `component` for several -- and which has no row in
+      # ENTRY_ELEMENT_MAPS cannot be profiled. Raises UnsupportedProfileError so
+      # the caller can skip and report it instead of emitting constraints on a
+      # path the resource lacks.
       def assert_supported!(entry)
-        return if entry[:fields].size <= 1
-
         resource_type = resource_for_entry(entry[:rm_type])
         return if resource_type == 'Observation' || element_map_for(entry[:archetype_id])
 

data/lib/openehr_rails/fhir/unsupported_profile_error.rb

@@ -2,13 +2,14 @@
 
 module OpenehrRails
   module Fhir
-    # Raised for an ENTRY that has more than one leaf, maps to a FHIR resource
-    # without a `component` element (anything but Observation), and has no row
-    # in TypeMap::ENTRY_ELEMENT_MAPS -- nothing valid can be generated for it
-    # (skoba/openehr-rails#33 ruling, docs/design/multi-leaf-non-observation-plan.md
-    # section 9.3). ProfileGenerator and FshGenerator rescue this per entry,
-    # skip the entry and expose the error through #skipped; a caller that wants
-    # a hard failure re-raises from there.
+    # Raised for an ENTRY that maps to a FHIR resource other than Observation --
+    # which has neither `value[x]` (single leaf) nor `component` (several) --
+    # and has no row in TypeMap::ENTRY_ELEMENT_MAPS: nothing valid can be
+    # generated for it (skoba/openehr-rails#33 ruling and #38,
+    # docs/design/multi-leaf-non-observation-plan.md sections 9.3 and 9.7).
+    # ProfileGenerator and FshGenerator rescue this per entry, skip the entry
+    # and expose the error through #skipped; a caller that wants a hard failure
+    # re-raises from there.
     class UnsupportedProfileError < StandardError
       attr_reader :archetype_id, :resource_type, :leaf_count
 
@@ -17,9 +18,10 @@ module OpenehrRails
         @resource_type = resource_type
         @leaf_count = leaf_count
         super(
-          "#{archetype_id}: #{leaf_count} leaves map to #{resource_type}, which has no " \
-          'component element, and TypeMap::ENTRY_ELEMENT_MAPS has no row for this ' \
-          'archetype -- skipped (skoba/openehr-rails#33, #35)'
+          "#{archetype_id}: #{leaf_count} #{leaf_count == 1 ? 'leaf maps' : 'leaves map'} to " \
+          "#{resource_type}, which has neither value[x] nor component, and " \
+          'TypeMap::ENTRY_ELEMENT_MAPS has no row for this archetype -- skipped ' \
+          '(skoba/openehr-rails#33, #38; mapping rows: #35, #37)'
         )
       end
     end

data/lib/openehr_rails/rm/rm_object_builder.rb

@@ -4,6 +4,26 @@ require 'openehr'
 
 module OpenehrRails
   module Rm
+    # Raised by RmObjectBuilder for a stored node whose rm_type the graph
+    # accepts (Rm::TypeMap::NODE_TYPES) but the read side cannot rebuild
+    # (RmObjectBuilder::TYPE_CLASSES) -- SECTION, INSTRUCTION, ACTIVITY,
+    # ACTION, ITEM_SINGLE, ITEM_TABLE today (#44; #45 narrows the gap).
+    # Names the composition and the node so a warning built from it is
+    # actionable.
+    class UnsupportedRmTypeError < StandardError
+      attr_reader :composition_uid, :rm_type, :path
+
+      def initialize(composition, node)
+        @composition_uid = composition.uid
+        @rm_type = node.rm_type
+        @path = node.path
+        super(
+          "composition uid=#{composition.uid}: node #{node.path} has rm_type #{node.rm_type}, " \
+          'which RmObjectBuilder::TYPE_CLASSES cannot rebuild as an OpenEHR::RM object'
+        )
+      end
+    end
+
     # Builds a full OpenEHR::RM::Composition object from the stored
     # graph, injecting config defaults for mandatory attributes not
     # carried in OPT/stored data. The gem's own constructor validations
@@ -66,8 +86,12 @@ module OpenehrRails
         )
       end
 
+      def node_class(node)
+        TYPE_CLASSES.fetch(node.rm_type) { raise UnsupportedRmTypeError.new(@composition, node) }
+      end
+
       def build_node(node)
-        klass = TYPE_CLASSES[node.rm_type]
+        klass = node_class(node)
         attrs = {
           archetype_node_id: node.archetype_node_id,
           name: dv_text(node.name_value || node.archetype_node_id)

data/lib/openehr_rails/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module OpenehrRails
-  VERSION = '0.7.0'
+  VERSION = '0.7.1'
 end

data/spec/openehr_rails/aql/dataset_adapter_spec.rb

@@ -54,4 +54,51 @@ describe OpenehrRails::Aql::DatasetAdapter do
   ensure
     ActiveSupport::Notifications.unsubscribe(subscriber) if subscriber
   end
+
+  # skoba/openehr-rails#44, resolution shape (a) bug: one composition whose
+  # graph cannot be rebuilt as RM objects used to fail every query in the
+  # store. Synthetic canonical hash (invented ids): a SECTION is accepted by
+  # GraphBuilder (Rm::TypeMap::NODE_TYPES) but not by RmObjectBuilder::
+  # TYPE_CLASSES, so it is the smallest graph whose to_rm fails today; #45
+  # makes SECTION buildable later, at which point this spec needs a different
+  # unsupported type (ITEM_TABLE is the next candidate).
+  describe 'a composition whose to_rm fails' do
+    let(:section_hash) do
+      {
+        '_type' => 'COMPOSITION',
+        'archetype_node_id' => 'openEHR-EHR-COMPOSITION.synthetic_section_test.v1',
+        'archetype_details' => {
+          '_type' => 'ARCHETYPED',
+          'archetype_id' => { 'value' => 'openEHR-EHR-COMPOSITION.synthetic_section_test.v1' },
+          'template_id' => { 'value' => 'synthetic_section_test' },
+          'rm_version' => '1.0.4'
+        },
+        'content' => [
+          {
+            '_type' => 'SECTION',
+            'archetype_node_id' => 'openEHR-EHR-SECTION.synthetic_test.v1',
+            'name' => { '_type' => 'DV_TEXT', 'value' => 'Synthetic section' },
+            'items' => []
+          }
+        ]
+      }
+    end
+
+    before do
+      BmiCalculation.create!(height: 170.0, ehr_id: 'ehr-mixed')
+      ehr = OpenehrRails::Rm::Ehr.find_by!(ehr_id: 'ehr-mixed')
+      OpenehrRails::Rm::CompositionCommitter.commit(section_hash, uid: 'uid-section', ehr: ehr)
+    end
+
+    it 'warns, skips that composition, and keeps the rest of the EHR queryable' do
+      records = nil
+
+      expect { records = described_class.build.each_ehr.to_a }
+        .to output(/uid-section.*UnsupportedRmTypeError.*SECTION/).to_stderr
+
+      matching = records.find { |r| r.ehr_id == 'ehr-mixed' }
+      expect(matching.compositions.size).to eq(1)
+      expect(matching.compositions.map { |c| c.uid.value }).not_to include('uid-section')
+    end
+  end
 end

data/spec/openehr_rails/aql/executor_spec.rb

@@ -96,4 +96,32 @@ describe OpenehrRails::Aql::Executor do
       expect(OpenehrRails::Aql.execute(height_query).rows).to eq([[170.0]])
     end
   end
+
+  # skoba/openehr-rails#44 (a) bug, end to end: the store also holds a
+  # composition whose to_rm fails (synthetic SECTION graph, see
+  # dataset_adapter_spec.rb); a query on an unrelated template must still
+  # return its rows.
+  describe 'with a composition whose to_rm fails in the store' do
+    before do
+      BmiCalculation.create!(height: 170.0)
+      OpenehrRails::Rm::CompositionCommitter.commit(
+        {
+          '_type' => 'COMPOSITION',
+          'archetype_node_id' => 'openEHR-EHR-COMPOSITION.synthetic_section_test.v1',
+          'content' => [
+            { '_type' => 'SECTION', 'archetype_node_id' => 'openEHR-EHR-SECTION.synthetic_test.v1', 'items' => [] }
+          ]
+        },
+        uid: 'uid-section-exec'
+      )
+    end
+
+    it 'still answers a query on another template, skipping the broken composition' do
+      rows = nil
+
+      expect { rows = described_class.execute(height_query).rows }.to output(/uid-section-exec/).to_stderr
+
+      expect(rows).to eq([[170.0]])
+    end
+  end
 end

data/spec/openehr_rails/fhir/fsh_generator_spec.rb

@@ -225,6 +225,49 @@ describe OpenehrRails::Fhir::FshGenerator do
     end
   end
 
+  # skoba/openehr-rails#38, resolution shape (a) bug: a single-leaf entry whose
+  # base resource is not Observation took the legacy `code` + `value[x]` path,
+  # and Condition has no value[x] either (sushi: 1 Error on a probe, plan
+  # section 9.5). Same decision point as the multi-leaf case, now regardless of
+  # leaf count. Synthetic entry for the same reason as above: no real
+  # single-leaf non-Observation fixture exists in this repo.
+  describe 'an unmapped single-leaf non-Observation entry' do
+    subject(:files) { generator.to_fsh_files }
+
+    let(:opt_file) { File.expand_path('../../templates/problem_list.opt', __dir__) }
+    let(:real_entries) { OpenehrRails::Opt::FieldExtractor.new(template).entries }
+    let(:synthetic_id) { 'openEHR-EHR-EVALUATION.synthetic_single_leaf_test.v1' }
+    let(:synthetic_entry) do
+      real = real_entries.first
+      real.merge(
+        archetype_id: synthetic_id,
+        concept: 'synthetic_single_leaf_test',
+        fields: real[:fields].first(1).map { |field| field.merge(archetype_id: synthetic_id) }
+      )
+    end
+
+    before do
+      extractor = instance_double(OpenehrRails::Opt::FieldExtractor, entries: [synthetic_entry, *real_entries])
+      allow(OpenehrRails::Opt::FieldExtractor).to receive(:new).with(template).and_return(extractor)
+    end
+
+    it 'skips the entry instead of constraining value[x] on Condition' do
+      expect(files.keys).to eq(['openehr-evaluation-problem-diagnosis-v1'])
+      expect(files.values.join).not_to include('value[x]')
+    end
+
+    it 'reports it through #skipped with the resource named' do
+      files
+      error = generator.skipped.first
+
+      expect(generator.skipped.size).to eq(1)
+      expect(error.archetype_id).to eq(synthetic_id)
+      expect(error.resource_type).to eq('Condition')
+      expect(error.leaf_count).to eq(1)
+      expect(error.message).to include('value[x]')
+    end
+  end
+
   describe '#skipped' do
     it 'is empty for an all-Observation template' do
       generator.to_fsh_files

data/spec/openehr_rails/fhir/profile_generator_spec.rb

@@ -241,6 +241,47 @@ describe OpenehrRails::Fhir::ProfileGenerator do
     end
   end
 
+  # skoba/openehr-rails#38, resolution shape (a) bug, JSON facade half: a
+  # single-leaf non-Observation entry produced `<Resource>.value[x]`, which
+  # Condition does not have. Synthetic entry as above.
+  describe 'an unmapped single-leaf non-Observation entry' do
+    subject(:profiles) { generator.profiles }
+
+    let(:opt_file) { File.expand_path('../../templates/problem_list.opt', __dir__) }
+    let(:real_entries) { OpenehrRails::Opt::FieldExtractor.new(template).entries }
+    let(:synthetic_id) { 'openEHR-EHR-EVALUATION.synthetic_single_leaf_test.v1' }
+    let(:synthetic_entry) do
+      real = real_entries.first
+      real.merge(
+        archetype_id: synthetic_id,
+        concept: 'synthetic_single_leaf_test',
+        fields: real[:fields].first(1).map { |field| field.merge(archetype_id: synthetic_id) }
+      )
+    end
+
+    before do
+      extractor = instance_double(OpenehrRails::Opt::FieldExtractor, entries: [synthetic_entry, *real_entries])
+      allow(OpenehrRails::Opt::FieldExtractor).to receive(:new).with(template).and_return(extractor)
+    end
+
+    it 'skips the entry instead of emitting Condition.value[x]' do
+      expect(profiles.map { |p| p[:id] }).to eq(['openehr-evaluation-problem-diagnosis-v1'])
+      expect(profiles.flat_map { |p| p[:differential][:element] }.map { |e| e[:path] })
+        .not_to include('Condition.value[x]')
+    end
+
+    it 'reports it through #skipped with the resource named' do
+      profiles
+      error = generator.skipped.first
+
+      expect(generator.skipped.size).to eq(1)
+      expect(error.archetype_id).to eq(synthetic_id)
+      expect(error.resource_type).to eq('Condition')
+      expect(error.leaf_count).to eq(1)
+      expect(error.message).to include('value[x]')
+    end
+  end
+
   describe '#skipped' do
     it 'is empty for an all-Observation template' do
       generator.profiles

data/spec/openehr_rails/rm/rm_object_builder_spec.rb

@@ -73,4 +73,25 @@ describe OpenehrRails::Rm::RmObjectBuilder do
     expect(result).to be_a(OpenEHR::RM::Composition::Composition)
     expect(result.language.code_string).to eq(OpenehrRails.default_language)
   end
+
+  # skoba/openehr-rails#44 (a) bug: a node type the graph stores but
+  # TYPE_CLASSES lacks used to surface as `NoMethodError: undefined method
+  # 'new' for nil`. The typed error names what the caller needs to act on.
+  it 'raises UnsupportedRmTypeError, naming composition and node, for an rm_type outside TYPE_CLASSES' do
+    composition = OpenehrRails::Rm::CompositionCommitter.commit(
+      {
+        '_type' => 'COMPOSITION',
+        'archetype_node_id' => 'openEHR-EHR-COMPOSITION.synthetic_section_test.v1',
+        'content' => [
+          { '_type' => 'SECTION', 'archetype_node_id' => 'openEHR-EHR-SECTION.synthetic_test.v1', 'items' => [] }
+        ]
+      },
+      uid: 'uid-section-builder'
+    )
+
+    expect { composition.to_rm }.to raise_error(OpenehrRails::Rm::UnsupportedRmTypeError) { |error|
+      expect(error.message).to include('uid-section-builder', 'SECTION', 'openEHR-EHR-SECTION.synthetic_test.v1')
+      expect(error.rm_type).to eq('SECTION')
+    }
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: openehr-rails
 version: !ruby/object:Gem::Version
-  version: 0.7.0
+  version: 0.7.1
 platform: ruby
 authors:
 - Shinji KOBAYASHI
@@ -260,9 +260,11 @@ files:
 - docs/design/fix-terminology-scope-plan.md
 - docs/design/fsh-generator-plan.md
 - docs/design/multi-leaf-non-observation-plan.md
+- docs/design/rm-object-builder-section-instruction-plan.md
 - docs/reports/binding-extraction-log.md
 - docs/reports/fsh-generator-log.md
 - docs/reports/institutionalization-log.md
+- docs/reports/referral-upstream-log.md
 - gemfiles/rails_7_2.gemfile
 - gemfiles/rails_8_0.gemfile
 - gemfiles/rails_8_1.gemfile
@@ -410,7 +412,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.16
+rubygems_version: 4.0.20
 specification_version: 4
 summary: Rails extension for the openEHR archetypes
 test_files: []