@native-systems/utility 1.0.0

package/dist/index.cjs.js

@@ -0,0 +1,768 @@
+'use strict';
+
+var common = require('@nestjs/common');
+
+var PostgresError = /*#__PURE__*/ (function (PostgresError) {
+  PostgresError['SUCCESSFUL_COMPLETION'] = '00000';
+  PostgresError['WARNING'] = '01000';
+  PostgresError['WARNING_DYNAMIC_RESULT_SETS_RETURNED'] = '0100C';
+  PostgresError['WARNING_IMPLICIT_ZERO_BIT_PADDING'] = '01008';
+  PostgresError['WARNING_NULL_VALUE_ELIMINATED_IN_SET_FUNCTION'] = '01003';
+  PostgresError['WARNING_PRIVILEGE_NOT_GRANTED'] = '01007';
+  PostgresError['WARNING_PRIVILEGE_NOT_REVOKED'] = '01006';
+  PostgresError['WARNING_STRING_DATA_RIGHT_TRUNCATION'] = '01004';
+  PostgresError['WARNING_DEPRECATED_FEATURE'] = '01P01';
+  PostgresError['NO_DATA'] = '02000';
+  PostgresError['NO_ADDITIONAL_DYNAMIC_RESULT_SETS_RETURNED'] = '02001';
+  PostgresError['SQL_STATEMENT_NOT_YET_COMPLETE'] = '03000';
+  PostgresError['CONNECTION_EXCEPTION'] = '08000';
+  PostgresError['CONNECTION_DOES_NOT_EXIST'] = '08003';
+  PostgresError['CONNECTION_FAILURE'] = '08006';
+  PostgresError['SQLCLIENT_UNABLE_TO_ESTABLISH_SQLCONNECTION'] = '08001';
+  PostgresError['SQLSERVER_REJECTED_ESTABLISHMENT_OF_SQLCONNECTION'] = '08004';
+  PostgresError['TRANSACTION_RESOLUTION_UNKNOWN'] = '08007';
+  PostgresError['PROTOCOL_VIOLATION'] = '08P01';
+  PostgresError['TRIGGERED_ACTION_EXCEPTION'] = '09000';
+  PostgresError['FEATURE_NOT_SUPPORTED'] = '0A000';
+  PostgresError['INVALID_TRANSACTION_INITIATION'] = '0B000';
+  PostgresError['LOCATOR_EXCEPTION'] = '0F000';
+  PostgresError['L_E_INVALID_SPECIFICATION'] = '0F001';
+  PostgresError['INVALID_GRANTOR'] = '0L000';
+  PostgresError['INVALID_GRANT_OPERATION'] = '0LP01';
+  PostgresError['INVALID_ROLE_SPECIFICATION'] = '0P000';
+  PostgresError['DIAGNOSTICS_EXCEPTION'] = '0Z000';
+  PostgresError['STACKED_DIAGNOSTICS_ACCESSED_WITHOUT_ACTIVE_HANDLER'] =
+    '0Z002';
+  PostgresError['INVALID_ARGUMENT_FOR_XQUERY'] = '10608';
+  PostgresError['CASE_NOT_FOUND'] = '20000';
+  PostgresError['CARDINALITY_VIOLATION'] = '21000';
+  PostgresError['DATA_EXCEPTION'] = '22000';
+  PostgresError['ARRAY_ELEMENT_ERROR'] = '2202E';
+  PostgresError['ARRAY_SUBSCRIPT_ERROR'] = '2202E';
+  PostgresError['CHARACTER_NOT_IN_REPERTOIRE'] = '22021';
+  PostgresError['DATETIME_FIELD_OVERFLOW'] = '22008';
+  PostgresError['DATETIME_VALUE_OUT_OF_RANGE'] = '22008';
+  PostgresError['DIVISION_BY_ZERO'] = '22012';
+  PostgresError['ERROR_IN_ASSIGNMENT'] = '22005';
+  PostgresError['ESCAPE_CHARACTER_CONFLICT'] = '2200B';
+  PostgresError['INDICATOR_OVERFLOW'] = '22022';
+  PostgresError['INTERVAL_FIELD_OVERFLOW'] = '22015';
+  PostgresError['INVALID_ARGUMENT_FOR_LOG'] = '2201E';
+  PostgresError['INVALID_ARGUMENT_FOR_NTILE'] = '22014';
+  PostgresError['INVALID_ARGUMENT_FOR_NTH_VALUE'] = '22016';
+  PostgresError['INVALID_ARGUMENT_FOR_POWER_FUNCTION'] = '2201F';
+  PostgresError['INVALID_ARGUMENT_FOR_WIDTH_BUCKET_FUNCTION'] = '2201G';
+  PostgresError['INVALID_CHARACTER_VALUE_FOR_CAST'] = '22018';
+  PostgresError['INVALID_DATETIME_FORMAT'] = '22007';
+  PostgresError['INVALID_ESCAPE_CHARACTER'] = '22019';
+  PostgresError['INVALID_ESCAPE_OCTET'] = '2200D';
+  PostgresError['INVALID_ESCAPE_SEQUENCE'] = '22025';
+  PostgresError['NONSTANDARD_USE_OF_ESCAPE_CHARACTER'] = '22P06';
+  PostgresError['INVALID_INDICATOR_PARAMETER_VALUE'] = '22010';
+  PostgresError['INVALID_PARAMETER_VALUE'] = '22023';
+  PostgresError['INVALID_PRECEDING_OR_FOLLOWING_SIZE'] = '22013';
+  PostgresError['INVALID_REGULAR_EXPRESSION'] = '2201B';
+  PostgresError['INVALID_ROW_COUNT_IN_LIMIT_CLAUSE'] = '2201W';
+  PostgresError['INVALID_ROW_COUNT_IN_RESULT_OFFSET_CLAUSE'] = '2201X';
+  PostgresError['INVALID_TABLESAMPLE_ARGUMENT'] = '2202H';
+  PostgresError['INVALID_TABLESAMPLE_REPEAT'] = '2202G';
+  PostgresError['INVALID_TIME_ZONE_DISPLACEMENT_VALUE'] = '22009';
+  PostgresError['INVALID_USE_OF_ESCAPE_CHARACTER'] = '2200C';
+  PostgresError['MOST_SPECIFIC_TYPE_MISMATCH'] = '2200G';
+  PostgresError['NULL_VALUE_NOT_ALLOWED'] = '22004';
+  PostgresError['NULL_VALUE_NO_INDICATOR_PARAMETER'] = '22002';
+  PostgresError['NUMERIC_VALUE_OUT_OF_RANGE'] = '22003';
+  PostgresError['SEQUENCE_GENERATOR_LIMIT_EXCEEDED'] = '2200H';
+  PostgresError['STRING_DATA_LENGTH_MISMATCH'] = '22026';
+  PostgresError['STRING_DATA_RIGHT_TRUNCATION'] = '22001';
+  PostgresError['SUBSTRING_ERROR'] = '22011';
+  PostgresError['TRIM_ERROR'] = '22027';
+  PostgresError['UNTERMINATED_C_STRING'] = '22024';
+  PostgresError['ZERO_LENGTH_CHARACTER_STRING'] = '2200F';
+  PostgresError['FLOATING_POINT_EXCEPTION'] = '22P01';
+  PostgresError['INVALID_TEXT_REPRESENTATION'] = '22P02';
+  PostgresError['INVALID_BINARY_REPRESENTATION'] = '22P03';
+  PostgresError['BAD_COPY_FILE_FORMAT'] = '22P04';
+  PostgresError['UNTRANSLATABLE_CHARACTER'] = '22P05';
+  PostgresError['NOT_AN_XML_DOCUMENT'] = '2200L';
+  PostgresError['INVALID_XML_DOCUMENT'] = '2200M';
+  PostgresError['INVALID_XML_CONTENT'] = '2200N';
+  PostgresError['INVALID_XML_COMMENT'] = '2200S';
+  PostgresError['INVALID_XML_PROCESSING_INSTRUCTION'] = '2200T';
+  PostgresError['DUPLICATE_JSON_OBJECT_KEY_VALUE'] = '22030';
+  PostgresError['INVALID_ARGUMENT_FOR_SQL_JSON_DATETIME_FUNCTION'] = '22031';
+  PostgresError['INVALID_JSON_TEXT'] = '22032';
+  PostgresError['INVALID_SQL_JSON_SUBSCRIPT'] = '22033';
+  PostgresError['MORE_THAN_ONE_SQL_JSON_ITEM'] = '22034';
+  PostgresError['NO_SQL_JSON_ITEM'] = '22035';
+  PostgresError['NON_NUMERIC_SQL_JSON_ITEM'] = '22036';
+  PostgresError['NON_UNIQUE_KEYS_IN_A_JSON_OBJECT'] = '22037';
+  PostgresError['SINGLETON_SQL_JSON_ITEM_REQUIRED'] = '22038';
+  PostgresError['SQL_JSON_ARRAY_NOT_FOUND'] = '22039';
+  PostgresError['SQL_JSON_MEMBER_NOT_FOUND'] = '2203A';
+  PostgresError['SQL_JSON_NUMBER_NOT_FOUND'] = '2203B';
+  PostgresError['SQL_JSON_OBJECT_NOT_FOUND'] = '2203C';
+  PostgresError['TOO_MANY_JSON_ARRAY_ELEMENTS'] = '2203D';
+  PostgresError['TOO_MANY_JSON_OBJECT_MEMBERS'] = '2203E';
+  PostgresError['SQL_JSON_SCALAR_REQUIRED'] = '2203F';
+  PostgresError['SQL_JSON_ITEM_CANNOT_BE_CAST_TO_TARGET_TYPE'] = '2203G';
+  PostgresError['INTEGRITY_CONSTRAINT_VIOLATION'] = '23000';
+  PostgresError['RESTRICT_VIOLATION'] = '23001';
+  PostgresError['NOT_NULL_VIOLATION'] = '23502';
+  PostgresError['FOREIGN_KEY_VIOLATION'] = '23503';
+  PostgresError['UNIQUE_VIOLATION'] = '23505';
+  PostgresError['CHECK_VIOLATION'] = '23514';
+  PostgresError['EXCLUSION_VIOLATION'] = '23P01';
+  PostgresError['INVALID_CURSOR_STATE'] = '24000';
+  PostgresError['INVALID_TRANSACTION_STATE'] = '25000';
+  PostgresError['ACTIVE_SQL_TRANSACTION'] = '25001';
+  PostgresError['BRANCH_TRANSACTION_ALREADY_ACTIVE'] = '25002';
+  PostgresError['HELD_CURSOR_REQUIRES_SAME_ISOLATION_LEVEL'] = '25008';
+  PostgresError['INAPPROPRIATE_ACCESS_MODE_FOR_BRANCH_TRANSACTION'] = '25003';
+  PostgresError['INAPPROPRIATE_ISOLATION_LEVEL_FOR_BRANCH_TRANSACTION'] =
+    '25004';
+  PostgresError['NO_ACTIVE_SQL_TRANSACTION_FOR_BRANCH_TRANSACTION'] = '25005';
+  PostgresError['READ_ONLY_SQL_TRANSACTION'] = '25006';
+  PostgresError['SCHEMA_AND_DATA_STATEMENT_MIXING_NOT_SUPPORTED'] = '25007';
+  PostgresError['NO_ACTIVE_SQL_TRANSACTION'] = '25P01';
+  PostgresError['IN_FAILED_SQL_TRANSACTION'] = '25P02';
+  PostgresError['IDLE_IN_TRANSACTION_SESSION_TIMEOUT'] = '25P03';
+  PostgresError['TRANSACTION_TIMEOUT'] = '25P04';
+  PostgresError['INVALID_SQL_STATEMENT_NAME'] = '26000';
+  PostgresError['TRIGGERED_DATA_CHANGE_VIOLATION'] = '27000';
+  PostgresError['INVALID_AUTHORIZATION_SPECIFICATION'] = '28000';
+  PostgresError['INVALID_PASSWORD'] = '28P01';
+  PostgresError['DEPENDENT_PRIVILEGE_DESCRIPTORS_STILL_EXIST'] = '2B000';
+  PostgresError['DEPENDENT_OBJECTS_STILL_EXIST'] = '2BP01';
+  PostgresError['INVALID_TRANSACTION_TERMINATION'] = '2D000';
+  PostgresError['SQL_ROUTINE_EXCEPTION'] = '2F000';
+  PostgresError['S_R_E_FUNCTION_EXECUTED_NO_RETURN_STATEMENT'] = '2F005';
+  PostgresError['S_R_E_MODIFYING_SQL_DATA_NOT_PERMITTED'] = '2F002';
+  PostgresError['S_R_E_PROHIBITED_SQL_STATEMENT_ATTEMPTED'] = '2F003';
+  PostgresError['S_R_E_READING_SQL_DATA_NOT_PERMITTED'] = '2F004';
+  PostgresError['INVALID_CURSOR_NAME'] = '34000';
+  PostgresError['EXTERNAL_ROUTINE_EXCEPTION'] = '38000';
+  PostgresError['E_R_E_CONTAINING_SQL_NOT_PERMITTED'] = '38001';
+  PostgresError['E_R_E_MODIFYING_SQL_DATA_NOT_PERMITTED'] = '38002';
+  PostgresError['E_R_E_PROHIBITED_SQL_STATEMENT_ATTEMPTED'] = '38003';
+  PostgresError['E_R_E_READING_SQL_DATA_NOT_PERMITTED'] = '38004';
+  PostgresError['EXTERNAL_ROUTINE_INVOCATION_EXCEPTION'] = '39000';
+  PostgresError['E_R_I_E_INVALID_SQLSTATE_RETURNED'] = '39001';
+  PostgresError['E_R_I_E_NULL_VALUE_NOT_ALLOWED'] = '39004';
+  PostgresError['E_R_I_E_TRIGGER_PROTOCOL_VIOLATED'] = '39P01';
+  PostgresError['E_R_I_E_SRF_PROTOCOL_VIOLATED'] = '39P02';
+  PostgresError['E_R_I_E_EVENT_TRIGGER_PROTOCOL_VIOLATED'] = '39P03';
+  PostgresError['SAVEPOINT_EXCEPTION'] = '3B000';
+  PostgresError['S_E_INVALID_SPECIFICATION'] = '3B001';
+  PostgresError['INVALID_CATALOG_NAME'] = '3D000';
+  PostgresError['INVALID_SCHEMA_NAME'] = '3F000';
+  PostgresError['TRANSACTION_ROLLBACK'] = '40000';
+  PostgresError['T_R_INTEGRITY_CONSTRAINT_VIOLATION'] = '40002';
+  PostgresError['T_R_SERIALIZATION_FAILURE'] = '40001';
+  PostgresError['T_R_STATEMENT_COMPLETION_UNKNOWN'] = '40003';
+  PostgresError['T_R_DEADLOCK_DETECTED'] = '40P01';
+  PostgresError['SYNTAX_ERROR_OR_ACCESS_RULE_VIOLATION'] = '42000';
+  PostgresError['SYNTAX_ERROR'] = '42601';
+  PostgresError['INSUFFICIENT_PRIVILEGE'] = '42501';
+  PostgresError['CANNOT_COERCE'] = '42846';
+  PostgresError['GROUPING_ERROR'] = '42803';
+  PostgresError['WINDOWING_ERROR'] = '42P20';
+  PostgresError['INVALID_RECURSION'] = '42P19';
+  PostgresError['INVALID_FOREIGN_KEY'] = '42830';
+  PostgresError['INVALID_NAME'] = '42602';
+  PostgresError['NAME_TOO_LONG'] = '42622';
+  PostgresError['RESERVED_NAME'] = '42939';
+  PostgresError['DATATYPE_MISMATCH'] = '42804';
+  PostgresError['INDETERMINATE_DATATYPE'] = '42P18';
+  PostgresError['COLLATION_MISMATCH'] = '42P21';
+  PostgresError['INDETERMINATE_COLLATION'] = '42P22';
+  PostgresError['WRONG_OBJECT_TYPE'] = '42809';
+  PostgresError['GENERATED_ALWAYS'] = '428C9';
+  PostgresError['UNDEFINED_COLUMN'] = '42703';
+  PostgresError['UNDEFINED_CURSOR'] = '34000';
+  PostgresError['UNDEFINED_DATABASE'] = '3D000';
+  PostgresError['UNDEFINED_FUNCTION'] = '42883';
+  PostgresError['UNDEFINED_PSTATEMENT'] = '26000';
+  PostgresError['UNDEFINED_SCHEMA'] = '3F000';
+  PostgresError['UNDEFINED_TABLE'] = '42P01';
+  PostgresError['UNDEFINED_PARAMETER'] = '42P02';
+  PostgresError['UNDEFINED_OBJECT'] = '42704';
+  PostgresError['DUPLICATE_COLUMN'] = '42701';
+  PostgresError['DUPLICATE_CURSOR'] = '42P03';
+  PostgresError['DUPLICATE_DATABASE'] = '42P04';
+  PostgresError['DUPLICATE_FUNCTION'] = '42723';
+  PostgresError['DUPLICATE_PSTATEMENT'] = '42P05';
+  PostgresError['DUPLICATE_SCHEMA'] = '42P06';
+  PostgresError['DUPLICATE_TABLE'] = '42P07';
+  PostgresError['DUPLICATE_ALIAS'] = '42712';
+  PostgresError['DUPLICATE_OBJECT'] = '42710';
+  PostgresError['AMBIGUOUS_COLUMN'] = '42702';
+  PostgresError['AMBIGUOUS_FUNCTION'] = '42725';
+  PostgresError['AMBIGUOUS_PARAMETER'] = '42P08';
+  PostgresError['AMBIGUOUS_ALIAS'] = '42P09';
+  PostgresError['INVALID_COLUMN_REFERENCE'] = '42P10';
+  PostgresError['INVALID_COLUMN_DEFINITION'] = '42611';
+  PostgresError['INVALID_CURSOR_DEFINITION'] = '42P11';
+  PostgresError['INVALID_DATABASE_DEFINITION'] = '42P12';
+  PostgresError['INVALID_FUNCTION_DEFINITION'] = '42P13';
+  PostgresError['INVALID_PSTATEMENT_DEFINITION'] = '42P14';
+  PostgresError['INVALID_SCHEMA_DEFINITION'] = '42P15';
+  PostgresError['INVALID_TABLE_DEFINITION'] = '42P16';
+  PostgresError['INVALID_OBJECT_DEFINITION'] = '42P17';
+  PostgresError['WITH_CHECK_OPTION_VIOLATION'] = '44000';
+  PostgresError['INSUFFICIENT_RESOURCES'] = '53000';
+  PostgresError['DISK_FULL'] = '53100';
+  PostgresError['OUT_OF_MEMORY'] = '53200';
+  PostgresError['TOO_MANY_CONNECTIONS'] = '53300';
+  PostgresError['CONFIGURATION_LIMIT_EXCEEDED'] = '53400';
+  PostgresError['PROGRAM_LIMIT_EXCEEDED'] = '54000';
+  PostgresError['STATEMENT_TOO_COMPLEX'] = '54001';
+  PostgresError['TOO_MANY_COLUMNS'] = '54011';
+  PostgresError['TOO_MANY_ARGUMENTS'] = '54023';
+  PostgresError['OBJECT_NOT_IN_PREREQUISITE_STATE'] = '55000';
+  PostgresError['OBJECT_IN_USE'] = '55006';
+  PostgresError['CANT_CHANGE_RUNTIME_PARAM'] = '55P02';
+  PostgresError['LOCK_NOT_AVAILABLE'] = '55P03';
+  PostgresError['UNSAFE_NEW_ENUM_VALUE_USAGE'] = '55P04';
+  PostgresError['OPERATOR_INTERVENTION'] = '57000';
+  PostgresError['QUERY_CANCELED'] = '57014';
+  PostgresError['ADMIN_SHUTDOWN'] = '57P01';
+  PostgresError['CRASH_SHUTDOWN'] = '57P02';
+  PostgresError['CANNOT_CONNECT_NOW'] = '57P03';
+  PostgresError['DATABASE_DROPPED'] = '57P04';
+  PostgresError['IDLE_SESSION_TIMEOUT'] = '57P05';
+  PostgresError['SYSTEM_ERROR'] = '58000';
+  PostgresError['IO_ERROR'] = '58030';
+  PostgresError['UNDEFINED_FILE'] = '58P01';
+  PostgresError['DUPLICATE_FILE'] = '58P02';
+  PostgresError['FILE_NAME_TOO_LONG'] = '58P03';
+  PostgresError['CONFIG_FILE_ERROR'] = 'F0000';
+  PostgresError['LOCK_FILE_EXISTS'] = 'F0001';
+  PostgresError['FDW_ERROR'] = 'HV000';
+  PostgresError['FDW_COLUMN_NAME_NOT_FOUND'] = 'HV005';
+  PostgresError['FDW_DYNAMIC_PARAMETER_VALUE_NEEDED'] = 'HV002';
+  PostgresError['FDW_FUNCTION_SEQUENCE_ERROR'] = 'HV010';
+  PostgresError['FDW_INCONSISTENT_DESCRIPTOR_INFORMATION'] = 'HV021';
+  PostgresError['FDW_INVALID_ATTRIBUTE_VALUE'] = 'HV024';
+  PostgresError['FDW_INVALID_COLUMN_NAME'] = 'HV007';
+  PostgresError['FDW_INVALID_COLUMN_NUMBER'] = 'HV008';
+  PostgresError['FDW_INVALID_DATA_TYPE'] = 'HV004';
+  PostgresError['FDW_INVALID_DATA_TYPE_DESCRIPTORS'] = 'HV006';
+  PostgresError['FDW_INVALID_DESCRIPTOR_FIELD_IDENTIFIER'] = 'HV091';
+  PostgresError['FDW_INVALID_HANDLE'] = 'HV00B';
+  PostgresError['FDW_INVALID_OPTION_INDEX'] = 'HV00C';
+  PostgresError['FDW_INVALID_OPTION_NAME'] = 'HV00D';
+  PostgresError['FDW_INVALID_STRING_LENGTH_OR_BUFFER_LENGTH'] = 'HV090';
+  PostgresError['FDW_INVALID_STRING_FORMAT'] = 'HV00A';
+  PostgresError['FDW_INVALID_USE_OF_NULL_POINTER'] = 'HV009';
+  PostgresError['FDW_TOO_MANY_HANDLES'] = 'HV014';
+  PostgresError['FDW_OUT_OF_MEMORY'] = 'HV001';
+  PostgresError['FDW_NO_SCHEMAS'] = 'HV00P';
+  PostgresError['FDW_OPTION_NAME_NOT_FOUND'] = 'HV00J';
+  PostgresError['FDW_REPLY_HANDLE'] = 'HV00K';
+  PostgresError['FDW_SCHEMA_NOT_FOUND'] = 'HV00Q';
+  PostgresError['FDW_TABLE_NOT_FOUND'] = 'HV00R';
+  PostgresError['FDW_UNABLE_TO_CREATE_EXECUTION'] = 'HV00L';
+  PostgresError['FDW_UNABLE_TO_CREATE_REPLY'] = 'HV00M';
+  PostgresError['FDW_UNABLE_TO_ESTABLISH_CONNECTION'] = 'HV00N';
+  PostgresError['PLPGSQL_ERROR'] = 'P0000';
+  PostgresError['RAISE_EXCEPTION'] = 'P0001';
+  PostgresError['NO_DATA_FOUND'] = 'P0002';
+  PostgresError['TOO_MANY_ROWS'] = 'P0003';
+  PostgresError['ASSERT_FAILURE'] = 'P0004';
+  PostgresError['INTERNAL_ERROR'] = 'XX000';
+  PostgresError['DATA_CORRUPTED'] = 'XX001';
+  PostgresError['INDEX_CORRUPTED'] = 'XX002';
+  PostgresError['UNDEFINED_CODE'] = '-1';
+  return PostgresError;
+})({});
+
+function _assert_this_initialized$1(self) {
+  if (self === void 0) {
+    throw new ReferenceError(
+      "this hasn't been initialised - super() hasn't been called"
+    );
+  }
+  return self;
+}
+function _call_super$1(_this, derived, args) {
+  derived = _get_prototype_of$1(derived);
+  return _possible_constructor_return$1(
+    _this,
+    _is_native_reflect_construct$1()
+      ? Reflect.construct(
+          derived,
+          args || [],
+          _get_prototype_of$1(_this).constructor
+        )
+      : derived.apply(_this, args)
+  );
+}
+function _class_call_check$2(instance, Constructor) {
+  if (!(instance instanceof Constructor)) {
+    throw new TypeError('Cannot call a class as a function');
+  }
+}
+function _construct$1(Parent, args, Class) {
+  if (_is_native_reflect_construct$1()) {
+    _construct$1 = Reflect.construct;
+  } else {
+    _construct$1 = function construct(Parent, args, Class) {
+      var a = [null];
+      a.push.apply(a, args);
+      var Constructor = Function.bind.apply(Parent, a);
+      var instance = new Constructor();
+      if (Class) _set_prototype_of$1(instance, Class.prototype);
+      return instance;
+    };
+  }
+  return _construct$1.apply(null, arguments);
+}
+function _define_property$1(obj, key, value) {
+  if (key in obj) {
+    Object.defineProperty(obj, key, {
+      value: value,
+      enumerable: true,
+      configurable: true,
+      writable: true,
+    });
+  } else {
+    obj[key] = value;
+  }
+  return obj;
+}
+function _get_prototype_of$1(o) {
+  _get_prototype_of$1 = Object.setPrototypeOf
+    ? Object.getPrototypeOf
+    : function getPrototypeOf(o) {
+        return o.__proto__ || Object.getPrototypeOf(o);
+      };
+  return _get_prototype_of$1(o);
+}
+function _inherits$1(subClass, superClass) {
+  if (typeof superClass !== 'function' && superClass !== null) {
+    throw new TypeError('Super expression must either be null or a function');
+  }
+  subClass.prototype = Object.create(superClass && superClass.prototype, {
+    constructor: {
+      value: subClass,
+      writable: true,
+      configurable: true,
+    },
+  });
+  if (superClass) _set_prototype_of$1(subClass, superClass);
+}
+function _is_native_function$1(fn) {
+  return Function.toString.call(fn).indexOf('[native code]') !== -1;
+}
+function _possible_constructor_return$1(self, call) {
+  if (call && (_type_of$1(call) === 'object' || typeof call === 'function')) {
+    return call;
+  }
+  return _assert_this_initialized$1(self);
+}
+function _set_prototype_of$1(o, p) {
+  _set_prototype_of$1 =
+    Object.setPrototypeOf ||
+    function setPrototypeOf(o, p) {
+      o.__proto__ = p;
+      return o;
+    };
+  return _set_prototype_of$1(o, p);
+}
+function _type_of$1(obj) {
+  '@swc/helpers - typeof';
+  return obj && typeof Symbol !== 'undefined' && obj.constructor === Symbol
+    ? 'symbol'
+    : typeof obj;
+}
+function _wrap_native_super$1(Class) {
+  var _cache = typeof Map === 'function' ? new Map() : undefined;
+  _wrap_native_super$1 = function wrapNativeSuper(Class) {
+    if (Class === null || !_is_native_function$1(Class)) return Class;
+    if (typeof Class !== 'function') {
+      throw new TypeError('Super expression must either be null or a function');
+    }
+    if (typeof _cache !== 'undefined') {
+      if (_cache.has(Class)) return _cache.get(Class);
+      _cache.set(Class, Wrapper);
+    }
+    function Wrapper() {
+      return _construct$1(
+        Class,
+        arguments,
+        _get_prototype_of$1(this).constructor
+      );
+    }
+    Wrapper.prototype = Object.create(Class.prototype, {
+      constructor: {
+        value: Wrapper,
+        enumerable: false,
+        writable: true,
+        configurable: true,
+      },
+    });
+    return _set_prototype_of$1(Wrapper, Class);
+  };
+  return _wrap_native_super$1(Class);
+}
+function _is_native_reflect_construct$1() {
+  try {
+    var result = !Boolean.prototype.valueOf.call(
+      Reflect.construct(Boolean, [], function () {})
+    );
+  } catch (_) {}
+  return (_is_native_reflect_construct$1 = function () {
+    return !!result;
+  })();
+}
+var NativeException = /*#__PURE__*/ (function (Error1) {
+  _inherits$1(NativeException, Error1);
+  function NativeException(code, message) {
+    _class_call_check$2(this, NativeException);
+    var _this;
+    (_this = _call_super$1(this, NativeException, [message])),
+      _define_property$1(_this, 'code', void 0);
+    _this.name = 'ShophubError';
+    _this.code = code;
+    return _this;
+  }
+  return NativeException;
+})(_wrap_native_super$1(Error));
+
+function _assert_this_initialized(self) {
+  if (self === void 0) {
+    throw new ReferenceError(
+      "this hasn't been initialised - super() hasn't been called"
+    );
+  }
+  return self;
+}
+function _call_super(_this, derived, args) {
+  derived = _get_prototype_of(derived);
+  return _possible_constructor_return(
+    _this,
+    _is_native_reflect_construct()
+      ? Reflect.construct(
+          derived,
+          args || [],
+          _get_prototype_of(_this).constructor
+        )
+      : derived.apply(_this, args)
+  );
+}
+function _class_call_check$1(instance, Constructor) {
+  if (!(instance instanceof Constructor)) {
+    throw new TypeError('Cannot call a class as a function');
+  }
+}
+function _construct(Parent, args, Class) {
+  if (_is_native_reflect_construct()) {
+    _construct = Reflect.construct;
+  } else {
+    _construct = function construct(Parent, args, Class) {
+      var a = [null];
+      a.push.apply(a, args);
+      var Constructor = Function.bind.apply(Parent, a);
+      var instance = new Constructor();
+      if (Class) _set_prototype_of(instance, Class.prototype);
+      return instance;
+    };
+  }
+  return _construct.apply(null, arguments);
+}
+function _defineProperties$1(target, props) {
+  for (var i = 0; i < props.length; i++) {
+    var descriptor = props[i];
+    descriptor.enumerable = descriptor.enumerable || false;
+    descriptor.configurable = true;
+    if ('value' in descriptor) descriptor.writable = true;
+    Object.defineProperty(target, descriptor.key, descriptor);
+  }
+}
+function _create_class$1(Constructor, protoProps, staticProps) {
+  if (protoProps) _defineProperties$1(Constructor.prototype, protoProps);
+  return Constructor;
+}
+function _define_property(obj, key, value) {
+  if (key in obj) {
+    Object.defineProperty(obj, key, {
+      value: value,
+      enumerable: true,
+      configurable: true,
+      writable: true,
+    });
+  } else {
+    obj[key] = value;
+  }
+  return obj;
+}
+function _get_prototype_of(o) {
+  _get_prototype_of = Object.setPrototypeOf
+    ? Object.getPrototypeOf
+    : function getPrototypeOf(o) {
+        return o.__proto__ || Object.getPrototypeOf(o);
+      };
+  return _get_prototype_of(o);
+}
+function _inherits(subClass, superClass) {
+  if (typeof superClass !== 'function' && superClass !== null) {
+    throw new TypeError('Super expression must either be null or a function');
+  }
+  subClass.prototype = Object.create(superClass && superClass.prototype, {
+    constructor: {
+      value: subClass,
+      writable: true,
+      configurable: true,
+    },
+  });
+  if (superClass) _set_prototype_of(subClass, superClass);
+}
+function _is_native_function(fn) {
+  return Function.toString.call(fn).indexOf('[native code]') !== -1;
+}
+function _possible_constructor_return(self, call) {
+  if (call && (_type_of(call) === 'object' || typeof call === 'function')) {
+    return call;
+  }
+  return _assert_this_initialized(self);
+}
+function _set_prototype_of(o, p) {
+  _set_prototype_of =
+    Object.setPrototypeOf ||
+    function setPrototypeOf(o, p) {
+      o.__proto__ = p;
+      return o;
+    };
+  return _set_prototype_of(o, p);
+}
+function _type_of(obj) {
+  '@swc/helpers - typeof';
+  return obj && typeof Symbol !== 'undefined' && obj.constructor === Symbol
+    ? 'symbol'
+    : typeof obj;
+}
+function _wrap_native_super(Class) {
+  var _cache = typeof Map === 'function' ? new Map() : undefined;
+  _wrap_native_super = function wrapNativeSuper(Class) {
+    if (Class === null || !_is_native_function(Class)) return Class;
+    if (typeof Class !== 'function') {
+      throw new TypeError('Super expression must either be null or a function');
+    }
+    if (typeof _cache !== 'undefined') {
+      if (_cache.has(Class)) return _cache.get(Class);
+      _cache.set(Class, Wrapper);
+    }
+    function Wrapper() {
+      return _construct(Class, arguments, _get_prototype_of(this).constructor);
+    }
+    Wrapper.prototype = Object.create(Class.prototype, {
+      constructor: {
+        value: Wrapper,
+        enumerable: false,
+        writable: true,
+        configurable: true,
+      },
+    });
+    return _set_prototype_of(Wrapper, Class);
+  };
+  return _wrap_native_super(Class);
+}
+function _is_native_reflect_construct() {
+  try {
+    var result = !Boolean.prototype.valueOf.call(
+      Reflect.construct(Boolean, [], function () {})
+    );
+  } catch (_) {}
+  return (_is_native_reflect_construct = function () {
+    return !!result;
+  })();
+}
+var PgException = /*#__PURE__*/ (function (Error1) {
+  _inherits(PgException, Error1);
+  function PgException(err, message, specific) {
+    _class_call_check$1(this, PgException);
+    var _this;
+    (_this = _call_super(this, PgException, [message])),
+      _define_property(_this, 'err', void 0),
+      _define_property(_this, 'specific', void 0);
+    _this.name = 'PgError';
+    _this.err = err;
+    _this.specific = specific;
+    return _this;
+  }
+  _create_class$1(PgException, [
+    {
+      key: 'getStatus',
+      value: function getStatus() {
+        var _this_err;
+        var _this_err_code;
+        return (_this_err_code =
+          (_this_err = this.err) === null || _this_err === void 0
+            ? void 0
+            : _this_err.code) !== null && _this_err_code !== void 0
+          ? _this_err_code
+          : PostgresError.UNDEFINED_CODE;
+      },
+    },
+    {
+      key: 'getSpecificMessage',
+      value: function getSpecificMessage(status) {
+        if (this.specific && this.specific[status.toString()]) {
+          return this.specific[status.toString()];
+        }
+        return null;
+      },
+    },
+  ]);
+  return PgException;
+})(_wrap_native_super(Error));
+
+var statusMap = {
+  100: 'Continue',
+  101: 'Switching Protocols',
+  102: 'Processing',
+  103: 'Early Hints',
+  200: 'OK',
+  201: 'Created',
+  202: 'Accepted',
+  203: 'Non-Authoritative Information',
+  204: 'No Content',
+  205: 'Reset Content',
+  206: 'Partial Content',
+  300: 'Multiple Choices',
+  301: 'Moved Permanently',
+  302: 'Found',
+  303: 'See Other',
+  304: 'Not Modified',
+  307: 'Temporary Redirect',
+  308: 'Permanent Redirect',
+  400: 'Bad Request',
+  401: 'Unauthorized',
+  402: 'Payment Required',
+  403: 'Forbidden',
+  404: 'Not Found',
+  405: 'Method Not Allowed',
+  406: 'Not Acceptable',
+  407: 'Proxy Authentication Required',
+  408: 'Request Timeout',
+  409: 'Conflict',
+  410: 'Gone',
+  411: 'Length Required',
+  412: 'Precondition Failed',
+  413: 'Payload Too Large',
+  414: 'URI Too Long',
+  415: 'Unsupported Media Type',
+  416: 'Requested Range Not Satisfiable',
+  417: 'Expectation Failed',
+  418: "I'm a Teapot",
+  421: 'Misdirected Request',
+  422: 'Unprocessable Entity',
+  424: 'Failed Dependency',
+  428: 'Precondition Required',
+  429: 'Too Many Requests',
+  500: 'Internal Server Error',
+  501: 'Not Implemented',
+  502: 'Bad Gateway',
+  503: 'Service Unavailable',
+  504: 'Gateway Timeout',
+  505: 'HTTP Version Not Supported',
+};
+function getHttpStatusText(statusCode) {
+  var statusText = statusMap[statusCode];
+  if (!statusText) {
+    return 'Error';
+  }
+  return statusText;
+}
+
+function _class_call_check(instance, Constructor) {
+  if (!(instance instanceof Constructor)) {
+    throw new TypeError('Cannot call a class as a function');
+  }
+}
+function _defineProperties(target, props) {
+  for (var i = 0; i < props.length; i++) {
+    var descriptor = props[i];
+    descriptor.enumerable = descriptor.enumerable || false;
+    descriptor.configurable = true;
+    if ('value' in descriptor) descriptor.writable = true;
+    Object.defineProperty(target, descriptor.key, descriptor);
+  }
+}
+function _create_class(Constructor, protoProps, staticProps) {
+  if (staticProps) _defineProperties(Constructor, staticProps);
+  return Constructor;
+}
+function _instanceof(left, right) {
+  if (
+    right != null &&
+    typeof Symbol !== 'undefined' &&
+    right[Symbol.hasInstance]
+  ) {
+    return !!right[Symbol.hasInstance](left);
+  } else {
+    return left instanceof right;
+  }
+}
+var Exceptions = /*#__PURE__*/ (function () {
+  function Exceptions() {
+    _class_call_check(this, Exceptions);
+  }
+  _create_class(Exceptions, null, [
+    {
+      key: 'transformPgError',
+      value: function transformPgError(error) {
+        var httpStatus;
+        var errMsg = null;
+        switch (error.getStatus()) {
+          case PostgresError.FOREIGN_KEY_VIOLATION:
+            httpStatus = common.HttpStatus.NOT_FOUND;
+            errMsg = error.getSpecificMessage(
+              PostgresError.FOREIGN_KEY_VIOLATION
+            );
+            break;
+          case PostgresError.UNIQUE_VIOLATION:
+            httpStatus = common.HttpStatus.CONFLICT;
+            errMsg = error.getSpecificMessage(PostgresError.UNIQUE_VIOLATION);
+            break;
+          case PostgresError.INVALID_TEXT_REPRESENTATION:
+            httpStatus = common.HttpStatus.BAD_REQUEST;
+            errMsg = error.getSpecificMessage(
+              PostgresError.INVALID_TEXT_REPRESENTATION
+            );
+            break;
+          default:
+            httpStatus = common.HttpStatus.INTERNAL_SERVER_ERROR;
+        }
+        return new NativeException(
+          httpStatus,
+          errMsg !== null && errMsg !== void 0 ? errMsg : error.message
+        );
+      },
+    },
+    {
+      key: 'toHttpException',
+      value: function toHttpException(error) {
+        var _error = error;
+        if (_instanceof(_error, PgException)) {
+          _error = this.transformPgError(_error);
+        }
+        return new common.HttpException(
+          {
+            status: _error.code,
+            message: _error.message,
+            error: getHttpStatusText(_error.code),
+          },
+          _error.code
+        );
+      },
+    },
+  ]);
+  return Exceptions;
+})();
+
+exports.Exceptions = Exceptions;
+exports.NativeException = NativeException;
+exports.PgException = PgException;
+exports.PostgresError = PostgresError;