@openhi/types 0.0.19 → 0.0.21

package/lib/summary/extract-summary.js

@@ -0,0 +1,177 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_SUMMARY_ERROR_BYTES = exports.DEFAULT_SUMMARY_WARN_BYTES = void 0;
+exports.extractSummary = extractSummary;
+/**
+ * Pure projection of a FHIR R4 resource into its summary JSON — the
+ * GSI-friendly shape defined by ADR 2026-04-17-02 and the generated
+ * `SUMMARY_PATHS` table (issue #812).
+ *
+ * Consumed by the write path in #814; no I/O, no DynamoDB access here.
+ *
+ * Threshold defaults come from the #811 size benchmark across every R4
+ * example resource. Both thresholds are warn-only — the guard is a
+ * diagnostic signal, never a reason to reject a store operation.
+ */
+const display_label_1 = require("./display-label");
+const summary_paths_1 = require("../data/summary-paths");
+/** Summary exceeds the clinical-path p99; worth looking at if it's a pattern. */
+exports.DEFAULT_SUMMARY_WARN_BYTES = 4 * 1024;
+/** Summary is outside any measured distribution; almost certainly inline attachment or unpacked Bundle. */
+exports.DEFAULT_SUMMARY_ERROR_BYTES = 8 * 1024;
+function extractSummary(resource, options = {}) {
+    const { resourceType, id } = resource;
+    const logger = options.logger ?? console;
+    const warnBytes = options.warnThresholdBytes ?? exports.DEFAULT_SUMMARY_WARN_BYTES;
+    const errorBytes = options.errorThresholdBytes ?? exports.DEFAULT_SUMMARY_ERROR_BYTES;
+    const result = { resourceType };
+    if (id !== undefined)
+        result.id = id;
+    const meta = resource.meta;
+    if (meta && typeof meta === "object") {
+        const projectedMeta = {};
+        if (meta.lastUpdated !== undefined) {
+            projectedMeta.lastUpdated = meta.lastUpdated;
+        }
+        if (meta.versionId !== undefined) {
+            projectedMeta.versionId = meta.versionId;
+        }
+        if (Object.keys(projectedMeta).length > 0) {
+            result.meta = projectedMeta;
+        }
+    }
+    // `displayLabel` on the summary is backed by the HL7
+    // `resource-instance-name` extension on the full resource. Reading it
+    // inline rather than through `getDisplayLabel` avoids a second import
+    // in the hot path — the URL check is the only thing that matters.
+    // Omitted from the output when absent so the summary stays minimal.
+    const displayLabel = readDisplayLabel(resource);
+    if (displayLabel !== undefined)
+        result.displayLabel = displayLabel;
+    const paths = summary_paths_1.SUMMARY_PATHS[resourceType];
+    if (paths && paths.length > 0) {
+        // `id` and `meta` are handled above with bespoke rules (meta is projected
+        // to just lastUpdated / versionId, not the whole Meta datatype).
+        const applicable = paths.filter((p) => p !== "id" && p !== "meta");
+        applyPaths(resource, result, applicable);
+    }
+    const bytes = utf8ByteLength(JSON.stringify(result));
+    if (bytes > errorBytes) {
+        logger.error("extractSummary: summary exceeds error threshold", {
+            resourceType,
+            id,
+            bytes,
+            thresholdBytes: errorBytes,
+        });
+    }
+    else if (bytes > warnBytes) {
+        logger.warn("extractSummary: summary exceeds warn threshold", {
+            resourceType,
+            id,
+            bytes,
+            thresholdBytes: warnBytes,
+        });
+    }
+    return result;
+}
+function applyPaths(source, target, paths) {
+    const groups = groupByHead(paths);
+    for (const [head, groupPaths] of groups) {
+        if (head.endsWith("[x]")) {
+            applyChoicePath(source, target, head);
+            continue;
+        }
+        const value = source[head];
+        if (value === undefined || value === null)
+            continue;
+        const children = [];
+        for (const p of groupPaths) {
+            if (p === head)
+                continue;
+            children.push(p.slice(head.length + 1));
+        }
+        if (children.length === 0) {
+            target[head] = shallowCopy(value);
+            continue;
+        }
+        if (Array.isArray(value)) {
+            const projected = [];
+            for (const el of value) {
+                if (el && typeof el === "object" && !Array.isArray(el)) {
+                    const sub = {};
+                    applyPaths(el, sub, children);
+                    if (Object.keys(sub).length > 0)
+                        projected.push(sub);
+                }
+            }
+            if (projected.length > 0)
+                target[head] = projected;
+            continue;
+        }
+        if (typeof value === "object") {
+            const sub = {};
+            applyPaths(value, sub, children);
+            if (Object.keys(sub).length > 0)
+                target[head] = sub;
+        }
+    }
+}
+function applyChoicePath(source, target, segment) {
+    const prefix = segment.slice(0, -"[x]".length);
+    for (const key of Object.keys(source)) {
+        if (!key.startsWith(prefix) || key.length <= prefix.length)
+            continue;
+        const nextCharCode = key.charCodeAt(prefix.length);
+        // Concrete FHIR variants are always `<prefix><CapitalizedType>`, e.g.
+        // `valueQuantity`, `effectiveDateTime`. Require an uppercase ASCII
+        // character immediately after the prefix to avoid false-positive
+        // matches against unrelated fields that happen to share the prefix.
+        if (nextCharCode < 65 || nextCharCode > 90)
+            continue;
+        const value = source[key];
+        if (value === undefined)
+            continue;
+        target[key] = shallowCopy(value);
+    }
+}
+function groupByHead(paths) {
+    const groups = new Map();
+    for (const p of paths) {
+        const dot = p.indexOf(".");
+        const head = dot === -1 ? p : p.slice(0, dot);
+        let bucket = groups.get(head);
+        if (!bucket) {
+            bucket = [];
+            groups.set(head, bucket);
+        }
+        bucket.push(p);
+    }
+    return groups;
+}
+function shallowCopy(value) {
+    if (Array.isArray(value))
+        return value.slice();
+    if (value !== null && typeof value === "object") {
+        return { ...value };
+    }
+    return value;
+}
+function utf8ByteLength(s) {
+    return new TextEncoder().encode(s).length;
+}
+function readDisplayLabel(resource) {
+    const ext = resource.extension;
+    if (!Array.isArray(ext))
+        return undefined;
+    for (const e of ext) {
+        if (e !== null &&
+            typeof e === "object" &&
+            e.url === display_label_1.DISPLAY_LABEL_EXTENSION_URL) {
+            const v = e.valueString;
+            if (typeof v === "string")
+                return v;
+        }
+    }
+    return undefined;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"extract-summary.js","sourceRoot":"","sources":["../../src/summary/extract-summary.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Pure projection of a FHIR R4 resource into its summary JSON — the\n * GSI-friendly shape defined by ADR 2026-04-17-02 and the generated\n * `SUMMARY_PATHS` table (issue #812).\n *\n * Consumed by the write path in #814; no I/O, no DynamoDB access here.\n *\n * Threshold defaults come from the #811 size benchmark across every R4\n * example resource. Both thresholds are warn-only — the guard is a\n * diagnostic signal, never a reason to reject a store operation.\n */\nimport { DISPLAY_LABEL_EXTENSION_URL } from \"./display-label\";\nimport { SUMMARY_PATHS } from \"../data/summary-paths\";\nimport type { ResourceSummaryByType } from \"../data/summary-types\";\n\n/** Summary exceeds the clinical-path p99; worth looking at if it's a pattern. */\nexport const DEFAULT_SUMMARY_WARN_BYTES = 4 * 1024;\n\n/** Summary is outside any measured distribution; almost certainly inline attachment or unpacked Bundle. */\nexport const DEFAULT_SUMMARY_ERROR_BYTES = 8 * 1024;\n\nexport interface SummaryJson {\n  resourceType: string;\n  id?: string;\n  meta?: {\n    lastUpdated?: string;\n    versionId?: string;\n  };\n  [key: string]: unknown;\n}\n\n/**\n * Narrow return type for `extractSummary`. When the caller supplies a\n * resource whose `resourceType` is known at compile time (which is the\n * usual case — every generated FHIR interface pins `resourceType` to a\n * string literal), the return type resolves to the matching\n * `{Resource}Summary` from `data/summary-types.ts`. When the caller\n * supplies a `FhirResourceLike` with a wide `resourceType: string`, or\n * a literal that doesn't correspond to a known resource, the return type\n * falls through to `SummaryJson`.\n */\nexport type SummaryFor<R extends string> = R extends keyof ResourceSummaryByType\n  ? ResourceSummaryByType[R]\n  : SummaryJson;\n\nexport interface FhirResourceLike {\n  resourceType: string;\n  id?: string;\n  meta?: {\n    lastUpdated?: string;\n    versionId?: string;\n    [key: string]: unknown;\n  };\n  [key: string]: unknown;\n}\n\nexport interface ExtractSummaryLogger {\n  warn(...args: unknown[]): void;\n  error(...args: unknown[]): void;\n}\n\nexport interface ExtractSummaryOptions {\n  /** Soft (info) warn threshold in UTF-8 bytes. Defaults to 4 KiB. */\n  warnThresholdBytes?: number;\n  /** Hard (error) warn threshold in UTF-8 bytes. Defaults to 8 KiB. */\n  errorThresholdBytes?: number;\n  /** Logger for size-guard warnings. Defaults to `console`. */\n  logger?: ExtractSummaryLogger;\n}\n\n/**\n * Projects `resource` into its summary JSON using `SUMMARY_PATHS`.\n *\n * Always emits `resourceType`, `id` (if present), and\n * `meta.{lastUpdated,versionId}` (if present). Then, for every path in\n * `SUMMARY_PATHS[resourceType]`:\n *   - Simple paths (`name`) copy the whole value (arrays shallow-copied).\n *   - Dotted paths (`component.code`) project the named sub-field of each\n *     element of the container; if any sub-paths are listed for a\n *     container, only those sub-fields are copied (not the whole element).\n *   - `[x]` choice-type paths (`value[x]`) match whichever concrete\n *     variant (`valueQuantity`, `valueString`, …) is present.\n *\n * Missing fields are omitted — no nulls.\n *\n * If the serialized summary exceeds `warnThresholdBytes` /\n * `errorThresholdBytes`, a warn / error is logged with `{ resourceType,\n * id, bytes }`. The summary is always returned; the size guard never\n * rejects.\n */\nexport function extractSummary<T extends FhirResourceLike>(\n  resource: T,\n  options?: ExtractSummaryOptions,\n): SummaryFor<T[\"resourceType\"]>;\nexport function extractSummary(\n  resource: FhirResourceLike,\n  options: ExtractSummaryOptions = {},\n): SummaryJson {\n  const { resourceType, id } = resource;\n  const logger: ExtractSummaryLogger = options.logger ?? console;\n  const warnBytes = options.warnThresholdBytes ?? DEFAULT_SUMMARY_WARN_BYTES;\n  const errorBytes = options.errorThresholdBytes ?? DEFAULT_SUMMARY_ERROR_BYTES;\n\n  const result: SummaryJson = { resourceType };\n  if (id !== undefined) result.id = id;\n\n  const meta = resource.meta;\n  if (meta && typeof meta === \"object\") {\n    const projectedMeta: { lastUpdated?: string; versionId?: string } = {};\n    if (meta.lastUpdated !== undefined) {\n      projectedMeta.lastUpdated = meta.lastUpdated;\n    }\n    if (meta.versionId !== undefined) {\n      projectedMeta.versionId = meta.versionId;\n    }\n    if (Object.keys(projectedMeta).length > 0) {\n      result.meta = projectedMeta;\n    }\n  }\n\n  // `displayLabel` on the summary is backed by the HL7\n  // `resource-instance-name` extension on the full resource. Reading it\n  // inline rather than through `getDisplayLabel` avoids a second import\n  // in the hot path — the URL check is the only thing that matters.\n  // Omitted from the output when absent so the summary stays minimal.\n  const displayLabel = readDisplayLabel(resource);\n  if (displayLabel !== undefined) result.displayLabel = displayLabel;\n\n  const paths = SUMMARY_PATHS[resourceType];\n  if (paths && paths.length > 0) {\n    // `id` and `meta` are handled above with bespoke rules (meta is projected\n    // to just lastUpdated / versionId, not the whole Meta datatype).\n    const applicable = paths.filter((p) => p !== \"id\" && p !== \"meta\");\n    applyPaths(\n      resource as unknown as Record<string, unknown>,\n      result as unknown as Record<string, unknown>,\n      applicable,\n    );\n  }\n\n  const bytes = utf8ByteLength(JSON.stringify(result));\n  if (bytes > errorBytes) {\n    logger.error(\"extractSummary: summary exceeds error threshold\", {\n      resourceType,\n      id,\n      bytes,\n      thresholdBytes: errorBytes,\n    });\n  } else if (bytes > warnBytes) {\n    logger.warn(\"extractSummary: summary exceeds warn threshold\", {\n      resourceType,\n      id,\n      bytes,\n      thresholdBytes: warnBytes,\n    });\n  }\n\n  return result;\n}\n\nfunction applyPaths(\n  source: Record<string, unknown>,\n  target: Record<string, unknown>,\n  paths: readonly string[],\n): void {\n  const groups = groupByHead(paths);\n  for (const [head, groupPaths] of groups) {\n    if (head.endsWith(\"[x]\")) {\n      applyChoicePath(source, target, head);\n      continue;\n    }\n\n    const value = source[head];\n    if (value === undefined || value === null) continue;\n\n    const children: string[] = [];\n    for (const p of groupPaths) {\n      if (p === head) continue;\n      children.push(p.slice(head.length + 1));\n    }\n\n    if (children.length === 0) {\n      target[head] = shallowCopy(value);\n      continue;\n    }\n\n    if (Array.isArray(value)) {\n      const projected: unknown[] = [];\n      for (const el of value) {\n        if (el && typeof el === \"object\" && !Array.isArray(el)) {\n          const sub: Record<string, unknown> = {};\n          applyPaths(el as Record<string, unknown>, sub, children);\n          if (Object.keys(sub).length > 0) projected.push(sub);\n        }\n      }\n      if (projected.length > 0) target[head] = projected;\n      continue;\n    }\n\n    if (typeof value === \"object\") {\n      const sub: Record<string, unknown> = {};\n      applyPaths(value as Record<string, unknown>, sub, children);\n      if (Object.keys(sub).length > 0) target[head] = sub;\n    }\n  }\n}\n\nfunction applyChoicePath(\n  source: Record<string, unknown>,\n  target: Record<string, unknown>,\n  segment: string,\n): void {\n  const prefix = segment.slice(0, -\"[x]\".length);\n  for (const key of Object.keys(source)) {\n    if (!key.startsWith(prefix) || key.length <= prefix.length) continue;\n    const nextCharCode = key.charCodeAt(prefix.length);\n    // Concrete FHIR variants are always `<prefix><CapitalizedType>`, e.g.\n    // `valueQuantity`, `effectiveDateTime`. Require an uppercase ASCII\n    // character immediately after the prefix to avoid false-positive\n    // matches against unrelated fields that happen to share the prefix.\n    if (nextCharCode < 65 || nextCharCode > 90) continue;\n    const value = source[key];\n    if (value === undefined) continue;\n    target[key] = shallowCopy(value);\n  }\n}\n\nfunction groupByHead(paths: readonly string[]): Map<string, string[]> {\n  const groups = new Map<string, string[]>();\n  for (const p of paths) {\n    const dot = p.indexOf(\".\");\n    const head = dot === -1 ? p : p.slice(0, dot);\n    let bucket = groups.get(head);\n    if (!bucket) {\n      bucket = [];\n      groups.set(head, bucket);\n    }\n    bucket.push(p);\n  }\n  return groups;\n}\n\nfunction shallowCopy(value: unknown): unknown {\n  if (Array.isArray(value)) return value.slice();\n  if (value !== null && typeof value === \"object\") {\n    return { ...(value as Record<string, unknown>) };\n  }\n  return value;\n}\n\nfunction utf8ByteLength(s: string): number {\n  return new TextEncoder().encode(s).length;\n}\n\nfunction readDisplayLabel(resource: FhirResourceLike): string | undefined {\n  const ext = resource.extension;\n  if (!Array.isArray(ext)) return undefined;\n  for (const e of ext) {\n    if (\n      e !== null &&\n      typeof e === \"object\" &&\n      (e as { url?: unknown }).url === DISPLAY_LABEL_EXTENSION_URL\n    ) {\n      const v = (e as { valueString?: unknown }).valueString;\n      if (typeof v === \"string\") return v;\n    }\n  }\n  return undefined;\n}\n"]}

package/lib/summary/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./display-label";
+export * from "./extract-summary";

package/lib/summary/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./display-label"), exports);
+__exportStar(require("./extract-summary"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvc3VtbWFyeS9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7O0FBQUEsa0RBQWdDO0FBQ2hDLG9EQUFrQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gXCIuL2Rpc3BsYXktbGFiZWxcIjtcbmV4cG9ydCAqIGZyb20gXCIuL2V4dHJhY3Qtc3VtbWFyeVwiO1xuIl19

package/package.json

@@ -36,7 +36,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "0.0.19",
+  "version": "0.0.21",
   "types": "lib/index.d.ts",
   "//": "~~ Generated by projen. To modify, edit .projenrc.js and run \"pnpm exec projen\".",
   "scripts": {