@nsshunt/stsfhirpg 1.2.29 → 1.2.31

package/dist/index.cjs

@@ -5007,8 +5007,21 @@ var DBSTSResourceVersion = class extends DBSTSFhirDBBase {
 	}
 };
 //#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(`
@@ -5056,323 +5069,502 @@ var DBSTSResourceLink = class {
 				data.COMPOSITE_HASH_EXACT ? BigInt(data.COMPOSITE_HASH_EXACT) : null
 			]);
 		} catch (error) {
-			_nsshunt_stsutils.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) {
-			_nsshunt_stsutils.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) {
-			_nsshunt_stsutils.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) {
-			_nsshunt_stsutils.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) {
-			_nsshunt_stsutils.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) {
-		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
-		]);
+		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) {
-		return (await client.query(`SELECT * FROM stsresfhirstring WHERE PID = $1 LIMIT 1`, [PID])).rows[0];
+		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) {
-		return (await client.query(`SELECT * FROM stsresfhirstring`)).rows;
+		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) {
-		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 = `DBSTSString:#FilterResults(): 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);
+		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) {
-		const res = await client.query(`SELECT * FROM stsresfhirstring WHERE HASH_EXACT = $1`, [BigInt(data.HASH_EXACT)]);
-		return this.#FilterResults(data, res.rows);
+		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) {
-		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 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) {
-		await client.query(`DELETE FROM stsresfhirstring WHERE RES_ID = $1 AND RES_TYPE = $2`, [data.RES_ID, data.RES_TYPE]);
+		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 {
+var DBSTSToken = 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 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);
+		} catch (error) {
+			const message = `DBSTSToken: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 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 stsresfhirtoken WHERE PID = $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 stsresfhirtoken`)).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);
+		}
 	}
 	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 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 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);
+		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 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);
+		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) {
-		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);
+		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 stsresfhirtoken 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);
+		}
 	}
 	#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 = `DBSTSToken:#filterResults(): Error: [${error}]`;
+			this._options.logger.error(message);
+			throw new Error(message);
+		}
 	}
 };
 //#endregion
 //#region src/fhir-database/pg/pgfhirquantity.ts
-var DBSTSQuantity = class {
+var DBSTSQuantity = 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 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 stsresfhirquantity 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 stsresfhirquantity 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 stsresfhirquantity`)).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 stsresfhirquantity 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 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);
+		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 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);
+		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 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 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) {
-		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 = `DBSTSQuantity:#filterResults(): Error: [${error}]`;
+			this._options.logger.error(message);
+			throw new Error(message);
+		}
 	}
 };
 //#endregion
 //#region src/fhir-database/pg/pgfhirnumber.ts
-var DBSTSNumber = class {
+var DBSTSNumber = class extends DBSTSFhirDBParamTypeBase {
+	constructor(options) {
+		super(options);
+	}
 	async InsertRecord(client, data) {
 		try {
 			const text = `
@@ -5416,262 +5608,439 @@ var DBSTSNumber = class {
 			];
 			await client.query(text, values);
 		} catch (error) {
-			console.error(error);
+			const message = `DBSTSNumber: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]);
+		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) {
-		return (await client.query(`SELECT * FROM stsresfhirnumber WHERE PID = $1`, [PID])).rows[0];
+		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) {
-		return (await client.query(`SELECT * FROM stsresfhirnumber`)).rows;
+		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) {
-		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);
+		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) {
-		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);
+		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 stsresfhirnumber 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/pgfhirdate.ts
-var DBSTSDate = class {
+var DBSTSDate = class extends DBSTSFhirDBParamTypeBase {
+	constructor(options) {
+		super(options);
+	}
 	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);
+		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 stsresfhirdate 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) {
-		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 = luxon.DateTime.fromJSDate(res.rows[0].sp_value_high);
-			if (res.rows[0].sp_value_low !== null) res.rows[0].sp_value_low = luxon.DateTime.fromJSDate(res.rows[0].sp_value_low);
+		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 = luxon.DateTime.fromJSDate(res.rows[0].sp_value_high);
+				if (res.rows[0].sp_value_low !== null) res.rows[0].sp_value_low = luxon.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);
 		}
-		return res.rows[0];
 	}
 	async ReadAllRecords(client) {
-		return (await client.query(`SELECT * FROM stsresfhirdate`)).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) {
-		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);
+		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) {
-		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);
+		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) {
-		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);
+		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) {
-		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);
+		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 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);
+		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 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);
+		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 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);
+		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 stsresfhirdate 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/pgfhiruri.ts
-var DBSTSUri = class {
+var DBSTSUri = class extends DBSTSFhirDBParamTypeBase {
+	constructor(options) {
+		super(options);
+	}
 	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);
+		try {
+			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);
+		} catch (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 stsresfhiruri WHERE RES_ID = $1 AND RES_TYPE = $2`, [data.RES_ID, data.RES_TYPE]);
+		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);
+		}
 	}
 	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 = `
@@ -5710,28 +6079,51 @@ var DBSTSCombo = class {
 			];
 			await client.query(text, values);
 		} catch (error) {
-			_nsshunt_stsutils.defaultLogger.error(`DBSTSCombo:InsertRecord(): Error: [${error}]`);
-			_nsshunt_stsutils.defaultLogger.error(data);
-			_nsshunt_stsutils.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 [];
@@ -5755,10 +6147,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
@@ -5780,8 +6184,6 @@ var PGFhirAccessLayer = class extends tiny_emitter.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;
@@ -5798,14 +6200,14 @@ var PGFhirAccessLayer = class extends tiny_emitter.TinyEmitter {
 			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 {