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

package/src/cli/searchparam.ts

@@ -3,14 +3,14 @@
  */
 
 import { CanonicalManager } from "../index.js";
-import { parseArgs, loadPackageJson, getConfigFromPackageJson } from "./index.js";
 import type { SearchParameter } from "../types/index.js";
+import { getConfigFromPackageJson, loadPackageJson, parseArgs } from "./index.js";
 
 export async function searchParamCommand(args: string[]): Promise<void> {
-  const { positional, options } = parseArgs(args);
-  
-  if (options.help || positional.length === 0) {
-    console.log(`
+    const { positional, options } = parseArgs(args);
+
+    if (options.help || positional.length === 0) {
+        console.log(`
 Usage: fcm searchparam <resourceType> [options]
 
 Display search parameters for a specific FHIR resource type
@@ -27,136 +27,137 @@ Examples:
   fcm searchparam Observation --format json
   fcm searchparam Encounter --format csv
 `);
-    return;
-  }
-
-  const resourceType = positional[0];
-  const format = (options.format as string) || 'table';
-
-  // Load config from package.json
-  const packageJson = await loadPackageJson();
-  if (!packageJson) {
-    throw new Error(
-      "No package.json found. Run 'fcm init' to initialize a project.",
-    );
-  }
-
-  const config = getConfigFromPackageJson(packageJson);
-  const manager = CanonicalManager({
-    packages: config.packages || [],
-    registry: config.registry,
-    workingDir: config.workingDir || process.cwd(),
-  });
-  
-  await manager.init();
-  
-  try {
-    const searchParams = await manager.getSearchParametersForResource(resourceType!);
-    
-    if (searchParams.length === 0) {
-      console.log(`No search parameters found for resource type '${resourceType}'`);
-      return;
+        return;
+    }
+
+    const resourceType = positional[0];
+    if (!resourceType) {
+        console.error("Error: Resource type is required");
+        process.exit(1);
     }
-    
-    // Format output based on requested format
-    switch (format) {
-      case 'json':
-        outputJson(searchParams);
-        break;
-      case 'csv':
-        outputCsv(searchParams);
-        break;
-      case 'table':
-      default:
-        outputTable(searchParams);
-        break;
+    const format = (options.format as string) || "table";
+
+    // Load config from package.json
+    const packageJson = await loadPackageJson();
+    if (!packageJson) {
+        throw new Error("No package.json found. Run 'fcm init' to initialize a project.");
+    }
+
+    const config = getConfigFromPackageJson(packageJson);
+    const manager = CanonicalManager({
+        packages: config.packages || [],
+        registry: config.registry,
+        workingDir: config.workingDir || process.cwd(),
+    });
+
+    await manager.init();
+
+    try {
+        const searchParams = await manager.getSearchParametersForResource(resourceType);
+
+        if (searchParams.length === 0) {
+            console.log(`No search parameters found for resource type '${resourceType}'`);
+            return;
+        }
+
+        // Format output based on requested format
+        switch (format) {
+            case "json":
+                outputJson(searchParams);
+                break;
+            case "csv":
+                outputCsv(searchParams);
+                break;
+            default:
+                outputTable(searchParams);
+                break;
+        }
+    } finally {
+        await manager.destroy();
     }
-  } finally {
-    await manager.destroy();
-  }
 }
 
 function outputTable(searchParams: SearchParameter[]): void {
-  console.log('');
-  
-  // Display each parameter as a multiline block
-  for (const param of searchParams) {
-    const code = param.code || '';
-    const type = param.type || '';
-    const expression = param.expression || '';
-    const url = param.url || '';
-    
-    console.log(`Code:       ${code}`);
-    console.log(`Type:       ${type}`);
-    if (expression) {
-      // Wrap long expressions
-      if (expression.length > 60) {
-        console.log(`Expression: ${wrapText(expression, 60, '            ')}`);
-      } else {
-        console.log(`Expression: ${expression}`);
-      }
-    } else {
-      console.log(`Expression: (none)`);
+    console.log("");
+
+    // Display each parameter as a multiline block
+    for (const param of searchParams) {
+        const code = param.code || "";
+        const type = param.type || "";
+        const expression = param.expression || "";
+        const url = param.url || "";
+
+        console.log(`Code:       ${code}`);
+        console.log(`Type:       ${type}`);
+        if (expression) {
+            // Wrap long expressions
+            if (expression.length > 60) {
+                console.log(`Expression: ${wrapText(expression, 60, "            ")}`);
+            } else {
+                console.log(`Expression: ${expression}`);
+            }
+        } else {
+            console.log(`Expression: (none)`);
+        }
+        console.log(`URL:        ${url}`);
+        console.log("---");
     }
-    console.log(`URL:        ${url}`);
-    console.log('---');
-  }
-  
-  console.log(`Total: ${searchParams.length} search parameters`);
+
+    console.log(`Total: ${searchParams.length} search parameters`);
 }
 
 // Helper function to wrap text at specified width
 function wrapText(text: string, width: number, indent: string): string {
-  const words = text.split(' ');
-  const lines: string[] = [];
-  let currentLine = '';
-  
-  for (const word of words) {
-    if (currentLine.length + word.length + 1 <= width) {
-      currentLine += (currentLine ? ' ' : '') + word;
-    } else {
-      if (currentLine) {
+    const words = text.split(" ");
+    const lines: string[] = [];
+    let currentLine = "";
+
+    for (const word of words) {
+        if (currentLine.length + word.length + 1 <= width) {
+            currentLine += (currentLine ? " " : "") + word;
+        } else {
+            if (currentLine) {
+                lines.push(currentLine);
+            }
+            currentLine = word;
+        }
+    }
+
+    if (currentLine) {
         lines.push(currentLine);
-      }
-      currentLine = word;
     }
-  }
-  
-  if (currentLine) {
-    lines.push(currentLine);
-  }
-  
-  return lines.join('\n' + indent);
+
+    return lines.join(`\n${indent}`);
 }
 
 function outputJson(searchParams: SearchParameter[]): void {
-  const output = searchParams.map(param => ({
-    code: param.code,
-    type: param.type,
-    expression: param.expression || null,
-    url: param.url,
-  }));
-  console.log(JSON.stringify(output, null, 2));
+    const output = searchParams.map((param) => ({
+        code: param.code,
+        type: param.type,
+        expression: param.expression || null,
+        url: param.url,
+    }));
+    console.log(JSON.stringify(output, null, 2));
 }
 
 function outputCsv(searchParams: SearchParameter[]): void {
-  // CSV header
-  console.log('Code,Type,Expression,URL');
-  
-  // CSV rows - no truncation for CSV output
-  for (const param of searchParams) {
-    const code = escapeCsv(param.code || '');
-    const type = escapeCsv(param.type || '');
-    const expression = escapeCsv(param.expression || '');
-    const url = escapeCsv(param.url || '');
-    console.log(`${code},${type},${expression},${url}`);
-  }
+    // CSV header
+    console.log("Code,Type,Expression,URL");
+
+    // CSV rows - no truncation for CSV output
+    for (const param of searchParams) {
+        const code = escapeCsv(param.code || "");
+        const type = escapeCsv(param.type || "");
+        const expression = escapeCsv(param.expression || "");
+        const url = escapeCsv(param.url || "");
+        console.log(`${code},${type},${expression},${url}`);
+    }
 }
 
 function escapeCsv(value: string): string {
-  // Escape CSV values that contain commas, quotes, or newlines
-  if (value.includes(',') || value.includes('"') || value.includes('\n')) {
-    return '"' + value.replace(/"/g, '""') + '"';
-  }
-  return value;
-}
+    // Escape CSV values that contain commas, quotes, or newlines
+    if (value.includes(",") || value.includes('"') || value.includes("\n")) {
+        return `"${value.replace(/"/g, '""')}"`;
+    }
+    return value;
+}

package/src/constants.ts

@@ -3,4 +3,4 @@
  */
 
 // Default FHIR package registry
-export const DEFAULT_REGISTRY = "https://fs.get-ig.org/pkgs/";
+export const DEFAULT_REGISTRY = "https://fs.get-ig.org/pkgs/";

package/src/fs/index.ts

@@ -2,4 +2,4 @@
  * File system utilities exports
  */
 
-export { fileExists, ensureDir, isFhirPackage } from './utils.js';
+export { ensureDir, fileExists, isFhirPackage } from "./utils.js";

package/src/fs/utils.ts

@@ -2,27 +2,27 @@
  * File system utility functions
  */
 
-import * as fs from 'fs/promises';
-import * as path from 'path';
+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;
-  }
+    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
-  }
+    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);
-};
+    const indexPath = path.join(dirPath, ".index.json");
+    return fileExists(indexPath);
+};

package/src/index.ts

@@ -3,19 +3,16 @@
  * A package manager for FHIR resources with canonical URL resolution
  */
 
-// Re-export all public types
-export * from './types/index.js';
-
-// Re-export reference management
-export { createReferenceManager, ReferenceManagerFactory as ReferenceManager } from './reference/index.js';
-export type { ReferenceManager as ReferenceManagerType } from './reference/index.js';
-
 // Re-export main CanonicalManager factory and class
-export { CanonicalManager, createCanonicalManager } from './manager/index.js';
-
+export { CanonicalManager, createCanonicalManager } from "./manager/index.js";
+export type { ReferenceManager as ReferenceManagerType } from "./reference.js";
+// Re-export reference management
+export { createReferenceManager, ReferenceManagerFactory as ReferenceManager } from "./reference.js";
 // Re-export CanonicalManager type interface with T prefix
-export type { CanonicalManager as TCanonicalManager } from './types/core.js';
+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;
+import { createCanonicalManager } from "./manager/index.js";
+export default createCanonicalManager;