@adaptic/backend-legacy 0.0.959 → 0.0.961

package/ABTest.cjs

@@ -1780,13 +1780,28 @@ exports.ABTest = {
                     await new Promise(resolve => setTimeout(resolve, delay));
                     continue;
                 }
-                // Log structured error details and rethrow
-                logger_1.logger.error("Database create operation failed", {
-                    operation: 'createOneABTest',
-                    model: 'ABTest',
-                    error: String(error),
-                    isRetryable: isConnectionError,
-                });
+                // Log structured error details and rethrow.
+                // Demote transient failures to WARN with explicit transient+recoveryHint
+                // metadata so log analytics can distinguish recoverable upstream retries
+                // from true defects.
+                if (isConnectionError) {
+                    logger_1.logger.warn("Database create operation failed (transient after retries)", {
+                        operation: 'createOneABTest',
+                        model: 'ABTest',
+                        error: String(error),
+                        isRetryable: true,
+                        transient: true,
+                        recoveryHint: "Upstream caller should retry on next cycle",
+                    });
+                }
+                else {
+                    logger_1.logger.error("Database create operation failed", {
+                        operation: 'createOneABTest',
+                        model: 'ABTest',
+                        error: String(error),
+                        isRetryable: false,
+                    });
+                }
                 throw error;
             }
         }
@@ -1930,13 +1945,25 @@ exports.ABTest = {
                     await new Promise(resolve => setTimeout(resolve, delay));
                     continue;
                 }
-                // Log structured error details and rethrow
-                logger_1.logger.error("Database createMany operation failed", {
-                    operation: 'createManyABTest',
-                    model: 'ABTest',
-                    error: String(error),
-                    isRetryable: isConnectionError,
-                });
+                // Log structured error details and rethrow (transient -> WARN).
+                if (isConnectionError) {
+                    logger_1.logger.warn("Database createMany operation failed (transient after retries)", {
+                        operation: 'createManyABTest',
+                        model: 'ABTest',
+                        error: String(error),
+                        isRetryable: true,
+                        transient: true,
+                        recoveryHint: "Upstream caller should retry on next cycle",
+                    });
+                }
+                else {
+                    logger_1.logger.error("Database createMany operation failed", {
+                        operation: 'createManyABTest',
+                        model: 'ABTest',
+                        error: String(error),
+                        isRetryable: false,
+                    });
+                }
                 throw error;
             }
         }
@@ -7919,14 +7946,27 @@ exports.ABTest = {
                     await new Promise(resolve => setTimeout(resolve, delay));
                     continue;
                 }
-                // Log structured error details and rethrow
-                logger_1.logger.error("Database update operation failed", {
-                    operation: 'updateOneABTest',
-                    model: 'ABTest',
-                    error: String(error),
-                    recordId: props.id,
-                    isRetryable: isConnectionError,
-                });
+                // Log structured error details and rethrow (transient -> WARN).
+                if (isConnectionError) {
+                    logger_1.logger.warn("Database update operation failed (transient after retries)", {
+                        operation: 'updateOneABTest',
+                        model: 'ABTest',
+                        error: String(error),
+                        recordId: props.id,
+                        isRetryable: true,
+                        transient: true,
+                        recoveryHint: "Upstream caller should retry on next cycle",
+                    });
+                }
+                else {
+                    logger_1.logger.error("Database update operation failed", {
+                        operation: 'updateOneABTest',
+                        model: 'ABTest',
+                        error: String(error),
+                        recordId: props.id,
+                        isRetryable: false,
+                    });
+                }
                 throw error;
             }
         }
@@ -15396,14 +15436,27 @@ exports.ABTest = {
                     await new Promise(resolve => setTimeout(resolve, delay));
                     continue;
                 }
-                // Log structured error details and rethrow
-                logger_1.logger.error("Database upsert operation failed", {
-                    operation: 'upsertOneABTest',
-                    model: 'ABTest',
-                    error: String(error),
-                    recordId: props.id,
-                    isRetryable: isConnectionError,
-                });
+                // Log structured error details and rethrow (transient -> WARN).
+                if (isConnectionError) {
+                    logger_1.logger.warn("Database upsert operation failed (transient after retries)", {
+                        operation: 'upsertOneABTest',
+                        model: 'ABTest',
+                        error: String(error),
+                        recordId: props.id,
+                        isRetryable: true,
+                        transient: true,
+                        recoveryHint: "Upstream caller should retry on next cycle",
+                    });
+                }
+                else {
+                    logger_1.logger.error("Database upsert operation failed", {
+                        operation: 'upsertOneABTest',
+                        model: 'ABTest',
+                        error: String(error),
+                        recordId: props.id,
+                        isRetryable: false,
+                    });
+                }
                 throw error;
             }
         }
@@ -21384,13 +21437,25 @@ exports.ABTest = {
                     await new Promise(resolve => setTimeout(resolve, delay));
                     continue;
                 }
-                // Log structured error details and rethrow
-                logger_1.logger.error("Database updateMany operation failed", {
-                    operation: 'updateManyABTest',
-                    model: 'ABTest',
-                    error: String(error),
-                    isRetryable: isConnectionError,
-                });
+                // Log structured error details and rethrow (transient -> WARN).
+                if (isConnectionError) {
+                    logger_1.logger.warn("Database updateMany operation failed (transient after retries)", {
+                        operation: 'updateManyABTest',
+                        model: 'ABTest',
+                        error: String(error),
+                        isRetryable: true,
+                        transient: true,
+                        recoveryHint: "Upstream caller should retry on next cycle",
+                    });
+                }
+                else {
+                    logger_1.logger.error("Database updateMany operation failed", {
+                        operation: 'updateManyABTest',
+                        model: 'ABTest',
+                        error: String(error),
+                        isRetryable: false,
+                    });
+                }
                 throw error;
             }
         }
@@ -21513,14 +21578,27 @@ exports.ABTest = {
                     await new Promise(resolve => setTimeout(resolve, delay));
                     continue;
                 }
-                // Log structured error details and rethrow
-                logger_1.logger.error("Database delete operation failed", {
-                    operation: 'deleteOneABTest',
-                    model: 'ABTest',
-                    error: String(error),
-                    recordId: props.id,
-                    isRetryable: isConnectionError,
-                });
+                // Log structured error details and rethrow (transient -> WARN).
+                if (isConnectionError) {
+                    logger_1.logger.warn("Database delete operation failed (transient after retries)", {
+                        operation: 'deleteOneABTest',
+                        model: 'ABTest',
+                        error: String(error),
+                        recordId: props.id,
+                        isRetryable: true,
+                        transient: true,
+                        recoveryHint: "Upstream caller should retry on next cycle",
+                    });
+                }
+                else {
+                    logger_1.logger.error("Database delete operation failed", {
+                        operation: 'deleteOneABTest',
+                        model: 'ABTest',
+                        error: String(error),
+                        recordId: props.id,
+                        isRetryable: false,
+                    });
+                }
                 throw error;
             }
         }
@@ -21628,13 +21706,25 @@ exports.ABTest = {
                     await new Promise(resolve => setTimeout(resolve, delay));
                     continue;
                 }
-                // Log structured error details and rethrow
-                logger_1.logger.error("Database get operation failed", {
-                    operation: 'getABTest',
-                    model: 'ABTest',
-                    error: String(error),
-                    isRetryable: isConnectionError,
-                });
+                // Log structured error details and rethrow (transient -> WARN).
+                if (isConnectionError) {
+                    logger_1.logger.warn("Database get operation failed (transient after retries)", {
+                        operation: 'getABTest',
+                        model: 'ABTest',
+                        error: String(error),
+                        isRetryable: true,
+                        transient: true,
+                        recoveryHint: "Upstream caller should retry on next cycle",
+                    });
+                }
+                else {
+                    logger_1.logger.error("Database get operation failed", {
+                        operation: 'getABTest',
+                        model: 'ABTest',
+                        error: String(error),
+                        isRetryable: false,
+                    });
+                }
                 throw error;
             }
         }
@@ -21721,13 +21811,25 @@ exports.ABTest = {
                     await new Promise(resolve => setTimeout(resolve, delay));
                     continue;
                 }
-                // Log structured error details and rethrow
-                logger_1.logger.error("Database getAll operation failed", {
-                    operation: 'getAllABTest',
-                    model: 'ABTest',
-                    error: String(error),
-                    isRetryable: isConnectionError,
-                });
+                // Log structured error details and rethrow (transient -> WARN).
+                if (isConnectionError) {
+                    logger_1.logger.warn("Database getAll operation failed (transient after retries)", {
+                        operation: 'getAllABTest',
+                        model: 'ABTest',
+                        error: String(error),
+                        isRetryable: true,
+                        transient: true,
+                        recoveryHint: "Upstream caller should retry on next cycle",
+                    });
+                }
+                else {
+                    logger_1.logger.error("Database getAll operation failed", {
+                        operation: 'getAllABTest',
+                        model: 'ABTest',
+                        error: String(error),
+                        isRetryable: false,
+                    });
+                }
                 throw error;
             }
         }
@@ -21847,13 +21949,25 @@ exports.ABTest = {
                     await new Promise(resolve => setTimeout(resolve, delay));
                     continue;
                 }
-                // Log structured error details and rethrow
-                logger_1.logger.error("Database findMany operation failed", {
-                    operation: 'findManyABTest',
-                    model: 'ABTest',
-                    error: String(error),
-                    isRetryable: isConnectionError,
-                });
+                // Log structured error details and rethrow (transient -> WARN).
+                if (isConnectionError) {
+                    logger_1.logger.warn("Database findMany operation failed (transient after retries)", {
+                        operation: 'findManyABTest',
+                        model: 'ABTest',
+                        error: String(error),
+                        isRetryable: true,
+                        transient: true,
+                        recoveryHint: "Upstream caller should retry on next cycle",
+                    });
+                }
+                else {
+                    logger_1.logger.error("Database findMany operation failed", {
+                        operation: 'findManyABTest',
+                        model: 'ABTest',
+                        error: String(error),
+                        isRetryable: false,
+                    });
+                }
                 throw error;
             }
         }

package/Account.cjs

@@ -594,13 +594,28 @@ exports.Account = {
                     await new Promise(resolve => setTimeout(resolve, delay));
                     continue;
                 }
-                // Log structured error details and rethrow
-                logger_1.logger.error("Database create operation failed", {
-                    operation: 'createOneAccount',
-                    model: 'Account',
-                    error: String(error),
-                    isRetryable: isConnectionError,
-                });
+                // Log structured error details and rethrow.
+                // Demote transient failures to WARN with explicit transient+recoveryHint
+                // metadata so log analytics can distinguish recoverable upstream retries
+                // from true defects.
+                if (isConnectionError) {
+                    logger_1.logger.warn("Database create operation failed (transient after retries)", {
+                        operation: 'createOneAccount',
+                        model: 'Account',
+                        error: String(error),
+                        isRetryable: true,
+                        transient: true,
+                        recoveryHint: "Upstream caller should retry on next cycle",
+                    });
+                }
+                else {
+                    logger_1.logger.error("Database create operation failed", {
+                        operation: 'createOneAccount',
+                        model: 'Account',
+                        error: String(error),
+                        isRetryable: false,
+                    });
+                }
                 throw error;
             }
         }
@@ -729,13 +744,25 @@ exports.Account = {
                     await new Promise(resolve => setTimeout(resolve, delay));
                     continue;
                 }
-                // Log structured error details and rethrow
-                logger_1.logger.error("Database createMany operation failed", {
-                    operation: 'createManyAccount',
-                    model: 'Account',
-                    error: String(error),
-                    isRetryable: isConnectionError,
-                });
+                // Log structured error details and rethrow (transient -> WARN).
+                if (isConnectionError) {
+                    logger_1.logger.warn("Database createMany operation failed (transient after retries)", {
+                        operation: 'createManyAccount',
+                        model: 'Account',
+                        error: String(error),
+                        isRetryable: true,
+                        transient: true,
+                        recoveryHint: "Upstream caller should retry on next cycle",
+                    });
+                }
+                else {
+                    logger_1.logger.error("Database createMany operation failed", {
+                        operation: 'createManyAccount',
+                        model: 'Account',
+                        error: String(error),
+                        isRetryable: false,
+                    });
+                }
                 throw error;
             }
         }
@@ -2513,14 +2540,27 @@ exports.Account = {
                     await new Promise(resolve => setTimeout(resolve, delay));
                     continue;
                 }
-                // Log structured error details and rethrow
-                logger_1.logger.error("Database update operation failed", {
-                    operation: 'updateOneAccount',
-                    model: 'Account',
-                    error: String(error),
-                    recordId: props.id,
-                    isRetryable: isConnectionError,
-                });
+                // Log structured error details and rethrow (transient -> WARN).
+                if (isConnectionError) {
+                    logger_1.logger.warn("Database update operation failed (transient after retries)", {
+                        operation: 'updateOneAccount',
+                        model: 'Account',
+                        error: String(error),
+                        recordId: props.id,
+                        isRetryable: true,
+                        transient: true,
+                        recoveryHint: "Upstream caller should retry on next cycle",
+                    });
+                }
+                else {
+                    logger_1.logger.error("Database update operation failed", {
+                        operation: 'updateOneAccount',
+                        model: 'Account',
+                        error: String(error),
+                        recordId: props.id,
+                        isRetryable: false,
+                    });
+                }
                 throw error;
             }
         }
@@ -4749,14 +4789,27 @@ exports.Account = {
                     await new Promise(resolve => setTimeout(resolve, delay));
                     continue;
                 }
-                // Log structured error details and rethrow
-                logger_1.logger.error("Database upsert operation failed", {
-                    operation: 'upsertOneAccount',
-                    model: 'Account',
-                    error: String(error),
-                    recordId: props.id,
-                    isRetryable: isConnectionError,
-                });
+                // Log structured error details and rethrow (transient -> WARN).
+                if (isConnectionError) {
+                    logger_1.logger.warn("Database upsert operation failed (transient after retries)", {
+                        operation: 'upsertOneAccount',
+                        model: 'Account',
+                        error: String(error),
+                        recordId: props.id,
+                        isRetryable: true,
+                        transient: true,
+                        recoveryHint: "Upstream caller should retry on next cycle",
+                    });
+                }
+                else {
+                    logger_1.logger.error("Database upsert operation failed", {
+                        operation: 'upsertOneAccount',
+                        model: 'Account',
+                        error: String(error),
+                        recordId: props.id,
+                        isRetryable: false,
+                    });
+                }
                 throw error;
             }
         }
@@ -6532,13 +6585,25 @@ exports.Account = {
                     await new Promise(resolve => setTimeout(resolve, delay));
                     continue;
                 }
-                // Log structured error details and rethrow
-                logger_1.logger.error("Database updateMany operation failed", {
-                    operation: 'updateManyAccount',
-                    model: 'Account',
-                    error: String(error),
-                    isRetryable: isConnectionError,
-                });
+                // Log structured error details and rethrow (transient -> WARN).
+                if (isConnectionError) {
+                    logger_1.logger.warn("Database updateMany operation failed (transient after retries)", {
+                        operation: 'updateManyAccount',
+                        model: 'Account',
+                        error: String(error),
+                        isRetryable: true,
+                        transient: true,
+                        recoveryHint: "Upstream caller should retry on next cycle",
+                    });
+                }
+                else {
+                    logger_1.logger.error("Database updateMany operation failed", {
+                        operation: 'updateManyAccount',
+                        model: 'Account',
+                        error: String(error),
+                        isRetryable: false,
+                    });
+                }
                 throw error;
             }
         }
@@ -6661,14 +6726,27 @@ exports.Account = {
                     await new Promise(resolve => setTimeout(resolve, delay));
                     continue;
                 }
-                // Log structured error details and rethrow
-                logger_1.logger.error("Database delete operation failed", {
-                    operation: 'deleteOneAccount',
-                    model: 'Account',
-                    error: String(error),
-                    recordId: props.id,
-                    isRetryable: isConnectionError,
-                });
+                // Log structured error details and rethrow (transient -> WARN).
+                if (isConnectionError) {
+                    logger_1.logger.warn("Database delete operation failed (transient after retries)", {
+                        operation: 'deleteOneAccount',
+                        model: 'Account',
+                        error: String(error),
+                        recordId: props.id,
+                        isRetryable: true,
+                        transient: true,
+                        recoveryHint: "Upstream caller should retry on next cycle",
+                    });
+                }
+                else {
+                    logger_1.logger.error("Database delete operation failed", {
+                        operation: 'deleteOneAccount',
+                        model: 'Account',
+                        error: String(error),
+                        recordId: props.id,
+                        isRetryable: false,
+                    });
+                }
                 throw error;
             }
         }
@@ -6771,13 +6849,25 @@ exports.Account = {
                     await new Promise(resolve => setTimeout(resolve, delay));
                     continue;
                 }
-                // Log structured error details and rethrow
-                logger_1.logger.error("Database get operation failed", {
-                    operation: 'getAccount',
-                    model: 'Account',
-                    error: String(error),
-                    isRetryable: isConnectionError,
-                });
+                // Log structured error details and rethrow (transient -> WARN).
+                if (isConnectionError) {
+                    logger_1.logger.warn("Database get operation failed (transient after retries)", {
+                        operation: 'getAccount',
+                        model: 'Account',
+                        error: String(error),
+                        isRetryable: true,
+                        transient: true,
+                        recoveryHint: "Upstream caller should retry on next cycle",
+                    });
+                }
+                else {
+                    logger_1.logger.error("Database get operation failed", {
+                        operation: 'getAccount',
+                        model: 'Account',
+                        error: String(error),
+                        isRetryable: false,
+                    });
+                }
                 throw error;
             }
         }
@@ -6864,13 +6954,25 @@ exports.Account = {
                     await new Promise(resolve => setTimeout(resolve, delay));
                     continue;
                 }
-                // Log structured error details and rethrow
-                logger_1.logger.error("Database getAll operation failed", {
-                    operation: 'getAllAccount',
-                    model: 'Account',
-                    error: String(error),
-                    isRetryable: isConnectionError,
-                });
+                // Log structured error details and rethrow (transient -> WARN).
+                if (isConnectionError) {
+                    logger_1.logger.warn("Database getAll operation failed (transient after retries)", {
+                        operation: 'getAllAccount',
+                        model: 'Account',
+                        error: String(error),
+                        isRetryable: true,
+                        transient: true,
+                        recoveryHint: "Upstream caller should retry on next cycle",
+                    });
+                }
+                else {
+                    logger_1.logger.error("Database getAll operation failed", {
+                        operation: 'getAllAccount',
+                        model: 'Account',
+                        error: String(error),
+                        isRetryable: false,
+                    });
+                }
                 throw error;
             }
         }
@@ -6987,13 +7089,25 @@ exports.Account = {
                     await new Promise(resolve => setTimeout(resolve, delay));
                     continue;
                 }
-                // Log structured error details and rethrow
-                logger_1.logger.error("Database findMany operation failed", {
-                    operation: 'findManyAccount',
-                    model: 'Account',
-                    error: String(error),
-                    isRetryable: isConnectionError,
-                });
+                // Log structured error details and rethrow (transient -> WARN).
+                if (isConnectionError) {
+                    logger_1.logger.warn("Database findMany operation failed (transient after retries)", {
+                        operation: 'findManyAccount',
+                        model: 'Account',
+                        error: String(error),
+                        isRetryable: true,
+                        transient: true,
+                        recoveryHint: "Upstream caller should retry on next cycle",
+                    });
+                }
+                else {
+                    logger_1.logger.error("Database findMany operation failed", {
+                        operation: 'findManyAccount',
+                        model: 'Account',
+                        error: String(error),
+                        isRetryable: false,
+                    });
+                }
                 throw error;
             }
         }