@atomic-ehr/fhir-canonical-manager 0.0.8 → 0.0.9

package/src/scanner/processor.ts

@@ -0,0 +1,69 @@
+/**
+ * Index processing functionality
+ */
+
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import type { PackageJson, IndexEntry } from '../types';
+import type { ExtendedCache } from '../cache/core';
+import { parseIndex } from './parser';
+
+export const processIndex = async (
+  basePath: string,
+  packageJson: PackageJson,
+  cache: ExtendedCache,
+): Promise<void> => {
+  const indexPath = path.join(basePath, ".index.json");
+
+  try {
+    const indexContent = await fs.readFile(indexPath, "utf-8");
+    const index = parseIndex(indexContent, indexPath);
+
+    if (!index) return;
+
+    for (const file of index.files) {
+      if (!file.url) continue;
+
+      const filePath = path.join(basePath, file.filename);
+
+      const id = cache.referenceManager.generateId({
+        packageName: packageJson.name,
+        packageVersion: packageJson.version,
+        filePath,
+      });
+
+      cache.referenceManager.set(id, {
+        packageName: packageJson.name,
+        packageVersion: packageJson.version,
+        filePath,
+        resourceType: file.resourceType,
+        url: file.url,
+        version: file.version,
+      });
+
+      const entry: IndexEntry = {
+        id,
+        resourceType: file.resourceType,
+        indexVersion: index["index-version"],
+        url: file.url,
+        version: file.version,
+        kind: file.kind,
+        type: file.type,
+        package: {
+          name: packageJson.name,
+          version: packageJson.version,
+        },
+      };
+
+      if (!cache.entries[file.url]) {
+        cache.entries[file.url] = [];
+      }
+      const entries = cache.entries[file.url];
+      if (entries) {
+        entries.push(entry);
+      }
+    }
+  } catch {
+    // Silently ignore index processing errors
+  }
+};

package/src/search/index.ts

@@ -0,0 +1,6 @@
+/**
+ * Search module exports
+ */
+
+export { expandedTerms } from './terms';
+export { filterBySmartSearch, type SmartSearchFilters } from './smart';

package/src/search/smart.ts

@@ -0,0 +1,57 @@
+/**
+ * Smart search functionality with abbreviation support
+ */
+
+import type { IndexEntry, PackageId } from '../types';
+import { expandedTerms } from './terms';
+
+export interface SmartSearchFilters {
+  resourceType?: string;
+  type?: string;
+  kind?: string;
+  package?: PackageId;
+}
+
+export const filterBySmartSearch = (
+  results: IndexEntry[],
+  searchTerms: string[],
+): IndexEntry[] => {
+  if (searchTerms.length === 0) {
+    return results;
+  }
+
+  const terms = searchTerms.map((t) => t.toLowerCase());
+
+  return results.filter((entry) => {
+    if (!entry.url) return false;
+    const urlLower = entry.url.toLowerCase();
+
+    // Also check type and resourceType for matching
+    const fullText = [
+      urlLower,
+      entry.type?.toLowerCase() || "",
+      entry.resourceType?.toLowerCase() || "",
+    ].join(" ");
+
+    // Check if all search terms match
+    return terms.every((term) => {
+      // Split the text into parts (by /, -, _, ., spaces)
+      const allParts = fullText.split(/[\/\-_\.\s]+/);
+
+      // Check if any part starts with the search term
+      const directMatch = allParts.some((part) => part.startsWith(term));
+      if (directMatch) return true;
+
+      // Check if the term is an abbreviation
+      const expansions = expandedTerms[term] || [];
+      for (const expansion of expansions) {
+        if (allParts.some((part) => part.startsWith(expansion))) {
+          return true;
+        }
+      }
+
+      // If still no match, check if the term appears anywhere (substring match)
+      return fullText.includes(term);
+    });
+  });
+};

package/src/search/terms.ts

@@ -0,0 +1,22 @@
+/**
+ * Search term expansion and abbreviations
+ */
+
+export const expandedTerms: Record<string, string[]> = {
+  str: ["structure"],
+  struct: ["structure"],
+  def: ["definition"],
+  pati: ["patient"],
+  obs: ["observation"],
+  org: ["organization"],
+  pract: ["practitioner"],
+  med: ["medication", "medicinal"],
+  req: ["request"],
+  resp: ["response"],
+  ref: ["reference"],
+  val: ["value"],
+  code: ["codesystem", "code"],
+  cs: ["codesystem"],
+  vs: ["valueset"],
+  sd: ["structuredefinition"],
+};

package/src/types/core.ts

@@ -0,0 +1,117 @@
+/**
+ * Core public API types for FHIR Canonical Manager
+ */
+
+export interface Reference {
+  id: string;
+  resourceType: string;
+}
+
+export interface PackageId {
+  name: string;
+  version: string;
+}
+
+export interface IndexEntry extends Reference {
+  indexVersion: number;
+  kind?: string;
+  url?: string;
+  type?: string;
+  version?: string;
+  package?: PackageId;
+}
+
+export interface Resource extends Reference {
+  url?: string;
+  version?: string;
+  [key: string]: any;
+}
+
+export interface SearchParameter {
+  // Required fields
+  url: string;
+  name: string;
+  code: string;
+  base: string[];
+  type: string;
+  expression: string;
+  
+  // Optional commonly-used fields
+  version?: string;
+  target?: string[];
+  multipleOr?: boolean;
+  multipleAnd?: boolean;
+  comparator?: Array<'eq' | 'ne' | 'gt' | 'lt' | 'ge' | 'le' | 'sa' | 'eb' | 'ap'>;
+  modifier?: Array<'missing' | 'exact' | 'contains' | 'not' | 'text' |
+                   'in' | 'not-in' | 'below' | 'above' | 'type' | 'identifier' | 'ofType'>;
+  
+  // Open for all other FHIR SearchParameter fields
+  [key: string]: any;
+}
+
+export interface SourceContext {
+  id?: string;
+  package?: PackageId;
+  url?: string;
+  path?: string;
+}
+
+export interface Config {
+  packages: string[];
+  workingDir: string;
+  registry?: string;
+}
+
+export interface PackageInfo {
+  id: PackageId;
+  path: string;
+  canonical?: string;
+  fhirVersions?: string[];
+}
+
+export interface CanonicalManager {
+  init(): Promise<void>;
+  destroy(): Promise<void>;
+  packages(): Promise<PackageId[]>;
+  resolveEntry(
+    canonicalUrl: string,
+    options?: {
+      package?: string;
+      version?: string;
+      sourceContext?: SourceContext;
+    },
+  ): Promise<IndexEntry>;
+  resolve(
+    canonicalUrl: string,
+    options?: {
+      package?: string;
+      version?: string;
+      sourceContext?: SourceContext;
+    },
+  ): Promise<Resource>;
+  read(reference: Reference): Promise<Resource>;
+  searchEntries(params: {
+    kind?: string;
+    url?: string;
+    type?: string;
+    version?: string;
+    package?: PackageId;
+  }): Promise<IndexEntry[]>;
+  search(params: {
+    kind?: string;
+    url?: string;
+    type?: string;
+    version?: string;
+    package?: PackageId;
+  }): Promise<Resource[]>;
+  smartSearch(
+    searchTerms: string[],
+    filters?: {
+      resourceType?: string;
+      type?: string;
+      kind?: string;
+      package?: PackageId;
+    },
+  ): Promise<IndexEntry[]>;
+  getSearchParametersForResource(resourceType: string): Promise<SearchParameter[]>;
+}

package/src/types/index.ts

@@ -0,0 +1,6 @@
+/**
+ * Type exports for FHIR Canonical Manager
+ */
+
+export * from './core';
+export * from './internal';

package/src/types/internal.ts

@@ -0,0 +1,57 @@
+/**
+ * Internal implementation types for FHIR Canonical Manager
+ */
+
+export interface IndexFile {
+  "index-version": number;
+  files: IndexFileEntry[];
+}
+
+export interface IndexFileEntry {
+  filename: string;
+  resourceType: string;
+  id: string;
+  url?: string;
+  version?: string;
+  kind?: string;
+  type?: string;
+}
+
+export interface PackageJson {
+  name: string;
+  version: string;
+  fhirVersions?: string[];
+  type?: string;
+  canonical?: string;
+  dependencies?: Record<string, string>;
+}
+
+export interface ReferenceMetadata {
+  packageName: string;
+  packageVersion: string;
+  filePath: string;
+  resourceType: string;
+  url?: string;
+  version?: string;
+}
+
+export interface IndexCache {
+  entries: Record<string, import('./core').IndexEntry[]>;
+  packages: Record<string, import('./core').PackageInfo>;
+  references: Record<string, ReferenceMetadata>;
+}
+
+export interface CacheData {
+  entries: Record<string, import('./core').IndexEntry[]>;
+  packages: Record<string, import('./core').PackageInfo>;
+  references: Record<string, ReferenceMetadata>;
+  packageLockHash?: string; // Hash of package-lock.json to detect changes
+}
+
+export interface ReferenceStore {
+  get(id: string): ReferenceMetadata | undefined;
+  set(id: string, metadata: ReferenceMetadata): void;
+  has(id: string): boolean;
+  clear(): void;
+  size(): number;
+}