@adaptic/backend-legacy 0.0.959 → 0.0.961

package/InstitutionalSentimentAlerts.cjs

@@ -150,13 +150,28 @@ exports.InstitutionalSentimentAlerts = {
                     await new Promise(resolve => setTimeout(resolve, delay));
                     continue;
                 }
-                // Log structured error details and rethrow
-                logger_1.logger.error("Database create operation failed", {
-                    operation: 'createOneInstitutionalSentimentAlerts',
-                    model: 'InstitutionalSentimentAlerts',
-                    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: 'createOneInstitutionalSentimentAlerts',
+                        model: 'InstitutionalSentimentAlerts',
+                        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: 'createOneInstitutionalSentimentAlerts',
+                        model: 'InstitutionalSentimentAlerts',
+                        error: String(error),
+                        isRetryable: false,
+                    });
+                }
                 throw error;
             }
         }
@@ -283,13 +298,25 @@ exports.InstitutionalSentimentAlerts = {
                     await new Promise(resolve => setTimeout(resolve, delay));
                     continue;
                 }
-                // Log structured error details and rethrow
-                logger_1.logger.error("Database createMany operation failed", {
-                    operation: 'createManyInstitutionalSentimentAlerts',
-                    model: 'InstitutionalSentimentAlerts',
-                    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: 'createManyInstitutionalSentimentAlerts',
+                        model: 'InstitutionalSentimentAlerts',
+                        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: 'createManyInstitutionalSentimentAlerts',
+                        model: 'InstitutionalSentimentAlerts',
+                        error: String(error),
+                        isRetryable: false,
+                    });
+                }
                 throw error;
             }
         }
@@ -447,14 +474,27 @@ exports.InstitutionalSentimentAlerts = {
                     await new Promise(resolve => setTimeout(resolve, delay));
                     continue;
                 }
-                // Log structured error details and rethrow
-                logger_1.logger.error("Database update operation failed", {
-                    operation: 'updateOneInstitutionalSentimentAlerts',
-                    model: 'InstitutionalSentimentAlerts',
-                    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: 'updateOneInstitutionalSentimentAlerts',
+                        model: 'InstitutionalSentimentAlerts',
+                        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: 'updateOneInstitutionalSentimentAlerts',
+                        model: 'InstitutionalSentimentAlerts',
+                        error: String(error),
+                        recordId: props.id,
+                        isRetryable: false,
+                    });
+                }
                 throw error;
             }
         }
@@ -617,14 +657,27 @@ exports.InstitutionalSentimentAlerts = {
                     await new Promise(resolve => setTimeout(resolve, delay));
                     continue;
                 }
-                // Log structured error details and rethrow
-                logger_1.logger.error("Database upsert operation failed", {
-                    operation: 'upsertOneInstitutionalSentimentAlerts',
-                    model: 'InstitutionalSentimentAlerts',
-                    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: 'upsertOneInstitutionalSentimentAlerts',
+                        model: 'InstitutionalSentimentAlerts',
+                        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: 'upsertOneInstitutionalSentimentAlerts',
+                        model: 'InstitutionalSentimentAlerts',
+                        error: String(error),
+                        recordId: props.id,
+                        isRetryable: false,
+                    });
+                }
                 throw error;
             }
         }
@@ -780,13 +833,25 @@ exports.InstitutionalSentimentAlerts = {
                     await new Promise(resolve => setTimeout(resolve, delay));
                     continue;
                 }
-                // Log structured error details and rethrow
-                logger_1.logger.error("Database updateMany operation failed", {
-                    operation: 'updateManyInstitutionalSentimentAlerts',
-                    model: 'InstitutionalSentimentAlerts',
-                    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: 'updateManyInstitutionalSentimentAlerts',
+                        model: 'InstitutionalSentimentAlerts',
+                        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: 'updateManyInstitutionalSentimentAlerts',
+                        model: 'InstitutionalSentimentAlerts',
+                        error: String(error),
+                        isRetryable: false,
+                    });
+                }
                 throw error;
             }
         }
@@ -909,14 +974,27 @@ exports.InstitutionalSentimentAlerts = {
                     await new Promise(resolve => setTimeout(resolve, delay));
                     continue;
                 }
-                // Log structured error details and rethrow
-                logger_1.logger.error("Database delete operation failed", {
-                    operation: 'deleteOneInstitutionalSentimentAlerts',
-                    model: 'InstitutionalSentimentAlerts',
-                    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: 'deleteOneInstitutionalSentimentAlerts',
+                        model: 'InstitutionalSentimentAlerts',
+                        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: 'deleteOneInstitutionalSentimentAlerts',
+                        model: 'InstitutionalSentimentAlerts',
+                        error: String(error),
+                        recordId: props.id,
+                        isRetryable: false,
+                    });
+                }
                 throw error;
             }
         }
@@ -1015,13 +1093,25 @@ exports.InstitutionalSentimentAlerts = {
                     await new Promise(resolve => setTimeout(resolve, delay));
                     continue;
                 }
-                // Log structured error details and rethrow
-                logger_1.logger.error("Database get operation failed", {
-                    operation: 'getInstitutionalSentimentAlerts',
-                    model: 'InstitutionalSentimentAlerts',
-                    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: 'getInstitutionalSentimentAlerts',
+                        model: 'InstitutionalSentimentAlerts',
+                        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: 'getInstitutionalSentimentAlerts',
+                        model: 'InstitutionalSentimentAlerts',
+                        error: String(error),
+                        isRetryable: false,
+                    });
+                }
                 throw error;
             }
         }
@@ -1108,13 +1198,25 @@ exports.InstitutionalSentimentAlerts = {
                     await new Promise(resolve => setTimeout(resolve, delay));
                     continue;
                 }
-                // Log structured error details and rethrow
-                logger_1.logger.error("Database getAll operation failed", {
-                    operation: 'getAllInstitutionalSentimentAlerts',
-                    model: 'InstitutionalSentimentAlerts',
-                    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: 'getAllInstitutionalSentimentAlerts',
+                        model: 'InstitutionalSentimentAlerts',
+                        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: 'getAllInstitutionalSentimentAlerts',
+                        model: 'InstitutionalSentimentAlerts',
+                        error: String(error),
+                        isRetryable: false,
+                    });
+                }
                 throw error;
             }
         }
@@ -1225,13 +1327,25 @@ exports.InstitutionalSentimentAlerts = {
                     await new Promise(resolve => setTimeout(resolve, delay));
                     continue;
                 }
-                // Log structured error details and rethrow
-                logger_1.logger.error("Database findMany operation failed", {
-                    operation: 'findManyInstitutionalSentimentAlerts',
-                    model: 'InstitutionalSentimentAlerts',
-                    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: 'findManyInstitutionalSentimentAlerts',
+                        model: 'InstitutionalSentimentAlerts',
+                        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: 'findManyInstitutionalSentimentAlerts',
+                        model: 'InstitutionalSentimentAlerts',
+                        error: String(error),
+                        isRetryable: false,
+                    });
+                }
                 throw error;
             }
         }

package/InstitutionalSentimentErrors.cjs

@@ -141,13 +141,28 @@ exports.InstitutionalSentimentErrors = {
                     await new Promise(resolve => setTimeout(resolve, delay));
                     continue;
                 }
-                // Log structured error details and rethrow
-                logger_1.logger.error("Database create operation failed", {
-                    operation: 'createOneInstitutionalSentimentErrors',
-                    model: 'InstitutionalSentimentErrors',
-                    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: 'createOneInstitutionalSentimentErrors',
+                        model: 'InstitutionalSentimentErrors',
+                        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: 'createOneInstitutionalSentimentErrors',
+                        model: 'InstitutionalSentimentErrors',
+                        error: String(error),
+                        isRetryable: false,
+                    });
+                }
                 throw error;
             }
         }
@@ -270,13 +285,25 @@ exports.InstitutionalSentimentErrors = {
                     await new Promise(resolve => setTimeout(resolve, delay));
                     continue;
                 }
-                // Log structured error details and rethrow
-                logger_1.logger.error("Database createMany operation failed", {
-                    operation: 'createManyInstitutionalSentimentErrors',
-                    model: 'InstitutionalSentimentErrors',
-                    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: 'createManyInstitutionalSentimentErrors',
+                        model: 'InstitutionalSentimentErrors',
+                        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: 'createManyInstitutionalSentimentErrors',
+                        model: 'InstitutionalSentimentErrors',
+                        error: String(error),
+                        isRetryable: false,
+                    });
+                }
                 throw error;
             }
         }
@@ -419,14 +446,27 @@ exports.InstitutionalSentimentErrors = {
                     await new Promise(resolve => setTimeout(resolve, delay));
                     continue;
                 }
-                // Log structured error details and rethrow
-                logger_1.logger.error("Database update operation failed", {
-                    operation: 'updateOneInstitutionalSentimentErrors',
-                    model: 'InstitutionalSentimentErrors',
-                    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: 'updateOneInstitutionalSentimentErrors',
+                        model: 'InstitutionalSentimentErrors',
+                        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: 'updateOneInstitutionalSentimentErrors',
+                        model: 'InstitutionalSentimentErrors',
+                        error: String(error),
+                        recordId: props.id,
+                        isRetryable: false,
+                    });
+                }
                 throw error;
             }
         }
@@ -570,14 +610,27 @@ exports.InstitutionalSentimentErrors = {
                     await new Promise(resolve => setTimeout(resolve, delay));
                     continue;
                 }
-                // Log structured error details and rethrow
-                logger_1.logger.error("Database upsert operation failed", {
-                    operation: 'upsertOneInstitutionalSentimentErrors',
-                    model: 'InstitutionalSentimentErrors',
-                    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: 'upsertOneInstitutionalSentimentErrors',
+                        model: 'InstitutionalSentimentErrors',
+                        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: 'upsertOneInstitutionalSentimentErrors',
+                        model: 'InstitutionalSentimentErrors',
+                        error: String(error),
+                        recordId: props.id,
+                        isRetryable: false,
+                    });
+                }
                 throw error;
             }
         }
@@ -718,13 +771,25 @@ exports.InstitutionalSentimentErrors = {
                     await new Promise(resolve => setTimeout(resolve, delay));
                     continue;
                 }
-                // Log structured error details and rethrow
-                logger_1.logger.error("Database updateMany operation failed", {
-                    operation: 'updateManyInstitutionalSentimentErrors',
-                    model: 'InstitutionalSentimentErrors',
-                    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: 'updateManyInstitutionalSentimentErrors',
+                        model: 'InstitutionalSentimentErrors',
+                        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: 'updateManyInstitutionalSentimentErrors',
+                        model: 'InstitutionalSentimentErrors',
+                        error: String(error),
+                        isRetryable: false,
+                    });
+                }
                 throw error;
             }
         }
@@ -847,14 +912,27 @@ exports.InstitutionalSentimentErrors = {
                     await new Promise(resolve => setTimeout(resolve, delay));
                     continue;
                 }
-                // Log structured error details and rethrow
-                logger_1.logger.error("Database delete operation failed", {
-                    operation: 'deleteOneInstitutionalSentimentErrors',
-                    model: 'InstitutionalSentimentErrors',
-                    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: 'deleteOneInstitutionalSentimentErrors',
+                        model: 'InstitutionalSentimentErrors',
+                        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: 'deleteOneInstitutionalSentimentErrors',
+                        model: 'InstitutionalSentimentErrors',
+                        error: String(error),
+                        recordId: props.id,
+                        isRetryable: false,
+                    });
+                }
                 throw error;
             }
         }
@@ -950,13 +1028,25 @@ exports.InstitutionalSentimentErrors = {
                     await new Promise(resolve => setTimeout(resolve, delay));
                     continue;
                 }
-                // Log structured error details and rethrow
-                logger_1.logger.error("Database get operation failed", {
-                    operation: 'getInstitutionalSentimentErrors',
-                    model: 'InstitutionalSentimentErrors',
-                    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: 'getInstitutionalSentimentErrors',
+                        model: 'InstitutionalSentimentErrors',
+                        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: 'getInstitutionalSentimentErrors',
+                        model: 'InstitutionalSentimentErrors',
+                        error: String(error),
+                        isRetryable: false,
+                    });
+                }
                 throw error;
             }
         }
@@ -1043,13 +1133,25 @@ exports.InstitutionalSentimentErrors = {
                     await new Promise(resolve => setTimeout(resolve, delay));
                     continue;
                 }
-                // Log structured error details and rethrow
-                logger_1.logger.error("Database getAll operation failed", {
-                    operation: 'getAllInstitutionalSentimentErrors',
-                    model: 'InstitutionalSentimentErrors',
-                    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: 'getAllInstitutionalSentimentErrors',
+                        model: 'InstitutionalSentimentErrors',
+                        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: 'getAllInstitutionalSentimentErrors',
+                        model: 'InstitutionalSentimentErrors',
+                        error: String(error),
+                        isRetryable: false,
+                    });
+                }
                 throw error;
             }
         }
@@ -1157,13 +1259,25 @@ exports.InstitutionalSentimentErrors = {
                     await new Promise(resolve => setTimeout(resolve, delay));
                     continue;
                 }
-                // Log structured error details and rethrow
-                logger_1.logger.error("Database findMany operation failed", {
-                    operation: 'findManyInstitutionalSentimentErrors',
-                    model: 'InstitutionalSentimentErrors',
-                    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: 'findManyInstitutionalSentimentErrors',
+                        model: 'InstitutionalSentimentErrors',
+                        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: 'findManyInstitutionalSentimentErrors',
+                        model: 'InstitutionalSentimentErrors',
+                        error: String(error),
+                        isRetryable: false,
+                    });
+                }
                 throw error;
             }
         }