@altertable/data-app 0.59.1 → 0.62.0

package/dist/local.js

@@ -12,6 +12,31 @@ function invariant(condition, message) {
 }
 // src/core/messages.ts
 var errorBrand = Symbol.for("@altertable/data-app/MessageRoutingError");
+function defineMessageRoute(route) {
+  return route;
+}
+var sqlQueryRoute = defineMessageRoute({
+  input(value) {
+    if (!value || typeof value !== "object")
+      throw new Error("Invalid SQL query.");
+    const query = value;
+    if (typeof query.statement !== "string" || !query.statement.trim() || typeof query.limit !== "number" || !Number.isSafeInteger(query.limit) || query.limit < 1)
+      throw new Error("Invalid SQL query.");
+    return { statement: query.statement, limit: query.limit };
+  },
+  output(value, input) {
+    if (!value || typeof value !== "object")
+      throw new Error("Invalid query result.");
+    const result = value;
+    if (!Array.isArray(result.columns) || !result.columns.every((column) => column && typeof column.name === "string" && (column.type === undefined || typeof column.type === "string")) || !Array.isArray(result.rows) || result.rows.length > input.limit || !result.rows.every((row) => Array.isArray(row) && row.length === result.columns.length) || result.queryId !== undefined && typeof result.queryId !== "string")
+      throw new Error("Invalid query result.");
+    return {
+      columns: result.columns,
+      rows: result.rows,
+      ...result.queryId === undefined ? {} : { queryId: result.queryId }
+    };
+  }
+});
 // src/core/contract.ts
 function defineQueryNames(names) {
   const values = Object.values(names);
@@ -34,14 +59,146 @@ var connectionQueryNames = defineQueryNames({
   connection: "connection-check"
 });
 
-// src/server/handler.ts
+// src/core/operation.ts
+async function executeDataOperation(operation, value, {
+  operationName,
+  lakehouse,
+  signal: requestSignal,
+  includeSql,
+  requestId
+}) {
+  requestSignal.throwIfAborted();
+  let input;
+  try {
+    input = operation.input(value);
+  } catch {
+    throw new OperationInputError;
+  }
+  const signal = AbortSignal.any([
+    requestSignal,
+    AbortSignal.timeout(operation.policy.maxDurationMs)
+  ]);
+  const execution = createOperationLakehouse(operation, lakehouse, signal, operationName);
+  try {
+    const output = await runOperation(operation, input, {
+      lakehouse: execution.lakehouse,
+      signal
+    });
+    const body = {
+      data: operation.output(output),
+      requestId,
+      queriedAt: new Date().toISOString(),
+      queryIds: execution.queryIds,
+      ...operation.policy.exposeSql && includeSql ? { queries: execution.queries } : {}
+    };
+    const serializedBody = JSON.stringify(body);
+    const responseBytes = new TextEncoder().encode(serializedBody).byteLength;
+    if (responseBytes > (operation.policy.maxResponseBytes ?? 1e6))
+      throw new Error("Response exceeds byte limit.");
+    return { body, serializedBody };
+  } catch (error) {
+    if (signal.aborted && !(error instanceof DataSourceError))
+      throw new OperationTimeoutError;
+    throw error;
+  }
+}
+function createOperationLakehouse(operation, source, signal, operationName) {
+  const queryIds = [];
+  const queries = [];
+  const lakehouse = {
+    async queryAll(statement, options) {
+      if (!Number.isInteger(options.limit) || options.limit < 1)
+        throw new Error("Query needs a positive row limit.");
+      if (operation.queryNames && !Object.values(operation.queryNames).includes(options.name ?? ""))
+        throw new Error(`Query name is not registered for operation ${operationName}.`);
+      const query = {
+        name: options.name ?? `Query ${queries.length + 1}`,
+        statement
+      };
+      queries.push(query);
+      const limit = Math.min(options.limit, operation.policy.maxQueryRows);
+      let result;
+      try {
+        result = await source.queryAll(statement, {
+          limit,
+          signal: AbortSignal.any([signal, options.signal])
+        });
+      } catch (error) {
+        if (error instanceof DataSourceError)
+          error.queryName = query.name;
+        throw error;
+      }
+      if (result.rows.length > limit)
+        throw new Error("Result exceeds row limit.");
+      if (result.queryId) {
+        query.queryId = result.queryId;
+        queryIds.push(result.queryId);
+      }
+      return result;
+    }
+  };
+  return { lakehouse, queries, queryIds };
+}
+async function runOperation(operation, input, { lakehouse, signal }) {
+  let abort;
+  try {
+    signal.throwIfAborted();
+    const cancelled = new Promise((_, reject) => {
+      function rejectAborted() {
+        reject(new Error("Request aborted."));
+      }
+      abort = rejectAborted;
+      signal.addEventListener("abort", rejectAborted, { once: true });
+      if (signal.aborted)
+        rejectAborted();
+    });
+    return await Promise.race([
+      cancelled,
+      Promise.resolve().then(() => {
+        signal.throwIfAborted();
+        return operation.run({ lakehouse, signal }, input);
+      })
+    ]);
+  } finally {
+    if (abort)
+      signal.removeEventListener("abort", abort);
+  }
+}
+
+class OperationTimeoutError extends Error {
+}
+
+class OperationInputError extends Error {
+}
 var sourceErrorMessages = {
-  unauthorized: "Lakehouse access needs attention. Run this app with 'altertable app dev', or run 'altertable login' and retry.",
-  forbidden: "This app cannot access its lakehouse data. Check the selected profile's permissions.",
+  unauthorized: "This app could not authenticate its data connection. Contact the app owner.",
+  forbidden: "This app cannot access the requested data. Contact the app owner.",
   rate_limited: "The lakehouse is busy. Wait a moment and retry.",
   query_rejected: "A lakehouse query was rejected. Check the app's data operation.",
   unavailable: "The lakehouse is unavailable. Check the connection and retry."
 };
+function toDataOperationFailure(error, aborted = false) {
+  if (error instanceof OperationInputError)
+    return {
+      status: 400,
+      code: "invalid_input",
+      message: "Check this operation's inputs."
+    };
+  if (error instanceof DataSourceError)
+    return {
+      status: error.reason === "rate_limited" ? 429 : 502,
+      code: `source_${error.reason}`,
+      message: sourceErrorMessages[error.reason]
+    };
+  const timedOut = aborted || error instanceof OperationTimeoutError;
+  return {
+    status: timedOut ? 504 : 502,
+    code: timedOut ? "timeout" : "query_failed",
+    message: timedOut ? "The data request timed out." : "The data request failed."
+  };
+}
+
+// src/server/handler.ts
 function createDataHandler(operations, authorize) {
   async function handleDataRequest(request) {
     const requestId = crypto.randomUUID();
@@ -80,78 +237,22 @@ function createDataHandler(operations, authorize) {
       return problem(504, "timeout", "The data request timed out.", requestId);
     try {
       const body = await readInput(request);
-      input = operation.input(JSON.parse(body));
+      input = JSON.parse(body);
     } catch (error) {
       if (error instanceof InputTooLargeError)
         return problem(413, "input_too_large", "Input is too large.", requestId);
       return problem(400, "invalid_input", "Check this operation's inputs.", requestId);
     }
-    const timeout = AbortSignal.timeout(operation.policy.maxDurationMs);
-    const signal = AbortSignal.any([request.signal, timeout]);
-    const queryIds = [];
-    const queries = [];
-    const boundedLakehouse = {
-      async queryAll(statement, options) {
-        if (!Number.isInteger(options.limit) || options.limit < 1)
-          throw new Error("Query needs a positive row limit.");
-        if (operation.queryNames && !Object.values(operation.queryNames).includes(options.name ?? ""))
-          throw new Error(`Query name is not registered for operation ${name}.`);
-        const query = {
-          name: options.name ?? `Query ${queries.length + 1}`,
-          statement
-        };
-        queries.push(query);
-        let result;
-        try {
-          result = await access.lakehouse.queryAll(statement, {
-            limit: Math.min(options.limit, operation.policy.maxQueryRows),
-            signal: AbortSignal.any([signal, options.signal])
-          });
-        } catch (error) {
-          if (error instanceof DataSourceError)
-            error.queryName = query.name;
-          throw error;
-        }
-        if (result.rows.length > operation.policy.maxQueryRows)
-          throw new Error("Result exceeds row limit.");
-        if (result.queryId) {
-          query.queryId = result.queryId;
-          queryIds.push(result.queryId);
-        }
-        return result;
-      }
-    };
-    let abort;
+    const signal = request.signal;
     try {
-      signal.throwIfAborted();
-      const cancelled = new Promise((_, reject) => {
-        function rejectAborted() {
-          reject(new Error("Request aborted."));
-        }
-        abort = rejectAborted;
-        signal.addEventListener("abort", rejectAborted, { once: true });
-        if (signal.aborted)
-          rejectAborted();
-      });
-      const data = operation.output(await Promise.race([
-        cancelled,
-        Promise.resolve().then(() => {
-          signal.throwIfAborted();
-          return operation.run({ lakehouse: boundedLakehouse, signal }, input);
-        })
-      ]));
-      const result = {
-        data,
+      const { serializedBody } = await executeDataOperation(operation, input, {
+        lakehouse: access.lakehouse,
+        includeSql: access.canDiscloseSql,
+        signal,
         requestId,
-        queriedAt: new Date().toISOString(),
-        queryIds,
-        ...operation.policy.exposeSql && access.canDiscloseSql ? { queries } : {}
-      };
-      const body = JSON.stringify(result);
-      if (new TextEncoder().encode(body).byteLength > (operation.policy.maxResponseBytes ?? 1e6)) {
-        throw new Error("Response exceeds byte limit.");
-      }
-      return new Response(body, {
+        operationName: name
+      });
+      return new Response(serializedBody, {
         headers: {
           "cache-control": "no-store",
           "content-type": "application/json"
@@ -160,13 +261,8 @@ function createDataHandler(operations, authorize) {
     } catch (error) {
       const source = error instanceof DataSourceError ? error : null;
       console.error(`Data operation ${name} failed (${requestId}): ${source ? `${source.reason}${source.status ? ` (${source.status})` : ""}${source.queryName ? ` in ${source.queryName}` : ""}` : error instanceof Error ? error.name : "unknown"}`);
-      if (source) {
-        return problem(source.reason === "rate_limited" ? 429 : 502, `source_${source.reason}`, sourceErrorMessages[source.reason], requestId);
-      }
-      return problem(signal.aborted ? 504 : 502, signal.aborted ? "timeout" : "query_failed", signal.aborted ? "The data request timed out." : "The data request failed.", requestId);
-    } finally {
-      if (abort)
-        signal.removeEventListener("abort", abort);
+      const failure = toDataOperationFailure(error, signal.aborted);
+      return problem(failure.status, failure.code, failure.message, requestId);
     }
   }
   return handleDataRequest;
@@ -310,23 +406,39 @@ function parseQueryResult(body, limit) {
   if (!lines.length)
     throw new Error("Query response is empty.");
   const metadata = JSON.parse(lines[0]);
+  if (!metadata || typeof metadata !== "object" || Array.isArray(metadata) || "query_id" in metadata && metadata.query_id !== undefined && typeof metadata.query_id !== "string")
+    throw new Error("Invalid query metadata.");
+  const queryId = "query_id" in metadata ? metadata.query_id : undefined;
   let firstRowIndex = 1;
   let columns = [];
   if (lines[firstRowIndex]) {
     const columnDefinitions = JSON.parse(lines[firstRowIndex]);
     if (Array.isArray(columnDefinitions) && columnDefinitions.every((value) => typeof value === "string" || typeof value === "object" && value !== null && ("name" in value))) {
-      columns = columnDefinitions.map((value) => typeof value === "string" ? { name: value } : value);
+      columns = columnDefinitions.map((value) => typeof value === "string" ? { name: value } : parseColumn(value));
       firstRowIndex++;
     }
   }
-  const rows = lines.slice(firstRowIndex).map((line) => JSON.parse(line));
+  const rows = lines.slice(firstRowIndex).map((line) => {
+    const row = JSON.parse(line);
+    if (!Array.isArray(row) || firstRowIndex === 2 && row.length !== columns.length)
+      throw new Error("Invalid query row.");
+    return row;
+  });
   if (rows.length > limit)
     throw new Error("Lakehouse returned more rows than requested.");
-  return { columns, rows, queryId: metadata.query_id };
+  return { columns, rows, queryId };
+}
+function parseColumn(value) {
+  if (!value || typeof value !== "object" || !("name" in value) || typeof value.name !== "string" || "type" in value && value.type !== undefined && typeof value.type !== "string")
+    throw new Error("Invalid query column.");
+  return {
+    name: value.name,
+    ..."type" in value && value.type !== undefined ? { type: value.type } : {}
+  };
 }
 export {
   localLakehouse,
   serveLocalApp
 };
 
-//# debugId=FE9002DDE845605A64756E2164756E21
+//# debugId=34D393952628512F64756E2164756E21