@atomic-ehr/fhir-canonical-manager 0.0.13 → 0.0.15

package/src/manager/index.ts

@@ -2,7 +2,5 @@
  * Manager module exports
  */
 
-export { createCanonicalManager } from './canonical.js';
-
 // For backward compatibility
-export { createCanonicalManager as CanonicalManager } from './canonical.js';
+export { createCanonicalManager, createCanonicalManager as CanonicalManager } from "./canonical.js";

package/src/package.ts

@@ -0,0 +1,79 @@
+/**
+ * Package management functionality
+ * Merged from package/detector.ts, package/installer.ts, and package/index.ts
+ */
+
+import { exec } from "node:child_process";
+import * as afs from "node:fs/promises";
+import * as Path from "node:path";
+import { promisify } from "node:util";
+import { ensureDir, fileExists } from "./fs/index.js";
+
+const execAsync = promisify(exec);
+
+export type PackageManager = "bun" | "npm";
+
+export const detectPackageManager = async (): Promise<PackageManager | undefined> => {
+    try {
+        await execAsync("bun --version");
+        return "bun";
+    } catch {
+        try {
+            await execAsync("npm --version");
+            return "npm";
+        } catch {
+            return;
+        }
+    }
+};
+
+const ensurePackageJson = async (pwd: string) => {
+    const packageJsonPath = Path.join(pwd, "package.json");
+    if (!(await fileExists(packageJsonPath))) {
+        const minimalPackageJson = {
+            name: "fhir-canonical-manager-workspace",
+            version: "1.0.0",
+            private: true,
+            dependencies: {},
+        };
+        await afs.writeFile(packageJsonPath, JSON.stringify(minimalPackageJson, null, 2));
+    }
+};
+
+export const installPackages = async (packages: string[], pwd: string, registry?: string): Promise<void> => {
+    await ensureDir(pwd);
+    ensurePackageJson(pwd);
+
+    const packageManager = await detectPackageManager();
+    if (!packageManager) throw new Error("No package manager found. Please install bun or npm.");
+
+    for (const pkg of packages) {
+        try {
+            if (packageManager === "bun") {
+                // Use bun with auth bypass trick for FHIR registry
+                const env = {
+                    ...process.env,
+                    HOME: pwd, // Prevent reading user's .npmrc
+                    NPM_CONFIG_USERCONFIG: "/dev/null", // Extra safety
+                };
+
+                const cmd = registry
+                    ? `bun add ${pkg} --cwd='${pwd}' --registry='${registry}'`
+                    : `bun add --cwd='${pwd}' ${pkg}`;
+                await execAsync(cmd, {
+                    env,
+                    maxBuffer: 10 * 1024 * 1024, // 10MB buffer
+                });
+            } else {
+                // Use npm (handles auth correctly)
+                const cmd = registry ? `cd ${pwd} && npm add ${pkg} --registry=${registry}` : `npm add ${pkg}`;
+                await execAsync(cmd, {
+                    maxBuffer: 10 * 1024 * 1024, // 10MB buffer
+                });
+            }
+        } catch (err) {
+            console.error(`Failed to install package ${pkg}:`, err);
+            throw err;
+        }
+    }
+};

package/src/reference.ts

@@ -0,0 +1,77 @@
+/**
+ * Reference management module
+ * Merged from reference/index.ts, reference/manager.ts, and reference/store.ts
+ */
+
+import { createHash } from "node:crypto";
+import type { Reference, ReferenceMetadata, ReferenceStore } from "./types/index.js";
+
+/**
+ * Generate a unique reference ID from metadata
+ */
+export const generateReferenceId = (metadata: {
+    packageName: string;
+    packageVersion: string;
+    filePath: string;
+}): string => {
+    const input = `${metadata.packageName}@${metadata.packageVersion}:${metadata.filePath}`;
+    return createHash("sha256").update(input).digest("base64url");
+};
+
+/**
+ * Reference manager interface
+ */
+export interface ReferenceManager extends ReferenceStore {
+    generateId: typeof generateReferenceId;
+    getIdsByUrl: (url: string) => string[];
+    createReference: (id: string, metadata: ReferenceMetadata) => Reference;
+    getAllReferences: () => Record<string, ReferenceMetadata>;
+}
+
+/**
+ * Create a reference manager instance
+ */
+export const createReferenceManager = (): ReferenceManager => {
+    const references: Record<string, ReferenceMetadata> = {};
+    const urlToIds: Record<string, string[]> = {};
+
+    const set = (id: string, metadata: ReferenceMetadata): void => {
+        references[id] = metadata;
+        if (metadata.url) {
+            if (!urlToIds[metadata.url]) {
+                urlToIds[metadata.url] = [];
+            }
+            const ids = urlToIds[metadata.url];
+            if (ids && !ids.includes(id)) {
+                ids.push(id);
+            }
+        }
+    };
+
+    const clear = (): void => {
+        Object.keys(references).forEach((key) => {
+            delete references[key];
+        });
+        Object.keys(urlToIds).forEach((key) => {
+            delete urlToIds[key];
+        });
+    };
+
+    return {
+        generateId: generateReferenceId,
+        get: (id: string) => references[id],
+        set,
+        has: (id: string) => id in references,
+        clear,
+        size: () => Object.keys(references).length,
+        getIdsByUrl: (url: string) => urlToIds[url] || [],
+        createReference: (id: string, metadata: ReferenceMetadata): Reference => ({
+            id,
+            resourceType: metadata.resourceType,
+        }),
+        getAllReferences: () => references,
+    };
+};
+
+// For backward compatibility - function alias (will be deprecated)
+export { createReferenceManager as ReferenceManagerFactory };

package/src/resolver.ts

@@ -0,0 +1,38 @@
+/**
+ * Resolver module - Context-aware resolution functionality
+ * Merged from resolver/index.ts and resolver/context.ts
+ */
+
+import type { ExtendedCache } from "./cache.js";
+import type { IndexEntry, SourceContext } from "./types/index.js";
+
+/**
+ * Resolve a canonical URL with context awareness
+ *
+ * Attempts to resolve a URL within a specific package context first,
+ * then falls back to global resolution if the context-specific resolution fails.
+ *
+ * @param url - The canonical URL to resolve
+ * @param context - The source context containing package information
+ * @param _cache - The extended cache instance (currently unused but kept for future use)
+ * @param resolveEntry - Function to resolve an entry by URL with optional package/version
+ * @returns The resolved index entry or null if resolution fails
+ */
+export const resolveWithContext = async (
+    url: string,
+    context: SourceContext,
+    _cache: ExtendedCache,
+    resolveEntry: (url: string, options?: any) => Promise<IndexEntry>,
+): Promise<IndexEntry | null> => {
+    if (context.package) {
+        try {
+            return await resolveEntry(url, {
+                package: context.package.name,
+                version: context.package.version,
+            });
+        } catch {
+            // Fall through to global resolution
+        }
+    }
+    return null;
+};

package/src/scanner/directory.ts

@@ -2,41 +2,35 @@
  * Directory scanning functionality
  */
 
-import * as fs from 'fs/promises';
-import * as path from 'path';
-import type { ExtendedCache } from '../cache/core.js';
-import { isFhirPackage } from '../fs/index.js';
-import { scanPackage } from './package.js';
-
-export const scanDirectory = async (
-  dirPath: string,
-  cache: ExtendedCache,
-): Promise<void> => {
-  try {
-    const entries = await fs.readdir(dirPath, { withFileTypes: true });
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import type { ExtendedCache } from "../cache.js";
+import { isFhirPackage } from "../fs/index.js";
+import { scanPackage } from "./package.js";
 
+export const scanDirectory = async (cache: ExtendedCache, pwd: string): Promise<void> => {
+    const nodeModulesPath = path.join(pwd, "node_modules");
+    const entries = await fs.readdir(nodeModulesPath, { withFileTypes: true });
     for (const entry of entries) {
-      if (!entry.isDirectory()) continue;
+        if (!entry.isDirectory()) continue;
+
+        const fullPath = path.join(entry.parentPath, entry.name);
 
-      const fullPath = path.join(dirPath, entry.name);
+        if (entry.name.startsWith("@")) {
+            const scopedEntries = await fs.readdir(fullPath, {
+                withFileTypes: true,
+            });
+            for (const scopedEntry of scopedEntries) {
+                if (!scopedEntry.isDirectory()) continue;
 
-      if (entry.name.startsWith("@")) {
-        const scopedEntries = await fs.readdir(fullPath, {
-          withFileTypes: true,
-        });
-        for (const scopedEntry of scopedEntries) {
-          if (!scopedEntry.isDirectory()) continue;
+                const scopedPath = path.join(fullPath, scopedEntry.name);
 
-          const scopedPath = path.join(fullPath, scopedEntry.name);
-          if (await isFhirPackage(scopedPath)) {
-            await scanPackage(scopedPath, cache);
-          }
+                if (await isFhirPackage(scopedPath)) {
+                    await scanPackage(scopedPath, cache);
+                }
+            }
+        } else if (await isFhirPackage(fullPath)) {
+            await scanPackage(fullPath, cache);
         }
-      } else if (await isFhirPackage(fullPath)) {
-        await scanPackage(fullPath, cache);
-      }
     }
-  } catch {
-    // Silently ignore scan errors
-  }
-};
+};

package/src/scanner/index.ts

@@ -2,7 +2,7 @@
  * Scanner module exports
  */
 
-export { parseIndex, isValidFileEntry, isValidIndexFile } from './parser.js';
-export { processIndex } from './processor.js';
-export { scanPackage } from './package.js';
-export { scanDirectory } from './directory.js';
+export { scanDirectory } from "./directory.js";
+export { scanPackage } from "./package.js";
+export { isValidFileEntry, isValidIndexFile, parseIndex } from "./parser.js";
+export { processIndex } from "./processor.js";

package/src/scanner/package.ts

@@ -2,37 +2,34 @@
  * Package scanning functionality
  */
 
-import * as fs from 'fs/promises';
-import * as path from 'path';
-import type { PackageJson, PackageInfo } from '../types/index.js';
-import type { ExtendedCache } from '../cache/core.js';
-import { fileExists } from '../fs/index.js';
-import { processIndex } from './processor.js';
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import type { ExtendedCache } from "../cache.js";
+import { fileExists } from "../fs/index.js";
+import type { PackageInfo, PackageJson } from "../types/index.js";
+import { processIndex } from "./processor.js";
 
-export const scanPackage = async (
-  packagePath: string,
-  cache: ExtendedCache,
-): Promise<void> => {
-  try {
-    const packageJsonPath = path.join(packagePath, "package.json");
-    const packageJsonContent = await fs.readFile(packageJsonPath, "utf-8");
-    const packageJson: PackageJson = JSON.parse(packageJsonContent);
+export const scanPackage = async (packagePath: string, cache: ExtendedCache): Promise<void> => {
+    try {
+        const packageJsonPath = path.join(packagePath, "package.json");
+        const packageJsonContent = await fs.readFile(packageJsonPath, "utf-8");
+        const packageJson: PackageJson = JSON.parse(packageJsonContent);
 
-    const packageInfo: PackageInfo = {
-      id: { name: packageJson.name, version: packageJson.version },
-      path: packagePath,
-      canonical: packageJson.canonical,
-      fhirVersions: packageJson.fhirVersions,
-    };
-    cache.packages[packageJson.name] = packageInfo;
+        const packageInfo: PackageInfo = {
+            id: { name: packageJson.name, version: packageJson.version },
+            path: packagePath,
+            canonical: packageJson.canonical,
+            fhirVersions: packageJson.fhirVersions,
+        };
+        cache.packages[packageJson.name] = packageInfo;
 
-    await processIndex(packagePath, packageJson, cache);
+        await processIndex(packagePath, packageJson, cache);
 
-    const examplesPath = path.join(packagePath, "examples");
-    if (await fileExists(path.join(examplesPath, ".index.json"))) {
-      await processIndex(examplesPath, packageJson, cache);
+        const examplesPath = path.join(packagePath, "examples");
+        if (await fileExists(path.join(examplesPath, ".index.json"))) {
+            await processIndex(examplesPath, packageJson, cache);
+        }
+    } catch {
+        // Silently ignore package scan errors
     }
-  } catch {
-    // Silently ignore package scan errors
-  }
-};
+};

package/src/scanner/parser.ts

@@ -2,41 +2,39 @@
  * Index file parsing and validation
  */
 
-import type { IndexFile, IndexFileEntry } from '../types/index.js';
+import type { IndexFile } from "../types/index.js";
 
 export const isValidFileEntry = (entry: any): boolean => {
-  if (!entry || typeof entry !== "object") return false;
-  if (!entry.filename || typeof entry.filename !== "string") return false;
-  if (!entry.resourceType || typeof entry.resourceType !== "string")
-    return false;
-  if (!entry.id || typeof entry.id !== "string") return false;
+    if (!entry || typeof entry !== "object") return false;
+    if (!entry.filename || typeof entry.filename !== "string") return false;
+    if (!entry.resourceType || typeof entry.resourceType !== "string") return false;
+    if (!entry.id || typeof entry.id !== "string") return false;
 
-  const optionalStringFields = ["url", "version", "kind", "type"];
-  for (const field of optionalStringFields) {
-    if (entry[field] !== undefined && typeof entry[field] !== "string") {
-      return false;
+    const optionalStringFields = ["url", "version", "kind", "type"];
+    for (const field of optionalStringFields) {
+        if (entry[field] !== undefined && typeof entry[field] !== "string") {
+            return false;
+        }
     }
-  }
 
-  return true;
+    return true;
 };
 
 export const isValidIndexFile = (data: any): boolean => {
-  if (!data || typeof data !== "object") return false;
-  if (!data["index-version"] || typeof data["index-version"] !== "number")
-    return false;
-  if (!Array.isArray(data.files)) return false;
-  return data.files.every((file: any) => isValidFileEntry(file));
+    if (!data || typeof data !== "object") return false;
+    if (!data["index-version"] || typeof data["index-version"] !== "number") return false;
+    if (!Array.isArray(data.files)) return false;
+    return data.files.every((file: any) => isValidFileEntry(file));
 };
 
-export const parseIndex = (content: string, filePath: string): IndexFile | null => {
-  try {
-    const data = JSON.parse(content);
-    if (!isValidIndexFile(data)) {
-      return null;
+export const parseIndex = (content: string, _filePath: string): IndexFile | null => {
+    try {
+        const data = JSON.parse(content);
+        if (!isValidIndexFile(data)) {
+            return null;
+        }
+        return data as IndexFile;
+    } catch {
+        return null;
     }
-    return data as IndexFile;
-  } catch {
-    return null;
-  }
-};
+};

package/src/scanner/processor.ts

@@ -2,68 +2,64 @@
  * Index processing functionality
  */
 
-import * as fs from 'fs/promises';
-import * as path from 'path';
-import type { PackageJson, IndexEntry } from '../types/index.js';
-import type { ExtendedCache } from '../cache/core.js';
-import { parseIndex } from './parser.js';
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import type { ExtendedCache } from "../cache.js";
+import type { IndexEntry, PackageJson } from "../types/index.js";
+import { parseIndex } from "./parser.js";
 
-export const processIndex = async (
-  basePath: string,
-  packageJson: PackageJson,
-  cache: ExtendedCache,
-): Promise<void> => {
-  const indexPath = path.join(basePath, ".index.json");
+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);
+    try {
+        const indexContent = await fs.readFile(indexPath, "utf-8");
+        const index = parseIndex(indexContent, indexPath);
 
-    if (!index) return;
+        if (!index) return;
 
-    for (const file of index.files) {
-      if (!file.url) continue;
+        for (const file of index.files) {
+            if (!file.url) continue;
 
-      const filePath = path.join(basePath, file.filename);
+            const filePath = path.join(basePath, file.filename);
 
-      const id = cache.referenceManager.generateId({
-        packageName: packageJson.name,
-        packageVersion: packageJson.version,
-        filePath,
-      });
+            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,
-      });
+            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,
-        },
-      };
+            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);
-      }
+            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
     }
-  } catch {
-    // Silently ignore index processing errors
-  }
-};
+};

package/src/search/index.ts

@@ -2,5 +2,5 @@
  * Search module exports
  */
 
-export { expandedTerms } from './terms.js';
-export { filterBySmartSearch, type SmartSearchFilters } from './smart.js';
+export { filterBySmartSearch, type SmartSearchFilters } from "./smart.js";
+export { expandedTerms } from "./terms.js";

package/src/search/smart.ts

@@ -2,56 +2,49 @@
  * Smart search functionality with abbreviation support
  */
 
-import type { IndexEntry, PackageId } from '../types/index.js';
-import { expandedTerms } from './terms.js';
+import type { IndexEntry, PackageId } from "../types/index.js";
+import { expandedTerms } from "./terms.js";
 
 export interface SmartSearchFilters {
-  resourceType?: string;
-  type?: string;
-  kind?: string;
-  package?: PackageId;
+    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);
+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);
+        });
     });
-  });
-};
+};