@checkdigit/eslint-athena-plugin 1.0.0-PR.2-dcdf

package/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License
+
+Copyright (c) 2021-2026 Check Digit, LLC
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

package/README.md

@@ -0,0 +1,17 @@
+# @checkdigit/eslint-athena-plugin
+
+Copyright (c) 2021-2026 [Check Digit, LLC](https://checkdigit.com)
+
+## Rules
+
+- `@checkdigit/athena`
+- `@checkdigit/sql-file`
+
+## Configurations
+
+- `@checkdigit/all`
+- `@checkdigit/recommended`
+
+## License
+
+MIT

package/SECURITY.md

@@ -0,0 +1,13 @@
+# Security Policy
+
+## Supported Versions
+
+These versions of `@checkdigit/eslint-athena-plugin` are currently being supported with security updates.
+
+| Version | Supported          |
+| ------- | ------------------ |
+| \>= 1.0 | :white_check_mark: |
+
+## Reporting a Vulnerability
+
+Please create an issue at https://github.com/checkdigit/eslint-athena-plugin/issues

package/dist-mjs/athena/api-locator.mjs

@@ -0,0 +1,66 @@
+// src/athena/api-locator.ts
+import fs from "node:fs";
+import debug from "debug";
+import {
+  generateSchemasForService
+} from "../openapi/generate-schema.mjs";
+var log = debug("eslint-athena-plugin:athena:api-locator");
+var SERVICES_ROOT_FOLDER = "src/services";
+var LEGACY_TABLE_SUFFIX = "_logs";
+var SCHEMA_MAX_AGE_MS = 60 * 60 * 1e3;
+function locateApi(originalServiceName) {
+  log("locating API for service", originalServiceName);
+  let serviceName = originalServiceName;
+  if (serviceName.endsWith(LEGACY_TABLE_SUFFIX)) {
+    log(
+      'service table is a legacy table name, looking for API schemas after removing "_logs" suffix',
+      serviceName
+    );
+    serviceName = serviceName.slice(0, -LEGACY_TABLE_SUFFIX.length);
+  }
+  const camelCaseServiceName = serviceName.replace(
+    /-(?<letter>[a-z])/gu,
+    (_, letter) => letter.toUpperCase()
+  );
+  const allSchemaFilenames = fs.globSync(
+    `${SERVICES_ROOT_FOLDER}/${camelCaseServiceName}/*/swagger.schema.deref.json`
+  );
+  log(
+    `${allSchemaFilenames.length.toString()} versions of API schemas located for service ${serviceName}`,
+    allSchemaFilenames
+  );
+  const outputDir = `${SERVICES_ROOT_FOLDER}/${camelCaseServiceName}`;
+  if (allSchemaFilenames.length > 0) {
+    const hasStaleSchema = allSchemaFilenames.some(
+      (schemaFilename) => Date.now() - fs.statSync(schemaFilename).mtimeMs > SCHEMA_MAX_AGE_MS
+    );
+    if (hasStaleSchema) {
+      log(
+        "cached schema(s) are stale (older than 1 hour), regenerating for service",
+        serviceName
+      );
+      const regenerated = generateSchemasForService(serviceName, outputDir);
+      if (regenerated.length > 0) {
+        return regenerated.map(({ schema }) => schema);
+      }
+      log(
+        "regeneration failed, falling back to stale cached schemas for service",
+        serviceName
+      );
+    }
+    return allSchemaFilenames.map(
+      (schemaFilename) => JSON.parse(fs.readFileSync(schemaFilename, "utf-8"))
+    );
+  }
+  log(
+    "no pre-generated schemas found, attempting on-demand generation for service",
+    serviceName
+  );
+  return generateSchemasForService(serviceName, outputDir).map(
+    ({ schema }) => schema
+  );
+}
+export {
+  locateApi
+};
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vc3JjL2F0aGVuYS9hcGktbG9jYXRvci50cyJdLAogICJtYXBwaW5ncyI6ICI7QUFFQSxPQUFPLFFBQVE7QUFFZixPQUFPLFdBQVc7QUFFbEI7QUFBQSxFQUVFO0FBQUEsT0FDSztBQUVQLElBQU0sTUFBTSxNQUFNLHlDQUF5QztBQUUzRCxJQUFNLHVCQUF1QjtBQUM3QixJQUFNLHNCQUFzQjtBQUU1QixJQUFNLG9CQUFvQixLQUFLLEtBQUs7QUFFN0IsU0FBUyxVQUFVLHFCQUEyQztBQUNuRSxNQUFJLDRCQUE0QixtQkFBbUI7QUFFbkQsTUFBSSxjQUFjO0FBQ2xCLE1BQUksWUFBWSxTQUFTLG1CQUFtQixHQUFHO0FBQzdDO0FBQUEsTUFDRTtBQUFBLE1BQ0E7QUFBQSxJQUNGO0FBQ0Esa0JBQWMsWUFBWSxNQUFNLEdBQUcsQ0FBQyxvQkFBb0IsTUFBTTtBQUFBLEVBQ2hFO0FBRUEsUUFBTSx1QkFBdUIsWUFBWTtBQUFBLElBQ3ZDO0FBQUEsSUFDQSxDQUFDLEdBQUcsV0FBbUIsT0FBTyxZQUFZO0FBQUEsRUFDNUM7QUFFQSxRQUFNLHFCQUFxQixHQUFHO0FBQUEsSUFDNUIsR0FBRyxvQkFBb0IsSUFBSSxvQkFBb0I7QUFBQSxFQUNqRDtBQUNBO0FBQUEsSUFDRSxHQUFHLG1CQUFtQixPQUFPLFNBQVMsQ0FBQyxnREFBZ0QsV0FBVztBQUFBLElBQ2xHO0FBQUEsRUFDRjtBQUVBLFFBQU0sWUFBWSxHQUFHLG9CQUFvQixJQUFJLG9CQUFvQjtBQUVqRSxNQUFJLG1CQUFtQixTQUFTLEdBQUc7QUFDakMsVUFBTSxpQkFBaUIsbUJBQW1CO0FBQUEsTUFDeEMsQ0FBQyxtQkFDQyxLQUFLLElBQUksSUFBSSxHQUFHLFNBQVMsY0FBYyxFQUFFLFVBQVU7QUFBQSxJQUN2RDtBQUNBLFFBQUksZ0JBQWdCO0FBQ2xCO0FBQUEsUUFDRTtBQUFBLFFBQ0E7QUFBQSxNQUNGO0FBQ0EsWUFBTSxjQUFjLDBCQUEwQixhQUFhLFNBQVM7QUFDcEUsVUFBSSxZQUFZLFNBQVMsR0FBRztBQUMxQixlQUFPLFlBQVksSUFBSSxDQUFDLEVBQUUsT0FBTyxNQUFNLE1BQU07QUFBQSxNQUMvQztBQUNBO0FBQUEsUUFDRTtBQUFBLFFBQ0E7QUFBQSxNQUNGO0FBQUEsSUFDRjtBQUNBLFdBQU8sbUJBQW1CO0FBQUEsTUFDeEIsQ0FBQyxtQkFDQyxLQUFLLE1BQU0sR0FBRyxhQUFhLGdCQUFnQixPQUFPLENBQUM7QUFBQSxJQUN2RDtBQUFBLEVBQ0Y7QUFFQTtBQUFBLElBQ0U7QUFBQSxJQUNBO0FBQUEsRUFDRjtBQUNBLFNBQU8sMEJBQTBCLGFBQWEsU0FBUyxFQUFFO0FBQUEsSUFDdkQsQ0FBQyxFQUFFLE9BQU8sTUFBTTtBQUFBLEVBQ2xCO0FBQ0Y7IiwKICAibmFtZXMiOiBbXQp9Cg==

package/dist-mjs/athena/api-matcher.mjs

@@ -0,0 +1,206 @@
+// src/athena/api-matcher.ts
+import debug from "debug";
+var log = debug("eslint-athena-plugin:athena:api-matcher");
+var ALWAYS_TRUE = () => true;
+function rec(node) {
+  return typeof node === "object" && node !== null ? node : void 0;
+}
+function getFunctionName(node) {
+  const fn = rec(node);
+  if (fn?.["type"] !== "function") {
+    return void 0;
+  }
+  const name = fn["name"];
+  const firstName = name?.name[0];
+  return firstName === void 0 ? void 0 : firstName.value.toLowerCase();
+}
+function getColumnRef(node) {
+  const col = rec(node);
+  return col?.["type"] === "column_ref" ? node : void 0;
+}
+function getColumnName(node) {
+  const column = getColumnRef(node)?.column;
+  return typeof column === "string" ? column.toLowerCase() : void 0;
+}
+function getColumnTable(node) {
+  return getColumnRef(node)?.table ?? void 0;
+}
+function getStringValue(node) {
+  const val = rec(node);
+  if (val?.["type"] !== "single_quote_string" && val?.["type"] !== "string") {
+    return void 0;
+  }
+  return typeof val["value"] === "string" ? val["value"] : void 0;
+}
+function getNumberValue(node) {
+  const val = rec(node);
+  return val?.["type"] === "number" && typeof val["value"] === "number" ? val["value"] : void 0;
+}
+function getSplitUrlFunctionArgs(node, functionName) {
+  if (getFunctionName(node) !== functionName) {
+    return void 0;
+  }
+  const args = rec(node)?.["args"]?.value;
+  if (!Array.isArray(args) || args.length < 2) {
+    return void 0;
+  }
+  if (getColumnName(args[0]) !== "url" || getStringValue(args[1]) !== "/") {
+    return void 0;
+  }
+  return args;
+}
+function isSplitUrlIndexed(node) {
+  if (getSplitUrlFunctionArgs(node, "split") === void 0) {
+    return false;
+  }
+  const fn = rec(node);
+  return Array.isArray(fn?.["array_index"]) && fn["array_index"].length > 0;
+}
+function isSplitPartUrl(node) {
+  const args = getSplitUrlFunctionArgs(node, "split_part");
+  return getNumberValue(args?.[2]) !== void 0;
+}
+function isCardinalitySplitUrl(node) {
+  if (getFunctionName(node) !== "cardinality") {
+    return false;
+  }
+  const outerArgs = rec(node)?.["args"]?.value;
+  if (!Array.isArray(outerArgs) || outerArgs.length === 0) {
+    return false;
+  }
+  return getSplitUrlFunctionArgs(outerArgs[0], "split") !== void 0;
+}
+function getConditionTableQualifier(left) {
+  const colName = getColumnName(left);
+  if (colName !== void 0) {
+    return getColumnTable(left);
+  }
+  const splitArgs = getSplitUrlFunctionArgs(left, "split") ?? getSplitUrlFunctionArgs(left, "split_part");
+  if (splitArgs !== void 0) {
+    return getColumnTable(splitArgs[0]);
+  }
+  if (isCardinalitySplitUrl(left)) {
+    const outerArgs = rec(left)?.["args"]?.value;
+    const splitFn = rec(outerArgs?.[0]);
+    const innerArgs = splitFn?.["args"]?.value;
+    return getColumnTable(innerArgs?.[0]);
+  }
+  return void 0;
+}
+function buildPathSegmentPredicate(index, value) {
+  return (path) => {
+    const part = path.split("/")[index - 1];
+    log("checking path segment", { path, index, part, value });
+    return part?.startsWith(":") === true ? true : part === value;
+  };
+}
+function buildLeafPredicate(node, tableAlias) {
+  if (node.operator !== "=") {
+    return void 0;
+  }
+  const { left, right } = node;
+  const conditionTable = getConditionTableQualifier(left);
+  if (conditionTable !== void 0 && tableAlias !== void 0 && conditionTable !== tableAlias) {
+    return void 0;
+  }
+  if (getColumnName(left) === "method") {
+    const value = getStringValue(right);
+    if (value !== void 0) {
+      return (_path, method) => method === value;
+    }
+  }
+  if (getColumnName(left) === "responsestatus") {
+    const value = getStringValue(right);
+    if (value !== void 0) {
+      return (_path, _method, responseCode) => responseCode === value;
+    }
+  }
+  if (isSplitUrlIndexed(left)) {
+    const index = left.array_index[0]?.index.value;
+    const value = getStringValue(right);
+    if (typeof index === "number" && value !== void 0) {
+      return buildPathSegmentPredicate(index, value);
+    }
+  }
+  if (isSplitPartUrl(left)) {
+    const index = getNumberValue(
+      getSplitUrlFunctionArgs(left, "split_part")?.[2]
+    );
+    const value = getStringValue(right);
+    if (index !== void 0 && value !== void 0) {
+      return buildPathSegmentPredicate(index, value);
+    }
+  }
+  if (isCardinalitySplitUrl(left)) {
+    const count = getNumberValue(right);
+    if (count !== void 0) {
+      return (path) => path.split("/").length === count;
+    }
+  }
+  return void 0;
+}
+function buildPredicate(expr, tableAlias) {
+  const node = rec(expr);
+  if (node?.["type"] !== "binary_expr") {
+    return ALWAYS_TRUE;
+  }
+  const binary = expr;
+  switch (binary.operator) {
+    case "AND": {
+      const leftPred = buildPredicate(binary.left, tableAlias);
+      const rightPred = buildPredicate(binary.right, tableAlias);
+      return (path, method, code) => leftPred(path, method, code) && rightPred(path, method, code);
+    }
+    case "OR": {
+      const leftPred = buildPredicate(binary.left, tableAlias);
+      const rightPred = buildPredicate(binary.right, tableAlias);
+      return (path, method, code) => leftPred(path, method, code) || rightPred(path, method, code);
+    }
+    case "NOT": {
+      const innerPred = buildPredicate(binary.left, tableAlias);
+      return (path, method, code) => !innerPred(path, method, code);
+    }
+    default: {
+      return buildLeafPredicate(binary, tableAlias) ?? ALWAYS_TRUE;
+    }
+  }
+}
+function matchApi(selectAST, tableAST, apiSchemas) {
+  const tableAlias = tableAST.as ?? void 0;
+  const predicate = buildPredicate(
+    selectAST.where,
+    tableAlias
+  );
+  const allOperations = apiSchemas.flatMap((apiSchema) => Object.entries(apiSchema.apis)).flatMap(
+    ([path, operations]) => Object.entries(operations).map(([method, operationSchemas]) => ({
+      path,
+      method: method.toUpperCase(),
+      operationSchemas
+    }))
+  );
+  log("total operation schemas", allOperations.length);
+  const matchedApis = allOperations.flatMap(
+    ({ path, method, operationSchemas }) => Object.entries(operationSchemas.responses).flatMap(
+      ([responseCode, responseSchema]) => predicate(path, method, responseCode) ? [
+        {
+          path,
+          method,
+          request: operationSchemas.request,
+          response: responseSchema
+        }
+      ] : []
+    )
+  );
+  log("matched apis", matchedApis.length);
+  if (matchedApis.length === 0) {
+    log("no matched api");
+    throw new Error(
+      "No matched api, please adjust your query conditions to match with at least one API endpoints with firehose enabled."
+    );
+  }
+  return matchedApis;
+}
+export {
+  matchApi
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist-mjs/athena/athena.mjs

@@ -0,0 +1,165 @@
+// src/athena/athena.ts
+import debug from "debug";
+import {
+  AST_NODE_TYPES,
+  ESLintUtils
+} from "@typescript-eslint/utils";
+import { parse } from "../peggy/athena-peggy.mjs";
+import { createRootContext } from "./context.mjs";
+import {
+  ATHENA_ERROR,
+  AthenaError,
+  checkAthenaAst,
+  offsetToLoc,
+  SYNTAXT_ERROR
+} from "./validate.mjs";
+var ruleId = "athena";
+var log = debug("eslint-athena-plugin:athena");
+var createRule = ESLintUtils.RuleCreator((name) => name);
+function buildSqlMapping(sqlNode) {
+  if (sqlNode.type !== AST_NODE_TYPES.TemplateLiteral) {
+    return [{ sqlStart: 0, srcStart: sqlNode.range[0] + 1 }];
+  }
+  const rawSql = sqlNode.quasis.map((quasi) => quasi.value.cooked ?? "").join("");
+  const trimStart = rawSql.length - rawSql.trimStart().length;
+  const segments = [];
+  let sqlCursor = 0;
+  for (const [index, quasi] of sqlNode.quasis.entries()) {
+    const cooked = quasi.value.cooked ?? "";
+    const localTrim = index === 0 ? trimStart : 0;
+    segments.push({
+      sqlStart: sqlCursor,
+      srcStart: quasi.range[0] + 1 + localTrim
+    });
+    sqlCursor += cooked.length - localTrim;
+  }
+  return segments;
+}
+function sqlOffsetToSource(sqlOffset, segments) {
+  for (let index = segments.length - 1; index >= 0; index--) {
+    const seg = segments[index];
+    if (seg !== void 0 && sqlOffset >= seg.sqlStart) {
+      return seg.srcStart + (sqlOffset - seg.sqlStart);
+    }
+  }
+  return segments[0]?.srcStart ?? 0;
+}
+var rule = createRule({
+  name: ruleId,
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Validate Athena SQL strings against OpenAPI schemas at lint time"
+    },
+    schema: [],
+    messages: {
+      [SYNTAXT_ERROR]: `SyntaxError {{ errorMessage }}`,
+      [ATHENA_ERROR]: `AthenaError {{ errorMessage }}`
+    }
+  },
+  defaultOptions: [],
+  create(context) {
+    function checkSql(sql, sqlNode) {
+      if (!/^\s*(?:SELECT\b[\s\S]*\bFROM\b|WITH\b[\s\S]*\bSELECT\b[\s\S]*\b)/iu.test(
+        sql
+      )) {
+        log("skipping non-SELECT SQL string", { sql });
+        return;
+      }
+      const sqlMapping = buildSqlMapping(sqlNode);
+      let ast;
+      try {
+        ({ ast } = parse(sql, { includeLocations: true }));
+      } catch (error) {
+        log("error parsing Athena SQL", { error, sql });
+        const pegLoc = error.location;
+        if (pegLoc !== void 0) {
+          const sourceText = context.sourceCode.getText();
+          context.report({
+            loc: {
+              start: offsetToLoc(
+                sourceText,
+                sqlOffsetToSource(pegLoc.start.offset, sqlMapping)
+              ),
+              end: offsetToLoc(
+                sourceText,
+                sqlOffsetToSource(pegLoc.end.offset, sqlMapping)
+              )
+            },
+            messageId: SYNTAXT_ERROR,
+            data: { errorMessage: error.message }
+          });
+        } else {
+          context.report({
+            node: sqlNode,
+            messageId: SYNTAXT_ERROR,
+            data: { errorMessage: error.message }
+          });
+        }
+        return;
+      }
+      const athenaCtx = createRootContext();
+      try {
+        checkAthenaAst(Array.isArray(ast) ? ast[0] : ast, athenaCtx);
+      } catch (error) {
+        log("error checking Athena AST", { error, sql });
+        if (error instanceof AthenaError) {
+          const astLoc = error.ast?.loc;
+          if (astLoc !== void 0) {
+            const sourceText = context.sourceCode.getText();
+            context.report({
+              loc: {
+                start: offsetToLoc(
+                  sourceText,
+                  sqlOffsetToSource(astLoc.start.offset, sqlMapping)
+                ),
+                end: offsetToLoc(
+                  sourceText,
+                  sqlOffsetToSource(astLoc.end.offset, sqlMapping)
+                )
+              },
+              messageId: ATHENA_ERROR,
+              data: { errorMessage: error.message }
+            });
+          } else {
+            context.report({
+              node: sqlNode,
+              messageId: ATHENA_ERROR,
+              data: { errorMessage: error.message }
+            });
+          }
+        } else {
+          console.error(
+            `Failed to apply ${ruleId} rule for "${context.filename}":`,
+            error
+          );
+          context.report({
+            node: sqlNode,
+            messageId: ATHENA_ERROR,
+            data: {
+              errorMessage: error instanceof Error ? String(error) : JSON.stringify(error, void 0, 2)
+            }
+          });
+        }
+      }
+    }
+    return {
+      TemplateLiteral(sqlNode) {
+        const sql = sqlNode.quasis.map((quasi) => quasi.value.cooked).join("").trim();
+        checkSql(sql, sqlNode);
+      },
+      Literal(sqlNode) {
+        if (typeof sqlNode.value !== "string") {
+          return;
+        }
+        checkSql(sqlNode.value, sqlNode);
+      }
+    };
+  }
+});
+var athena_default = rule;
+export {
+  athena_default as default,
+  ruleId
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist-mjs/athena/column.mjs

@@ -0,0 +1 @@
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFtdLAogICJtYXBwaW5ncyI6ICIiLAogICJuYW1lcyI6IFtdCn0K

package/dist-mjs/athena/context.mjs

@@ -0,0 +1,21 @@
+// src/athena/context.ts
+function createRootContext() {
+  return {
+    tables: /* @__PURE__ */ new Map(),
+    aliases: /* @__PURE__ */ new Map(),
+    apiSchemas: /* @__PURE__ */ new Map()
+  };
+}
+function createChildContext(parent) {
+  return {
+    tables: new Map(parent.tables),
+    aliases: /* @__PURE__ */ new Map(),
+    apiSchemas: parent.apiSchemas,
+    parent
+  };
+}
+export {
+  createChildContext,
+  createRootContext
+};
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vc3JjL2F0aGVuYS9jb250ZXh0LnRzIl0sCiAgIm1hcHBpbmdzIjogIjtBQThCTyxTQUFTLG9CQUFrQztBQUNoRCxTQUFPO0FBQUEsSUFDTCxRQUFRLG9CQUFJLElBQUk7QUFBQSxJQUNoQixTQUFTLG9CQUFJLElBQUk7QUFBQSxJQUNqQixZQUFZLG9CQUFJLElBQUk7QUFBQSxFQUN0QjtBQUNGO0FBR08sU0FBUyxtQkFBbUIsUUFBb0M7QUFDckUsU0FBTztBQUFBLElBQ0wsUUFBUSxJQUFJLElBQUksT0FBTyxNQUFNO0FBQUEsSUFDN0IsU0FBUyxvQkFBSSxJQUFJO0FBQUEsSUFDakIsWUFBWSxPQUFPO0FBQUEsSUFDbkI7QUFBQSxFQUNGO0FBQ0Y7IiwKICAibmFtZXMiOiBbXQp9Cg==

package/dist-mjs/athena/index.mjs

@@ -0,0 +1 @@
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFtdLAogICJtYXBwaW5ncyI6ICIiLAogICJuYW1lcyI6IFtdCn0K

package/dist-mjs/athena/service-table.mjs

@@ -0,0 +1,45 @@
+// src/athena/service-table.ts
+var SCHEMA_STRING = { type: "string" };
+var SCHEMA_OBJECT = { type: "object" };
+function col(name, schema) {
+  return { name, schema };
+}
+function bodySchema(envelope, field) {
+  return envelope["properties"]?.[field] ?? SCHEMA_OBJECT;
+}
+function buildServiceTables(tableName, operations) {
+  return operations.map((operation) => ({
+    name: tableName,
+    apiOperation: [operation],
+    columns: /* @__PURE__ */ new Map([
+      ["method", [col("method", SCHEMA_STRING)]],
+      ["started", [col("started", SCHEMA_STRING)]],
+      ["ended", [col("ended", SCHEMA_STRING)]],
+      ["url", [col("url", SCHEMA_STRING)]],
+      [
+        "requestbody",
+        [col("requestbody", bodySchema(operation.request, "body"))]
+      ],
+      [
+        "requestheaders",
+        [col("requestheaders", bodySchema(operation.request, "headers"))]
+      ],
+      ["responsestatus", [col("responsestatus", SCHEMA_STRING)]],
+      ["responsemessage", [col("responsemessage", SCHEMA_STRING)]],
+      ["responsetype", [col("responsetype", SCHEMA_STRING)]],
+      [
+        "responsebody",
+        [col("responsebody", bodySchema(operation.response, "body"))]
+      ],
+      [
+        "responseheaders",
+        [col("responseheaders", bodySchema(operation.response, "headers"))]
+      ],
+      ["partition_date", [col("partition_date", SCHEMA_STRING)]]
+    ])
+  }));
+}
+export {
+  buildServiceTables
+};
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vc3JjL2F0aGVuYS9zZXJ2aWNlLXRhYmxlLnRzIl0sCiAgIm1hcHBpbmdzIjogIjtBQW9CQSxJQUFNLGdCQUE4QixFQUFFLE1BQU0sU0FBUztBQUNyRCxJQUFNLGdCQUE4QixFQUFFLE1BQU0sU0FBUztBQUVyRCxTQUFTLElBQUksTUFBYyxRQUF5QztBQUNsRSxTQUFPLEVBQUUsTUFBTSxPQUFPO0FBQ3hCO0FBRUEsU0FBUyxXQUNQLFVBQ0EsT0FDaUI7QUFDakIsU0FDRyxTQUNDLFlBQ0YsSUFBSSxLQUFLLEtBQUs7QUFFbEI7QUFPTyxTQUFTLG1CQUNkLFdBQ0EsWUFDaUI7QUFDakIsU0FBTyxXQUFXLElBQUksQ0FBQyxlQUFlO0FBQUEsSUFDcEMsTUFBTTtBQUFBLElBQ04sY0FBYyxDQUFDLFNBQVM7QUFBQSxJQUN4QixTQUFTLG9CQUFJLElBQThCO0FBQUEsTUFDekMsQ0FBQyxVQUFVLENBQUMsSUFBSSxVQUFVLGFBQWEsQ0FBQyxDQUFDO0FBQUEsTUFDekMsQ0FBQyxXQUFXLENBQUMsSUFBSSxXQUFXLGFBQWEsQ0FBQyxDQUFDO0FBQUEsTUFDM0MsQ0FBQyxTQUFTLENBQUMsSUFBSSxTQUFTLGFBQWEsQ0FBQyxDQUFDO0FBQUEsTUFDdkMsQ0FBQyxPQUFPLENBQUMsSUFBSSxPQUFPLGFBQWEsQ0FBQyxDQUFDO0FBQUEsTUFDbkM7QUFBQSxRQUNFO0FBQUEsUUFDQSxDQUFDLElBQUksZUFBZSxXQUFXLFVBQVUsU0FBUyxNQUFNLENBQUMsQ0FBQztBQUFBLE1BQzVEO0FBQUEsTUFDQTtBQUFBLFFBQ0U7QUFBQSxRQUNBLENBQUMsSUFBSSxrQkFBa0IsV0FBVyxVQUFVLFNBQVMsU0FBUyxDQUFDLENBQUM7QUFBQSxNQUNsRTtBQUFBLE1BQ0EsQ0FBQyxrQkFBa0IsQ0FBQyxJQUFJLGtCQUFrQixhQUFhLENBQUMsQ0FBQztBQUFBLE1BQ3pELENBQUMsbUJBQW1CLENBQUMsSUFBSSxtQkFBbUIsYUFBYSxDQUFDLENBQUM7QUFBQSxNQUMzRCxDQUFDLGdCQUFnQixDQUFDLElBQUksZ0JBQWdCLGFBQWEsQ0FBQyxDQUFDO0FBQUEsTUFDckQ7QUFBQSxRQUNFO0FBQUEsUUFDQSxDQUFDLElBQUksZ0JBQWdCLFdBQVcsVUFBVSxVQUFVLE1BQU0sQ0FBQyxDQUFDO0FBQUEsTUFDOUQ7QUFBQSxNQUNBO0FBQUEsUUFDRTtBQUFBLFFBQ0EsQ0FBQyxJQUFJLG1CQUFtQixXQUFXLFVBQVUsVUFBVSxTQUFTLENBQUMsQ0FBQztBQUFBLE1BQ3BFO0FBQUEsTUFDQSxDQUFDLGtCQUFrQixDQUFDLElBQUksa0JBQWtCLGFBQWEsQ0FBQyxDQUFDO0FBQUEsSUFDM0QsQ0FBQztBQUFBLEVBQ0gsRUFBRTtBQUNKOyIsCiAgIm5hbWVzIjogW10KfQo=