@atomic-ehr/fhir-canonical-manager 0.0.14 → 0.0.16

package/src/constants.ts

@@ -1,6 +0,0 @@
-/**
- * Shared constants for FHIR Canonical Manager
- */
-
-// Default FHIR package registry
-export const DEFAULT_REGISTRY = "https://fs.get-ig.org/pkgs/";

package/src/fs/index.ts

@@ -1,5 +0,0 @@
-/**
- * File system utilities exports
- */
-
-export { ensureDir, fileExists, isFhirPackage } from "./utils.js";

package/src/fs/utils.ts

@@ -1,28 +0,0 @@
-/**
- * File system utility functions
- */
-
-import * as fs from "node:fs/promises";
-import * as path from "node:path";
-
-export const fileExists = async (filePath: string): Promise<boolean> => {
-    try {
-        await fs.access(filePath);
-        return true;
-    } catch {
-        return false;
-    }
-};
-
-export const ensureDir = async (dirPath: string): Promise<void> => {
-    try {
-        await fs.mkdir(dirPath, { recursive: true });
-    } catch {
-        // Ignore errors
-    }
-};
-
-export const isFhirPackage = async (dirPath: string): Promise<boolean> => {
-    const indexPath = path.join(dirPath, ".index.json");
-    return fileExists(indexPath);
-};

package/src/index.ts

@@ -1,18 +0,0 @@
-/**
- * FHIR Canonical Manager - Modular Implementation
- * A package manager for FHIR resources with canonical URL resolution
- */
-
-// Re-export main CanonicalManager factory and class
-export { CanonicalManager, createCanonicalManager } from "./manager/index.js";
-export type { ReferenceManager as ReferenceManagerType } from "./reference/index.js";
-// Re-export reference management
-export { createReferenceManager, ReferenceManagerFactory as ReferenceManager } from "./reference/index.js";
-// Re-export CanonicalManager type interface with T prefix
-export type { CanonicalManager as TCanonicalManager } from "./types/core.js";
-// Re-export all public types
-export * from "./types/index.js";
-
-// Default export for backward compatibility
-import { createCanonicalManager } from "./manager/index.js";
-export default createCanonicalManager;

package/src/manager/canonical.ts

@@ -1,327 +0,0 @@
-/**
- * Main CanonicalManager implementation
- */
-
-import * as afs from "node:fs/promises";
-import * as Path from "node:path";
-import { cacheRecordPaths, createCacheRecord, loadCacheRecordFromDisk, saveCacheRecordToDisk } from "../cache.js";
-import { DEFAULT_REGISTRY } from "../constants.js";
-import { ensureDir } from "../fs/index.js";
-import { installPackages } from "../package.js";
-import { resolveWithContext } from "../resolver/index.js";
-import { scanDirectory } from "../scanner/index.js";
-import { filterBySmartSearch } from "../search/index.js";
-import type {
-    CanonicalManager,
-    Config,
-    IndexEntry,
-    PackageId,
-    PackageInfo,
-    Reference,
-    Resource,
-    SearchParameter,
-    SourceContext,
-} from "../types/index.js";
-
-export const createCanonicalManager = (config: Config): CanonicalManager => {
-    const { packages = [], workingDir } = config;
-    // Ensure registry URL ends with /
-    let registry = DEFAULT_REGISTRY;
-    if (config.registry) {
-        registry = config.registry.endsWith("/") ? config.registry : `${config.registry}/`;
-    }
-
-    const cache = createCacheRecord();
-    let initialized = false;
-    const searchParamsCache = new Map<string, SearchParameter[]>();
-
-    const ensureInitialized = (): void => {
-        if (!initialized) {
-            throw new Error("CanonicalManager not initialized. Call init() first.");
-        }
-    };
-
-    const init = async (): Promise<void> => {
-        if (initialized) return;
-
-        await ensureDir(workingDir);
-        const { cacheKey, npmPackagePath } = cacheRecordPaths(workingDir, packages);
-
-        const cachedData = await loadCacheRecordFromDisk(workingDir, cacheKey);
-        const isCacheValid = cachedData && cachedData.packageLockHash === cacheKey;
-        if (isCacheValid) {
-            // Restore cache from disk
-            cache.entries = cachedData.entries;
-            cache.packages = cachedData.packages;
-            Object.entries(cachedData.references).forEach(([id, metadata]) => {
-                cache.referenceManager.set(id, metadata);
-            });
-        } else {
-            await installPackages(packages, npmPackagePath, registry);
-            await scanDirectory(cache, npmPackagePath);
-            await saveCacheRecordToDisk(cache, workingDir, cacheKey);
-        }
-
-        initialized = true;
-    };
-
-    const destroy = async (): Promise<void> => {
-        cache.entries = {};
-        cache.packages = {};
-        cache.referenceManager.clear();
-        searchParamsCache.clear();
-        initialized = false;
-    };
-
-    const getPackages = async (): Promise<PackageId[]> => {
-        ensureInitialized();
-        return Object.values(cache.packages).map((p: PackageInfo) => p.id);
-    };
-
-    const addPackages = async (...newPackages: string[]): Promise<void> => {
-        if (newPackages.length === 0) return;
-
-        // Check if packages already exists in packages
-        const packagesToAdd = newPackages.filter((pkg) => !packages.includes(pkg));
-        if (packagesToAdd.length !== 0) {
-            packages.push(...packagesToAdd);
-        }
-
-        if (!initialized) {
-            await init();
-            return;
-        }
-
-        if (packagesToAdd.length > 0) {
-            // TODO: very expensive, we can just copy/paste old cache to avoid reinstalling packages
-            await destroy();
-            await init();
-        }
-        return;
-    };
-
-    const resolveEntry = async (
-        canonicalUrl: string,
-        options?: {
-            package?: string;
-            version?: string;
-            sourceContext?: SourceContext;
-        },
-    ): Promise<IndexEntry> => {
-        ensureInitialized();
-
-        if (options?.sourceContext) {
-            const contextResolved = await resolveWithContext(canonicalUrl, options.sourceContext, cache, resolveEntry);
-            if (contextResolved) {
-                return contextResolved;
-            }
-        }
-
-        const entries = cache.entries[canonicalUrl] || [];
-
-        if (entries.length === 0) {
-            throw new Error(`Cannot resolve canonical URL: ${canonicalUrl}`);
-        }
-
-        let filtered = [...entries];
-
-        if (options?.package) {
-            filtered = filtered.filter((e) => e.package?.name === options.package);
-        }
-
-        if (options?.version) {
-            filtered = filtered.filter((e) => e.version === options.version);
-        }
-
-        if (filtered.length === 0) {
-            throw new Error(`No matching resource found for ${canonicalUrl} with given options`);
-        }
-
-        const result = filtered[0];
-        if (!result) {
-            throw new Error(`No matching resource found for ${canonicalUrl}`);
-        }
-        return result;
-    };
-
-    const resolve = async (
-        canonicalUrl: string,
-        options?: {
-            package?: string;
-            version?: string;
-            sourceContext?: SourceContext;
-        },
-    ): Promise<Resource> => {
-        const entry = await resolveEntry(canonicalUrl, options);
-        return read(entry);
-    };
-
-    const read = async (reference: Reference): Promise<Resource> => {
-        ensureInitialized();
-
-        const metadata = cache.referenceManager.get(reference.id);
-        if (!metadata) {
-            throw new Error(`Invalid reference ID: ${reference.id}`);
-        }
-
-        try {
-            const content = await afs.readFile(metadata.filePath, "utf-8");
-            const resource = JSON.parse(content);
-
-            return {
-                ...resource,
-                id: reference.id,
-                resourceType: reference.resourceType,
-            };
-        } catch (err) {
-            throw new Error(`Failed to read resource: ${err}`);
-        }
-    };
-
-    const searchEntries = async (params: {
-        kind?: string;
-        url?: string;
-        type?: string;
-        version?: string;
-        package?: PackageId;
-    }): Promise<IndexEntry[]> => {
-        ensureInitialized();
-
-        let results: IndexEntry[] = [];
-
-        if (params.url) {
-            results = cache.entries[params.url] || [];
-        } else {
-            for (const entries of Object.values(cache.entries)) {
-                results.push(...entries);
-            }
-        }
-
-        if (params.kind !== undefined) {
-            results = results.filter((e) => e.kind === params.kind);
-        }
-
-        if (params.type !== undefined) {
-            results = results.filter((e) => e.type === params.type);
-        }
-
-        if (params.version !== undefined) {
-            results = results.filter((e) => e.version === params.version);
-        }
-
-        if (params.package) {
-            const pkg = params.package;
-            results = results.filter((e) => e.package?.name === pkg.name && e.package?.version === pkg.version);
-        }
-
-        return results;
-    };
-
-    const search = async (params: {
-        kind?: string;
-        url?: string;
-        type?: string;
-        version?: string;
-        package?: PackageId;
-    }): Promise<Resource[]> => {
-        const entries = await searchEntries(params);
-        const resources = await Promise.all(entries.map((entry) => read(entry)));
-        return resources;
-    };
-
-    const smartSearch = async (
-        searchTerms: string[],
-        filters?: {
-            resourceType?: string;
-            type?: string;
-            kind?: string;
-            package?: PackageId;
-        },
-    ): Promise<IndexEntry[]> => {
-        ensureInitialized();
-
-        // Start with base search using filters
-        let results = await searchEntries({
-            kind: filters?.kind,
-            package: filters?.package,
-        });
-
-        // Apply resourceType filter
-        if (filters?.resourceType) {
-            results = results.filter((entry) => entry.resourceType === filters.resourceType);
-        }
-
-        // Apply type filter
-        if (filters?.type) {
-            results = results.filter((entry) => entry.type === filters.type);
-        }
-
-        // Apply smart search filtering
-        return filterBySmartSearch(results, searchTerms);
-    };
-
-    const getSearchParametersForResource = async (resourceType: string): Promise<SearchParameter[]> => {
-        ensureInitialized();
-
-        // Check cache first
-        if (searchParamsCache.has(resourceType)) {
-            const cached = searchParamsCache.get(resourceType);
-            if (cached) {
-                return cached;
-            }
-        }
-
-        // Query all SearchParameter resources
-        // Note: We search by resourceType, not type, because for SearchParameter resources,
-        // 'type' refers to the search parameter type (token, string, etc.)
-        const allEntries = await searchEntries({});
-        const searchParamEntries = allEntries.filter((entry) => entry.resourceType === "SearchParameter");
-
-        const results: SearchParameter[] = [];
-
-        for (const entry of searchParamEntries) {
-            const resource = await read(entry);
-
-            // Check if this parameter applies to the requested resource
-            const bases = resource.base || [];
-            if (Array.isArray(bases) && bases.includes(resourceType)) {
-                // Return the full original resource - it already contains all fields
-                // Cast through unknown to satisfy TypeScript
-                results.push(resource as unknown as SearchParameter);
-            }
-        }
-
-        // Sort by code for consistent output
-        results.sort((a, b) => {
-            const codeA = a.code || "";
-            const codeB = b.code || "";
-            return codeA.localeCompare(codeB);
-        });
-
-        // Cache the results
-        searchParamsCache.set(resourceType, results);
-
-        return results;
-    };
-
-    return {
-        init,
-        destroy,
-        packages: getPackages,
-        addPackages,
-        resolveEntry,
-        resolve,
-        read,
-        searchEntries,
-        search,
-        smartSearch,
-        getSearchParametersForResource,
-        packageJson: async (packageName: string) => {
-            ensureInitialized();
-            const fn = cache.packages[packageName]?.path;
-            if (!fn) throw new Error(`Package ${packageName} not found`);
-            const packageJSON = JSON.parse(await afs.readFile(Path.join(fn, "package.json"), "utf8"));
-            return packageJSON;
-        },
-    };
-};

package/src/manager/index.ts

@@ -1,6 +0,0 @@
-/**
- * Manager module exports
- */
-
-// For backward compatibility
-export { createCanonicalManager, createCanonicalManager as CanonicalManager } from "./canonical.js";

package/src/package.ts

@@ -1,79 +0,0 @@
-/**
- * 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/index.ts

@@ -1,8 +0,0 @@
-/**
- * Reference management exports
- */
-
-export type { ReferenceManager } from "./manager.js";
-// For backward compatibility - function alias (will be deprecated)
-export { createReferenceManager, createReferenceManager as ReferenceManagerFactory } from "./manager.js";
-export { generateReferenceId } from "./store.js";

package/src/reference/manager.ts

@@ -1,55 +0,0 @@
-/**
- * Reference manager factory
- */
-
-import type { Reference, ReferenceMetadata, ReferenceStore } from "../types/index.js";
-import { generateReferenceId } from "./store.js";
-
-export interface ReferenceManager extends ReferenceStore {
-    generateId: typeof generateReferenceId;
-    getIdsByUrl: (url: string) => string[];
-    createReference: (id: string, metadata: ReferenceMetadata) => Reference;
-    getAllReferences: () => Record<string, ReferenceMetadata>;
-}
-
-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,
-    };
-};

package/src/reference/store.ts

@@ -1,14 +0,0 @@
-/**
- * Reference store implementation
- */
-
-import { createHash } from "node:crypto";
-
-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");
-};

package/src/resolver/context.ts

@@ -1,25 +0,0 @@
-/**
- * Context-aware resolution functionality
- */
-
-import type { ExtendedCache } from "../cache.js";
-import type { IndexEntry, SourceContext } from "../types/index.js";
-
-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/resolver/index.ts

@@ -1,5 +0,0 @@
-/**
- * Resolver module exports
- */
-
-export { resolveWithContext } from "./context.js";

package/src/scanner/directory.ts

@@ -1,36 +0,0 @@
-/**
- * Directory scanning functionality
- */
-
-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;
-
-        const fullPath = path.join(entry.parentPath, entry.name);
-
-        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);
-
-                if (await isFhirPackage(scopedPath)) {
-                    await scanPackage(scopedPath, cache);
-                }
-            }
-        } else if (await isFhirPackage(fullPath)) {
-            await scanPackage(fullPath, cache);
-        }
-    }
-};

package/src/scanner/index.ts

@@ -1,8 +0,0 @@
-/**
- * Scanner module exports
- */
-
-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

@@ -1,35 +0,0 @@
-/**
- * Package scanning functionality
- */
-
-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);
-
-        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);
-
-        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
-    }
-};