@514labs/moose-lib 0.6.256-ci-4-g0ca62054 → 0.6.256-ci-3-gafce5840

package/dist/moose-runner.js

@@ -39,22 +39,6 @@ function isTruthy(value) {
       return false;
   }
 }
-function createProducerConfig(maxMessageBytes) {
-  return {
-    kafkaJS: {
-      idempotent: false,
-      // Not needed for at-least-once delivery
-      acks: ACKs,
-      retry: {
-        retries: MAX_RETRIES_PRODUCER,
-        maxRetryTime: MAX_RETRY_TIME_MS
-      }
-    },
-    "linger.ms": 0,
-    // This is to make sure at least once delivery with immediate feedback on the send
-    ...maxMessageBytes && { "message.max.bytes": maxMessageBytes }
-  };
-}
 var import_http, import_client, import_kafka_javascript, Kafka, compilerLog, getClickhouseClient, cliLog, MAX_RETRIES, MAX_RETRY_TIME_MS, RETRY_INITIAL_TIME_MS, MAX_RETRIES_PRODUCER, ACKs, parseBrokerString, logError, buildSaslConfig, getKafkaClient;
 var init_commons = __esm({
   "src/commons.ts"() {
@@ -1175,7 +1159,9 @@ var moose_internal = {
   apis: /* @__PURE__ */ new Map(),
   sqlResources: /* @__PURE__ */ new Map(),
   workflows: /* @__PURE__ */ new Map(),
-  webApps: /* @__PURE__ */ new Map()
+  webApps: /* @__PURE__ */ new Map(),
+  materializedViews: /* @__PURE__ */ new Map(),
+  customViews: /* @__PURE__ */ new Map()
 };
 var defaultRetentionPeriod = 60 * 60 * 24 * 7;
 function isS3QueueConfig(config) {
@@ -1373,6 +1359,8 @@ var toInfraMap = (registry) => {
   const sqlResources = {};
   const workflows = {};
   const webApps = {};
+  const materializedViews = {};
+  const customViews = {};
   registry.tables.forEach((table) => {
     const id = table.config.version ? `${table.name}_${table.config.version}` : table.name;
     let metadata = table.metadata;
@@ -1560,6 +1548,24 @@ var toInfraMap = (registry) => {
       metadata: webApp.config.metadata
     };
   });
+  registry.materializedViews.forEach((mv) => {
+    materializedViews[mv.name] = {
+      name: mv.name,
+      selectSql: mv.selectSql,
+      sourceTables: mv.sourceTables,
+      targetTable: mv.targetTable.name,
+      targetDatabase: mv.targetTable.config.database,
+      sourceFile: mv.sourceFile
+    };
+  });
+  registry.customViews.forEach((view) => {
+    customViews[view.name] = {
+      name: view.name,
+      selectSql: view.selectSql,
+      sourceTables: view.sourceTables,
+      sourceFile: view.sourceFile
+    };
+  });
   return {
     topics,
     tables,
@@ -1567,7 +1573,9 @@ var toInfraMap = (registry) => {
     apis,
     sqlResources,
     workflows,
-    webApps
+    webApps,
+    materializedViews,
+    customViews
   };
 };
 var getMooseInternal = () => globalThis.moose_internal;
@@ -1591,6 +1599,8 @@ var loadIndex = () => {
   registry.sqlResources.clear();
   registry.workflows.clear();
   registry.webApps.clear();
+  registry.materializedViews.clear();
+  registry.customViews.clear();
   const appDir = `${import_process.default.cwd()}/${getSourceDir()}`;
   Object.keys(require.cache).forEach((key) => {
     if (key.startsWith(appDir)) {
@@ -1832,7 +1842,156 @@ var MAX_RETRIES_CONSUMER = 150;
 var SESSION_TIMEOUT_CONSUMER = 3e4;
 var HEARTBEAT_INTERVAL_CONSUMER = 3e3;
 var DEFAULT_MAX_STREAMING_CONCURRENCY = 100;
-var CONSUMER_MAX_BATCH_SIZE = 1e3;
+var KAFKAJS_BYTE_MESSAGE_OVERHEAD = 500;
+var isMessageTooLargeError = (error) => {
+  if (import_kafka_javascript2.KafkaJS.isKafkaJSError && error instanceof Error && import_kafka_javascript2.KafkaJS.isKafkaJSError(error)) {
+    return error.type === "ERR_MSG_SIZE_TOO_LARGE" || error.code === 10 || error.cause !== void 0 && isMessageTooLargeError(error.cause);
+  }
+  if (error && typeof error === "object") {
+    const err = error;
+    return err.type === "ERR_MSG_SIZE_TOO_LARGE" || err.code === 10 || err.cause !== void 0 && isMessageTooLargeError(err.cause);
+  }
+  return false;
+};
+var splitBatch = (messages, maxChunkSize) => {
+  if (messages.length <= 1) {
+    return [messages];
+  }
+  const chunks = [];
+  let currentChunk = [];
+  let currentSize = 0;
+  for (const message of messages) {
+    const messageSize = import_node_buffer.Buffer.byteLength(message.value, "utf8") + KAFKAJS_BYTE_MESSAGE_OVERHEAD;
+    if (currentSize + messageSize > maxChunkSize && currentChunk.length > 0) {
+      chunks.push(currentChunk);
+      currentChunk = [message];
+      currentSize = messageSize;
+    } else {
+      currentChunk.push(message);
+      currentSize += messageSize;
+    }
+  }
+  if (currentChunk.length > 0) {
+    chunks.push(currentChunk);
+  }
+  return chunks;
+};
+var sendChunkWithRetry = async (logger2, targetTopic, producer, messages, currentMaxSize, maxRetries = 3) => {
+  const currentMessages = messages;
+  let attempts = 0;
+  while (attempts < maxRetries) {
+    try {
+      await producer.send({
+        topic: targetTopic.name,
+        messages: currentMessages
+      });
+      logger2.log(
+        `Successfully sent ${currentMessages.length} messages to ${targetTopic.name}`
+      );
+      return;
+    } catch (error) {
+      if (isMessageTooLargeError(error) && currentMessages.length > 1) {
+        logger2.warn(
+          `Got MESSAGE_TOO_LARGE error, splitting batch of ${currentMessages.length} messages and retrying (${maxRetries - attempts} attempts left)`
+        );
+        const newMaxSize = Math.floor(currentMaxSize / 2);
+        const splitChunks = splitBatch(currentMessages, newMaxSize);
+        for (const chunk of splitChunks) {
+          await sendChunkWithRetry(
+            logger2,
+            targetTopic,
+            producer,
+            chunk,
+            newMaxSize,
+            // this error does not count as one failed attempt
+            maxRetries - attempts
+          );
+        }
+        return;
+      } else {
+        attempts++;
+        if (attempts >= maxRetries) {
+          let messagesHandledByDLQ = 0;
+          let messagesWithoutDLQ = 0;
+          const dlqErrors = [];
+          for (const failedMessage of currentMessages) {
+            const dlqTopic = failedMessage.dlq;
+            if (dlqTopic && failedMessage.originalValue) {
+              const dlqTopicName = dlqTopic.name;
+              const deadLetterRecord = {
+                originalRecord: {
+                  ...failedMessage.originalValue,
+                  // Include original Kafka message metadata
+                  __sourcePartition: failedMessage.originalMessage.partition,
+                  __sourceOffset: failedMessage.originalMessage.offset,
+                  __sourceTimestamp: failedMessage.originalMessage.timestamp
+                },
+                errorMessage: error instanceof Error ? error.message : String(error),
+                errorType: error instanceof Error ? error.constructor.name : "Unknown",
+                failedAt: /* @__PURE__ */ new Date(),
+                source: "transform"
+              };
+              cliLog({
+                action: "DeadLetter",
+                message: `Sending failed message to DLQ ${dlqTopicName}: ${error instanceof Error ? error.message : String(error)}`,
+                message_type: "Error"
+              });
+              try {
+                await producer.send({
+                  topic: dlqTopicName,
+                  messages: [{ value: JSON.stringify(deadLetterRecord) }]
+                });
+                logger2.log(`Sent failed message to DLQ ${dlqTopicName}`);
+                messagesHandledByDLQ++;
+              } catch (dlqError) {
+                const errorMsg = `Failed to send message to DLQ: ${dlqError}`;
+                logger2.error(errorMsg);
+                dlqErrors.push(errorMsg);
+              }
+            } else if (!dlqTopic) {
+              messagesWithoutDLQ++;
+              logger2.warn(
+                `Cannot send to DLQ: no DLQ configured for message (batch has mixed DLQ configurations)`
+              );
+            } else {
+              messagesWithoutDLQ++;
+              logger2.warn(
+                `Cannot send to DLQ: original message value not available`
+              );
+            }
+          }
+          const allMessagesHandled = messagesHandledByDLQ === currentMessages.length && messagesWithoutDLQ === 0 && dlqErrors.length === 0;
+          if (allMessagesHandled) {
+            logger2.log(
+              `All ${messagesHandledByDLQ} failed message(s) sent to DLQ, not throwing original error`
+            );
+            return;
+          }
+          if (messagesWithoutDLQ > 0) {
+            logger2.error(
+              `Cannot handle batch failure: ${messagesWithoutDLQ} message(s) have no DLQ configured`
+            );
+          }
+          if (dlqErrors.length > 0) {
+            logger2.error(
+              `Some messages failed to send to DLQ: ${dlqErrors.join(", ")}`
+            );
+          }
+          if (messagesHandledByDLQ > 0) {
+            logger2.warn(
+              `Partial DLQ success: ${messagesHandledByDLQ}/${currentMessages.length} message(s) sent to DLQ, but throwing due to incomplete batch handling`
+            );
+          }
+          throw error;
+        }
+        logger2.warn(
+          `Send ${currentMessages.length} messages failed (attempt ${attempts}/${maxRetries}), retrying: ${error}`
+        );
+        await new Promise((resolve2) => setTimeout(resolve2, 100 * attempts));
+      }
+    }
+  }
+};
 var MAX_STREAMING_CONCURRENCY = process3.env.MAX_STREAMING_CONCURRENCY ? parseInt(process3.env.MAX_STREAMING_CONCURRENCY, 10) : DEFAULT_MAX_STREAMING_CONCURRENCY;
 var metricsLog = (log) => {
   const req = http3.request({
@@ -1978,95 +2137,57 @@ var handleMessage = async (logger2, streamingFunctionWithConfigList, message, pr
   }
   return void 0;
 };
-var handleDLQForFailedMessages = async (logger2, producer, messages, error) => {
-  let messagesHandledByDLQ = 0;
-  let messagesWithoutDLQ = 0;
-  let dlqErrors = 0;
-  for (const msg of messages) {
-    if (msg.dlq && msg.originalValue) {
-      const deadLetterRecord = {
-        originalRecord: {
-          ...msg.originalValue,
-          // Include original Kafka message metadata
-          __sourcePartition: msg.originalMessage.partition,
-          __sourceOffset: msg.originalMessage.offset,
-          __sourceTimestamp: msg.originalMessage.timestamp
-        },
-        errorMessage: error instanceof Error ? error.message : String(error),
-        errorType: error instanceof Error ? error.constructor.name : "Unknown",
-        failedAt: /* @__PURE__ */ new Date(),
-        source: "transform"
-      };
-      cliLog({
-        action: "DeadLetter",
-        message: `Sending failed message to DLQ ${msg.dlq.name}: ${error instanceof Error ? error.message : String(error)}`,
-        message_type: "Error"
-      });
-      try {
-        await producer.send({
-          topic: msg.dlq.name,
-          messages: [{ value: JSON.stringify(deadLetterRecord) }]
-        });
-        logger2.log(`Sent failed message to DLQ ${msg.dlq.name}`);
-        messagesHandledByDLQ++;
-      } catch (dlqError) {
-        logger2.error(`Failed to send to DLQ: ${dlqError}`);
-        dlqErrors++;
+var sendMessages = async (logger2, metrics, targetTopic, producer, messages) => {
+  try {
+    let chunk = [];
+    let chunkSize = 0;
+    const maxMessageSize = targetTopic.max_message_bytes || 1024 * 1024;
+    for (const message of messages) {
+      const messageSize = import_node_buffer.Buffer.byteLength(message.value, "utf8") + KAFKAJS_BYTE_MESSAGE_OVERHEAD;
+      if (chunkSize + messageSize > maxMessageSize) {
+        logger2.log(
+          `Sending ${chunkSize} bytes of a transformed record batch to ${targetTopic.name}`
+        );
+        await sendChunkWithRetry(
+          logger2,
+          targetTopic,
+          producer,
+          chunk,
+          maxMessageSize
+        );
+        logger2.log(
+          `Sent ${chunk.length} transformed records to ${targetTopic.name}`
+        );
+        chunk = [message];
+        chunkSize = messageSize;
+      } else {
+        chunk.push(message);
+        metrics.bytes += import_node_buffer.Buffer.byteLength(message.value, "utf8");
+        chunkSize += messageSize;
       }
-    } else if (!msg.dlq) {
-      messagesWithoutDLQ++;
-      logger2.warn(`Cannot send to DLQ: no DLQ configured for message`);
-    } else {
-      messagesWithoutDLQ++;
-      logger2.warn(`Cannot send to DLQ: original message value not available`);
     }
-  }
-  const allMessagesHandled = messagesHandledByDLQ === messages.length && messagesWithoutDLQ === 0 && dlqErrors === 0;
-  if (allMessagesHandled) {
-    logger2.log(
-      `All ${messagesHandledByDLQ} failed message(s) sent to DLQ, suppressing original error`
-    );
-  } else if (messagesHandledByDLQ > 0) {
-    logger2.warn(
-      `Partial DLQ success: ${messagesHandledByDLQ}/${messages.length} message(s) sent to DLQ`
-    );
-    if (messagesWithoutDLQ > 0) {
-      logger2.error(
-        `Cannot handle batch failure: ${messagesWithoutDLQ} message(s) have no DLQ configured or missing original value`
+    metrics.count_out += chunk.length;
+    if (chunk.length > 0) {
+      logger2.log(
+        `Sending ${chunkSize} bytes of a transformed record batch to ${targetTopic.name}`
+      );
+      await sendChunkWithRetry(
+        logger2,
+        targetTopic,
+        producer,
+        chunk,
+        maxMessageSize
+      );
+      logger2.log(
+        `Sent final ${chunk.length} transformed data to ${targetTopic.name}`
       );
     }
-    if (dlqErrors > 0) {
-      logger2.error(`${dlqErrors} message(s) failed to send to DLQ`);
-    }
-  }
-  return allMessagesHandled;
-};
-var sendMessages = async (logger2, metrics, targetTopic, producer, messages) => {
-  if (messages.length === 0) return;
-  try {
-    await producer.send({
-      topic: targetTopic.name,
-      messages
-    });
-    for (const msg of messages) {
-      metrics.bytes += import_node_buffer.Buffer.byteLength(msg.value, "utf8");
-    }
-    metrics.count_out += messages.length;
-    logger2.log(`Sent ${messages.length} messages to ${targetTopic.name}`);
   } catch (e) {
     logger2.error(`Failed to send transformed data`);
     if (e instanceof Error) {
       logError(logger2, e);
     }
-    const allHandledByDLQ = await handleDLQForFailedMessages(
-      logger2,
-      producer,
-      messages,
-      e
-    );
-    if (!allHandledByDLQ) {
-      throw e;
-    }
+    throw e;
   }
 };
 var sendMessageMetrics = (logger2, metrics) => {
@@ -2306,13 +2427,18 @@ var runStreamingFunctions = async (args) => {
           autoCommit: true,
           autoCommitInterval: AUTO_COMMIT_INTERVAL_MS,
           fromBeginning: true
-        },
-        "js.consumer.max.batch.size": CONSUMER_MAX_BATCH_SIZE
+        }
+      });
+      const producer = kafka.producer({
+        kafkaJS: {
+          idempotent: true,
+          acks: ACKs,
+          retry: {
+            retries: MAX_RETRIES_PRODUCER,
+            maxRetryTime: MAX_RETRY_TIME_MS
+          }
+        }
       });
-      const maxMessageBytes = args.targetTopic?.max_message_bytes || 1024 * 1024;
-      const producer = kafka.producer(
-        createProducerConfig(maxMessageBytes)
-      );
       try {
         logger2.log("Starting producer...");
         await startProducer(logger2, producer);