qlcodes 1.2.0 → 1.3.1

package/README.md

@@ -55,9 +55,58 @@ Output :
 }
 ```
 
+Alternatively, you may need to retrive matching codes via a known key for some technologies
+
+```js
+import { lens } from "qlcodes";
+
+const state = lens("insufficient_privilege");
+
+console.log(state);
+```
+
+Output :
+
+```js
+{
+  "key": "insufficient_privilege",
+  "qlcs": "qlcodes_success",
+  "matches": [
+    {
+      "code": "42501",
+      "keys": [
+        "insufficient_privilege",
+        "authorization_id_does_not_have_privilege_to_perform_specified_operation_on_identified_object"
+      ],
+      "reasons": [
+        "The authorization ID does not have the privilege to perform the specified operation on the identified object."
+      ],
+      "use": [
+        "pgsql",
+        "ibm"
+      ],
+      "class": "42 - Syntax Error or Access Rule Violation"
+    },
+    {
+      "code": "258",
+      "keys": [
+        "insufficient_privilege"
+      ],
+      "reasons": [
+        "Insufficient privilege"
+      ],
+      "use": [
+        "sap_hana"
+      ],
+      "class": "NA - Non associable class codes"
+    }
+  ]
+}
+```
+
 ### Mismatches
 
-If the provided SQLSTATE does not match any known entry, we return a normalized fallback object
+If the provided SQLSTATE code or provided key does not match any known entry, we return a normalized fallback object
 This guarantees that lens() always returns a predictable object shape.
 
 There are three mismatch levels that we detect.

package/dist/index.mjs

@@ -1,69 +1,120 @@
-import { readFileSync } from "fs";
+import data from "./qlCodes.json" with { type: "json" };
 
-const data = JSON.parse(readFileSync("./qlCodes.json"));
+const keyRegex = /^[a-zA-Z0-9_]+$/;
+const codeRegex = /^[A-Z0-9]{5}$/;
 
-export const lens = (code) => {
-	let response = {
-		code,
-		qlcs: "",
-		matches: [],
-	};
+const NON_ASSOCIATED_CLASS = "NA";
 
-	try {
-		// ---- validation ----
-		if (
-			code === "" ||
-			(!code && code !== "0") ||
-			!/^[A-Z0-9]{5}$/.test(`${code}`.padStart(5, "0"))
-		) {
-			throw "qlcodes_malformed";
-		}
+const QLCODES_ERR_MALFORMED = "qlcodes_malformed";
+const QLCODES_ERR_NOT_FOUND = "qlcodes_no_code_found";
+const QLCODES_ERR_UNEXPECTED_ERR = "qlcodes_unexpected_error";
 
-		const paddedCode = `${code}`.padStart(5, "0");
+const QLCODES_SUCCESS = "qlcodes_success";
 
-		// ---- find matching class ----
-		const classEntry = Object.entries(data).find(([id]) =>
-			paddedCode.startsWith(id)
-		);
+const _validateSearch = (search, response) => {
+	if (
+		search === "" ||
+		(!search && search !== "0") ||
+		(!codeRegex.test(`${search}`.padStart(5, "0")) &&
+			!keyRegex.test(`${search}`))
+	) {
+		throw QLCODES_ERR_MALFORMED;
+	} else if (codeRegex.test(`${search}`)) {
+		response.code = search;
+	} else {
+		response.key = search;
+	}
+};
 
-		const classesToSearch = [];
+const _getHitKeyOrCode = (cls, response, paddedSearch) => {
+	if (!response.key && !response.code) {
+		return [];
+	}
+	const matchingInKeys = (x) => x.keys.find((k) => paddedSearch === k);
+	const matchingCode = (x) =>
+		x.code === paddedSearch || x.code === paddedSearch;
 
-		if (classEntry) {
-			classesToSearch.push({
-				id: classEntry[0],
-				data: classEntry[1],
-			});
-		}
+	return cls.data.messageSet.filter(
+		response.key ? matchingInKeys : matchingCode
+	);
+};
 
-		// Always include NA as fallback / collision source
-		if (data["NA"]) {
-			classesToSearch.push({
-				id: "NA",
-				data: data["NA"],
+const _collectAllMatches = (classesToSearch, response, paddedSearch) => {
+	const matches = [];
+	for (const cls of classesToSearch) {
+		for (const hit of _getHitKeyOrCode(cls, response, paddedSearch)) {
+			matches.push({
+				...hit,
+				class: `${cls.id} - ${cls.data.label}`,
 			});
 		}
+	}
+	return matches;
+};
 
-		// ---- collect all matches ----
-		for (const cls of classesToSearch) {
-			const hits = cls.data.messageSet.filter(
-				(x) => x.code === paddedCode || x.code === code
-			);
-
-			for (const hit of hits) {
-				response.matches.push({
-					...hit,
-					class: `${cls.id} - ${cls.data.label}`,
-				});
-			}
-		}
+const _classesForCodeSearch = (entries, paddedSearch) => {
+	const classesToSearch = [];
+	const classEntry = entries.find(([id]) => paddedSearch.startsWith(id));
+	if (classEntry) {
+		classesToSearch.push({
+			id: classEntry[0],
+			data: classEntry[1],
+		});
+	}
+	// Always include NA as fallback / collision source
+	if (data[NON_ASSOCIATED_CLASS]) {
+		classesToSearch.push({
+			id: NON_ASSOCIATED_CLASS,
+			data: data[NON_ASSOCIATED_CLASS],
+		});
+	}
+	return classesToSearch;
+};
+
+const _classesForKeySearche = (entries) => {
+	const classesToSearch = [];
+	entries.forEach(([id]) => {
+		classesToSearch.push({
+			id,
+			data: data[id],
+		});
+	});
+	return classesToSearch;
+};
+
+export const lens = (search) => {
+	let response = {
+		code: undefined,
+		key: undefined,
+		qlcs: "",
+		matches: [],
+	};
+
+	try {
+		_validateSearch(search, response);
+
+		const paddedSearch = `${search}`.padStart(5, "0");
+		const classes = Object.entries(data);
+
+		const classesToSearch = response.code
+			? _classesForCodeSearch(classes, paddedSearch)
+			: response.key
+			? _classesForKeySearche(classes)
+			: [];
+
+		response.matches = _collectAllMatches(
+			classesToSearch,
+			response,
+			paddedSearch
+		);
 
 		if (response.matches.length === 0) {
-			throw "qlcodes_no_code_found";
+			throw QLCODES_ERR_NOT_FOUND;
 		}
 
-		response.qlcs = "qlcodes_success";
+		response.qlcs = QLCODES_SUCCESS;
 	} catch (err) {
-		response.qlcs = typeof err === "string" ? err : "qlcodes_unexpected_error";
+		response.qlcs = typeof err === "string" ? err : QLCODES_ERR_UNEXPECTED_ERR;
 	}
 
 	return response;