@adaptic/backend-legacy 0.0.960 → 0.0.962

package/TradingPolicy.cjs

@@ -660,13 +660,28 @@ exports.TradingPolicy = {
                     await new Promise(resolve => setTimeout(resolve, delay));
                     continue;
                 }
-                // Log structured error details and rethrow
-                logger_1.logger.error("Database create operation failed", {
-                    operation: 'createOneTradingPolicy',
-                    model: 'TradingPolicy',
-                    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: 'createOneTradingPolicy',
+                        model: 'TradingPolicy',
+                        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: 'createOneTradingPolicy',
+                        model: 'TradingPolicy',
+                        error: String(error),
+                        isRetryable: false,
+                    });
+                }
                 throw error;
             }
         }
@@ -848,13 +863,25 @@ exports.TradingPolicy = {
                     await new Promise(resolve => setTimeout(resolve, delay));
                     continue;
                 }
-                // Log structured error details and rethrow
-                logger_1.logger.error("Database createMany operation failed", {
-                    operation: 'createManyTradingPolicy',
-                    model: 'TradingPolicy',
-                    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: 'createManyTradingPolicy',
+                        model: 'TradingPolicy',
+                        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: 'createManyTradingPolicy',
+                        model: 'TradingPolicy',
+                        error: String(error),
+                        isRetryable: false,
+                    });
+                }
                 throw error;
             }
         }
@@ -2566,14 +2593,27 @@ exports.TradingPolicy = {
                     await new Promise(resolve => setTimeout(resolve, delay));
                     continue;
                 }
-                // Log structured error details and rethrow
-                logger_1.logger.error("Database update operation failed", {
-                    operation: 'updateOneTradingPolicy',
-                    model: 'TradingPolicy',
-                    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: 'updateOneTradingPolicy',
+                        model: 'TradingPolicy',
+                        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: 'updateOneTradingPolicy',
+                        model: 'TradingPolicy',
+                        error: String(error),
+                        recordId: props.id,
+                        isRetryable: false,
+                    });
+                }
                 throw error;
             }
         }
@@ -4752,14 +4792,27 @@ exports.TradingPolicy = {
                     await new Promise(resolve => setTimeout(resolve, delay));
                     continue;
                 }
-                // Log structured error details and rethrow
-                logger_1.logger.error("Database upsert operation failed", {
-                    operation: 'upsertOneTradingPolicy',
-                    model: 'TradingPolicy',
-                    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: 'upsertOneTradingPolicy',
+                        model: 'TradingPolicy',
+                        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: 'upsertOneTradingPolicy',
+                        model: 'TradingPolicy',
+                        error: String(error),
+                        recordId: props.id,
+                        isRetryable: false,
+                    });
+                }
                 throw error;
             }
         }
@@ -6469,13 +6522,25 @@ exports.TradingPolicy = {
                     await new Promise(resolve => setTimeout(resolve, delay));
                     continue;
                 }
-                // Log structured error details and rethrow
-                logger_1.logger.error("Database updateMany operation failed", {
-                    operation: 'updateManyTradingPolicy',
-                    model: 'TradingPolicy',
-                    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: 'updateManyTradingPolicy',
+                        model: 'TradingPolicy',
+                        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: 'updateManyTradingPolicy',
+                        model: 'TradingPolicy',
+                        error: String(error),
+                        isRetryable: false,
+                    });
+                }
                 throw error;
             }
         }
@@ -6598,14 +6663,27 @@ exports.TradingPolicy = {
                     await new Promise(resolve => setTimeout(resolve, delay));
                     continue;
                 }
-                // Log structured error details and rethrow
-                logger_1.logger.error("Database delete operation failed", {
-                    operation: 'deleteOneTradingPolicy',
-                    model: 'TradingPolicy',
-                    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: 'deleteOneTradingPolicy',
+                        model: 'TradingPolicy',
+                        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: 'deleteOneTradingPolicy',
+                        model: 'TradingPolicy',
+                        error: String(error),
+                        recordId: props.id,
+                        isRetryable: false,
+                    });
+                }
                 throw error;
             }
         }
@@ -6711,13 +6789,25 @@ exports.TradingPolicy = {
                     await new Promise(resolve => setTimeout(resolve, delay));
                     continue;
                 }
-                // Log structured error details and rethrow
-                logger_1.logger.error("Database get operation failed", {
-                    operation: 'getTradingPolicy',
-                    model: 'TradingPolicy',
-                    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: 'getTradingPolicy',
+                        model: 'TradingPolicy',
+                        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: 'getTradingPolicy',
+                        model: 'TradingPolicy',
+                        error: String(error),
+                        isRetryable: false,
+                    });
+                }
                 throw error;
             }
         }
@@ -6804,13 +6894,25 @@ exports.TradingPolicy = {
                     await new Promise(resolve => setTimeout(resolve, delay));
                     continue;
                 }
-                // Log structured error details and rethrow
-                logger_1.logger.error("Database getAll operation failed", {
-                    operation: 'getAllTradingPolicy',
-                    model: 'TradingPolicy',
-                    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: 'getAllTradingPolicy',
+                        model: 'TradingPolicy',
+                        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: 'getAllTradingPolicy',
+                        model: 'TradingPolicy',
+                        error: String(error),
+                        isRetryable: false,
+                    });
+                }
                 throw error;
             }
         }
@@ -6930,13 +7032,25 @@ exports.TradingPolicy = {
                     await new Promise(resolve => setTimeout(resolve, delay));
                     continue;
                 }
-                // Log structured error details and rethrow
-                logger_1.logger.error("Database findMany operation failed", {
-                    operation: 'findManyTradingPolicy',
-                    model: 'TradingPolicy',
-                    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: 'findManyTradingPolicy',
+                        model: 'TradingPolicy',
+                        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: 'findManyTradingPolicy',
+                        model: 'TradingPolicy',
+                        error: String(error),
+                        isRetryable: false,
+                    });
+                }
                 throw error;
             }
         }

package/User.cjs

@@ -807,13 +807,28 @@ exports.User = {
                     await new Promise(resolve => setTimeout(resolve, delay));
                     continue;
                 }
-                // Log structured error details and rethrow
-                logger_1.logger.error("Database create operation failed", {
-                    operation: 'createOneUser',
-                    model: 'User',
-                    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: 'createOneUser',
+                        model: 'User',
+                        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: 'createOneUser',
+                        model: 'User',
+                        error: String(error),
+                        isRetryable: false,
+                    });
+                }
                 throw error;
             }
         }
@@ -944,13 +959,25 @@ exports.User = {
                     await new Promise(resolve => setTimeout(resolve, delay));
                     continue;
                 }
-                // Log structured error details and rethrow
-                logger_1.logger.error("Database createMany operation failed", {
-                    operation: 'createManyUser',
-                    model: 'User',
-                    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: 'createManyUser',
+                        model: 'User',
+                        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: 'createManyUser',
+                        model: 'User',
+                        error: String(error),
+                        isRetryable: false,
+                    });
+                }
                 throw error;
             }
         }
@@ -2468,14 +2495,27 @@ exports.User = {
                     await new Promise(resolve => setTimeout(resolve, delay));
                     continue;
                 }
-                // Log structured error details and rethrow
-                logger_1.logger.error("Database update operation failed", {
-                    operation: 'updateOneUser',
-                    model: 'User',
-                    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: 'updateOneUser',
+                        model: 'User',
+                        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: 'updateOneUser',
+                        model: 'User',
+                        error: String(error),
+                        recordId: props.id,
+                        isRetryable: false,
+                    });
+                }
                 throw error;
             }
         }
@@ -4483,14 +4523,27 @@ exports.User = {
                     await new Promise(resolve => setTimeout(resolve, delay));
                     continue;
                 }
-                // Log structured error details and rethrow
-                logger_1.logger.error("Database upsert operation failed", {
-                    operation: 'upsertOneUser',
-                    model: 'User',
-                    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: 'upsertOneUser',
+                        model: 'User',
+                        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: 'upsertOneUser',
+                        model: 'User',
+                        error: String(error),
+                        recordId: props.id,
+                        isRetryable: false,
+                    });
+                }
                 throw error;
             }
         }
@@ -6006,13 +6059,25 @@ exports.User = {
                     await new Promise(resolve => setTimeout(resolve, delay));
                     continue;
                 }
-                // Log structured error details and rethrow
-                logger_1.logger.error("Database updateMany operation failed", {
-                    operation: 'updateManyUser',
-                    model: 'User',
-                    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: 'updateManyUser',
+                        model: 'User',
+                        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: 'updateManyUser',
+                        model: 'User',
+                        error: String(error),
+                        isRetryable: false,
+                    });
+                }
                 throw error;
             }
         }
@@ -6135,14 +6200,27 @@ exports.User = {
                     await new Promise(resolve => setTimeout(resolve, delay));
                     continue;
                 }
-                // Log structured error details and rethrow
-                logger_1.logger.error("Database delete operation failed", {
-                    operation: 'deleteOneUser',
-                    model: 'User',
-                    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: 'deleteOneUser',
+                        model: 'User',
+                        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: 'deleteOneUser',
+                        model: 'User',
+                        error: String(error),
+                        recordId: props.id,
+                        isRetryable: false,
+                    });
+                }
                 throw error;
             }
         }
@@ -6242,13 +6320,25 @@ exports.User = {
                     await new Promise(resolve => setTimeout(resolve, delay));
                     continue;
                 }
-                // Log structured error details and rethrow
-                logger_1.logger.error("Database get operation failed", {
-                    operation: 'getUser',
-                    model: 'User',
-                    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: 'getUser',
+                        model: 'User',
+                        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: 'getUser',
+                        model: 'User',
+                        error: String(error),
+                        isRetryable: false,
+                    });
+                }
                 throw error;
             }
         }
@@ -6335,13 +6425,25 @@ exports.User = {
                     await new Promise(resolve => setTimeout(resolve, delay));
                     continue;
                 }
-                // Log structured error details and rethrow
-                logger_1.logger.error("Database getAll operation failed", {
-                    operation: 'getAllUser',
-                    model: 'User',
-                    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: 'getAllUser',
+                        model: 'User',
+                        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: 'getAllUser',
+                        model: 'User',
+                        error: String(error),
+                        isRetryable: false,
+                    });
+                }
                 throw error;
             }
         }
@@ -6455,13 +6557,25 @@ exports.User = {
                     await new Promise(resolve => setTimeout(resolve, delay));
                     continue;
                 }
-                // Log structured error details and rethrow
-                logger_1.logger.error("Database findMany operation failed", {
-                    operation: 'findManyUser',
-                    model: 'User',
-                    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: 'findManyUser',
+                        model: 'User',
+                        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: 'findManyUser',
+                        model: 'User',
+                        error: String(error),
+                        isRetryable: false,
+                    });
+                }
                 throw error;
             }
         }