@jskit-ai/database-runtime 0.1.184 → 0.1.186

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jskit-ai/database-runtime",
-  "version": "0.1.184",
+  "version": "0.1.186",
   "type": "module",
   "scripts": {
     "test": "node --test"
@@ -21,7 +21,6 @@
     "./shared/repositoryOptions": "./src/shared/repositoryOptions.js",
     "./shared/visibility": "./src/shared/visibility.js",
     "./shared/retention": "./src/shared/retention.js",
-    "./shared/runtime": "./src/shared/runtime.js",
     "./shared/runtimeErrors": "./src/shared/runtimeErrors.js",
     "./shared/transactionManager": "./src/shared/transactionManager.js",
     "./shared/transactions": "./src/shared/transactions.js"
@@ -80,6 +79,6 @@
     }
   },
   "peerDependencies": {
-    "@jskit-ai/kernel": "0.1.184"
+    "@jskit-ai/kernel": "0.1.186"
   }
 }

package/src/shared/duplicateEntry.js

@@ -15,23 +15,35 @@ function isPostgresDuplicateEntryError(error) {
   return code === "23505";
 }
 
-function isDuplicateEntryError(error, { dialect = "", client = null } = {}) {
-  if (!error) {
-    return false;
-  }
-
+function findDuplicateEntryError(error, { dialect = "", client = null } = {}) {
   const resolvedDialect =
     normalizeDialect(dialect) || (client ? normalizeDialect(detectDialectFromClient(client)) : "");
-
-  if (resolvedDialect === "postgres") {
-    return isPostgresDuplicateEntryError(error);
+  const seen = new Set();
+  let duplicate = null;
+
+  while (error && typeof error === "object" && !seen.has(error)) {
+    seen.add(error);
+    let matches;
+    if (resolvedDialect === "postgres") {
+      matches = isPostgresDuplicateEntryError(error);
+    } else if (resolvedDialect === "mysql") {
+      matches = isMysqlDuplicateEntryError(error);
+    } else {
+      matches = isMysqlDuplicateEntryError(error) || isPostgresDuplicateEntryError(error);
+    }
+
+    if (matches) {
+      // Wrappers may copy driver codes; retain the underlying constraint details.
+      duplicate = error;
+    }
+    error = error.cause;
   }
 
-  if (resolvedDialect === "mysql") {
-    return isMysqlDuplicateEntryError(error);
-  }
+  return duplicate;
+}
 
-  return isMysqlDuplicateEntryError(error) || isPostgresDuplicateEntryError(error);
+function isDuplicateEntryError(error, options) {
+  return findDuplicateEntryError(error, options) !== null;
 }
 
-export { isDuplicateEntryError };
+export { findDuplicateEntryError, isDuplicateEntryError };

package/src/shared/index.js

@@ -23,7 +23,7 @@ export {
   resolveDatabaseConnectionFromEnvironment,
   resolveKnexConnectionFromEnvironment
 } from "./databaseConnection.js";
-export { isDuplicateEntryError } from "./duplicateEntry.js";
+export { findDuplicateEntryError, isDuplicateEntryError } from "./duplicateEntry.js";
 export { normalizePath, jsonTextExpression, whereJsonTextEquals } from "./json.js";
 export { DEFAULT_VISIBILITY_COLUMNS, applyVisibility, applyVisibilityOwners } from "./visibility.js";
 export { createRepositoryScope } from "./repositoryScope.js";

package/test/duplicateEntry.test.js

@@ -1,6 +1,6 @@
 import test from "node:test";
 import assert from "node:assert/strict";
-import { isDuplicateEntryError } from "../src/shared/duplicateEntry.js";
+import { findDuplicateEntryError, isDuplicateEntryError } from "../src/shared/duplicateEntry.js";
 
 test("isDuplicateEntryError matches mysql and postgres duplicate signatures", () => {
   assert.equal(isDuplicateEntryError({ code: "ER_DUP_ENTRY" }), true);
@@ -8,3 +8,26 @@ test("isDuplicateEntryError matches mysql and postgres duplicate signatures", ()
   assert.equal(isDuplicateEntryError({ code: "23505" }), true);
   assert.equal(isDuplicateEntryError({ code: "ER_PARSE_ERROR", errno: 1064 }), false);
 });
+
+test("duplicate classification follows causes and retains the database error", () => {
+  const databaseError = Object.freeze({ code: "23505", message: "users_email_unique" });
+  const failure = new Error("Write failed", { cause: new Error("Storage failed", { cause: databaseError }) });
+
+  assert.equal(isDuplicateEntryError(failure, { dialect: "postgres" }), true);
+  assert.equal(findDuplicateEntryError(failure), databaseError);
+  failure.code = "23505";
+  assert.equal(findDuplicateEntryError(failure), databaseError);
+  assert.equal(findDuplicateEntryError(failure, { dialect: "mysql" }), null);
+  assert.equal(findDuplicateEntryError({ cause: { errno: 1062 } }, { dialect: "mysql" }).errno, 1062);
+});
+
+test("duplicate classification terminates on missing, primitive and cyclic causes", () => {
+  const first = new Error("first");
+  const second = new Error("second", { cause: first });
+  first.cause = second;
+
+  for (const error of [null, undefined, false, "failure", { cause: 42 }, first]) {
+    assert.equal(findDuplicateEntryError(error), null);
+    assert.equal(isDuplicateEntryError(error), false);
+  }
+});