fhirsmith 0.3.0

package/npmprojector/watcher.js

@@ -0,0 +1,335 @@
+//
+// Package Watcher
+// Watches a local directory or .tgz file and triggers reloads on changes
+//
+
+const chokidar = require('chokidar');
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const tar = require('tar');
+
+class PackageWatcher {
+  constructor(packagePath, options = {}) {
+    this.packagePath = packagePath;
+    this.debounceMs = options.debounceMs || 500;
+    this.onReload = options.onReload || (() => {});
+    this.log = options.log || console;
+    this.watcher = null;
+    this.debounceTimer = null;
+    this.extractDir = null;
+    this.isTgz = false;
+    
+    // Folder options (paths relative to package root)
+    this.resourceFolders = options.resourceFolders || null;  // null = load all
+    this.searchParametersFolder = options.searchParametersFolder || null;  // folder within package
+  }
+
+  /**
+   * Start watching the package directory or .tgz file
+   */
+  start() {
+    this.log.info(`Watching package at: ${this.packagePath}`);
+
+    // Check if this is a .tgz file
+    this.isTgz = this.packagePath.endsWith('.tgz') || this.packagePath.endsWith('.tar.gz');
+
+    if (this.isTgz) {
+      // Create temp directory for extraction
+      this.extractDir = fs.mkdtempSync(path.join(os.tmpdir(), 'npmprojector-'));
+      this.log.info(`Using temp directory: ${this.extractDir}`);
+    }
+
+    this.watcher = chokidar.watch(this.packagePath, {
+      persistent: true,
+      ignoreInitial: true,
+      awaitWriteFinish: {
+        stabilityThreshold: 300,
+        pollInterval: 100
+      }
+    });
+
+    this.watcher
+      .on('add', filePath => this.handleChange('add', filePath))
+      .on('change', filePath => this.handleChange('change', filePath))
+      .on('unlink', filePath => this.handleChange('unlink', filePath))
+      .on('error', error => this.log.error('Watcher error:', error));
+
+    // Do initial load
+    this.triggerReload();
+  }
+
+  /**
+   * Handle a file change event
+   */
+  handleChange(event, filePath) {
+    this.log.info(`File ${event}: ${filePath}`);
+
+    // Debounce rapid changes
+    if (this.debounceTimer) {
+      clearTimeout(this.debounceTimer);
+    }
+
+    this.debounceTimer = setTimeout(() => {
+      this.triggerReload();
+    }, this.debounceMs);
+  }
+
+  /**
+   * Load all data and trigger the reload callback
+   */
+  triggerReload() {
+    this.log.info('Reloading package data...');
+
+    try {
+      // If .tgz, extract first
+      if (this.isTgz) {
+        this.extractTgz();
+      }
+
+      // Determine which directory to read from
+      const readPath = this.getReadPath();
+      this.log.info(`Reading from: ${readPath}`);
+
+      const data = this.loadPackageDataFrom(readPath);
+      this.onReload(data);
+      this.log.info(`Reload complete: ${data.resources.length} resources, ${data.searchParameters.length} search parameters`);
+    } catch (error) {
+      this.log.error('Error loading package data:', error);
+    }
+  }
+
+  /**
+   * Extract .tgz file to temp directory
+   */
+  extractTgz() {
+    // Clear existing extracted content
+    if (fs.existsSync(this.extractDir)) {
+      fs.rmSync(this.extractDir, { recursive: true, force: true });
+    }
+    fs.mkdirSync(this.extractDir, { recursive: true });
+
+    // Extract synchronously
+    tar.extract({
+      file: this.packagePath,
+      cwd: this.extractDir,
+      sync: true
+    });
+
+    this.log.info(`Extracted .tgz to ${this.extractDir}`);
+  }
+
+  /**
+   * Get the actual directory to read from
+   */
+  getReadPath() {
+    if (this.isTgz) {
+      // npm packages typically extract to a 'package' subdirectory
+      const packageSubdir = path.join(this.extractDir, 'package');
+      if (fs.existsSync(packageSubdir)) {
+        return packageSubdir;
+      }
+      return this.extractDir;
+    }
+    return this.packagePath;
+  }
+
+  /**
+   * Load all FHIR resources and search parameters from a directory
+   */
+  loadPackageDataFrom(dirPath) {
+    const resources = [];
+    const searchParameters = [];
+
+    // Load search parameters from specified folder within package
+    if (this.searchParametersFolder) {
+      const spPath = path.join(dirPath, this.searchParametersFolder);
+      if (fs.existsSync(spPath)) {
+        const spFiles = this.findJsonFiles(spPath);
+        this.log.info(`Loading search parameters from ${this.searchParametersFolder}: ${spFiles.length} files`);
+        for (const filePath of spFiles) {
+          this.loadSearchParamsFromFile(filePath, searchParameters);
+        }
+      } else {
+        this.log.warn(`Search parameters folder not found: ${spPath}`);
+      }
+    }
+
+    // Determine which folders to load resources from
+    let foldersToLoad = [];
+    if (this.resourceFolders && this.resourceFolders.length > 0) {
+      // Load only from specified folders
+      for (const folder of this.resourceFolders) {
+        const folderPath = path.join(dirPath, folder);
+        if (fs.existsSync(folderPath)) {
+          foldersToLoad.push(folderPath);
+        } else {
+          this.log.warn(`Resource folder not found: ${folderPath}`);
+        }
+      }
+    } else {
+      // Load from entire package
+      foldersToLoad = [dirPath];
+    }
+
+    // Load all JSON files from the designated folders
+    let totalFiles = 0;
+    for (const folder of foldersToLoad) {
+      const jsonFiles = this.findJsonFiles(folder);
+      totalFiles += jsonFiles.length;
+      
+      for (const filePath of jsonFiles) {
+        // Skip if this is in the search parameters folder (already loaded)
+        if (this.searchParametersFolder) {
+          const spPath = path.join(dirPath, this.searchParametersFolder);
+          if (filePath.startsWith(spPath)) {
+            continue;
+          }
+        }
+
+        try {
+          const content = fs.readFileSync(filePath, 'utf-8');
+          const parsed = JSON.parse(content);
+
+          // Handle Bundles
+          if (parsed.resourceType === 'Bundle' && parsed.entry) {
+            for (const entry of parsed.entry) {
+              if (entry.resource) {
+                this.categorizeResource(entry.resource, resources, searchParameters);
+              }
+            }
+          } else if (parsed.resourceType) {
+            this.categorizeResource(parsed, resources, searchParameters);
+          }
+        } catch (err) {
+          // Skip files that can't be parsed as FHIR
+        }
+      }
+    }
+    
+    this.log.info(`Found ${totalFiles} JSON files in ${foldersToLoad.length} folder(s)`);
+
+    return { resources, searchParameters };
+  }
+
+  /**
+   * Load search parameters from a specific path
+   */
+  loadSearchParametersFrom(searchParamPath) {
+    const searchParameters = [];
+
+    if (!fs.existsSync(searchParamPath)) {
+      this.log.warn(`Search parameters path does not exist: ${searchParamPath}`);
+      return searchParameters;
+    }
+
+    const stat = fs.statSync(searchParamPath);
+
+    if (stat.isDirectory()) {
+      const jsonFiles = this.findJsonFiles(searchParamPath);
+      for (const filePath of jsonFiles) {
+        this.loadSearchParamsFromFile(filePath, searchParameters);
+      }
+    } else if (stat.isFile()) {
+      this.loadSearchParamsFromFile(searchParamPath, searchParameters);
+    }
+
+    return searchParameters;
+  }
+
+  /**
+   * Load search parameters from a single file
+   */
+  loadSearchParamsFromFile(filePath, searchParameters) {
+    try {
+      const content = fs.readFileSync(filePath, 'utf-8');
+      const parsed = JSON.parse(content);
+
+      if (parsed.resourceType === 'Bundle' && parsed.entry) {
+        for (const entry of parsed.entry) {
+          if (entry.resource && entry.resource.resourceType === 'SearchParameter') {
+            searchParameters.push(entry.resource);
+          }
+        }
+      } else if (parsed.resourceType === 'SearchParameter') {
+        searchParameters.push(parsed);
+      }
+    } catch (err) {
+      this.log.warn(`Failed to parse search params from ${filePath}: ${err.message}`);
+    }
+  }
+
+  /**
+   * Categorize a resource as either a SearchParameter or a regular resource
+   */
+  categorizeResource(resource, resources, searchParameters) {
+    if (resource.resourceType === 'SearchParameter') {
+      searchParameters.push(resource);
+    } else {
+      resources.push(resource);
+    }
+  }
+
+  /**
+   * Recursively find all JSON files in a directory
+   */
+  findJsonFiles(dir) {
+    const files = [];
+
+    if (!fs.existsSync(dir)) {
+      this.log.warn(`Directory does not exist: ${dir}`);
+      return files;
+    }
+
+    const stat = fs.statSync(dir);
+    if (!stat.isDirectory()) {
+      this.log.warn(`Path is not a directory: ${dir}`);
+      return files;
+    }
+
+    const entries = fs.readdirSync(dir);
+
+    for (const entry of entries) {
+      // Skip hidden files and node_modules
+      if (entry.startsWith('.') || entry === 'node_modules') {
+        continue;
+      }
+
+      const fullPath = path.join(dir, entry);
+      const entryStat = fs.statSync(fullPath);
+
+      if (entryStat.isDirectory()) {
+        files.push(...this.findJsonFiles(fullPath));
+      } else if (entryStat.isFile() && path.extname(entry).toLowerCase() === '.json') {
+        files.push(fullPath);
+      }
+    }
+
+    return files;
+  }
+
+  /**
+   * Stop watching
+   */
+  stop() {
+    if (this.watcher) {
+      this.watcher.close();
+      this.watcher = null;
+    }
+    if (this.debounceTimer) {
+      clearTimeout(this.debounceTimer);
+      this.debounceTimer = null;
+    }
+    // Clean up temp directory
+    if (this.extractDir && fs.existsSync(this.extractDir)) {
+      try {
+        fs.rmSync(this.extractDir, { recursive: true, force: true });
+        this.log.info(`Cleaned up temp directory: ${this.extractDir}`);
+      } catch (err) {
+        this.log.warn(`Failed to clean up temp directory: ${err.message}`);
+      }
+    }
+  }
+}
+
+module.exports = PackageWatcher;

package/package.json

@@ -0,0 +1,119 @@
+{
+  "name": "fhirsmith",
+  "version": "0.3.0",
+  "description": "A Node.js server that provides a collection of tools to serve the FHIR ecosystem",
+  "main": "server.js",
+  "engines": {
+    "node": ">=24"
+  },
+  "scripts": {
+    "start": "node server.js",
+    "dev": "nodemon server.js",
+    "test": "jest",
+    "test:watch": "jest --watch",
+    "test:coverage": "jest --coverage",
+    "test:ci": "jest --ci --coverage --watchAll=false --reporters=default --reporters=jest-junit --verbose",
+    "test:shl": "jest --testPathPattern=shl",
+    "test:vcl": "jest --testPathPattern=vcl",
+    "test:xig": "jest --testPathPattern=xig",
+    "test:packages": "jest --testPathPattern=packages",
+    "test:token": "jest --testPathPattern=token",
+    "test:integration": "jest --testPathPattern=integration",
+    "test:unit": "jest --testPathPattern=unit",
+    "lint": "eslint . --ext .js --ignore-path .gitignore",
+    "lint:fix": "eslint . --fix --ignore-pattern 'static/assets/js/html5shiv.js'",
+    "lint:relaxed": "eslint . --config .eslintrc.relaxed.js",
+    "install-global": "npm link",
+    "list": "node tx-import.js list",
+    "import": "node tx-import.js",
+    "tx-import": "node tx/importers/tx-import.js"
+  },
+  "dependencies": {
+    "axios": "^1.13.4",
+    "base45": "^3.0.0",
+    "bcrypt": "^6.0.0",
+    "cbor": "^9.0.1",
+    "chalk": "^4.1.2",
+    "chokidar": "^4.0.3",
+    "cli-progress": "^3.12.0",
+    "commander": "^14.0.3",
+    "commonmark": "^0.31.2",
+    "connect-sqlite3": "^0.9.16",
+    "cors": "^2.8.6",
+    "express": "^5.2.1",
+    "express-rate-limit": "^7.4.1",
+    "express-session": "^1.19.0",
+    "fast-xml-parser": "^5.3.4",
+    "fhir-validator-wrapper": "1.2.1",
+    "fhirpath": "^4.8.3",
+    "fs-extra": "^11.3.3",
+    "inquirer": "^8.2.5",
+    "liquidjs": "^10.24.0",
+    "lusca": "^1.7.0",
+    "natural": "^6.12.0",
+    "node-cron": "^3.0.3",
+    "pako": "^2.1.0",
+    "passport": "^0.7.0",
+    "passport-facebook": "^3.0.0",
+    "passport-github2": "^0.1.12",
+    "passport-google-oauth20": "^2.0.0",
+    "properties-file": "^3.6.4",
+    "rimraf": "^5.0.10",
+    "sqlite3": "^5.1.7",
+    "tar": "^7.5.7",
+    "winston": "^3.19.0",
+    "winston-daily-rotate-file": "^4.7.1",
+    "yaml": "^2.8.2"
+  },
+  "devDependencies": {
+    "@types/jest": "^29.5.8",
+    "@typescript-eslint/eslint-plugin": "^8.54.0",
+    "@typescript-eslint/parser": "^8.54.0",
+    "eslint": "^8.57.1",
+    "eslint-plugin-promise": "^7.2.1",
+    "jest": "^29.7.0",
+    "jest-environment-node": "^29.7.0",
+    "jest-junit": "^16.0.0",
+    "mock-fs": "^5.5.0",
+    "nock": "^13.4.0",
+    "nodemon": "^3.1.11",
+    "supertest": "^7.2.2",
+    "tmp": "^0.2.5"
+  },
+  "jest-junit": {
+    "outputDirectory": "./test-results",
+    "outputName": "junit.xml",
+    "classNameTemplate": "{classname}",
+    "titleTemplate": "{title}",
+    "ancestorSeparator": " › "
+  },
+  "keywords": [
+    "fhir",
+    "shc",
+    "shl",
+    "xig",
+    "token",
+    "oauth",
+    "api-keys",
+    "smart-health-link",
+    "smart-health-card"
+  ],
+  "author": "Health Intersections Pty Ltd",
+  "license": "BSD-3",
+  "overrides": {
+    "tar": "^7.5.7",
+    "fast-xml-parser": "^5.3.4"
+  },
+  "bin": {
+    "tx-import": "./tx/importers/tx-import.js",
+    "fhirsmith": "./server.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/HealthIntersections/fhirsmith.git"
+  },
+  "bugs": {
+    "url": "https://github.com/HealthIntersections/fhirsmith/issues"
+  },
+  "homepage": "https://github.com/HealthIntersections/fhirsmith#readme"
+}