@nsshunt/stsfhirpg 1.2.28 → 1.2.30

package/dist/index.mjs

@@ -13,7 +13,7 @@ import cluster from "cluster";
 import { Pool } from "pg";
 import { TinyEmitter } from "tiny-emitter";
 //#region \0rolldown/runtime.js
-var __commonJSMin = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __commonJSMin = (cb, mod) => () => (mod || (cb((mod = { exports: {} }).exports, mod), cb = null), mod.exports);
 //#endregion
 //#region src/fhir-utils/fhirDateUtils.ts
 var FHIRDateUtils = class {
@@ -3245,7 +3245,8 @@ var HashUtils = class HashUtils {
 		return input.trim().replace(/\s+/g, " ").toLowerCase();
 	};
 	InitHash = async () => {
-		this.h64 = (await e()).h64;
+		const api = await e();
+		this.h64 = api.h64;
 	};
 	xxhash64Signed(input) {
 		if (this.h64) return BigInt.asIntN(64, this.h64(input, this.HASH_SEED));
@@ -4786,19 +4787,46 @@ var PGPoolManager = class extends TinyEmitter {
 	}
 };
 //#endregion
+//#region src/fhir-database/pg/pgfhirdbbase.ts
+var DBSTSFhirDBBase = class {
+	_options;
+	_poolManager;
+	constructor(options) {
+		this._options = options;
+		this._poolManager = options.poolManager;
+	}
+	async withClient(fname, fn) {
+		let client;
+		try {
+			client = await this._poolManager.connectReadWrite();
+		} catch (error) {
+			this._options.logger.error(`${fname}(): DB: Connection Error: [${error}]`);
+			throw error;
+		}
+		try {
+			return await fn(client);
+		} catch (error) {
+			this._options.logger.error(`${fname}(): DB: Query Error: [${error}]`);
+			throw error;
+		} finally {
+			client.release();
+		}
+	}
+};
+//#endregion
 //#region src/fhir-database/pg/pgfhirresource.ts
-var DBSTSResource = class {
-	#poolManager;
-	constructor(poolManager) {
-		this.#poolManager = poolManager;
+var DBSTSResource = class extends DBSTSFhirDBBase {
+	constructor(options) {
+		super(options);
 	}
 	async InsertResourceEx(client, data) {
 		try {
-			await client.query(`
+			return (await client.query(`
                 INSERT INTO stsresfhir (
                     PID, PARTITION_ID, PARTITION_DATE, RES_ID, RES_TYPE,
                     RES_VER, RES_VERSION, RES_PUBLISHED, RES_UPDATED
                 ) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9)
+                RETURNING RES_VER
                 `, [
 				data.PID,
 				data.PARTITION_ID,
@@ -4809,146 +4837,90 @@ var DBSTSResource = class {
 				data.RES_VERSION,
 				BigInt(data.RES_PUBLISHED),
 				BigInt(data.RES_UPDATED)
-			]);
+			])).rows[0]?.res_ver;
 		} catch (error) {
-			defaultLogger.error(`DBSTSResource:InsertResource(): Query Error: [${error}]`);
+			this._options.logger.error(`DBSTSResource:InsertResource(): Query Error: [${error}]`);
 			throw error;
 		}
 	}
 	async InsertResource(data) {
-		try {
-			const client = await this.#poolManager.connectReadWrite();
-			try {
-				await this.InsertResourceEx(client, data);
-			} catch (error) {
-				defaultLogger.error(`DBSTSResource:InsertResource(): Query Error: [${error}]`);
-			} finally {
-				client.release();
-			}
-		} catch (error) {
-			defaultLogger.error(`DBSTSResource:InsertResource(): Connection Error: [${error}]`);
-		}
+		return this.withClient("InsertResource", ((client) => this.InsertResourceEx(client, data)));
 	}
 	async UpdateResourceRecordEx(client, data) {
 		try {
-			const res = await client.query(`
+			return (await client.query(`
                 UPDATE stsresfhir SET
                     RES_VER = RES_VER + 1,
                     RES_UPDATED = $1,
                     RES_DELETED_AT = NULL
                 WHERE RES_ID = $2 AND RES_TYPE = $3 AND RES_VER = $4
+                RETURNING RES_VER
                 `, [
 				BigInt(data.RES_UPDATED),
 				data.RES_ID,
 				data.RES_TYPE,
 				data.RES_VER
-			]);
-			return res.rowCount ? res.rowCount > 0 : false;
+			])).rows[0]?.res_ver;
 		} catch (error) {
-			defaultLogger.error(`DBSTSResource:UpdateResourceRecordEx(): Query Error: [${error}]`);
+			this._options.logger.error(`DBSTSResource:UpdateResourceRecordEx(): Query Error: [${error}]`);
 			throw error;
 		}
 	}
 	async UpdateResourceRecord(data) {
-		try {
-			const client = await this.#poolManager.connectReadWrite();
-			try {
-				return await this.UpdateResourceRecordEx(client, data);
-			} catch (error) {
-				defaultLogger.error(`DBSTSResource:UpdateResourceRecord-1(): Query Error: [${error}]`);
-			} finally {
-				client.release();
-			}
-		} catch (error) {
-			defaultLogger.error(`DBSTSResource:UpdateResourceRecord-2(): Connection Error: [${error}]`);
-		}
+		return this.withClient("UpdateResourceRecord", ((client) => this.UpdateResourceRecordEx(client, data)));
 	}
 	async DeleteResourceRecordEx(client, data) {
 		try {
-			const res = await client.query(`
+			return (await client.query(`
                 UPDATE stsresfhir SET
                     RES_DELETED_AT = $1,
                     RES_VER = RES_VER + 1,
                     RES_UPDATED = $2
                 WHERE RES_ID = $3 AND RES_TYPE = $4 AND RES_VER = $5
+                RETURNING RES_VER
                 `, [
 				BigInt(data.RES_DELETED_AT),
 				BigInt(data.RES_UPDATED),
 				data.RES_ID,
 				data.RES_TYPE,
 				data.RES_VER
-			]);
-			return res.rowCount ? res.rowCount > 0 : false;
+			])).rows[0]?.res_ver;
 		} catch (error) {
-			defaultLogger.error(`DBSTSResource:DeleteResourceRecord(): Query Error: [${error}]`);
+			this._options.logger.error(`DBSTSResource:DeleteResourceRecord(): Query Error: [${error}]`);
 			throw error;
 		}
 	}
 	async DeleteResourceRecord(data) {
-		try {
-			const client = await this.#poolManager.connectReadWrite();
-			try {
-				return await this.DeleteResourceRecordEx(client, data);
-			} catch (error) {
-				defaultLogger.error(`DBSTSResource:DeleteResourceRecord(): Query Error: [${error}]`);
-			} finally {
-				client.release();
-			}
-		} catch (error) {
-			defaultLogger.error(`DBSTSResource:DeleteResourceRecord(): Connection Error: [${error}]`);
-		}
+		return this.withClient("DeleteResourceRecord", ((client) => this.DeleteResourceRecordEx(client, data)));
 	}
 	async ReadResourceRecordEx(client, PID) {
 		try {
 			return (await client.query(`SELECT * FROM stsresfhir WHERE PID = $1`, [PID])).rows[0];
 		} catch (error) {
-			defaultLogger.error(`DBSTSResource:ReadResourceRecord(): Query Error: [${error}]`);
+			this._options.logger.error(`DBSTSResource:ReadResourceRecord(): Query Error: [${error}]`);
 			throw error;
 		}
 	}
 	async ReadResourceRecord(PID) {
-		try {
-			const client = await this.#poolManager.connectReadOnly();
-			try {
-				return await this.ReadResourceRecordEx(client, PID);
-			} catch (error) {
-				defaultLogger.error(`DBSTSResource:ReadResourceRecord(): Query Error: [${error}]`);
-			} finally {
-				client.release();
-			}
-		} catch (error) {
-			defaultLogger.error(`DBSTSResource:ReadResourceRecord(): Connection Error: [${error}]`);
-		}
+		return this.withClient("ReadResourceRecord", ((client) => this.ReadResourceRecordEx(client, PID)));
 	}
 	async ReadAllResourceRecordsEx(client) {
 		try {
 			return (await client.query(`SELECT * FROM stsresfhir`)).rows;
 		} catch (error) {
-			defaultLogger.error(`DBSTSResource:ReadAllResourceRecords(): Query Error: [${error}]`);
+			this._options.logger.error(`DBSTSResource:ReadAllResourceRecords(): Query Error: [${error}]`);
 			throw error;
 		}
 	}
 	async ReadAllResourceRecords() {
-		try {
-			const client = await this.#poolManager.connectReadOnly();
-			try {
-				return await this.ReadAllResourceRecordsEx(client);
-			} catch (error) {
-				defaultLogger.error(`DBSTSResource:ReadAllResourceRecords(): Query Error: [${error}]`);
-			} finally {
-				client.release();
-			}
-		} catch (error) {
-			defaultLogger.error(`DBSTSResource:ReadAllResourceRecords(): Connection Error: [${error}]`);
-		}
+		return this.withClient("ReadAllResourceRecords", ((client) => this.ReadAllResourceRecordsEx(client)));
 	}
 };
 //#endregion
 //#region src/fhir-database/pg/pgfhirresourceversion.ts
-var DBSTSResourceVersion = class {
-	#poolManager;
-	constructor(poolManager) {
-		this.#poolManager = poolManager;
+var DBSTSResourceVersion = class extends DBSTSFhirDBBase {
+	constructor(options) {
+		super(options);
 	}
 	async InsertResourceVersionEx(client, data) {
 		const values = [
@@ -4962,86 +4934,67 @@ var DBSTSResourceVersion = class {
 			data.RES
 		];
 		try {
-			await client.query(`
+			return (await client.query(`
                 INSERT INTO stsresfhirver (
                     PID, PARTITION_ID, PARTITION_DATE,
                     RES_ID, RES_TYPE, RES_VER, OPERATION, RES
                 ) VALUES ($1, $2, $3, $4, $5, $6, $7, $8)
-                `, values);
+                RETURNING RES_VER
+                `, values)).rows[0]?.res_ver;
 		} catch (error) {
-			defaultLogger.error(`DBSTSResourceVersion:InsertResourceVersion(): Query Error: [${error}]`);
-			defaultLogger.error(`DBSTSResourceVersion:InsertResourceVersion(): --> Values PID: [${values[0]}]`);
-			defaultLogger.error(`DBSTSResourceVersion:InsertResourceVersion(): --> Values PARTITION_ID: [${values[1]}]`);
-			defaultLogger.error(`DBSTSResourceVersion:InsertResourceVersion(): --> Values PARTITION_DATE: [${values[2]}]`);
-			defaultLogger.error(`DBSTSResourceVersion:InsertResourceVersion(): --> Values RES_ID: [${values[3]}]`);
-			defaultLogger.error(`DBSTSResourceVersion:InsertResourceVersion(): --> Values RES_TYPE: [${values[4]}]`);
-			defaultLogger.error(`DBSTSResourceVersion:InsertResourceVersion(): --> Values RES_VER: [${values[5]}]`);
-			defaultLogger.error(`DBSTSResourceVersion:InsertResourceVersion(): --> Values OPERATION: [${values[6]}]`);
+			this._options.logger.error(`DBSTSResourceVersion:InsertResourceVersion(): Query Error: [${error}]`);
+			this._options.logger.error(`DBSTSResourceVersion:InsertResourceVersion(): --> Values PID: [${values[0]}]`);
+			this._options.logger.error(`DBSTSResourceVersion:InsertResourceVersion(): --> Values PARTITION_ID: [${values[1]}]`);
+			this._options.logger.error(`DBSTSResourceVersion:InsertResourceVersion(): --> Values PARTITION_DATE: [${values[2]}]`);
+			this._options.logger.error(`DBSTSResourceVersion:InsertResourceVersion(): --> Values RES_ID: [${values[3]}]`);
+			this._options.logger.error(`DBSTSResourceVersion:InsertResourceVersion(): --> Values RES_TYPE: [${values[4]}]`);
+			this._options.logger.error(`DBSTSResourceVersion:InsertResourceVersion(): --> Values RES_VER: [${values[5]}]`);
+			this._options.logger.error(`DBSTSResourceVersion:InsertResourceVersion(): --> Values OPERATION: [${values[6]}]`);
 			throw error;
 		}
 	}
 	async InsertResourceVersion(data) {
-		try {
-			const client = await this.#poolManager.connectReadWrite();
-			try {
-				await this.InsertResourceVersionEx(client, data);
-			} catch (error) {
-				defaultLogger.error(`DBSTSResourceVersion:InsertResourceVersion(): Query Error: [${error}]`);
-			} finally {
-				client.release();
-			}
-		} catch (error) {
-			defaultLogger.error(`DBSTSResourceVersion:InsertResourceVersion(): Connection Error: [${error}]`);
-		}
+		return this.withClient("InsertResourceVersion", ((client) => this.InsertResourceVersionEx(client, data)));
 	}
 	async ReadResourceVersionRecordEx(client, PID, RES_VER) {
 		try {
 			return (await client.query(`SELECT * FROM stsresfhirver WHERE PID = $1 AND RES_VER = $2`, [PID, RES_VER])).rows[0];
 		} catch (error) {
-			defaultLogger.error(`DBSTSResourceVersion:ReadResourceVersionRecord(): Query Error: [${error}]`);
+			this._options.logger.error(`DBSTSResourceVersion:ReadResourceVersionRecord(): Query Error: [${error}]`);
 			throw error;
 		}
 	}
 	async ReadResourceVersionRecord(PID, RES_VER) {
-		try {
-			const client = await this.#poolManager.connectReadWrite();
-			try {
-				return await this.ReadResourceVersionRecordEx(client, PID, RES_VER);
-			} catch (error) {
-				defaultLogger.error(`DBSTSResourceVersion:ReadResourceVersionRecord(): Query Error: [${error}]`);
-			} finally {
-				client.release();
-			}
-		} catch (error) {
-			defaultLogger.error(`DBSTSResourceVersion:ReadResourceVersionRecord(): Connection Error: [${error}]`);
-		}
+		return this.withClient("ReadResourceVersionRecord", ((client) => this.ReadResourceVersionRecordEx(client, PID, RES_VER)));
 	}
 	async ReadAllResourceVersionRecordsEx(client) {
 		try {
 			return (await client.query(`SELECT * FROM stsresfhirver`)).rows;
 		} catch (error) {
-			defaultLogger.error(`DBSTSResourceVersion:ReadAllResourceVersionRecords(): Query Error: [${error}]`);
+			this._options.logger.error(`DBSTSResourceVersion:ReadAllResourceVersionRecords(): Query Error: [${error}]`);
 			throw error;
 		}
 	}
 	async ReadAllResourceVersionRecords() {
-		try {
-			const client = await this.#poolManager.connectReadWrite();
-			try {
-				return await this.ReadAllResourceVersionRecordsEx(client);
-			} catch (error) {
-				defaultLogger.error(`DBSTSResourceVersion:ReadAllResourceVersionRecords(): Query Error: [${error}]`);
-			} finally {
-				client.release();
-			}
-		} catch (error) {
-			defaultLogger.error(`DBSTSResourceVersion:ReadAllResourceVersionRecords(): Connection Error: [${error}]`);
-		}
+		return this.withClient("ReadAllResourceVersionRecords", ((client) => this.ReadAllResourceVersionRecordsEx(client)));
 	}
 };
 //#endregion
+//#region src/fhir-database/pg/pgfhirdbparamtypebase.ts
+var DBSTSFhirDBParamTypeBase = class {
+	_options;
+	constructor(options) {
+		this._options = options;
+	}
+	replacer = (_, v) => typeof v === "bigint" ? { __bigint__: v.toString() } : v;
+	reviver = (_, v) => v && v.__bigint__ !== void 0 ? BigInt(v.__bigint__) : v;
+};
+//#endregion
 //#region src/fhir-database/pg/pgfhirresourcelink.ts
-var DBSTSResourceLink = class {
+var DBSTSResourceLink = class extends DBSTSFhirDBParamTypeBase {
+	constructor(options) {
+		super(options);
+	}
 	async InsertResourceLink(client, data) {
 		try {
 			await client.query(`
@@ -5089,327 +5042,852 @@ var DBSTSResourceLink = class {
 				data.COMPOSITE_HASH_EXACT ? BigInt(data.COMPOSITE_HASH_EXACT) : null
 			]);
 		} catch (error) {
-			defaultLogger.error(`DBSTSResourceLink:InsertResourceLink(): Query Error: [${error}]`);
-			throw error;
+			const message = `DBSTSResourceLink:InsertResourceLink(): Query Error: [${error}]`;
+			this._options.logger.error(message);
+			throw new Error(message);
 		}
 	}
 	async ReadResourceLinkByResourceIdRecord(client, RES_ID, RES_TYPE) {
 		try {
 			return (await client.query(`SELECT * FROM stsresfhirlink WHERE RES_ID = $1 AND RES_TYPE = $2`, [RES_ID, RES_TYPE])).rows;
 		} catch (error) {
-			defaultLogger.error(`DBSTSResourceLink:ReadResourceLinkByResourceIdRecord(): Query Error: [${error}]`);
-			throw error;
+			const message = `DBSTSResourceLink:ReadResourceLinkByResourceIdRecord(): Query Error: [${error}]`;
+			this._options.logger.error(message);
+			throw new Error(message);
 		}
 	}
 	async ReadResourceLinkByPIDRecord(client, PID) {
 		try {
 			return (await client.query(`SELECT * FROM stsresfhirlink WHERE PID = $1 LIMIT 1`, [PID])).rows[0];
 		} catch (error) {
-			defaultLogger.error(`DBSTSResourceLink:ReadResourceLinkByPIDRecord(): Query Error: [${error}]`);
-			throw error;
+			const message = `DBSTSResourceLink:ReadResourceLinkByPIDRecord(): Query Error: [${error}]`;
+			this._options.logger.error(message);
+			throw new Error(message);
 		}
 	}
 	async ReadAllResourceLinkRecords(client) {
 		try {
 			return (await client.query(`SELECT * FROM stsresfhirlink`)).rows;
 		} catch (error) {
-			defaultLogger.error(`DBSTSResourceLink:ReadAllResourceLinkRecords(): Query Error: [${error}]`);
-			throw error;
+			const message = `DBSTSResourceLink:ReadAllResourceLinkRecords(): Query Error: [${error}]`;
+			this._options.logger.error(message);
+			throw new Error(message);
 		}
 	}
 	async DeleteResourceLinkRecord(client, data) {
 		try {
 			await client.query(`DELETE FROM stsresfhirlink WHERE RES_ID = $1 AND RES_TYPE = $2`, [data.RES_ID, data.RES_TYPE]);
 		} catch (error) {
-			defaultLogger.error(`DBSTSResourceLink:DeleteResourceLinkRecord(): Query Error: [${error}]`);
-			throw error;
+			const message = `DBSTSResourceLink:DeleteResourceLinkRecord(): Query Error: [${error}]`;
+			this._options.logger.error(message);
+			throw new Error(message);
 		}
 	}
 };
 //#endregion
 //#region src/fhir-database/pg/pgfhirstring.ts
-var DBSTSString = class {
+var DBSTSString = class extends DBSTSFhirDBParamTypeBase {
+	constructor(options) {
+		super(options);
+	}
+	async InsertRecord(client, data) {
+		try {
+			await client.query(`
+                INSERT INTO stsresfhirstring (
+                    PID, 
+                    PARTITION_ID, 
+                    PARTITION_DATE,
+                    SP_NAME, 
+                    SP_PARAM_TYPE, 
+                    RES_ID, 
+                    RES_TYPE,
+                    SP_MISSING, 
+                    SP_STR, 
+                    HASH_IDENTITY, 
+                    HASH_EXACT,
+                    SP_VALUE_NORMALIZED, 
+                    SP_VALUE_EXACT, 
+                    UPDATED,
+                    PATH_FOR_COMP,
+                    COMPOSITE,
+                    COMPOSITE_HASH_EXACT
+                ) VALUES (
+                    $1, $2, $3,
+                    $4, $5, $6, $7,
+                    $8, $9, $10,
+                    $11, $12, $13, $14,
+                    $15, $16, $17
+                )
+                `, [
+				data.PID,
+				data.PARTITION_ID,
+				data.PARTITION_DATE,
+				data.SP_NAME ?? null,
+				data.SP_PARAM_TYPE,
+				data.RES_ID,
+				data.RES_TYPE ?? null,
+				data.SP_MISSING,
+				data.SP_STR,
+				data.HASH_IDENTITY,
+				data.HASH_EXACT,
+				data.SP_VALUE_NORMALIZED,
+				data.SP_VALUE_EXACT,
+				data.UPDATED,
+				data.PATH_FOR_COMP,
+				data.COMPOSITE,
+				data.COMPOSITE_HASH_EXACT ? BigInt(data.COMPOSITE_HASH_EXACT) : null
+			]);
+		} catch (error) {
+			const message = `DBSTSString:InsertRecord(): Error: [${error}]`;
+			this._options.logger.error(message);
+			throw new Error(message);
+		}
+	}
+	async ReadByPIDRecord(client, PID) {
+		try {
+			return (await client.query(`SELECT * FROM stsresfhirstring WHERE PID = $1 LIMIT 1`, [PID])).rows[0];
+		} catch (error) {
+			const message = `DBSTSString:ReadByPIDRecord(): Error: [${error}]`;
+			this._options.logger.error(message);
+			throw new Error(message);
+		}
+	}
+	async ReadAllRecords(client) {
+		try {
+			return (await client.query(`SELECT * FROM stsresfhirstring`)).rows;
+		} catch (error) {
+			const message = `DBSTSString:ReadAllRecords(): Error: [${error}]`;
+			this._options.logger.error(message);
+			throw new Error(message);
+		}
+	}
+	#FilterResults(data, results) {
+		try {
+			return results.filter((r) => r.SP_NAME === data.SP_NAME && r.RES_TYPE === data.RES_TYPE);
+		} catch (error) {
+			const message = `DBSTSString:#FilterResults(): Error: [${error}]`;
+			this._options.logger.error(message);
+			throw new Error(message);
+		}
+	}
+	async ReadByValueNormalized(client, searchString, parameterName, resourceName) {
+		try {
+			const hash = hashStringParam(`${parameterName}|${resourceName}`, true);
+			const norm = normalizeStringParam(searchString);
+			const res = await client.query(`SELECT * FROM stsresfhirstring WHERE HASH_IDENTITY = $1 AND SP_VALUE_NORMALIZED LIKE $2`, [hash, norm]);
+			return this.#FilterResults({
+				SP_NAME: parameterName,
+				RES_TYPE: resourceName
+			}, res.rows);
+		} catch (error) {
+			const message = `DBSTSString:ReadByValueNormalized(): Error: [${error}]`;
+			this._options.logger.error(message);
+			throw new Error(message);
+		}
+	}
+	async ReadByValueExact(client, data) {
+		try {
+			const res = await client.query(`SELECT * FROM stsresfhirstring WHERE HASH_EXACT = $1`, [BigInt(data.HASH_EXACT)]);
+			return this.#FilterResults(data, res.rows);
+		} catch (error) {
+			const message = `DBSTSString:ReadByValueExact(): Error: [${error}]`;
+			this._options.logger.error(message);
+			throw new Error(message);
+		}
+	}
+	async ReadByResID(client, RES_ID, RES_TYPE) {
+		try {
+			return (await client.query(`SELECT * FROM stsresfhirstring WHERE RES_ID = $1 AND RES_TYPE = $2`, [RES_ID, RES_TYPE])).rows;
+		} catch (error) {
+			const message = `DBSTSString:ReadByResID(): Error: [${error}]`;
+			this._options.logger.error(message);
+			throw new Error(message);
+		}
+	}
+	async DeleteRecord(client, data) {
+		try {
+			await client.query(`DELETE FROM stsresfhirstring WHERE RES_ID = $1 AND RES_TYPE = $2`, [data.RES_ID, data.RES_TYPE]);
+		} catch (error) {
+			const message = `DBSTSString:DeleteRecord(): Error: [${error}]`;
+			this._options.logger.error(message);
+			throw new Error(message);
+		}
+	}
+};
+//#endregion
+//#region src/fhir-database/pg/pgfhirtoken.ts
+var DBSTSToken = class extends DBSTSFhirDBParamTypeBase {
+	constructor(options) {
+		super(options);
+	}
 	async InsertRecord(client, data) {
-		await client.query(`
-            INSERT INTO stsresfhirstring (
+		try {
+			const text = `
+            INSERT INTO stsresfhirtoken (
                 PID, 
                 PARTITION_ID, 
-                PARTITION_DATE,
+                PARTITION_DATE, 
                 SP_NAME, 
                 SP_PARAM_TYPE, 
-                RES_ID, 
-                RES_TYPE,
-                SP_MISSING, 
                 SP_STR, 
+                RES_ID,
+                RES_TYPE, 
+                UPDATED, 
+                SP_MISSING, 
                 HASH_IDENTITY, 
-                HASH_EXACT,
-                SP_VALUE_NORMALIZED, 
-                SP_VALUE_EXACT, 
-                UPDATED,
+                SP_SYSTEM, 
+                SP_TOKEN_TYPE, 
+                SP_VALUE,
+                HASH_VALUE, 
+                HASH_SYS, 
+                HASH_SYS_AND_VALUE,
                 PATH_FOR_COMP,
                 COMPOSITE,
                 COMPOSITE_HASH_EXACT
             ) VALUES (
-                $1, $2, $3,
-                $4, $5, $6, $7,
-                $8, $9, $10,
-                $11, $12, $13, $14,
-                $15, $16, $17
-            )
-            `, [
-			data.PID,
-			data.PARTITION_ID,
-			data.PARTITION_DATE,
-			data.SP_NAME ?? null,
-			data.SP_PARAM_TYPE,
-			data.RES_ID,
-			data.RES_TYPE ?? null,
-			data.SP_MISSING,
-			data.SP_STR,
-			data.HASH_IDENTITY,
-			data.HASH_EXACT,
-			data.SP_VALUE_NORMALIZED,
-			data.SP_VALUE_EXACT,
-			data.UPDATED,
-			data.PATH_FOR_COMP,
-			data.COMPOSITE,
-			data.COMPOSITE_HASH_EXACT ? BigInt(data.COMPOSITE_HASH_EXACT) : null
-		]);
+                $1, $2, $3, $4, $5, $6,
+                $7, $8, $9, $10, $11, $12,
+                $13, $14, $15, $16, $17,
+                $18, $19, $20
+            )`;
+			const values = [
+				data.PID,
+				data.PARTITION_ID ?? 0,
+				data.PARTITION_DATE ?? 0,
+				data.SP_NAME,
+				data.SP_PARAM_TYPE,
+				data.SP_STR,
+				data.RES_ID,
+				data.RES_TYPE,
+				BigInt(data.UPDATED),
+				data.SP_MISSING,
+				BigInt(data.HASH_IDENTITY),
+				data.SP_SYSTEM,
+				data.SP_TOKEN_TYPE,
+				data.SP_VALUE,
+				data.HASH_VALUE,
+				data.HASH_SYS,
+				data.HASH_SYS_AND_VALUE,
+				data.PATH_FOR_COMP,
+				data.COMPOSITE,
+				data.COMPOSITE_HASH_EXACT ? BigInt(data.COMPOSITE_HASH_EXACT) : null
+			];
+			await client.query(text, values);
+		} catch (error) {
+			const message = `DBSTSToken:InsertRecord(): Error: [${error}]`;
+			this._options.logger.error(message);
+			throw new Error(message);
+		}
+	}
+	async DeleteRecord(client, data) {
+		try {
+			await client.query(`DELETE FROM stsresfhirtoken WHERE RES_ID = $1 AND RES_TYPE = $2`, [data.RES_ID, data.RES_TYPE]);
+		} catch (error) {
+			const message = `DBSTSToken:DeleteRecord(): Error: [${error}]`;
+			this._options.logger.error(message);
+			throw new Error(message);
+		}
 	}
 	async ReadByPIDRecord(client, PID) {
-		return (await client.query(`SELECT * FROM stsresfhirstring WHERE PID = $1 LIMIT 1`, [PID])).rows[0];
+		try {
+			return (await client.query(`SELECT * FROM stsresfhirtoken WHERE PID = $1`, [PID])).rows[0];
+		} catch (error) {
+			const message = `DBSTSToken:ReadByPIDRecord(): Error: [${error}]`;
+			this._options.logger.error(message);
+			throw new Error(message);
+		}
 	}
 	async ReadAllRecords(client) {
-		return (await client.query(`SELECT * FROM stsresfhirstring`)).rows;
+		try {
+			return (await client.query(`SELECT * FROM stsresfhirtoken`)).rows;
+		} catch (error) {
+			const message = `DBSTSToken:ReadAllRecords(): Error: [${error}]`;
+			this._options.logger.error(message);
+			throw new Error(message);
+		}
 	}
-	#FilterResults(data, results) {
-		return results.filter((r) => r.SP_NAME === data.SP_NAME && r.RES_TYPE === data.RES_TYPE);
+	async ReadByIdentity(client, parameterName, resourceName) {
+		try {
+			const hash = hashStringParam(`${parameterName}|${resourceName}`, true);
+			const res = await client.query(`SELECT * FROM stsresfhirtoken WHERE HASH_IDENTITY = $1`, [hash]);
+			return this.#filterResults({
+				SP_NAME: parameterName,
+				RES_TYPE: resourceName
+			}, res.rows);
+		} catch (error) {
+			const message = `DBSTSToken:ReadByIdentity(): Error: [${error}]`;
+			this._options.logger.error(message);
+			throw new Error(message);
+		}
 	}
-	async ReadByValueNormalized(client, searchString, parameterName, resourceName) {
-		const hash = hashStringParam(`${parameterName}|${resourceName}`, true);
-		const norm = normalizeStringParam(searchString);
-		const res = await client.query(`SELECT * FROM stsresfhirstring WHERE HASH_IDENTITY = $1 AND SP_VALUE_NORMALIZED LIKE $2`, [hash, norm]);
-		return this.#FilterResults({
-			SP_NAME: parameterName,
-			RES_TYPE: resourceName
-		}, res.rows);
+	async ReadByValue(client, searchValue, parameterName, resourceName) {
+		try {
+			const hash = hashStringParam(`${parameterName}|${resourceName}|${searchValue}`, true);
+			const res = await client.query(`SELECT * FROM stsresfhirtoken WHERE HASH_VALUE = $1`, [hash]);
+			return this.#filterResults({
+				SP_NAME: parameterName,
+				RES_TYPE: resourceName
+			}, res.rows);
+		} catch (error) {
+			const message = `DBSTSToken:ReadByValue(): Error: [${error}]`;
+			this._options.logger.error(message);
+			throw new Error(message);
+		}
 	}
-	async ReadByValueExact(client, data) {
-		const res = await client.query(`SELECT * FROM stsresfhirstring WHERE HASH_EXACT = $1`, [BigInt(data.HASH_EXACT)]);
-		return this.#FilterResults(data, res.rows);
+	async ReadBySystem(client, searchSystem, parameterName, resourceName) {
+		try {
+			const hash = hashStringParam(`${parameterName}|${resourceName}|${searchSystem}`, true);
+			const res = await client.query(`SELECT * FROM stsresfhirtoken WHERE HASH_SYS = $1`, [hash]);
+			return this.#filterResults({
+				SP_NAME: parameterName,
+				RES_TYPE: resourceName
+			}, res.rows);
+		} catch (error) {
+			const message = `DBSTSToken:ReadBySystem(): Error: [${error}]`;
+			this._options.logger.error(message);
+			throw new Error(message);
+		}
+	}
+	async ReadBySystemAndValue(client, searchSystem, searchValue, parameterName, resourceName) {
+		try {
+			const hash = hashStringParam(`${parameterName}|${resourceName}|${searchSystem}|${searchValue}`, true);
+			const res = await client.query(`SELECT * FROM stsresfhirtoken WHERE HASH_SYS_AND_VALUE = $1`, [hash]);
+			return this.#filterResults({
+				SP_NAME: parameterName,
+				RES_TYPE: resourceName
+			}, res.rows);
+		} catch (error) {
+			const message = `DBSTSToken:ReadBySystemAndValue(): Error: [${error}]`;
+			this._options.logger.error(message);
+			throw new Error(message);
+		}
 	}
 	async ReadByResID(client, RES_ID, RES_TYPE) {
-		return (await client.query(`SELECT * FROM stsresfhirstring WHERE RES_ID = $1 AND RES_TYPE = $2`, [RES_ID, RES_TYPE])).rows;
+		try {
+			return (await client.query(`SELECT * FROM stsresfhirtoken WHERE RES_ID = $1 AND RES_TYPE = $2`, [RES_ID, RES_TYPE])).rows;
+		} catch (error) {
+			const message = `DBSTSToken:ReadByResID(): Error: [${error}]`;
+			this._options.logger.error(message);
+			throw new Error(message);
+		}
 	}
-	async DeleteRecord(client, data) {
-		await client.query(`DELETE FROM stsresfhirstring WHERE RES_ID = $1 AND RES_TYPE = $2`, [data.RES_ID, data.RES_TYPE]);
+	#filterResults(data, results) {
+		try {
+			return results.filter((r) => r.SP_NAME === data.SP_NAME && r.RES_TYPE === data.RES_TYPE);
+		} catch (error) {
+			const message = `DBSTSToken:#filterResults(): Error: [${error}]`;
+			this._options.logger.error(message);
+			throw new Error(message);
+		}
 	}
 };
 //#endregion
-//#region src/fhir-database/pg/pgfhirtoken.ts
-var DBSTSToken = class {
+//#region src/fhir-database/pg/pgfhirquantity.ts
+var DBSTSQuantity = class extends DBSTSFhirDBParamTypeBase {
+	constructor(options) {
+		super(options);
+	}
 	async InsertRecord(client, data) {
-		const text = `
-        INSERT INTO stsresfhirtoken (
-            PID, 
-            PARTITION_ID, 
-            PARTITION_DATE, 
-            SP_NAME, 
-            SP_PARAM_TYPE, 
-            SP_STR, 
-            RES_ID,
-            RES_TYPE, 
-            UPDATED, 
-            SP_MISSING, 
-            HASH_IDENTITY, 
-            SP_SYSTEM, 
-            SP_TOKEN_TYPE, 
-            SP_VALUE,
-            HASH_VALUE, 
-            HASH_SYS, 
-            HASH_SYS_AND_VALUE,
-            PATH_FOR_COMP,
-            COMPOSITE,
-            COMPOSITE_HASH_EXACT
-        ) VALUES (
-            $1, $2, $3, $4, $5, $6,
-            $7, $8, $9, $10, $11, $12,
-            $13, $14, $15, $16, $17,
-            $18, $19, $20
-        )`;
-		const values = [
-			data.PID,
-			data.PARTITION_ID ?? 0,
-			data.PARTITION_DATE ?? 0,
-			data.SP_NAME,
-			data.SP_PARAM_TYPE,
-			data.SP_STR,
-			data.RES_ID,
-			data.RES_TYPE,
-			BigInt(data.UPDATED),
-			data.SP_MISSING,
-			BigInt(data.HASH_IDENTITY),
-			data.SP_SYSTEM,
-			data.SP_TOKEN_TYPE,
-			data.SP_VALUE,
-			data.HASH_VALUE,
-			data.HASH_SYS,
-			data.HASH_SYS_AND_VALUE,
-			data.PATH_FOR_COMP,
-			data.COMPOSITE,
-			data.COMPOSITE_HASH_EXACT ? BigInt(data.COMPOSITE_HASH_EXACT) : null
-		];
-		await client.query(text, values);
+		try {
+			const text = `
+            INSERT INTO stsresfhirquantity (
+                PID, 
+                PARTITION_ID, 
+                PARTITION_DATE, 
+                SP_NAME, 
+                SP_PARAM_TYPE, 
+                SP_STR,
+                RES_ID,
+                RES_TYPE, 
+                UPDATED, 
+                SP_MISSING, 
+                HASH_IDENTITY, 
+                SP_SYSTEM, 
+                SP_VALUE,
+                SP_UNITS, 
+                HASH_IDENTITY_AND_UNITS, 
+                HASH_IDENTITY_SYS_UNITS,
+                PATH_FOR_COMP,
+                COMPOSITE,
+                COMPOSITE_HASH_EXACT
+            ) VALUES (
+                $1, $2, $3, $4, $5, $6,
+                $7, $8, $9, $10, $11, $12,
+                $13, $14, $15, $16,
+                $17, $18, $19
+            )`;
+			const values = [
+				data.PID,
+				data.PARTITION_ID,
+				data.PARTITION_DATE,
+				data.SP_NAME,
+				data.SP_PARAM_TYPE,
+				data.SP_STR,
+				data.RES_ID,
+				data.RES_TYPE,
+				BigInt(data.UPDATED),
+				data.SP_MISSING,
+				BigInt(data.HASH_IDENTITY),
+				data.SP_SYSTEM,
+				data.SP_VALUE,
+				data.SP_UNITS,
+				data.HASH_IDENTITY_AND_UNITS,
+				data.HASH_IDENTITY_SYS_UNITS,
+				data.PATH_FOR_COMP,
+				data.COMPOSITE,
+				data.COMPOSITE_HASH_EXACT ? BigInt(data.COMPOSITE_HASH_EXACT) : null
+			];
+			await client.query(text, values);
+		} catch (error) {
+			const message = `DBSTSQuantity:InsertRecord(): Error: [${error}]`;
+			this._options.logger.error(message);
+			throw new Error(message);
+		}
 	}
 	async DeleteRecord(client, data) {
-		await client.query(`DELETE FROM stsresfhirtoken WHERE RES_ID = $1 AND RES_TYPE = $2`, [data.RES_ID, data.RES_TYPE]);
+		try {
+			await client.query(`DELETE FROM stsresfhirquantity WHERE RES_ID = $1 AND RES_TYPE = $2`, [data.RES_ID, data.RES_TYPE]);
+		} catch (error) {
+			const message = `DBSTSQuantity:DeleteRecord(): Error: [${error}]`;
+			this._options.logger.error(message);
+			throw new Error(message);
+		}
 	}
 	async ReadByPIDRecord(client, PID) {
-		return (await client.query(`SELECT * FROM stsresfhirtoken WHERE PID = $1`, [PID])).rows[0];
+		try {
+			return (await client.query(`SELECT * FROM stsresfhirquantity WHERE PID = $1`, [PID])).rows[0];
+		} catch (error) {
+			const message = `DBSTSQuantity:ReadByPIDRecord(): Error: [${error}]`;
+			this._options.logger.error(message);
+			throw new Error(message);
+		}
 	}
 	async ReadAllRecords(client) {
-		return (await client.query(`SELECT * FROM stsresfhirtoken`)).rows;
+		try {
+			return (await client.query(`SELECT * FROM stsresfhirquantity`)).rows;
+		} catch (error) {
+			const message = `DBSTSQuantity:ReadAllRecords(): Error: [${error}]`;
+			this._options.logger.error(message);
+			throw new Error(message);
+		}
 	}
 	async ReadByIdentity(client, parameterName, resourceName) {
-		const hash = hashStringParam(`${parameterName}|${resourceName}`, true);
-		const res = await client.query(`SELECT * FROM stsresfhirtoken WHERE HASH_IDENTITY = $1`, [hash]);
-		return this.#filterResults({
-			SP_NAME: parameterName,
-			RES_TYPE: resourceName
-		}, res.rows);
+		try {
+			const hash = hashStringParam(`${parameterName}|${resourceName}`, true);
+			const res = await client.query(`SELECT * FROM stsresfhirquantity WHERE HASH_IDENTITY = $1`, [hash]);
+			return this.#filterResults({
+				SP_NAME: parameterName,
+				RES_TYPE: resourceName
+			}, res.rows);
+		} catch (error) {
+			const message = `DBSTSQuantity:ReadByIdentity(): Error: [${error}]`;
+			this._options.logger.error(message);
+			throw new Error(message);
+		}
 	}
-	async ReadByValue(client, searchValue, parameterName, resourceName) {
-		const hash = hashStringParam(`${parameterName}|${resourceName}|${searchValue}`, true);
-		const res = await client.query(`SELECT * FROM stsresfhirtoken WHERE HASH_VALUE = $1`, [hash]);
-		return this.#filterResults({
-			SP_NAME: parameterName,
-			RES_TYPE: resourceName
-		}, res.rows);
+	async ReadByUnits(client, units, searchValue, parameterName, resourceName) {
+		try {
+			const hash = hashStringParam(`${parameterName}|${resourceName}|${units}`, true);
+			const res = await client.query(`SELECT * FROM stsresfhirquantity WHERE HASH_IDENTITY_AND_UNITS = $1 AND SP_VALUE = $2`, [hash, searchValue]);
+			return this.#filterResults({
+				SP_NAME: parameterName,
+				RES_TYPE: resourceName
+			}, res.rows);
+		} catch (error) {
+			const message = `DBSTSQuantity:ReadByUnits(): Error: [${error}]`;
+			this._options.logger.error(message);
+			throw new Error(message);
+		}
 	}
-	async ReadBySystem(client, searchSystem, parameterName, resourceName) {
-		const hash = hashStringParam(`${parameterName}|${resourceName}|${searchSystem}`, true);
-		const res = await client.query(`SELECT * FROM stsresfhirtoken WHERE HASH_SYS = $1`, [hash]);
-		return this.#filterResults({
-			SP_NAME: parameterName,
-			RES_TYPE: resourceName
-		}, res.rows);
+	async ReadBySystemAndUnits(client, searchSystem, units, searchValue, parameterName, resourceName) {
+		try {
+			const hash = hashStringParam(`${parameterName}|${resourceName}|${searchSystem}|${units}`, true);
+			const res = await client.query(`SELECT * FROM stsresfhirquantity WHERE HASH_IDENTITY_SYS_UNITS = $1 AND SP_VALUE = $2`, [hash, searchValue]);
+			return this.#filterResults({
+				SP_NAME: parameterName,
+				RES_TYPE: resourceName
+			}, res.rows);
+		} catch (error) {
+			const message = `DBSTSQuantity:ReadBySystemAndUnits(): Error: [${error}]`;
+			this._options.logger.error(message);
+			throw new Error(message);
+		}
 	}
-	async ReadBySystemAndValue(client, searchSystem, searchValue, parameterName, resourceName) {
-		const hash = hashStringParam(`${parameterName}|${resourceName}|${searchSystem}|${searchValue}`, true);
-		const res = await client.query(`SELECT * FROM stsresfhirtoken WHERE HASH_SYS_AND_VALUE = $1`, [hash]);
-		return this.#filterResults({
-			SP_NAME: parameterName,
-			RES_TYPE: resourceName
-		}, res.rows);
+	async ReadByResID(client, RES_ID, RES_TYPE) {
+		try {
+			return (await client.query(`SELECT * FROM stsresfhirquantity WHERE RES_ID = $1 AND RES_TYPE = $2`, [RES_ID, RES_TYPE])).rows;
+		} catch (error) {
+			const message = `DBSTSQuantity:ReadByResID(): Error: [${error}]`;
+			this._options.logger.error(message);
+			throw new Error(message);
+		}
+	}
+	#filterResults(data, results) {
+		try {
+			return results.filter((r) => r.SP_NAME === data.SP_NAME && r.RES_TYPE === data.RES_TYPE);
+		} catch (error) {
+			const message = `DBSTSQuantity:#filterResults(): Error: [${error}]`;
+			this._options.logger.error(message);
+			throw new Error(message);
+		}
+	}
+};
+//#endregion
+//#region src/fhir-database/pg/pgfhirnumber.ts
+var DBSTSNumber = class extends DBSTSFhirDBParamTypeBase {
+	constructor(options) {
+		super(options);
+	}
+	async InsertRecord(client, data) {
+		try {
+			const text = `
+            INSERT INTO stsresfhirnumber (
+                PID, 
+                PARTITION_ID, 
+                PARTITION_DATE, 
+                SP_NAME, 
+                SP_PARAM_TYPE, 
+                SP_STR,
+                RES_ID,
+                RES_TYPE, 
+                UPDATED, 
+                SP_MISSING, 
+                HASH_IDENTITY, 
+                SP_VALUE,
+                PATH_FOR_COMP,
+                COMPOSITE,
+                COMPOSITE_HASH_EXACT
+            ) VALUES (
+                $1, $2, $3, $4, $5, $6,
+                $7, $8, $9, $10, $11, $12,
+                $13, $14, $15
+            )`;
+			const values = [
+				data.PID,
+				data.PARTITION_ID ?? 0,
+				data.PARTITION_DATE ?? 0,
+				data.SP_NAME,
+				data.SP_PARAM_TYPE,
+				data.SP_STR,
+				data.RES_ID,
+				data.RES_TYPE,
+				BigInt(data.UPDATED),
+				data.SP_MISSING,
+				BigInt(data.HASH_IDENTITY),
+				data.SP_VALUE ?? 0,
+				data.PATH_FOR_COMP,
+				data.COMPOSITE,
+				data.COMPOSITE_HASH_EXACT ? BigInt(data.COMPOSITE_HASH_EXACT) : null
+			];
+			await client.query(text, values);
+		} catch (error) {
+			const message = `DBSTSNumber:InsertRecord(): Error: [${error}]`;
+			this._options.logger.error(message);
+			throw new Error(message);
+		}
+	}
+	async DeleteRecord(client, data) {
+		try {
+			await client.query(`DELETE FROM stsresfhirnumber WHERE RES_ID = $1 AND RES_TYPE = $2`, [data.RES_ID, data.RES_TYPE]);
+		} catch (error) {
+			const message = `DBSTSNumber:DeleteRecord(): Error: [${error}]`;
+			this._options.logger.error(message);
+			throw new Error(message);
+		}
+	}
+	async ReadByPIDRecord(client, PID) {
+		try {
+			return (await client.query(`SELECT * FROM stsresfhirnumber WHERE PID = $1`, [PID])).rows[0];
+		} catch (error) {
+			const message = `DBSTSNumber:ReadByPIDRecord(): Error: [${error}]`;
+			this._options.logger.error(message);
+			throw new Error(message);
+		}
+	}
+	async ReadAllRecords(client) {
+		try {
+			return (await client.query(`SELECT * FROM stsresfhirnumber`)).rows;
+		} catch (error) {
+			const message = `DBSTSNumber:ReadAllRecords(): Error: [${error}]`;
+			this._options.logger.error(message);
+			throw new Error(message);
+		}
+	}
+	async ReadByIdentity(client, parameterName, resourceName) {
+		try {
+			const hash = hashStringParam(`${parameterName}|${resourceName}`, true);
+			const res = await client.query(`SELECT * FROM stsresfhirnumber WHERE HASH_IDENTITY = $1`, [hash]);
+			return this.#filterResults({
+				SP_NAME: parameterName,
+				RES_TYPE: resourceName
+			}, res.rows);
+		} catch (error) {
+			const message = `DBSTSNumber:ReadByIdentity(): Error: [${error}]`;
+			this._options.logger.error(message);
+			throw new Error(message);
+		}
+	}
+	async ReadByValue(client, searchValue, parameterName, resourceName) {
+		try {
+			const hash = hashStringParam(`${parameterName}|${resourceName}`, true);
+			const res = await client.query(`SELECT * FROM stsresfhirnumber WHERE HASH_IDENTITY = $1 AND SP_VALUE = $2`, [hash, searchValue]);
+			return this.#filterResults({
+				SP_NAME: parameterName,
+				RES_TYPE: resourceName
+			}, res.rows);
+		} catch (error) {
+			const message = `DBSTSNumber:ReadByValue(): Error: [${error}]`;
+			this._options.logger.error(message);
+			throw new Error(message);
+		}
 	}
 	async ReadByResID(client, RES_ID, RES_TYPE) {
-		return (await client.query(`SELECT * FROM stsresfhirtoken WHERE RES_ID = $1 AND RES_TYPE = $2`, [RES_ID, RES_TYPE])).rows;
+		try {
+			return (await client.query(`SELECT * FROM stsresfhirnumber WHERE RES_ID = $1 AND RES_TYPE = $2`, [RES_ID, RES_TYPE])).rows;
+		} catch (error) {
+			const message = `DBSTSNumber:ReadByResID(): Error: [${error}]`;
+			this._options.logger.error(message);
+			throw new Error(message);
+		}
 	}
 	#filterResults(data, results) {
-		return results.filter((r) => r.SP_NAME === data.SP_NAME && r.RES_TYPE === data.RES_TYPE);
+		try {
+			return results.filter((r) => r.SP_NAME === data.SP_NAME && r.RES_TYPE === data.RES_TYPE);
+		} catch (error) {
+			const message = `DBSTSNumber:#filterResults(): Error: [${error}]`;
+			this._options.logger.error(message);
+			throw new Error(message);
+		}
 	}
 };
 //#endregion
-//#region src/fhir-database/pg/pgfhirquantity.ts
-var DBSTSQuantity = class {
+//#region src/fhir-database/pg/pgfhirdate.ts
+var DBSTSDate = class extends DBSTSFhirDBParamTypeBase {
+	constructor(options) {
+		super(options);
+	}
 	async InsertRecord(client, data) {
-		const text = `
-        INSERT INTO stsresfhirquantity (
-            PID, 
-            PARTITION_ID, 
-            PARTITION_DATE, 
-            SP_NAME, 
-            SP_PARAM_TYPE, 
-            SP_STR,
-            RES_ID,
-            RES_TYPE, 
-            UPDATED, 
-            SP_MISSING, 
-            HASH_IDENTITY, 
-            SP_SYSTEM, 
-            SP_VALUE,
-            SP_UNITS, 
-            HASH_IDENTITY_AND_UNITS, 
-            HASH_IDENTITY_SYS_UNITS,
-            PATH_FOR_COMP,
-            COMPOSITE,
-            COMPOSITE_HASH_EXACT
-        ) VALUES (
-            $1, $2, $3, $4, $5, $6,
-            $7, $8, $9, $10, $11, $12,
-            $13, $14, $15, $16,
-            $17, $18, $19
-        )`;
-		const values = [
-			data.PID,
-			data.PARTITION_ID,
-			data.PARTITION_DATE,
-			data.SP_NAME,
-			data.SP_PARAM_TYPE,
-			data.SP_STR,
-			data.RES_ID,
-			data.RES_TYPE,
-			BigInt(data.UPDATED),
-			data.SP_MISSING,
-			BigInt(data.HASH_IDENTITY),
-			data.SP_SYSTEM,
-			data.SP_VALUE,
-			data.SP_UNITS,
-			data.HASH_IDENTITY_AND_UNITS,
-			data.HASH_IDENTITY_SYS_UNITS,
-			data.PATH_FOR_COMP,
-			data.COMPOSITE,
-			data.COMPOSITE_HASH_EXACT ? BigInt(data.COMPOSITE_HASH_EXACT) : null
-		];
-		await client.query(text, values);
+		try {
+			const text = `
+            INSERT INTO stsresfhirdate (
+                PID, 
+                PARTITION_ID, 
+                PARTITION_DATE, 
+                SP_NAME, 
+                SP_PARAM_TYPE, 
+                SP_STR,
+                RES_ID,
+                RES_TYPE, 
+                UPDATED, 
+                SP_MISSING, 
+                HASH_IDENTITY, 
+                SP_VALUE_LOW,
+                SP_VALUE_HIGH,
+                SP_VALUE_LOW_DATE_ORDINAL,
+                SP_VALUE_HIGH_DATE_ORDINAL,
+                PATH_FOR_COMP,
+                COMPOSITE,
+                COMPOSITE_HASH_EXACT
+            ) VALUES (
+                $1, $2, $3, $4, $5, $6,
+                $7, $8, $9, $10, $11, $12,
+                $13, $14, $15,
+                $16, $17, $18
+            )`;
+			const values = [
+				data.PID,
+				data.PARTITION_ID ?? 0,
+				data.PARTITION_DATE ?? 0,
+				data.SP_NAME,
+				data.SP_PARAM_TYPE,
+				data.SP_STR,
+				data.RES_ID,
+				data.RES_TYPE,
+				BigInt(data.UPDATED),
+				data.SP_MISSING,
+				BigInt(data.HASH_IDENTITY),
+				data.SP_VALUE_LOW ? data.SP_VALUE_LOW.toJSDate() : null,
+				data.SP_VALUE_HIGH ? data.SP_VALUE_HIGH.toJSDate() : null,
+				data.SP_VALUE_LOW_DATE_ORDINAL,
+				data.SP_VALUE_HIGH_DATE_ORDINAL,
+				data.PATH_FOR_COMP,
+				data.COMPOSITE,
+				data.COMPOSITE_HASH_EXACT ? BigInt(data.COMPOSITE_HASH_EXACT) : null
+			];
+			await client.query(text, values);
+		} catch (error) {
+			const message = `DBSTSDate:InsertRecord(): Error: [${error}]`;
+			this._options.logger.error(message);
+			throw new Error(message);
+		}
 	}
 	async DeleteRecord(client, data) {
-		await client.query(`DELETE FROM stsresfhirquantity WHERE RES_ID = $1 AND RES_TYPE = $2`, [data.RES_ID, data.RES_TYPE]);
+		try {
+			await client.query(`DELETE FROM stsresfhirdate WHERE RES_ID = $1 AND RES_TYPE = $2`, [data.RES_ID, data.RES_TYPE]);
+		} catch (error) {
+			const message = `DBSTSDate:DeleteRecord(): Error: [${error}]`;
+			this._options.logger.error(message);
+			throw new Error(message);
+		}
 	}
 	async ReadByPIDRecord(client, PID) {
-		return (await client.query(`SELECT * FROM stsresfhirquantity WHERE PID = $1`, [PID])).rows[0];
+		try {
+			const res = await client.query(`SELECT * FROM stsresfhirdate WHERE PID = $1`, [PID]);
+			if (res.rows && res.rows.length === 1) {
+				if (res.rows[0].sp_value_high !== null) res.rows[0].sp_value_high = DateTime.fromJSDate(res.rows[0].sp_value_high);
+				if (res.rows[0].sp_value_low !== null) res.rows[0].sp_value_low = DateTime.fromJSDate(res.rows[0].sp_value_low);
+			}
+			return res.rows[0];
+		} catch (error) {
+			const message = `DBSTSDate:ReadByPIDRecord(): Error: [${error}]`;
+			this._options.logger.error(message);
+			throw new Error(message);
+		}
 	}
 	async ReadAllRecords(client) {
-		return (await client.query(`SELECT * FROM stsresfhirquantity`)).rows;
+		try {
+			return (await client.query(`SELECT * FROM stsresfhirdate`)).rows;
+		} catch (error) {
+			const message = `DBSTSDate:ReadAllRecords(): Error: [${error}]`;
+			this._options.logger.error(message);
+			throw new Error(message);
+		}
+	}
+	async ReadByIdentity(client, parameterName, resourceName) {
+		try {
+			const hash = hashStringParam(`${parameterName}|${resourceName}`, true);
+			const res = await client.query(`SELECT * FROM stsresfhirdate WHERE HASH_IDENTITY = $1`, [hash]);
+			return this.#filterResults({
+				SP_NAME: parameterName,
+				RES_TYPE: resourceName
+			}, res.rows);
+		} catch (error) {
+			const message = `DBSTSDate:ReadByIdentity(): Error: [${error}]`;
+			this._options.logger.error(message);
+			throw new Error(message);
+		}
+	}
+	async ReadByDateTime(client, SP_VALUE_LOW, SP_VALUE_HIGH, parameterName, resourceName) {
+		try {
+			const hash = hashStringParam(`${parameterName}|${resourceName}`, true);
+			const res = await client.query(`SELECT * FROM stsresfhirdate WHERE HASH_IDENTITY = $1 AND SP_VALUE_LOW >= $2 AND SP_VALUE_HIGH <= $3`, [
+				hash,
+				SP_VALUE_LOW,
+				SP_VALUE_HIGH
+			]);
+			return this.#filterResults({
+				SP_NAME: parameterName,
+				RES_TYPE: resourceName
+			}, res.rows);
+		} catch (error) {
+			const message = `DBSTSDate:ReadByDateTime(): Error: [${error}]`;
+			this._options.logger.error(message);
+			throw new Error(message);
+		}
+	}
+	async ReadByDateTimeLow(client, SP_VALUE_LOW, parameterName, resourceName) {
+		try {
+			const hash = hashStringParam(`${parameterName}|${resourceName}`, true);
+			const res = await client.query(`SELECT * FROM stsresfhirdate WHERE HASH_IDENTITY = $1 AND SP_VALUE_LOW >= $2`, [hash, SP_VALUE_LOW]);
+			return this.#filterResults({
+				SP_NAME: parameterName,
+				RES_TYPE: resourceName
+			}, res.rows);
+		} catch (error) {
+			const message = `DBSTSDate:ReadByDateTimeLow(): Error: [${error}]`;
+			this._options.logger.error(message);
+			throw new Error(message);
+		}
+	}
+	async ReadByDateTimeHigh(client, SP_VALUE_HIGH, parameterName, resourceName) {
+		try {
+			const hash = hashStringParam(`${parameterName}|${resourceName}`, true);
+			const res = await client.query(`SELECT * FROM stsresfhirdate WHERE HASH_IDENTITY = $1 AND SP_VALUE_HIGH <= $2`, [hash, SP_VALUE_HIGH]);
+			return this.#filterResults({
+				SP_NAME: parameterName,
+				RES_TYPE: resourceName
+			}, res.rows);
+		} catch (error) {
+			const message = `DBSTSDate:ReadByDateTimeHigh(): Error: [${error}]`;
+			this._options.logger.error(message);
+			throw new Error(message);
+		}
 	}
-	async ReadByIdentity(client, parameterName, resourceName) {
-		const hash = hashStringParam(`${parameterName}|${resourceName}`, true);
-		const res = await client.query(`SELECT * FROM stsresfhirquantity WHERE HASH_IDENTITY = $1`, [hash]);
-		return this.#filterResults({
-			SP_NAME: parameterName,
-			RES_TYPE: resourceName
-		}, res.rows);
+	async ReadByDateOrdinal(client, SP_VALUE_LOW_DATE_ORDINAL, SP_VALUE_HIGH_DATE_ORDINAL, parameterName, resourceName) {
+		try {
+			const hash = hashStringParam(`${parameterName}|${resourceName}`, true);
+			const res = await client.query(`SELECT * FROM stsresfhirdate WHERE HASH_IDENTITY = $1 AND SP_VALUE_LOW_DATE_ORDINAL >= $2 AND SP_VALUE_HIGH_DATE_ORDINAL <= $3`, [
+				hash,
+				SP_VALUE_LOW_DATE_ORDINAL,
+				SP_VALUE_HIGH_DATE_ORDINAL
+			]);
+			return this.#filterResults({
+				SP_NAME: parameterName,
+				RES_TYPE: resourceName
+			}, res.rows);
+		} catch (error) {
+			const message = `DBSTSDate:ReadByDateOrdinal(): Error: [${error}]`;
+			this._options.logger.error(message);
+			throw new Error(message);
+		}
 	}
-	async ReadByUnits(client, units, searchValue, parameterName, resourceName) {
-		const hash = hashStringParam(`${parameterName}|${resourceName}|${units}`, true);
-		const res = await client.query(`SELECT * FROM stsresfhirquantity WHERE HASH_IDENTITY_AND_UNITS = $1 AND SP_VALUE = $2`, [hash, searchValue]);
-		return this.#filterResults({
-			SP_NAME: parameterName,
-			RES_TYPE: resourceName
-		}, res.rows);
+	async ReadByDateOrdinalLow(client, SP_VALUE_LOW_DATE_ORDINAL, parameterName, resourceName) {
+		try {
+			const hash = hashStringParam(`${parameterName}|${resourceName}`, true);
+			const res = await client.query(`SELECT * FROM stsresfhirdate WHERE HASH_IDENTITY = $1 AND SP_VALUE_LOW_DATE_ORDINAL >= $2`, [hash, SP_VALUE_LOW_DATE_ORDINAL]);
+			return this.#filterResults({
+				SP_NAME: parameterName,
+				RES_TYPE: resourceName
+			}, res.rows);
+		} catch (error) {
+			const message = `DBSTSDate:ReadByDateOrdinalLow(): Error: [${error}]`;
+			this._options.logger.error(message);
+			throw new Error(message);
+		}
 	}
-	async ReadBySystemAndUnits(client, searchSystem, units, searchValue, parameterName, resourceName) {
-		const hash = hashStringParam(`${parameterName}|${resourceName}|${searchSystem}|${units}`, true);
-		const res = await client.query(`SELECT * FROM stsresfhirquantity WHERE HASH_IDENTITY_SYS_UNITS = $1 AND SP_VALUE = $2`, [hash, searchValue]);
-		return this.#filterResults({
-			SP_NAME: parameterName,
-			RES_TYPE: resourceName
-		}, res.rows);
+	async ReadByDateOrdinalHigh(client, SP_VALUE_HIGH_DATE_ORDINAL, parameterName, resourceName) {
+		try {
+			const hash = hashStringParam(`${parameterName}|${resourceName}`, true);
+			const res = await client.query(`SELECT * FROM stsresfhirdate WHERE HASH_IDENTITY = $1 AND SP_VALUE_HIGH_DATE_ORDINAL <= $2`, [hash, SP_VALUE_HIGH_DATE_ORDINAL]);
+			return this.#filterResults({
+				SP_NAME: parameterName,
+				RES_TYPE: resourceName
+			}, res.rows);
+		} catch (error) {
+			const message = `DBSTSDate:ReadByDateOrdinalHigh(): Error: [${error}]`;
+			this._options.logger.error(message);
+			throw new Error(message);
+		}
 	}
 	async ReadByResID(client, RES_ID, RES_TYPE) {
-		return (await client.query(`SELECT * FROM stsresfhirquantity WHERE RES_ID = $1 AND RES_TYPE = $2`, [RES_ID, RES_TYPE])).rows;
+		try {
+			return (await client.query(`SELECT * FROM stsresfhirdate WHERE RES_ID = $1 AND RES_TYPE = $2`, [RES_ID, RES_TYPE])).rows;
+		} catch (error) {
+			const message = `DBSTSDate:ReadByResID(): Error: [${error}]`;
+			this._options.logger.error(message);
+			throw new Error(message);
+		}
 	}
 	#filterResults(data, results) {
-		return results.filter((r) => r.SP_NAME === data.SP_NAME && r.RES_TYPE === data.RES_TYPE);
+		try {
+			return results.filter((r) => r.SP_NAME === data.SP_NAME && r.RES_TYPE === data.RES_TYPE);
+		} catch (error) {
+			const message = `DBSTSDate:#filterResults(): Error: [${error}]`;
+			this._options.logger.error(message);
+			throw new Error(message);
+		}
 	}
 };
 //#endregion
-//#region src/fhir-database/pg/pgfhirnumber.ts
-var DBSTSNumber = class {
+//#region src/fhir-database/pg/pgfhiruri.ts
+var DBSTSUri = class extends DBSTSFhirDBParamTypeBase {
+	constructor(options) {
+		super(options);
+	}
 	async InsertRecord(client, data) {
 		try {
 			const text = `
-            INSERT INTO stsresfhirnumber (
+            INSERT INTO stsresfhiruri (
                 PID, 
                 PARTITION_ID, 
                 PARTITION_DATE, 
@@ -5421,14 +5899,15 @@ var DBSTSNumber = class {
                 UPDATED, 
                 SP_MISSING, 
                 HASH_IDENTITY, 
-                SP_VALUE,
+                SP_URI, 
+                HASH_URI,
                 PATH_FOR_COMP,
                 COMPOSITE,
                 COMPOSITE_HASH_EXACT
             ) VALUES (
                 $1, $2, $3, $4, $5, $6,
-                $7, $8, $9, $10, $11, $12,
-                $13, $14, $15
+                $7, $8, $9, $10, $11, $12, $13,
+                $14, $15, $16
             )`;
 			const values = [
 				data.PID,
@@ -5442,269 +5921,99 @@ var DBSTSNumber = class {
 				BigInt(data.UPDATED),
 				data.SP_MISSING,
 				BigInt(data.HASH_IDENTITY),
-				data.SP_VALUE ?? 0,
+				data.SP_URI,
+				data.HASH_URI,
 				data.PATH_FOR_COMP,
 				data.COMPOSITE,
 				data.COMPOSITE_HASH_EXACT ? BigInt(data.COMPOSITE_HASH_EXACT) : null
 			];
 			await client.query(text, values);
 		} catch (error) {
-			console.error(error);
+			const message = `DBSTSUri:InsertRecord(): Error: [${error}]`;
+			this._options.logger.error(message);
+			throw new Error(message);
 		}
 	}
 	async DeleteRecord(client, data) {
-		await client.query(`DELETE FROM stsresfhirnumber WHERE RES_ID = $1 AND RES_TYPE = $2`, [data.RES_ID, data.RES_TYPE]);
-	}
-	async ReadByPIDRecord(client, PID) {
-		return (await client.query(`SELECT * FROM stsresfhirnumber WHERE PID = $1`, [PID])).rows[0];
-	}
-	async ReadAllRecords(client) {
-		return (await client.query(`SELECT * FROM stsresfhirnumber`)).rows;
-	}
-	async ReadByIdentity(client, parameterName, resourceName) {
-		const hash = hashStringParam(`${parameterName}|${resourceName}`, true);
-		const res = await client.query(`SELECT * FROM stsresfhirnumber WHERE HASH_IDENTITY = $1`, [hash]);
-		return this.#filterResults({
-			SP_NAME: parameterName,
-			RES_TYPE: resourceName
-		}, res.rows);
-	}
-	async ReadByValue(client, searchValue, parameterName, resourceName) {
-		const hash = hashStringParam(`${parameterName}|${resourceName}`, true);
-		const res = await client.query(`SELECT * FROM stsresfhirnumber WHERE HASH_IDENTITY = $1 AND SP_VALUE = $2`, [hash, searchValue]);
-		return this.#filterResults({
-			SP_NAME: parameterName,
-			RES_TYPE: resourceName
-		}, res.rows);
-	}
-	async ReadByResID(client, RES_ID, RES_TYPE) {
-		return (await client.query(`SELECT * FROM stsresfhirnumber WHERE RES_ID = $1 AND RES_TYPE = $2`, [RES_ID, RES_TYPE])).rows;
-	}
-	#filterResults(data, results) {
-		return results.filter((r) => r.SP_NAME === data.SP_NAME && r.RES_TYPE === data.RES_TYPE);
-	}
-};
-//#endregion
-//#region src/fhir-database/pg/pgfhirdate.ts
-var DBSTSDate = class {
-	async InsertRecord(client, data) {
-		const text = `
-        INSERT INTO stsresfhirdate (
-            PID, 
-            PARTITION_ID, 
-            PARTITION_DATE, 
-            SP_NAME, 
-            SP_PARAM_TYPE, 
-            SP_STR,
-            RES_ID,
-            RES_TYPE, 
-            UPDATED, 
-            SP_MISSING, 
-            HASH_IDENTITY, 
-            SP_VALUE_LOW,
-            SP_VALUE_HIGH,
-            SP_VALUE_LOW_DATE_ORDINAL,
-            SP_VALUE_HIGH_DATE_ORDINAL,
-            PATH_FOR_COMP,
-            COMPOSITE,
-            COMPOSITE_HASH_EXACT
-        ) VALUES (
-            $1, $2, $3, $4, $5, $6,
-            $7, $8, $9, $10, $11, $12,
-            $13, $14, $15,
-            $16, $17, $18
-        )`;
-		const values = [
-			data.PID,
-			data.PARTITION_ID ?? 0,
-			data.PARTITION_DATE ?? 0,
-			data.SP_NAME,
-			data.SP_PARAM_TYPE,
-			data.SP_STR,
-			data.RES_ID,
-			data.RES_TYPE,
-			BigInt(data.UPDATED),
-			data.SP_MISSING,
-			BigInt(data.HASH_IDENTITY),
-			data.SP_VALUE_LOW ? data.SP_VALUE_LOW.toJSDate() : null,
-			data.SP_VALUE_HIGH ? data.SP_VALUE_HIGH.toJSDate() : null,
-			data.SP_VALUE_LOW_DATE_ORDINAL,
-			data.SP_VALUE_HIGH_DATE_ORDINAL,
-			data.PATH_FOR_COMP,
-			data.COMPOSITE,
-			data.COMPOSITE_HASH_EXACT ? BigInt(data.COMPOSITE_HASH_EXACT) : null
-		];
-		await client.query(text, values);
-	}
-	async DeleteRecord(client, data) {
-		await client.query(`DELETE FROM stsresfhirdate WHERE RES_ID = $1 AND RES_TYPE = $2`, [data.RES_ID, data.RES_TYPE]);
-	}
-	async ReadByPIDRecord(client, PID) {
-		const res = await client.query(`SELECT * FROM stsresfhirdate WHERE PID = $1`, [PID]);
-		if (res.rows && res.rows.length === 1) {
-			if (res.rows[0].sp_value_high !== null) res.rows[0].sp_value_high = DateTime.fromJSDate(res.rows[0].sp_value_high);
-			if (res.rows[0].sp_value_low !== null) res.rows[0].sp_value_low = DateTime.fromJSDate(res.rows[0].sp_value_low);
+		try {
+			await client.query(`DELETE FROM stsresfhiruri WHERE RES_ID = $1 AND RES_TYPE = $2`, [data.RES_ID, data.RES_TYPE]);
+		} catch (error) {
+			const message = `DBSTSUri:DeleteRecord(): Error: [${error}]`;
+			this._options.logger.error(message);
+			throw new Error(message);
 		}
-		return res.rows[0];
-	}
-	async ReadAllRecords(client) {
-		return (await client.query(`SELECT * FROM stsresfhirdate`)).rows;
-	}
-	async ReadByIdentity(client, parameterName, resourceName) {
-		const hash = hashStringParam(`${parameterName}|${resourceName}`, true);
-		const res = await client.query(`SELECT * FROM stsresfhirdate WHERE HASH_IDENTITY = $1`, [hash]);
-		return this.#filterResults({
-			SP_NAME: parameterName,
-			RES_TYPE: resourceName
-		}, res.rows);
-	}
-	async ReadByDateTime(client, SP_VALUE_LOW, SP_VALUE_HIGH, parameterName, resourceName) {
-		const hash = hashStringParam(`${parameterName}|${resourceName}`, true);
-		const res = await client.query(`SELECT * FROM stsresfhirdate WHERE HASH_IDENTITY = $1 AND SP_VALUE_LOW >= $2 AND SP_VALUE_HIGH <= $3`, [
-			hash,
-			SP_VALUE_LOW,
-			SP_VALUE_HIGH
-		]);
-		return this.#filterResults({
-			SP_NAME: parameterName,
-			RES_TYPE: resourceName
-		}, res.rows);
-	}
-	async ReadByDateTimeLow(client, SP_VALUE_LOW, parameterName, resourceName) {
-		const hash = hashStringParam(`${parameterName}|${resourceName}`, true);
-		const res = await client.query(`SELECT * FROM stsresfhirdate WHERE HASH_IDENTITY = $1 AND SP_VALUE_LOW >= $2`, [hash, SP_VALUE_LOW]);
-		return this.#filterResults({
-			SP_NAME: parameterName,
-			RES_TYPE: resourceName
-		}, res.rows);
-	}
-	async ReadByDateTimeHigh(client, SP_VALUE_HIGH, parameterName, resourceName) {
-		const hash = hashStringParam(`${parameterName}|${resourceName}`, true);
-		const res = await client.query(`SELECT * FROM stsresfhirdate WHERE HASH_IDENTITY = $1 AND SP_VALUE_HIGH <= $2`, [hash, SP_VALUE_HIGH]);
-		return this.#filterResults({
-			SP_NAME: parameterName,
-			RES_TYPE: resourceName
-		}, res.rows);
-	}
-	async ReadByDateOrdinal(client, SP_VALUE_LOW_DATE_ORDINAL, SP_VALUE_HIGH_DATE_ORDINAL, parameterName, resourceName) {
-		const hash = hashStringParam(`${parameterName}|${resourceName}`, true);
-		const res = await client.query(`SELECT * FROM stsresfhirdate WHERE HASH_IDENTITY = $1 AND SP_VALUE_LOW_DATE_ORDINAL >= $2 AND SP_VALUE_HIGH_DATE_ORDINAL <= $3`, [
-			hash,
-			SP_VALUE_LOW_DATE_ORDINAL,
-			SP_VALUE_HIGH_DATE_ORDINAL
-		]);
-		return this.#filterResults({
-			SP_NAME: parameterName,
-			RES_TYPE: resourceName
-		}, res.rows);
-	}
-	async ReadByDateOrdinalLow(client, SP_VALUE_LOW_DATE_ORDINAL, parameterName, resourceName) {
-		const hash = hashStringParam(`${parameterName}|${resourceName}`, true);
-		const res = await client.query(`SELECT * FROM stsresfhirdate WHERE HASH_IDENTITY = $1 AND SP_VALUE_LOW_DATE_ORDINAL >= $2`, [hash, SP_VALUE_LOW_DATE_ORDINAL]);
-		return this.#filterResults({
-			SP_NAME: parameterName,
-			RES_TYPE: resourceName
-		}, res.rows);
-	}
-	async ReadByDateOrdinalHigh(client, SP_VALUE_HIGH_DATE_ORDINAL, parameterName, resourceName) {
-		const hash = hashStringParam(`${parameterName}|${resourceName}`, true);
-		const res = await client.query(`SELECT * FROM stsresfhirdate WHERE HASH_IDENTITY = $1 AND SP_VALUE_HIGH_DATE_ORDINAL <= $2`, [hash, SP_VALUE_HIGH_DATE_ORDINAL]);
-		return this.#filterResults({
-			SP_NAME: parameterName,
-			RES_TYPE: resourceName
-		}, res.rows);
-	}
-	async ReadByResID(client, RES_ID, RES_TYPE) {
-		return (await client.query(`SELECT * FROM stsresfhirdate WHERE RES_ID = $1 AND RES_TYPE = $2`, [RES_ID, RES_TYPE])).rows;
-	}
-	#filterResults(data, results) {
-		return results.filter((r) => r.SP_NAME === data.SP_NAME && r.RES_TYPE === data.RES_TYPE);
-	}
-};
-//#endregion
-//#region src/fhir-database/pg/pgfhiruri.ts
-var DBSTSUri = class {
-	async InsertRecord(client, data) {
-		const text = `
-        INSERT INTO stsresfhiruri (
-            PID, 
-            PARTITION_ID, 
-            PARTITION_DATE, 
-            SP_NAME, 
-            SP_PARAM_TYPE, 
-            SP_STR,
-            RES_ID,
-            RES_TYPE, 
-            UPDATED, 
-            SP_MISSING, 
-            HASH_IDENTITY, 
-            SP_URI, 
-            HASH_URI,
-            PATH_FOR_COMP,
-            COMPOSITE,
-            COMPOSITE_HASH_EXACT
-        ) VALUES (
-            $1, $2, $3, $4, $5, $6,
-            $7, $8, $9, $10, $11, $12, $13,
-            $14, $15, $16
-        )`;
-		const values = [
-			data.PID,
-			data.PARTITION_ID ?? 0,
-			data.PARTITION_DATE ?? 0,
-			data.SP_NAME,
-			data.SP_PARAM_TYPE,
-			data.SP_STR,
-			data.RES_ID,
-			data.RES_TYPE,
-			BigInt(data.UPDATED),
-			data.SP_MISSING,
-			BigInt(data.HASH_IDENTITY),
-			data.SP_URI,
-			data.HASH_URI,
-			data.PATH_FOR_COMP,
-			data.COMPOSITE,
-			data.COMPOSITE_HASH_EXACT ? BigInt(data.COMPOSITE_HASH_EXACT) : null
-		];
-		await client.query(text, values);
-	}
-	async DeleteRecord(client, data) {
-		await client.query(`DELETE FROM stsresfhiruri WHERE RES_ID = $1 AND RES_TYPE = $2`, [data.RES_ID, data.RES_TYPE]);
 	}
 	async ReadByPIDRecord(client, PID) {
-		return (await client.query(`SELECT * FROM stsresfhiruri WHERE PID = $1`, [PID])).rows[0];
+		try {
+			return (await client.query(`SELECT * FROM stsresfhiruri WHERE PID = $1`, [PID])).rows[0];
+		} catch (error) {
+			const message = `DBSTSUri:ReadByPIDRecord(): Error: [${error}]`;
+			this._options.logger.error(message);
+			throw new Error(message);
+		}
 	}
 	async ReadAllRecords(client) {
-		return (await client.query(`SELECT * FROM stsresfhiruri`)).rows;
+		try {
+			return (await client.query(`SELECT * FROM stsresfhiruri`)).rows;
+		} catch (error) {
+			const message = `DBSTSUri:ReadAllRecords(): Error: [${error}]`;
+			this._options.logger.error(message);
+			throw new Error(message);
+		}
 	}
 	async ReadByIdentity(client, parameterName, resourceName) {
-		const hash = hashStringParam(`${parameterName}|${resourceName}`, true);
-		const res = await client.query(`SELECT * FROM stsresfhiruri WHERE HASH_IDENTITY = $1`, [hash]);
-		return this.#filterResults({
-			SP_NAME: parameterName,
-			RES_TYPE: resourceName
-		}, res.rows);
+		try {
+			const hash = hashStringParam(`${parameterName}|${resourceName}`, true);
+			const res = await client.query(`SELECT * FROM stsresfhiruri WHERE HASH_IDENTITY = $1`, [hash]);
+			return this.#filterResults({
+				SP_NAME: parameterName,
+				RES_TYPE: resourceName
+			}, res.rows);
+		} catch (error) {
+			const message = `DBSTSUri:ReadByIdentity(): Error: [${error}]`;
+			this._options.logger.error(message);
+			throw new Error(message);
+		}
 	}
 	async ReadByURI(client, uri, parameterName, resourceName) {
-		const hash = hashStringParam(`${parameterName}|${resourceName}|${uri}`, true);
-		const res = await client.query(`SELECT * FROM stsresfhiruri WHERE HASH_URI = $1`, [hash]);
-		return this.#filterResults({
-			SP_NAME: parameterName,
-			RES_TYPE: resourceName
-		}, res.rows);
+		try {
+			const hash = hashStringParam(`${parameterName}|${resourceName}|${uri}`, true);
+			const res = await client.query(`SELECT * FROM stsresfhiruri WHERE HASH_URI = $1`, [hash]);
+			return this.#filterResults({
+				SP_NAME: parameterName,
+				RES_TYPE: resourceName
+			}, res.rows);
+		} catch (error) {
+			const message = `DBSTSUri:ReadByURI(): Error: [${error}]`;
+			this._options.logger.error(message);
+			throw new Error(message);
+		}
 	}
 	async ReadByResID(client, RES_ID, RES_TYPE) {
-		return (await client.query(`SELECT * FROM stsresfhiruri WHERE RES_ID = $1 AND RES_TYPE = $2`, [RES_ID, RES_TYPE])).rows;
+		try {
+			return (await client.query(`SELECT * FROM stsresfhiruri WHERE RES_ID = $1 AND RES_TYPE = $2`, [RES_ID, RES_TYPE])).rows;
+		} catch (error) {
+			const message = `DBSTSUri:ReadByResID(): Error: [${error}]`;
+			this._options.logger.error(message);
+			throw new Error(message);
+		}
 	}
 	#filterResults(data, results) {
-		return results.filter((r) => r.SP_NAME === data.SP_NAME && r.RES_TYPE === data.RES_TYPE);
+		try {
+			return results.filter((r) => r.SP_NAME === data.SP_NAME && r.RES_TYPE === data.RES_TYPE);
+		} catch (error) {
+			const message = `DBSTSUri:#filterResults(): Error: [${error}]`;
+			this._options.logger.error(message);
+			throw new Error(message);
+		}
 	}
 };
 //#endregion
 //#region src/fhir-database/pg/pgfhircombo.ts
-var DBSTSCombo = class {
-	#replacer = (_, v) => typeof v === "bigint" ? { __bigint__: v.toString() } : v;
-	#reviver = (_, v) => v && v.__bigint__ !== void 0 ? BigInt(v.__bigint__) : v;
+var DBSTSCombo = class extends DBSTSFhirDBParamTypeBase {
+	constructor(options) {
+		super(options);
+	}
 	async InsertRecord(client, data) {
 		try {
 			const text = `
@@ -5743,28 +6052,51 @@ var DBSTSCombo = class {
 			];
 			await client.query(text, values);
 		} catch (error) {
-			defaultLogger.error(`DBSTSCombo:InsertRecord(): Error: [${error}]`);
-			defaultLogger.error(data);
-			defaultLogger.error(JSON.stringify(data, this.#replacer, 2));
-			throw error;
+			const message = `DBSTSCombo:InsertRecord(): Error: [${error}]`;
+			this._options.logger.error(message);
+			throw new Error(message);
 		}
 	}
 	async DeleteRecord(client, data) {
-		await client.query(`DELETE FROM stsresfhircombo WHERE RES_ID = $1 AND RES_TYPE = $2`, [data.RES_ID, data.RES_TYPE]);
+		try {
+			await client.query(`DELETE FROM stsresfhircombo WHERE RES_ID = $1 AND RES_TYPE = $2`, [data.RES_ID, data.RES_TYPE]);
+		} catch (error) {
+			const message = `DBSTSCombo:DeleteRecord(): Error: [${error}]`;
+			this._options.logger.error(message);
+			throw new Error(message);
+		}
 	}
 	async ReadByPIDRecord(client, PID) {
-		return (await client.query(`SELECT * FROM stsresfhircombo WHERE PID = $1`, [PID])).rows[0];
+		try {
+			return (await client.query(`SELECT * FROM stsresfhircombo WHERE PID = $1`, [PID])).rows[0];
+		} catch (error) {
+			const message = `DBSTSCombo:ReadByPIDRecord(): Error: [${error}]`;
+			this._options.logger.error(message);
+			throw new Error(message);
+		}
 	}
 	async ReadAllRecords(client) {
-		return (await client.query(`SELECT * FROM stsresfhircombo`)).rows;
+		try {
+			return (await client.query(`SELECT * FROM stsresfhircombo`)).rows;
+		} catch (error) {
+			const message = `DBSTSCombo:ReadAllRecords(): Error: [${error}]`;
+			this._options.logger.error(message);
+			throw new Error(message);
+		}
 	}
 	async ReadByIdentity(client, parameterName, resourceName) {
-		const hash = hashStringParam(`${parameterName}|${resourceName}`, true);
-		const res = await client.query(`SELECT * FROM stsresfhircombo WHERE HASH_IDENTITY = $1`, [hash]);
-		return this.#filterResults({
-			SP_NAME: parameterName,
-			RES_TYPE: resourceName
-		}, res.rows);
+		try {
+			const hash = hashStringParam(`${parameterName}|${resourceName}`, true);
+			const res = await client.query(`SELECT * FROM stsresfhircombo WHERE HASH_IDENTITY = $1`, [hash]);
+			return this.#filterResults({
+				SP_NAME: parameterName,
+				RES_TYPE: resourceName
+			}, res.rows);
+		} catch (error) {
+			const message = `DBSTSCombo:ReadByIdentity(): Error: [${error}]`;
+			this._options.logger.error(message);
+			throw new Error(message);
+		}
 	}
 	async ReadByString(client, stringVal, parameterName, resourceName) {
 		return [];
@@ -5788,10 +6120,22 @@ var DBSTSCombo = class {
 		return [];
 	}
 	async ReadByResID(client, RES_ID, RES_TYPE) {
-		return (await client.query(`SELECT * FROM stsresfhircombo WHERE RES_ID = $1 AND RES_TYPE = $2`, [RES_ID, RES_TYPE])).rows;
+		try {
+			return (await client.query(`SELECT * FROM stsresfhircombo WHERE RES_ID = $1 AND RES_TYPE = $2`, [RES_ID, RES_TYPE])).rows;
+		} catch (error) {
+			const message = `DBSTSCombo:ReadByResID(): Error: [${error}]`;
+			this._options.logger.error(message);
+			throw new Error(message);
+		}
 	}
 	#filterResults(data, results) {
-		return results.filter((r) => r.SP_NAME === data.SP_NAME && r.RES_TYPE === data.RES_TYPE);
+		try {
+			return results.filter((r) => r.SP_NAME === data.SP_NAME && r.RES_TYPE === data.RES_TYPE);
+		} catch (error) {
+			const message = `DBSTSCombo:#filterResults(): Error: [${error}]`;
+			this._options.logger.error(message);
+			throw new Error(message);
+		}
 	}
 };
 //#endregion
@@ -5813,8 +6157,6 @@ var PGFhirAccessLayer = class extends TinyEmitter {
 	#dbSTSCombo;
 	#transactions = {};
 	#maxTransactionTime = 6e4;
-	#replacer = (_, v) => typeof v === "bigint" ? { __bigint__: v.toString() } : v;
-	#reviver = (_, v) => v && v.__bigint__ !== void 0 ? BigInt(v.__bigint__) : v;
 	constructor(options) {
 		super();
 		this.#options = options;
@@ -5822,18 +6164,34 @@ var PGFhirAccessLayer = class extends TinyEmitter {
 			logger: this.#options.logger,
 			usedefaultdb: this.#options.usedefaultdb
 		});
-		this.#dbSTSResource = new DBSTSResource(this.#poolManager);
-		this.#dbSTSResourceVersion = new DBSTSResourceVersion(this.#poolManager);
+		this.#dbSTSResource = new DBSTSResource({
+			logger: this.#options.logger,
+			poolManager: this.#poolManager
+		});
+		this.#dbSTSResourceVersion = new DBSTSResourceVersion({
+			logger: this.#options.logger,
+			poolManager: this.#poolManager
+		});
 		this.#dbSearchIndex = DBSearchIndex.getInstance();
-		this.#dbSTSResourceLink = new DBSTSResourceLink();
-		this.#dbSTSString = new DBSTSString();
-		this.#dbSTSToken = new DBSTSToken();
-		this.#dbSTSQuantity = new DBSTSQuantity();
-		this.#dbSTSNumber = new DBSTSNumber();
-		this.#dbSTSDate = new DBSTSDate();
-		this.#dbSTSUri = new DBSTSUri();
-		this.#dbSTSCombo = new DBSTSCombo();
-	}
+		this.#dbSTSResourceLink = new DBSTSResourceLink({ logger: this.#options.logger });
+		this.#dbSTSString = new DBSTSString({ logger: this.#options.logger });
+		this.#dbSTSToken = new DBSTSToken({ logger: this.#options.logger });
+		this.#dbSTSQuantity = new DBSTSQuantity({ logger: this.#options.logger });
+		this.#dbSTSNumber = new DBSTSNumber({ logger: this.#options.logger });
+		this.#dbSTSDate = new DBSTSDate({ logger: this.#options.logger });
+		this.#dbSTSUri = new DBSTSUri({ logger: this.#options.logger });
+		this.#dbSTSCombo = new DBSTSCombo({ logger: this.#options.logger });
+	}
+	GetOperationOutcome = (code, diagnostics) => {
+		return {
+			resourceType: "OperationOutcome",
+			issue: [{
+				severity: "error",
+				code,
+				diagnostics
+			}]
+		};
+	};
 	async StartDatabase() {
 		return true;
 	}
@@ -6019,14 +6377,14 @@ var PGFhirAccessLayer = class extends TinyEmitter {
 		return false;
 	};
 	CreateResource = async (resource, transactionHandle) => {
-		if (this.#poolManager) try {
-			let PK = randomUUID$1();
-			const RES_ID = resource.id;
-			const RES_TYPE = resource.resourceType;
-			const RES = JSON.stringify(resource);
-			const now = (/* @__PURE__ */ new Date()).getTime();
-			let client;
-			let useTransaction;
+		if (!this.#poolManager) {
+			const errorMessage = `CreateResource(): poolManager not set`;
+			this.#options.logger.error(errorMessage);
+			throw new Error(errorMessage);
+		}
+		let client;
+		let useTransaction;
+		try {
 			if (transactionHandle && this.#transactions[transactionHandle]) {
 				client = this.#transactions[transactionHandle].client;
 				useTransaction = false;
@@ -6034,50 +6392,72 @@ var PGFhirAccessLayer = class extends TinyEmitter {
 				client = await this.#poolManager.connectReadWrite();
 				useTransaction = true;
 			}
-			try {
-				if (useTransaction) await client.query("BEGIN");
-				await this.#dbSTSResource.InsertResourceEx(client, {
-					PID: PK,
-					PARTITION_ID: 0,
-					PARTITION_DATE: 0,
-					RES_ID,
-					RES_TYPE,
-					RES_VER: 1,
-					RES_VERSION: "r5",
-					RES_PUBLISHED: now,
-					RES_UPDATED: now
-				});
-				await this.#dbSTSResourceVersion.InsertResourceVersionEx(client, {
-					PID: randomUUID$1(),
-					PARTITION_ID: 0,
-					PARTITION_DATE: 0,
-					RES_ID,
-					RES_TYPE,
-					RES_VER: 1,
-					OPERATION: "POST",
-					RES
-				});
-				performance.now();
-				await this.UpdateIndexes(client, resource);
-				if (useTransaction) await client.query("COMMIT");
-				return resource;
-			} catch (error) {
-				if (useTransaction) await client.query("ROLLBACK");
-			} finally {
-				if (useTransaction) client.release();
-			}
 		} catch (error) {
-			defaultLogger.error(`PGFhirAccessLayer:CreateResource(): [${error}]`);
+			const errorMessage = `CreateResource(): Could not get connection: Error: [${error}]`;
+			this.#options.logger.error(errorMessage);
+			throw new Error(errorMessage);
 		}
-	};
-	UpdateResource = async (resource, RES_VER, operation, transactionHandle) => {
-		if (this.#poolManager) try {
+		try {
 			const RES_ID = resource.id;
 			const RES_TYPE = resource.resourceType;
-			const RES = JSON.stringify(resource);
 			const now = (/* @__PURE__ */ new Date()).getTime();
-			let client;
-			let useTransaction;
+			if (useTransaction) await client.query("BEGIN");
+			const newVersion = await this.#dbSTSResource.InsertResourceEx(client, {
+				PID: randomUUID$1(),
+				PARTITION_ID: 0,
+				PARTITION_DATE: 0,
+				RES_ID,
+				RES_TYPE,
+				RES_VER: 1,
+				RES_VERSION: "r5",
+				RES_PUBLISHED: now,
+				RES_UPDATED: now
+			});
+			if (newVersion === void 0) {
+				const errorMessage = `CreateResource(): Version Conflict. newVersion is undefined.`;
+				this.#options.logger.error(errorMessage);
+				throw new Error(errorMessage);
+			}
+			resource.meta ??= {};
+			resource.meta.versionId = String(newVersion);
+			resource.meta.lastUpdated = new Date(now).toISOString();
+			const RES = JSON.stringify(resource);
+			if (await this.#dbSTSResourceVersion.InsertResourceVersionEx(client, {
+				PID: randomUUID$1(),
+				PARTITION_ID: 0,
+				PARTITION_DATE: 0,
+				RES_ID,
+				RES_TYPE,
+				RES_VER: newVersion,
+				OPERATION: "POST",
+				RES
+			}) === void 0) {
+				const errorMessage = `CreateResource(): Version Conflict. resourceVersionRunResult is undefined.`;
+				this.#options.logger.error(errorMessage);
+				throw new Error(errorMessage);
+			}
+			performance.now();
+			await this.UpdateIndexes(client, resource);
+			if (useTransaction) await client.query("COMMIT");
+			return resource;
+		} catch (error) {
+			if (useTransaction) await client.query("ROLLBACK");
+			const errorMessage = `CreateResource(): Error: [${error}]`;
+			this.#options.logger.error(errorMessage);
+			throw new Error(errorMessage);
+		} finally {
+			if (useTransaction) client.release();
+		}
+	};
+	UpdateResource = async (resource, RES_VER, operation, transactionHandle) => {
+		if (!this.#poolManager) {
+			const errorMessage = `UpdateResource(): poolManager not set`;
+			this.#options.logger.error(errorMessage);
+			throw new Error(errorMessage);
+		}
+		let client;
+		let useTransaction;
+		try {
 			if (transactionHandle && this.#transactions[transactionHandle]) {
 				client = this.#transactions[transactionHandle].client;
 				useTransaction = false;
@@ -6085,43 +6465,66 @@ var PGFhirAccessLayer = class extends TinyEmitter {
 				client = await this.#poolManager.connectReadWrite();
 				useTransaction = true;
 			}
-			try {
-				if (useTransaction) await client.query("BEGIN");
-				await this.#dbSTSResource.UpdateResourceRecordEx(client, {
-					RES_TYPE,
-					RES_ID,
-					RES_VER,
-					RES_UPDATED: now
-				});
-				await this.#dbSTSResourceVersion.InsertResourceVersionEx(client, {
-					PID: randomUUID$1(),
-					PARTITION_ID: 0,
-					PARTITION_DATE: 0,
-					RES_ID,
-					RES_TYPE,
-					RES_VER: RES_VER + 1,
-					OPERATION: operation,
-					RES
-				});
-				await this.UpdateIndexes(client, resource);
-				if (useTransaction) await client.query("COMMIT");
-				return resource;
-			} catch (error) {
-				if (useTransaction) await client.query("ROLLBACK");
-			} finally {
-				if (useTransaction) client.release();
+		} catch (error) {
+			const errorMessage = `UpdateResource(): Could not get connection: Error: [${error}]`;
+			this.#options.logger.error(errorMessage);
+			throw new Error(errorMessage);
+		}
+		try {
+			const RES_ID = resource.id;
+			const RES_TYPE = resource.resourceType;
+			const now = (/* @__PURE__ */ new Date()).getTime();
+			if (useTransaction) await client.query("BEGIN");
+			const newVersion = await this.#dbSTSResource.UpdateResourceRecordEx(client, {
+				RES_TYPE,
+				RES_ID,
+				RES_VER,
+				RES_UPDATED: now
+			});
+			if (newVersion === void 0) {
+				const errorMessage = `UpdateResource(): Version Conflict. newVersion is undefined. RES_VER: [${RES_VER}]`;
+				this.#options.logger.error(errorMessage);
+				throw new Error(errorMessage);
+			}
+			resource.meta ??= {};
+			resource.meta.versionId = String(newVersion);
+			resource.meta.lastUpdated = new Date(now).toISOString();
+			const RES = JSON.stringify(resource);
+			if (await this.#dbSTSResourceVersion.InsertResourceVersionEx(client, {
+				PID: randomUUID$1(),
+				PARTITION_ID: 0,
+				PARTITION_DATE: 0,
+				RES_ID,
+				RES_TYPE,
+				RES_VER: newVersion,
+				OPERATION: operation,
+				RES
+			}) === void 0) {
+				const errorMessage = `UpdateResource(): Version Conflict. resourceVersionRunResult is undefined. RES_VER: [${RES_VER}]`;
+				this.#options.logger.error(errorMessage);
+				throw new Error(errorMessage);
 			}
+			await this.UpdateIndexes(client, resource);
+			if (useTransaction) await client.query("COMMIT");
+			return resource;
 		} catch (error) {
-			defaultLogger.error(`PGFhirAccessLayer:UpdateResource(): [${error}]`);
+			if (useTransaction) await client.query("ROLLBACK");
+			const errorMessage = `UpdateResource(): Error: [${error}]`;
+			this.#options.logger.error(errorMessage);
+			throw new Error(errorMessage);
+		} finally {
+			if (useTransaction) client.release();
 		}
 	};
 	DeleteResource = async (resource, RES_VER, transactionHandle) => {
-		if (this.#poolManager) try {
-			const RES_ID = resource.id;
-			const RES_TYPE = resource.resourceType;
-			const now = new Date(DateTime.fromISO(resource.meta.lastUpdated).toJSDate()).getTime();
-			let client;
-			let useTransaction;
+		if (!this.#poolManager) {
+			const errorMessage = `DeleteResource(): poolManager not set`;
+			this.#options.logger.error(errorMessage);
+			throw new Error(errorMessage);
+		}
+		let client;
+		let useTransaction;
+		try {
 			if (transactionHandle && this.#transactions[transactionHandle]) {
 				client = this.#transactions[transactionHandle].client;
 				useTransaction = false;
@@ -6129,39 +6532,64 @@ var PGFhirAccessLayer = class extends TinyEmitter {
 				client = await this.#poolManager.connectReadWrite();
 				useTransaction = true;
 			}
-			try {
-				if (useTransaction) await client.query("BEGIN");
-				await this.#dbSTSResource.DeleteResourceRecordEx(client, {
-					RES_ID,
-					RES_TYPE,
-					RES_VER,
-					RES_DELETED_AT: now,
-					RES_UPDATED: now
-				});
-				await this.#dbSTSResourceVersion.InsertResourceVersionEx(client, {
-					PID: randomUUID$1(),
-					PARTITION_ID: 0,
-					PARTITION_DATE: 0,
-					RES_ID,
-					RES_TYPE,
-					RES_VER: RES_VER + 1,
-					OPERATION: "DELETE",
-					RES: ""
-				});
-				await this.UpdateIndexes(client, resource);
-				if (useTransaction) await client.query("COMMIT");
-				return resource;
-			} catch (error) {
-				if (useTransaction) await client.query("ROLLBACK");
-			} finally {
-				if (useTransaction) client.release();
+		} catch (error) {
+			const errorMessage = `DeleteResource(): Could not get connection: Error: [${error}]`;
+			this.#options.logger.error(errorMessage);
+			throw new Error(errorMessage);
+		}
+		try {
+			const RES_ID = resource.id;
+			const RES_TYPE = resource.resourceType;
+			const now = (/* @__PURE__ */ new Date()).getTime();
+			if (useTransaction) await client.query("BEGIN");
+			const newVersion = await this.#dbSTSResource.DeleteResourceRecordEx(client, {
+				RES_ID,
+				RES_TYPE,
+				RES_VER,
+				RES_DELETED_AT: now,
+				RES_UPDATED: now
+			});
+			if (newVersion === void 0) {
+				const errorMessage = `DeleteResource(): Version Conflict. newVersion is undefined. RES_VER: [${RES_VER}]`;
+				this.#options.logger.error(errorMessage);
+				throw new Error(errorMessage);
 			}
+			resource.meta ??= {};
+			resource.meta.versionId = String(newVersion);
+			resource.meta.lastUpdated = new Date(now).toISOString();
+			if (await this.#dbSTSResourceVersion.InsertResourceVersionEx(client, {
+				PID: randomUUID$1(),
+				PARTITION_ID: 0,
+				PARTITION_DATE: 0,
+				RES_ID,
+				RES_TYPE,
+				RES_VER: newVersion,
+				OPERATION: "DELETE",
+				RES: ""
+			}) === void 0) {
+				const errorMessage = `DeleteResource(): Version Conflict. resourceVersionRunResult is undefined. RES_VER: [${RES_VER}]`;
+				this.#options.logger.error(errorMessage);
+				throw new Error(errorMessage);
+			}
+			await this.UpdateIndexes(client, resource);
+			if (useTransaction) await client.query("COMMIT");
+			return resource;
 		} catch (error) {
-			defaultLogger.error(`PGFhirAccessLayer:DeleteResource(): [${error}]`);
+			if (useTransaction) await client.query("ROLLBACK");
+			const errorMessage = `DeleteResource(): Error: [${error}]`;
+			this.#options.logger.error(errorMessage);
+			throw new Error(errorMessage);
+		} finally {
+			if (useTransaction) client.release();
 		}
 	};
 	ReadResourceRecord = async (RES_TYPE, RES_ID, transactionHandle) => {
-		if (this.#poolManager) try {
+		if (!this.#poolManager) {
+			const errorMessage = `ReadResourceRecord(): poolManager not set`;
+			this.#options.logger.error(errorMessage);
+			throw new Error(errorMessage);
+		}
+		try {
 			let client;
 			let useTransaction;
 			if (transactionHandle && this.#transactions[transactionHandle]) {
@@ -6173,19 +6601,19 @@ var PGFhirAccessLayer = class extends TinyEmitter {
 			}
 			try {
 				return (await client.query(`
-                        SELECT
-                            r.*, v.* FROM stsresfhir r
-                        JOIN 
-                            stsresfhirver v
-                        ON 
-                            r.RES_ID = v.RES_ID AND 
-                            r.RES_TYPE = v.RES_TYPE AND
-                            r.RES_VER = v.RES_VER
-                        WHERE
-                            r.RES_ID = $1 AND
-                            r.RES_TYPE = $2 AND
-                            r.RES_DELETED_AT IS NULL
-                    `, [RES_ID, RES_TYPE])).rows[0];
+                    SELECT
+                        r.*, v.* FROM stsresfhir r
+                    JOIN 
+                        stsresfhirver v
+                    ON 
+                        r.RES_ID = v.RES_ID AND 
+                        r.RES_TYPE = v.RES_TYPE AND
+                        r.RES_VER = v.RES_VER
+                    WHERE
+                        r.RES_ID = $1 AND
+                        r.RES_TYPE = $2 AND
+                        r.RES_DELETED_AT IS NULL
+                `, [RES_ID, RES_TYPE])).rows[0];
 			} catch (error) {
 				defaultLogger.error(`DBSTSResource:ReadResourceRecord(): Query Error: [${error}]`);
 			} finally {
@@ -6196,7 +6624,12 @@ var PGFhirAccessLayer = class extends TinyEmitter {
 		}
 	};
 	ReadResourceRecordWithVersion = async (RES_TYPE, RES_ID, RES_VER, transactionHandle) => {
-		if (this.#poolManager) try {
+		if (!this.#poolManager) {
+			const errorMessage = `ReadResourceRecordWithVersion(): poolManager not set`;
+			this.#options.logger.error(errorMessage);
+			throw new Error(errorMessage);
+		}
+		try {
 			let client;
 			let useTransaction;
 			if (transactionHandle && this.#transactions[transactionHandle]) {
@@ -6208,18 +6641,18 @@ var PGFhirAccessLayer = class extends TinyEmitter {
 			}
 			try {
 				return (await client.query(`
-                        SELECT
-                            r.*, v.*, r.res_ver as R_res_ver, v.res_ver as V_res_ver FROM stsresfhir r
-                        JOIN 
-                            stsresfhirver v
-                        ON 
-                            r.RES_ID = v.RES_ID AND 
-                            r.RES_TYPE = v.RES_TYPE
-                        WHERE
-                            r.RES_ID = $1 AND
-                            r.RES_TYPE = $2 AND
-                            v.RES_VER = $3
-                    `, [
+                    SELECT
+                        r.*, v.*, r.res_ver as R_res_ver, v.res_ver as V_res_ver FROM stsresfhir r
+                    JOIN 
+                        stsresfhirver v
+                    ON 
+                        r.RES_ID = v.RES_ID AND 
+                        r.RES_TYPE = v.RES_TYPE
+                    WHERE
+                        r.RES_ID = $1 AND
+                        r.RES_TYPE = $2 AND
+                        v.RES_VER = $3
+                `, [
 					RES_ID,
 					RES_TYPE,
 					RES_VER
@@ -6234,7 +6667,12 @@ var PGFhirAccessLayer = class extends TinyEmitter {
 		}
 	};
 	ReadResourceInstanceWithAllVersions = async (RES_TYPE, RES_ID, transactionHandle) => {
-		if (this.#poolManager) try {
+		if (!this.#poolManager) {
+			const errorMessage = `ReadResourceInstanceWithAllVersions(): poolManager not set`;
+			this.#options.logger.error(errorMessage);
+			throw new Error(errorMessage);
+		}
+		try {
 			let client;
 			let useTransaction;
 			if (transactionHandle && this.#transactions[transactionHandle]) {
@@ -6246,19 +6684,19 @@ var PGFhirAccessLayer = class extends TinyEmitter {
 			}
 			try {
 				return (await client.query(`
-                        SELECT
-                            r.*, v.*, r.res_ver as R_res_ver, v.res_ver as V_res_ver FROM stsresfhir r
-                        JOIN 
-                            stsresfhirver v
-                        ON 
-                            r.RES_ID = v.RES_ID AND 
-                            r.RES_TYPE = v.RES_TYPE
-                        WHERE
-                            r.RES_ID = $1 AND
-                            r.RES_TYPE = $2
-                        ORDER BY
-                            v.RES_TYPE ASC, v.RES_ID ASC, v.RES_VER DESC
-                    `, [RES_ID, RES_TYPE])).rows;
+                    SELECT
+                        r.*, v.*, r.res_ver as R_res_ver, v.res_ver as V_res_ver FROM stsresfhir r
+                    JOIN 
+                        stsresfhirver v
+                    ON 
+                        r.RES_ID = v.RES_ID AND 
+                        r.RES_TYPE = v.RES_TYPE
+                    WHERE
+                        r.RES_ID = $1 AND
+                        r.RES_TYPE = $2
+                    ORDER BY
+                        v.RES_TYPE ASC, v.RES_ID ASC, v.RES_VER DESC
+                `, [RES_ID, RES_TYPE])).rows;
 			} catch (error) {
 				defaultLogger.error(`DBSTSResource:ReadResourceRecord(): Query Error: [${error}]`);
 			} finally {
@@ -6269,7 +6707,12 @@ var PGFhirAccessLayer = class extends TinyEmitter {
 		}
 	};
 	ReadResourcesWithAllVersions = async (RES_TYPE, transactionHandle) => {
-		if (this.#poolManager) try {
+		if (!this.#poolManager) {
+			const errorMessage = `ReadResourcesWithAllVersions(): poolManager not set`;
+			this.#options.logger.error(errorMessage);
+			throw new Error(errorMessage);
+		}
+		try {
 			let client;
 			let useTransaction;
 			if (transactionHandle && this.#transactions[transactionHandle]) {
@@ -6281,18 +6724,18 @@ var PGFhirAccessLayer = class extends TinyEmitter {
 			}
 			try {
 				return (await client.query(`
-                        SELECT
-                            r.*, v.*, r.res_ver as R_res_ver, v.res_ver as V_res_ver FROM stsresfhir r
-                        JOIN 
-                            stsresfhirver v
-                        ON 
-                            r.RES_ID = v.RES_ID AND 
-                            r.RES_TYPE = v.RES_TYPE
-                        WHERE
-                            r.RES_TYPE = $1
-                        ORDER BY
-                            v.RES_TYPE ASC, v.RES_ID ASC, v.RES_VER DESC
-                    `, [RES_TYPE])).rows;
+                    SELECT
+                        r.*, v.*, r.res_ver as R_res_ver, v.res_ver as V_res_ver FROM stsresfhir r
+                    JOIN 
+                        stsresfhirver v
+                    ON 
+                        r.RES_ID = v.RES_ID AND 
+                        r.RES_TYPE = v.RES_TYPE
+                    WHERE
+                        r.RES_TYPE = $1
+                    ORDER BY
+                        v.RES_TYPE ASC, v.RES_ID ASC, v.RES_VER DESC
+                `, [RES_TYPE])).rows;
 			} catch (error) {
 				defaultLogger.error(`DBSTSResource:ReadResourceRecord(): Query Error: [${error}]`);
 			} finally {
@@ -6303,7 +6746,12 @@ var PGFhirAccessLayer = class extends TinyEmitter {
 		}
 	};
 	ReadAllResourcesWithVersions = async (transactionHandle) => {
-		if (this.#poolManager) try {
+		if (!this.#poolManager) {
+			const errorMessage = `ReadAllResourcesWithVersions(): poolManager not set`;
+			this.#options.logger.error(errorMessage);
+			throw new Error(errorMessage);
+		}
+		try {
 			let client;
 			let useTransaction;
 			if (transactionHandle && this.#transactions[transactionHandle]) {
@@ -6315,16 +6763,16 @@ var PGFhirAccessLayer = class extends TinyEmitter {
 			}
 			try {
 				return (await client.query(`
-                        SELECT
-                            r.*, v.* FROM stsresfhir r
-                        JOIN 
-                            stsresfhirver v
-                        ON 
-                            r.RES_ID = v.RES_ID AND 
-                            r.RES_TYPE = v.RES_TYPE AND
-                        ORDER BY
-                            v.RES_TYPE ASC, v.RES_ID ASC, v.RES_VER DESC
-                    `)).rows;
+                    SELECT
+                        r.*, v.* FROM stsresfhir r
+                    JOIN 
+                        stsresfhirver v
+                    ON 
+                        r.RES_ID = v.RES_ID AND 
+                        r.RES_TYPE = v.RES_TYPE AND
+                    ORDER BY
+                        v.RES_TYPE ASC, v.RES_ID ASC, v.RES_VER DESC
+                `)).rows;
 			} catch (error) {
 				defaultLogger.error(`DBSTSResource:ReadResourceRecord(): Query Error: [${error}]`);
 			} finally {
@@ -6338,7 +6786,12 @@ var PGFhirAccessLayer = class extends TinyEmitter {
 		return this.#dbSTSResourceVersion.ReadAllResourceVersionRecords();
 	};
 	ReadResourceIndexes = async (resource, transactionHandle) => {
-		if (this.#poolManager) try {
+		if (!this.#poolManager) {
+			const errorMessage = `ReadResourceIndexes(): poolManager not set`;
+			this.#options.logger.error(errorMessage);
+			throw new Error(errorMessage);
+		}
+		try {
 			const resultSet = {
 				"stsresfhirlink": [],
 				"stsresfhirstring": [],
@@ -6378,7 +6831,12 @@ var PGFhirAccessLayer = class extends TinyEmitter {
 		}
 	};
 	ExecuteReadQuery = async (queryData, transactionHandle) => {
-		if (this.#poolManager) try {
+		if (!this.#poolManager) {
+			const errorMessage = `ExecuteReadQuery(): poolManager not set`;
+			this.#options.logger.error(errorMessage);
+			throw new Error(errorMessage);
+		}
+		try {
 			let client;
 			let useTransaction;
 			if (transactionHandle && this.#transactions[transactionHandle]) {
@@ -6401,7 +6859,12 @@ var PGFhirAccessLayer = class extends TinyEmitter {
 		}
 	};
 	TruncateAll = async () => {
-		if (this.#poolManager) try {
+		if (!this.#poolManager) {
+			const errorMessage = `TruncateAll(): poolManager not set`;
+			this.#options.logger.error(errorMessage);
+			throw new Error(errorMessage);
+		}
+		try {
 			let client;
 			client = await this.#poolManager.connectReadWrite();
 			try {