fhirsmith 0.18.1 → 1.0.0

package/tx/library.js

@@ -22,6 +22,8 @@ const {RxNormServicesFactory} = require("./cs/cs-rxnorm");
 const {NdcServicesFactory} = require("./cs/cs-ndc");
 const {UniiServicesFactory} = require("./cs/cs-unii");
 const {SnomedServicesFactory} = require("./cs/cs-snomed");
+const {SnomedFileReader} = require("./sct/structures");
+const {SnomedLoadConfig} = require("./sct/load-config");
 const {CPTServicesFactory} = require("./cs/cs-cpt");
 const {OMOPServicesFactory} = require("./cs/cs-omop");
 const {ICD11ServicesFactory} = require("./cs/cs-icd11");
@@ -31,9 +33,10 @@ const {IETFLanguageCodeFactory} = require("./cs/cs-lang");
 const {LanguageDefinitions} = require("../library/languages");
 const {VersionUtilities} = require("../library/version-utilities");
 const {ListCodeSystemProvider} = require("./cs/cs-provider-list");
-const { Provider } = require("./provider");
+const { Provider, CodeSystemMap } = require("./provider");
 const {I18nSupport} = require("../library/i18nsupport");
 const folders = require('../library/folder-setup');
+const memoryGuard = require('../library/memory-guard');
 const {VSACValueSetProvider} = require("./vs/vs-vsac");
 const { OCLCodeSystemProvider, OCLSourceCodeSystemFactory } = require('./ocl/cs-ocl');
 const { OCLValueSetProvider } = require('./ocl/vs-ocl');
@@ -42,6 +45,32 @@ const {UriServicesFactory} = require("./cs/cs-uri");
 const {debugLog} = require("./operation-context");
 const { checkIdPrefix } = require("./library/resource-ids");
 
+// folder:/file: sources keep their SQLite caches in <terminology-cache>/folder-source-<hash>
+const LOCAL_SOURCE_CACHE_PREFIX = 'folder-source-';
+// how long an unused folder-source-* cache is kept, in case another Library is using it
+const LOCAL_SOURCE_CACHE_MAX_AGE = 24 * 60 * 60 * 1000;
+// an unused .db or .cache file or package folder changed more recently than this isn't pruned
+// (see pruneUnusedCaches)
+const PRUNE_MIN_AGE = 24 * 60 * 60 * 1000;
+
+/**
+ * The bytes in the files under a folder
+ * @param {string} dir
+ * @returns {Promise<number>}
+ */
+async function folderSize(dir) {
+  let total = 0;
+  for (const entry of await fs.readdir(dir, { withFileTypes: true })) {
+    const p = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      total += await folderSize(p);
+    } else if (entry.isFile()) {
+      total += (await fs.stat(p)).size;
+    }
+  }
+  return total;
+}
+
 /**
  * This class holds all the loaded content ready for processing
  *
@@ -85,6 +114,28 @@ class Library {
    */
   #givenPrefixes = new Set();
 
+  /**
+   * {Set<string>} the folder-source-* cache folders this load used - the rest are pruned
+   * once they're stale (see #pruneLocalSourceCaches)
+   */
+  #localSourceCaches = new Set();
+
+  /**
+   * {Set<string>} the names of the files in the cache folder that this load used (see
+   * getOrDownloadFile) - with pruneTerminologyCache, the other .db and .cache files there are
+   * deleted once the library has loaded (see pruneTerminologyCache)
+   */
+  #usedCacheFiles = new Set();
+
+  /**
+   * {boolean} once the library and the endpoints' core packages are loaded, delete the .db and
+   * .cache files and the package folders in the cache folder that weren't used (the tx module's
+   * pruneTerminologyCache setting; see pruneUnusedCaches). Off by default: the cache folder is
+   * shared by everything that runs from the same data directory - a development server and the
+   * tests, say - and what one doesn't use, another may
+   */
+  pruneTerminologyCacheFiles = false;
+
   baseUrl = null;
   cacheFolder = null;
   startTime = Date.now();
@@ -92,6 +143,35 @@ class Library {
   lastTime = null;
   totalDownloaded = 0;
   vsacCfg = undefined;
+  /**
+   * {string|null} with several processes on one data directory (cluster.md), a name every
+   * process in the cluster shares (the master's role): the folder-source-* caches are the
+   * master's, named folder-source-<tag>-<hash>. The master builds each in a temporary sibling
+   * and renames it into place, so a worker never sees one half built; a worker
+   * (packageCachesReadOnly) only reads them, waiting for the master as for package caches,
+   * and never prunes
+   */
+  localSourceTag = null;
+
+  /**
+   * {boolean} a tx-worker (cluster.md): the package value set and concept map caches are the
+   * master's. This process opens them read-only, waits for the master to have finished one,
+   * and never builds, rebuilds or migrates one
+   */
+  packageCachesReadOnly = false;
+
+  /**
+   * {boolean} a tx-worker (cluster.md): the cached IANA media types registry is the master's.
+   * This process reads it and never downloads or writes it
+   */
+  mimeTypesReadOnly = false;
+
+  /**
+   * {boolean} a tx-worker (cluster.md): the LOINC, RxNorm, NDC, UNII, CPT and OMOP databases
+   * are the master's, which sets them up (LOINC's journal mode, the LOINC and RxNorm indexes)
+   * before the workers start. This process opens them read-only
+   */
+  terminologyDatabasesReadOnly = false;
 
   /**
    * {SyndicationStore|null} where the content this library loads is recorded for the
@@ -112,11 +192,20 @@ class Library {
     }
   }
 
-  constructor(configFile, vsacCfg, log, stats) {
+  /**
+   * @param {string} configFile - the library yml
+   * @param {object} vsacCfg
+   * @param {object} log
+   * @param {object} stats
+   * @param {object} [snomedCfg] - the tx module's "snomed" block: how SNOMED CT cache files are
+   *   loaded (see tx/sct/load-config.js)
+   */
+  constructor(configFile, vsacCfg, log, stats, snomedCfg = undefined) {
     this.configFile = configFile;
     this.vsacCfg = vsacCfg;
     this.log = log;
     this.stats = stats;
+    this.snomedLoad = new SnomedLoadConfig(snomedCfg, (msg) => (this.log ? this.log.warn(msg) : console.warn(msg)));
 
     // Only synchronous initialization here
     this.codeSystemFactories = new Map();
@@ -215,6 +304,7 @@ class Library {
         throw error;
       }
     }
+    this.snomedLoad.checkUnused();
     this.log.info('Loading Packages');
     this.#logPackagesHeader();
 
@@ -238,6 +328,11 @@ class Library {
       external: endMemory.external - this.startMemory.external
     };
 
+    if (!this.packageCachesReadOnly) {
+      // the master, or no role: a worker leaves the master's caches alone
+      await this.#pruneLocalSourceCaches();
+    }
+
     this.log.info(`Loading Time: ${(totalTime / 1000).toLocaleString()}s`);
     this.log.info(`Memory Used: ${(memoryIncrease.rss / 1024 / 1024).toFixed(2)} MB`);
 
@@ -541,7 +636,7 @@ class Library {
         break;
       }
       case "mimetypes" : {
-        const mime = new MimeTypeServicesFactory(this.i18n, this.cacheFolder, this.log);
+        const mime = new MimeTypeServicesFactory(this.i18n, this.cacheFolder, this.log, { readOnly: this.mimeTypesReadOnly });
         await mime.load();
         this.registerProvider('internal', mime);
         break;
@@ -610,7 +705,7 @@ class Library {
       return;
     }
 
-    const loinc = new LoincServicesFactory(this.i18n, loincFN);
+    const loinc = new LoincServicesFactory(this.i18n, loincFN, { readOnly: this.terminologyDatabasesReadOnly });
     await loinc.load();
     this.registerProvider(loincFN, loinc, isDefault);
     this.#syndicateBinary('loinc', loincFN, loinc);
@@ -621,7 +716,7 @@ class Library {
     if (mode === "fetch" || mode === "npm") {
       return;
     }
-    const rxn = new RxNormServicesFactory(this.i18n, rxNormFN);
+    const rxn = new RxNormServicesFactory(this.i18n, rxNormFN, { readOnly: this.terminologyDatabasesReadOnly });
     await rxn.load();
     this.registerProvider(rxNormFN, rxn, isDefault);
     this.#syndicateBinary('rxnorm', rxNormFN, rxn);
@@ -632,7 +727,7 @@ class Library {
     if (mode === "fetch" || mode === "npm") {
       return;
     }
-    const ndc = new NdcServicesFactory(this.i18n, ndcFN);
+    const ndc = new NdcServicesFactory(this.i18n, ndcFN, { readOnly: this.terminologyDatabasesReadOnly });
     await ndc.load();
     this.registerProvider(ndcFN, ndc, isDefault);
     this.#syndicateBinary('ndc', ndcFN, ndc);
@@ -643,7 +738,7 @@ class Library {
     if (mode === "fetch" || mode === "npm") {
       return;
     }
-    const unii = new UniiServicesFactory(this.i18n, uniFN);
+    const unii = new UniiServicesFactory(this.i18n, uniFN, { readOnly: this.terminologyDatabasesReadOnly });
     await unii.load();
     this.registerProvider(uniFN, unii, isDefault);
     this.#syndicateBinary('unii', uniFN, unii);
@@ -654,8 +749,18 @@ class Library {
     if (mode === "fetch" || mode === "npm") {
       return;
     }
-    const sct = new SnomedServicesFactory(this.i18n, sctFN);
+    const loadMode = this.snomedLoad.modeFor(sctFN, SnomedFileReader.versionUri(sctFN));
+    const sct = new SnomedServicesFactory(this.i18n, sctFN, loadMode, this.log);
     await sct.load();
+    if (loadMode !== 'read') {
+      // if it could not be mapped, mapFile has already said why, through this.log
+      this.log.info(`SNOMED CT ${path.basename(sctFN)}: load ${loadMode}, ` +
+        (sct.mapped ? 'memory-mapped' : 'not mapped, read into memory'));
+    }
+    if (sct.mapped && !memoryGuard._state.excludeFileBacked) {
+      memoryGuard.measureExcludingFileBacked();
+      this.log.info(`SNOMED CT cache files are memory-mapped. ${memoryGuard.describe()}`);
+    }
     this.registerProvider(sctFN, sct, isDefault);
     this.#syndicateBinary('snomed', sctFN, sct);
   }
@@ -665,7 +770,7 @@ class Library {
     if (mode === "fetch" || mode === "npm") {
       return;
     }
-    const cpt = new CPTServicesFactory(this.i18n, cptFN);
+    const cpt = new CPTServicesFactory(this.i18n, cptFN, { readOnly: this.terminologyDatabasesReadOnly });
     await cpt.load();
     this.registerProvider(cptFN, cpt, isDefault);
     // the store syndicates the public fragment only, never the full (licensed) database
@@ -677,7 +782,7 @@ class Library {
     if (mode === "fetch" || mode === "npm") {
       return;
     }
-    const omop = new OMOPServicesFactory(this.i18n, omopFN);
+    const omop = new OMOPServicesFactory(this.i18n, omopFN, { readOnly: this.terminologyDatabasesReadOnly });
     await omop.load();
     this.registerProvider(omopFN, omop, isDefault);
     this.#syndicateBinary('omop', omopFN, omop);
@@ -831,10 +936,10 @@ class Library {
     this.codeSystemProviders.push(cp);
     let vs = null;
     if (!csOnly) {
-      vs = new PackageValueSetProvider(contentLoader);
+      vs = new PackageValueSetProvider(contentLoader, { readOnly: this.packageCachesReadOnly });
       await vs.initialize();
       this.valueSetProviders.push(vs);
-      const cm = new PackageConceptMapProvider(contentLoader);
+      const cm = new PackageConceptMapProvider(contentLoader, { readOnly: this.packageCachesReadOnly });
       await cm.initialize();
       this.conceptMapProviders.push(cm);
     }
@@ -861,7 +966,7 @@ class Library {
     }
 
     const folderPath = this.#resolveLocalSourcePath(details);
-    const cacheSubdir = await this.#prepareLocalSourceCache(folderPath);
+    const cacheSubdir = await this.#prepareLocalSourceCache(folderPath, dir => new FolderContentLoader(folderPath, dir));
     await this.#loadLocalSource(new FolderContentLoader(folderPath, cacheSubdir));
   }
 
@@ -886,7 +991,7 @@ class Library {
     }
 
     const filePath = this.#resolveLocalSourcePath(details);
-    const cacheSubdir = await this.#prepareLocalSourceCache(filePath);
+    const cacheSubdir = await this.#prepareLocalSourceCache(filePath, dir => new FileContentLoader(filePath, dir));
     await this.#loadLocalSource(new FileContentLoader(filePath, cacheSubdir));
   }
 
@@ -906,16 +1011,207 @@ class Library {
    * Parks the Package*Provider SQLite caches under the terminology cache rather
    * than polluting the user's source folder, and wipes between runs so edits to
    * the source are reliably picked up.
+   *
+   * In a cluster (localSourceTag set) every process uses the master's folder:
+   * - a worker (packageCachesReadOnly) touches nothing; its providers open the caches
+   *   read-only, waiting for the master to have built them
+   * - the master builds the caches in a temporary sibling, then renames it into place, so a
+   *   running worker never finds the folder half built
+   *
+   * @param {string} sourcePath
+   * @param {function(string): FolderContentLoader} makeLoader - a loader with its caches in a folder
+   * @returns {Promise<string>} the cache folder
    * @private
    */
-  async #prepareLocalSourceCache(sourcePath) {
+  async #prepareLocalSourceCache(sourcePath, makeLoader) {
     const hash = crypto.createHash('sha1').update(sourcePath).digest('hex').substring(0, 16);
-    const cacheSubdir = path.join(this.cacheFolder, 'folder-source-' + hash);
-    await fs.rm(cacheSubdir, { recursive: true, force: true });
-    await fs.mkdir(cacheSubdir, { recursive: true });
+    const name = LOCAL_SOURCE_CACHE_PREFIX + (this.localSourceTag ? this.localSourceTag + '-' : '') + hash;
+    const cacheSubdir = path.join(this.cacheFolder, name);
+    this.#localSourceCaches.add(name);
+    if (this.packageCachesReadOnly) {
+      return cacheSubdir;
+    }
+    if (!this.localSourceTag) {
+      await fs.rm(cacheSubdir, { recursive: true, force: true });
+      await fs.mkdir(cacheSubdir, { recursive: true });
+      return cacheSubdir;
+    }
+    const building = `${cacheSubdir}.building-${process.pid}`;
+    const old = `${cacheSubdir}.old-${process.pid}`;
+    await fs.rm(building, { recursive: true, force: true });
+    await fs.rm(old, { recursive: true, force: true });
+    await fs.mkdir(building, { recursive: true });
+    const loader = makeLoader(building);
+    await loader.initialize();
+    const vs = new PackageValueSetProvider(loader);
+    await vs.initialize();
+    await vs.close();
+    const cm = new PackageConceptMapProvider(loader);
+    await cm.initialize();
+    // a directory can't be renamed over a non-empty one: move the old one aside first. A
+    // worker that looks in between finds no folder, and waits for it
+    try {
+      await fs.rename(cacheSubdir, old);
+    } catch (e) {
+      if (e.code !== 'ENOENT') {
+        throw e;
+      }
+    }
+    await fs.rename(building, cacheSubdir);
+    await fs.rm(old, { recursive: true, force: true });
     return cacheSubdir;
   }
 
+  /**
+   * Removes the folder-source-* caches left by sources that are no longer loaded (the
+   * name is a hash of the source path, so a moved or temporary folder leaves one behind).
+   *
+   * The cache folder can be shared by more than one Library at a time (a server and the
+   * tests, run from the same checkout), so a cache this load didn't use may be another
+   * one's. Every load rebuilds its caches, so a live one is always recent - only those
+   * untouched for LOCAL_SOURCE_CACHE_MAX_AGE are removed.
+   * @private
+   */
+  async #pruneLocalSourceCaches() {
+    let entries;
+    try {
+      entries = await fs.readdir(this.cacheFolder, { withFileTypes: true });
+    } catch (e) {
+      return;
+    }
+    const cutoff = Date.now() - LOCAL_SOURCE_CACHE_MAX_AGE;
+    let count = 0;
+    for (const entry of entries) {
+      if (!entry.isDirectory() || !entry.name.startsWith(LOCAL_SOURCE_CACHE_PREFIX) || this.#localSourceCaches.has(entry.name)) {
+        continue;
+      }
+      const dir = path.join(this.cacheFolder, entry.name);
+      try {
+        const stat = await fs.stat(dir);
+        if (stat.mtimeMs < cutoff) {
+          await fs.rm(dir, { recursive: true, force: true });
+          count++;
+        }
+      } catch (e) {
+        this.log.warn(`Unable to remove stale local source cache ${dir}: ${e.message}`);
+      }
+    }
+    if (count > 0) {
+      this.log.info(`Removed ${count} stale local source cache folder${count === 1 ? '' : 's'}`);
+    }
+  }
+
+  /**
+   * With pruneTerminologyCacheFiles, and in a process that owns the caches (not a tx-worker):
+   * delete what's in the cache folder that wasn't used - the .db and .cache files
+   * (pruneTerminologyCache) and the package folders (prunePackages). Call it once everything is
+   * loaded: the library (load) and every endpoint's core packages (cloneWithFhirVersion)
+   * @returns {Promise<{files: string[], packages: string[]}>} what was deleted
+   */
+  async pruneUnusedCaches() {
+    if (!this.pruneTerminologyCacheFiles || this.packageCachesReadOnly) {
+      return { files: [], packages: [] };
+    }
+    return { files: await this.pruneTerminologyCache(), packages: await this.prunePackages() };
+  }
+
+  /**
+   * Deletes the package folders (id#version) in the cache folder that the package manager
+   * hasn't returned this run (see PackageManager.usedPackages): packages no longer in the
+   * library, older versions of ones that are, the core packages of FHIR versions no endpoint
+   * has any more, and what failed or interrupted downloads left behind. Their value set and
+   * concept map caches are in them, so go with them. A folder changed in the last
+   * PRUNE_MIN_AGE is kept.
+   * @returns {Promise<string[]>} the names of the folders deleted
+   */
+  async prunePackages() {
+    let entries;
+    try {
+      entries = await fs.readdir(this.cacheFolder, { withFileTypes: true });
+    } catch (e) {
+      return [];
+    }
+    const used = this.packageManager.usedPackages;
+    const cutoff = Date.now() - PRUNE_MIN_AGE;
+    const deleted = [];
+    let bytes = 0;
+    for (const entry of entries) {
+      if (!entry.isDirectory() || !entry.name.includes('#') || used.has(entry.name)) {
+        continue;
+      }
+      const dir = path.join(this.cacheFolder, entry.name);
+      try {
+        const stat = await fs.stat(dir);
+        if (stat.mtimeMs >= cutoff) {
+          this.log.info(`Not deleting unused package ${entry.name} yet: it changed in the last day`);
+          continue;
+        }
+        const size = await folderSize(dir);
+        await fs.rm(dir, { recursive: true, force: true });
+        deleted.push(entry.name);
+        bytes += size;
+        this.log.info(`Deleted unused package ${entry.name} (${(size / 1024 / 1024).toFixed(1)} MB) from the terminology cache`);
+      } catch (e) {
+        this.log.warn(`Unable to delete unused package ${dir}: ${e.message}`);
+      }
+    }
+    if (deleted.length > 0) {
+      this.log.info(`Deleted ${deleted.length} unused package${deleted.length === 1 ? '' : 's'} from the terminology cache, ${(bytes / 1024 / 1024).toFixed(1)} MB`);
+    }
+    return deleted;
+  }
+
+  /**
+   * Deletes the .db and .cache files directly in the cache folder (terminology-cache) that this
+   * load didn't use: the downloaded databases and SNOMED CT caches of sources that are no longer
+   * in the library, and the fallback of an "a|b" source whose first file is there. Their SQLite
+   * side files (-wal, -shm, -journal) go with them. Package folders, and the other folders and
+   * files there, are left alone.
+   *
+   * A file changed in the last PRUNE_MIN_AGE is kept: it may be being copied in, or built,
+   * for a library that doesn't name it yet.
+   *
+   * See pruneUnusedCaches, which calls it
+   * @returns {Promise<string[]>} the names of the files deleted
+   */
+  async pruneTerminologyCache() {
+    let entries;
+    try {
+      entries = await fs.readdir(this.cacheFolder, { withFileTypes: true });
+    } catch (e) {
+      return [];
+    }
+    const cutoff = Date.now() - PRUNE_MIN_AGE;
+    const deleted = [];
+    let bytes = 0;
+    for (const entry of entries) {
+      if (!entry.isFile() || !/\.(db|cache)$/i.test(entry.name) || this.#usedCacheFiles.has(entry.name)) {
+        continue;
+      }
+      const file = path.join(this.cacheFolder, entry.name);
+      try {
+        const stat = await fs.stat(file);
+        if (stat.mtimeMs >= cutoff) {
+          this.log.info(`Not deleting unused ${entry.name} yet: it changed in the last day`);
+          continue;
+        }
+        await fs.rm(file, { force: true });
+        for (const suffix of ['-wal', '-shm', '-journal']) {
+          await fs.rm(file + suffix, { force: true });
+        }
+        deleted.push(entry.name);
+        bytes += stat.size;
+        this.log.info(`Deleted unused ${entry.name} (${(stat.size / 1024 / 1024).toFixed(1)} MB) from the terminology cache`);
+      } catch (e) {
+        this.log.warn(`Unable to delete unused ${file}: ${e.message}`);
+      }
+    }
+    if (deleted.length > 0) {
+      this.log.info(`Deleted ${deleted.length} unused file${deleted.length === 1 ? '' : 's'} from the terminology cache, ${(bytes / 1024 / 1024).toFixed(1)} MB`);
+    }
+    return deleted;
+  }
+
   /**
    * Shared loader for folder- and file-sourced content: registers the loader's
    * CodeSystems, ValueSets and ConceptMaps with this library.
@@ -972,10 +1268,10 @@ class Library {
     }
     this.codeSystemProviders.push(cp);
 
-    const vs = new PackageValueSetProvider(contentLoader);
+    const vs = new PackageValueSetProvider(contentLoader, { readOnly: this.packageCachesReadOnly });
     await vs.initialize();
     this.valueSetProviders.push(vs);
-    const cm = new PackageConceptMapProvider(contentLoader);
+    const cm = new PackageConceptMapProvider(contentLoader, { readOnly: this.packageCachesReadOnly });
     await cm.initialize();
     this.conceptMapProviders.push(cm);
 
@@ -1000,10 +1296,12 @@ class Library {
 
       const firstPath = path.join(this.cacheFolder, firstName);
       if (await this.fileExists(firstPath)) {
+        this.#usedCacheFiles.add(path.basename(firstPath));
         return firstPath;
       }
     }
     const filePath = path.join(this.cacheFolder, fileName);
+    this.#usedCacheFiles.add(path.basename(filePath));
 
     // Check if file already exists
     if (await this.fileExists(filePath)) {
@@ -1118,7 +1416,7 @@ class Library {
     const provider = new Provider();
     provider.i18n = this.i18n;
     provider.codeSystemFactories = new Map(this.codeSystemFactories); // all of them
-    provider.codeSystems = new Map();
+    provider.codeSystems = new CodeSystemMap();
     provider.valueSetProviders = [];
     provider.conceptMapProviders = [];
     provider.path = path;
@@ -1142,7 +1440,8 @@ class Library {
 
     // Load FHIR packages - these will be added to valueSetProviders first
     for (const packageId of fhirPackages) {
-      const contentLoader = await provider.loadNpm(this.packageManager, this.cacheFolder, packageId, false, "npm", false);
+      const contentLoader = await provider.loadNpm(this.packageManager, this.cacheFolder, packageId, false, "npm",
+        { readOnly: this.packageCachesReadOnly });
       // the core packages are the only version specific content in the syndication store
       this.syndicatePackage(contentLoader, { fhirVersion: VersionUtilities.getMajMin(String(fhirVersion)) });
     }

package/tx/openapi-operations.js

@@ -183,13 +183,15 @@ const OPERATIONS = [
     methods: ['post'],
     summary: 'Validate many codes against code systems',
     description: 'A batch of CodeSystem $validate-code requests: each `validation` is a ' +
-      'Parameters resource with the parameters of one. system, codeSystem, tx-resource and ' +
-      'lenient-display-validation at the top level apply to every validation that doesn\'t ' +
-      'have its own.',
+      'Parameters resource with the parameters of one. url (the code system), version, system, ' +
+      'codeSystem, tx-resource and lenient-display-validation at the top level apply to every ' +
+      'validation that doesn\'t have its own. Every validation is against a code system.',
     postBody: ['Parameters'],
     in: [
       p('validation', 'Parameters', '*', 'The parameters of one $validate-code', { min: 1 }),
-      p('system', 'uri', '1', 'The code system, for every validation'),
+      p('url', 'uri', '1', 'The code system, for every validation'),
+      p('version', 'string', '1', 'The code system version, for every validation'),
+      p('system', 'uri', '1', 'The code system, if url isn\'t given, for every validation'),
       p('codeSystem', 'CodeSystem', '1', 'The code system, for every validation'),
       p('lenient-display-validation', 'boolean', '1', 'For every validation'),
       p('tx-resource', 'Resource', '*', 'Resources for every validation')