@xylex-group/athena 3.0.3 → 3.3.0

package/dist/browser.cjs

@@ -2005,7 +2005,7 @@ function buildAthenaGatewayUrl(baseUrl, path) {
 
 // package.json
 var package_default = {
-  version: "3.0.3"
+  version: "3.3.0"
 };
 
 // src/sdk-version.ts
@@ -4765,6 +4765,14 @@ function createAuthModule(config = {}, runtimeOptions = {}) {
     changeEmailVerify: (input, options) => getWithQuery("/change-email/verify", input, options),
     deleteUserVerify: (input, options) => getWithQuery("/delete-user/verify", input, options),
     changePassword: (input, options) => postGeneric("/change-password", input, options),
+    // Better Auth UI flat method aliases (also nested under session/account/social/user).
+    listSessions: (input, options) => getGeneric("/list-sessions", input, options),
+    revokeSession: sessionRevokeBinding,
+    revokeOtherSessions,
+    listAccounts: (input, options) => getGeneric("/list-accounts", input, options),
+    unlinkAccount: (input, options) => postGeneric("/unlink-account", input, options),
+    linkSocial: (input, options) => postGeneric("/link-social", input, options),
+    updateUser: (input, options) => postGeneric("/update-user", input, options),
     user: {
       update: (input, options) => postGeneric("/update-user", input, options),
       delete: (input, options) => postGeneric("/delete-user", input, options),
@@ -10574,6 +10582,82 @@ function mergeAthenaRequestContexts(base, override) {
   };
 }
 
+// src/diagnostics.ts
+function readProcessEnv2() {
+  try {
+    return globalThis.process?.env ?? {};
+  } catch {
+    return {};
+  }
+}
+function isTruthyEnv(value) {
+  if (!value) return false;
+  const normalized = value.trim().toLowerCase();
+  return normalized === "1" || normalized === "true" || normalized === "yes" || normalized === "on";
+}
+function isQuietAthenaDiagnosticsEnvironment(env = readProcessEnv2()) {
+  const nodeEnv = env.NODE_ENV?.trim().toLowerCase();
+  if (nodeEnv === "production") {
+    return true;
+  }
+  if (isTruthyEnv(env.OPENNEXT_BUILD)) {
+    return true;
+  }
+  const nextPhase = env.NEXT_PHASE?.trim();
+  if (nextPhase === "phase-production-build") {
+    return true;
+  }
+  if (isTruthyEnv(env.CI) && nodeEnv !== "test") {
+    if (nodeEnv === "production" || isTruthyEnv(env.OPENNEXT_BUILD)) {
+      return true;
+    }
+  }
+  return false;
+}
+function resolveBooleanFlag(explicit, mode, quiet) {
+  if (typeof explicit === "boolean") {
+    return explicit;
+  }
+  if (mode === true) {
+    return true;
+  }
+  if (mode === false) {
+    return false;
+  }
+  if (mode === "auto") {
+    return false;
+  }
+  return false;
+}
+function resolveAthenaClientDiagnostics(input) {
+  const env = input.env ?? readProcessEnv2();
+  const quiet = isQuietAthenaDiagnosticsEnvironment(env);
+  const mode = input.diagnostics;
+  const effectiveMode = mode === "auto" && quiet ? false : mode;
+  const debugAst = resolveBooleanFlag(input.debugAst, effectiveMode);
+  const findManyAst = resolveBooleanFlag(input.findManyAst, effectiveMode);
+  let traceQueries;
+  if (input.traceQueries !== void 0) {
+    if (typeof input.traceQueries === "boolean") {
+      traceQueries = input.traceQueries;
+    } else if (effectiveMode === false || mode === "auto" && quiet) {
+      const enabled = input.traceQueries.enabled;
+      traceQueries = typeof enabled === "boolean" ? enabled ? input.traceQueries : false : false;
+    } else {
+      traceQueries = input.traceQueries;
+    }
+  } else if (effectiveMode === true) {
+    traceQueries = true;
+  } else {
+    traceQueries = false;
+  }
+  return {
+    debugAst,
+    findManyAst,
+    traceQueries
+  };
+}
+
 // src/v3-client.ts
 var ENV_URL_KEYS = ["ATHENA_URL", "NEXT_PUBLIC_ATHENA_URL"];
 var ENV_DB_URL_KEYS = ["ATHENA_DB_URL", "ATHENA_GATEWAY_URL", "NEXT_PUBLIC_ATHENA_DB_API_URL"];
@@ -10582,7 +10666,13 @@ var ENV_CHAT_URL_KEYS = ["ATHENA_CHAT_URL", "NEXT_PUBLIC_ATHENA_CHAT_URL"];
 var ENV_CHAT_WS_URL_KEYS = ["ATHENA_CHAT_WS_URL", "NEXT_PUBLIC_ATHENA_CHAT_WS_URL"];
 var ENV_STORAGE_URL_KEYS = ["ATHENA_STORAGE_URL", "NEXT_PUBLIC_ATHENA_STORAGE_URL"];
 var ENV_KEY_KEYS = ["ATHENA_API_KEY", "NEXT_PUBLIC_ATHENA_API_KEY", "ATHENA_GATEWAY_API_KEY", "X_API_KEY"];
-var ENV_CLIENT_KEYS = ["ATHENA_CLIENT", "NEXT_PUBLIC_ATHENA_CLIENT"];
+var ENV_CLIENT_KEYS = [
+  "ATHENA_CLIENT",
+  "ATHENA_GATEWAY_CLIENT",
+  "ATHENA_GENERATOR_CLIENT",
+  "NEXT_PUBLIC_ATHENA_CLIENT",
+  "NEXT_PUBLIC_ATHENA_GATEWAY_CLIENT"
+];
 var MISSING_DB_SENTINEL = "https://athena.invalid/db";
 function readFirstEnv(env, keys) {
   for (const key of keys) {
@@ -10657,6 +10747,13 @@ function createInternalConfig(core) {
   const { config, urls } = core;
   const { url: _authUrl, ...authOptions } = config.auth ?? {};
   const { url: _storageUrl, directUpload, ...storageOptions } = config.storage ?? {};
+  const diagnostics = resolveAthenaClientDiagnostics({
+    diagnostics: config.diagnostics,
+    debugAst: config.debugAst,
+    findManyAst: config.findManyAst,
+    traceQueries: config.traceQueries,
+    env: config.env
+  });
   return {
     baseUrl: urls.db ?? MISSING_DB_SENTINEL,
     apiKey: core.key,
@@ -10673,9 +10770,9 @@ function createInternalConfig(core) {
     models: config.models,
     behavior: {
       retryReads: config.retryReads,
-      traceQueries: config.traceQueries,
-      debugAst: config.debugAst,
-      findManyAst: config.findManyAst
+      traceQueries: diagnostics.traceQueries,
+      debugAst: diagnostics.debugAst,
+      findManyAst: diagnostics.findManyAst
     },
     storage: {
       ...storageOptions,
@@ -10749,11 +10846,30 @@ function createClientView(core, viewContext) {
       return resolved.verifyConnection(options);
     },
     withContext(context) {
+      warnIfEmptyRequestContext(context);
       return createClientView(core, mergeAthenaRequestContexts(viewContext, context));
     }
   };
   return Object.freeze(client);
 }
+function isEmptyAthenaRequestContext(context) {
+  if (!context) return true;
+  const hasHeaders = context.headers != null && Object.keys(context.headers).length > 0;
+  return context.userId == null && context.organizationId == null && !normalizeOptionalContextString(context.cookie) && !normalizeOptionalContextString(context.bearerToken) && !normalizeOptionalContextString(context.sessionToken) && !context.forceNoCache && !hasHeaders;
+}
+function normalizeOptionalContextString(value) {
+  const trimmed = value?.trim();
+  return trimmed || void 0;
+}
+function warnIfEmptyRequestContext(context) {
+  if (!isEmptyAthenaRequestContext(context)) return;
+  if (typeof process !== "undefined" && process.env?.NODE_ENV === "production") {
+    return;
+  }
+  console.warn(
+    "[athena] withContext({}) has no userId, organizationId, cookie, bearerToken, sessionToken, headers, or forceNoCache. Gateway scope headers will not change. Pass identity fields, or use createAthenaServerClient({ session, scope })."
+  );
+}
 function createClient(config) {
   return createClientView(resolveCore(config));
 }
@@ -11883,6 +11999,765 @@ function athenaAuth(config) {
   return auth;
 }
 
+// src/query/read-query.ts
+function normalizeAthenaReadQueryOrderBy(orderBy) {
+  if (!orderBy) {
+    return [];
+  }
+  const list = Array.isArray(orderBy) ? orderBy : [orderBy];
+  return list.filter(
+    (entry) => entry && typeof entry.column === "string" && entry.column.trim().length > 0
+  );
+}
+function isRecord14(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function flattenAthenaRowValue(row, column) {
+  if (!column.relation) {
+    return row[column.column];
+  }
+  const relationValue = row[column.relation.name];
+  if (Array.isArray(relationValue)) {
+    return relationValue.map((entry) => isRecord14(entry) ? entry[column.column] : void 0).filter((entry) => entry !== void 0);
+  }
+  if (isRecord14(relationValue)) {
+    return relationValue[column.column];
+  }
+  return void 0;
+}
+function resolveFlatRowKey(row, index, preferredKey) {
+  const preferredValue = preferredKey && preferredKey in row ? row[preferredKey] : void 0;
+  if (preferredValue !== void 0 && preferredValue !== null && `${preferredValue}`.trim().length > 0) {
+    return String(preferredValue);
+  }
+  for (const [key, value] of Object.entries(row)) {
+    if (key === "__rowKey") {
+      continue;
+    }
+    if (value === void 0 || value === null) {
+      continue;
+    }
+    if (Array.isArray(value)) {
+      if (value.length > 0) {
+        return `${key}-${value.join("-")}`;
+      }
+      continue;
+    }
+    const nextValue = String(value).trim();
+    if (nextValue.length > 0) {
+      return nextValue;
+    }
+  }
+  return `row-${index + 1}`;
+}
+function flattenAthenaReadQueryRows(rows, columns, preferredKey) {
+  return rows.map((entry, index) => {
+    const sourceRow = isRecord14(entry) ? entry : {};
+    const flatRow = columns.reduce(
+      (currentRow, column) => {
+        currentRow[column.key] = flattenAthenaRowValue(sourceRow, column);
+        return currentRow;
+      },
+      { __rowKey: "" }
+    );
+    flatRow.__rowKey = resolveFlatRowKey(flatRow, index, preferredKey);
+    return flatRow;
+  });
+}
+var flattenAthenaRows = flattenAthenaReadQueryRows;
+function buildAthenaReadQuerySelectString(columns) {
+  const baseColumns = columns.filter((column) => !column.relation).map((column) => column.column);
+  const relationGroups = /* @__PURE__ */ new Map();
+  for (const column of columns) {
+    if (!column.relation) {
+      continue;
+    }
+    const groupKey = [
+      column.relation.name,
+      column.relation.schema ?? "",
+      column.relation.table
+    ].join(":");
+    const existingGroup = relationGroups.get(groupKey);
+    if (existingGroup) {
+      if (!existingGroup.columns.includes(column.column)) {
+        existingGroup.columns.push(column.column);
+      }
+      continue;
+    }
+    relationGroups.set(groupKey, {
+      columns: [column.column],
+      relation: column.relation
+    });
+  }
+  const relationColumns = [...relationGroups.values()].map(
+    ({ columns: relationColumns2, relation }) => {
+      const relationTarget = relation.schema ? `${relation.schema}.${relation.table}` : relation.table;
+      return `${relation.name}:${relationTarget}(${relationColumns2.join(",")})`;
+    }
+  );
+  return [...baseColumns, ...relationColumns].join(",");
+}
+var buildAthenaTableSelectString = buildAthenaReadQuerySelectString;
+function buildAthenaReadQueryFindManySelect(columns) {
+  const select = {};
+  for (const column of columns) {
+    if (!column.relation) {
+      select[column.column] = true;
+      continue;
+    }
+    const existingRelation = select[column.relation.name];
+    if (existingRelation && existingRelation !== true && isRecord14(existingRelation.select)) {
+      existingRelation.select[column.column] = true;
+      continue;
+    }
+    select[column.relation.name] = {
+      ...column.relation.schema ? { schema: column.relation.schema } : {},
+      select: {
+        [column.column]: true
+      }
+    };
+  }
+  return select;
+}
+var buildAthenaTableFindManySelect = buildAthenaReadQueryFindManySelect;
+function buildAthenaReadQueryFindManyWhere(filters) {
+  if (!filters?.length) {
+    return;
+  }
+  return filters.reduce(
+    (where, filter) => {
+      const operator = filter.operator ?? "eq";
+      where[filter.column] = operator === "eq" ? filter.value : { [operator]: filter.value };
+      return where;
+    },
+    {}
+  );
+}
+var buildAthenaTableFindManyWhere = buildAthenaReadQueryFindManyWhere;
+function buildAthenaReadQueryFindManyOrderBy(orderBy) {
+  const normalized = normalizeAthenaReadQueryOrderBy(orderBy);
+  if (normalized.length === 0) {
+    return;
+  }
+  if (normalized.length === 1) {
+    const primary = normalized[0];
+    if (!primary) {
+      return;
+    }
+    return {
+      ascending: primary.direction !== "desc",
+      column: primary.column
+    };
+  }
+  return Object.fromEntries(
+    normalized.map((entry) => [
+      entry.column,
+      entry.direction === "desc" ? "desc" : "asc"
+    ])
+  );
+}
+var buildAthenaTableFindManyOrderBy = buildAthenaReadQueryFindManyOrderBy;
+var normalizeAthenaTableOrderBy = normalizeAthenaReadQueryOrderBy;
+function applyAthenaReadQueryFilters(queryBuilder, filters) {
+  if (!filters?.length) {
+    return queryBuilder;
+  }
+  return filters.reduce((currentBuilder, filter) => {
+    const operator = filter.operator ?? "eq";
+    const builderMethod = currentBuilder[operator];
+    if (typeof builderMethod !== "function") {
+      return currentBuilder;
+    }
+    return builderMethod.call(currentBuilder, filter.column, filter.value);
+  }, queryBuilder);
+}
+var applyAthenaTableFilters = applyAthenaReadQueryFilters;
+function applyAthenaReadQuerySelectOrder(queryBuilder, orderBy) {
+  const normalized = normalizeAthenaReadQueryOrderBy(orderBy);
+  if (normalized.length === 0) {
+    return queryBuilder;
+  }
+  return normalized.reduce(
+    (builder, entry) => builder.order(entry.column, {
+      ascending: entry.direction !== "desc"
+    }),
+    queryBuilder
+  );
+}
+var applyAthenaTableSelectOrder = applyAthenaReadQuerySelectOrder;
+function applyAthenaReadQuerySelectLimit(queryBuilder, limit) {
+  if (!limit || limit < 1) {
+    return queryBuilder;
+  }
+  return queryBuilder.limit(limit);
+}
+var applyAthenaTableSelectLimit = applyAthenaReadQuerySelectLimit;
+function clampAthenaReadQueryTotalItems(totalItems, limit) {
+  if (!limit || limit < 1) {
+    return totalItems;
+  }
+  return Math.min(totalItems, limit);
+}
+var clampAthenaTableTotalItems = clampAthenaReadQueryTotalItems;
+function resolveCountValue(...candidates) {
+  for (const candidate of candidates) {
+    if (typeof candidate === "number" && Number.isFinite(candidate)) {
+      return Math.max(0, Math.trunc(candidate));
+    }
+  }
+  return 0;
+}
+function resolveTotalItemsFromPage({
+  countCandidates,
+  limit,
+  page,
+  pageSize,
+  rowCount
+}) {
+  const exactCount = resolveCountValue(...countCandidates);
+  if (exactCount > 0) {
+    return clampAthenaReadQueryTotalItems(exactCount, limit);
+  }
+  if (rowCount > 0) {
+    const base = (page - 1) * pageSize + rowCount;
+    const synthetic = rowCount >= pageSize ? base + 1 : base;
+    return clampAthenaReadQueryTotalItems(synthetic, limit);
+  }
+  return clampAthenaReadQueryTotalItems(exactCount, limit);
+}
+function resolveAthenaReadQueryPageFetch({
+  page,
+  pageSize,
+  limit
+}) {
+  const safePage = Math.max(1, Math.trunc(page) || 1);
+  const safePageSize = Math.max(1, Math.trunc(pageSize) || 1);
+  if (!limit || limit < 1) {
+    return { page: safePage, pageSize: safePageSize, shouldFetch: true };
+  }
+  const totalCap = Math.trunc(limit);
+  const offset = (safePage - 1) * safePageSize;
+  if (offset >= totalCap) {
+    return { page: safePage, pageSize: safePageSize, shouldFetch: false };
+  }
+  return {
+    page: safePage,
+    pageSize: Math.min(safePageSize, totalCap - offset),
+    shouldFetch: true
+  };
+}
+async function executeAthenaReadQuery({
+  client,
+  page,
+  pageSize,
+  query
+}) {
+  const db = client.db;
+  const baseBuilder = db.from(query.table, {
+    schema: query.schema
+  });
+  const countBuilder = applyAthenaReadQueryFilters(
+    db.from(query.table, { schema: query.schema }),
+    query.filters
+  );
+  const countResult = await countBuilder.select(query.countColumn, {
+    count: "exact",
+    head: true
+  });
+  const pageFetch = resolveAthenaReadQueryPageFetch({
+    limit: query.limit,
+    page,
+    pageSize
+  });
+  if (!pageFetch.shouldFetch) {
+    return {
+      rows: [],
+      totalItems: resolveTotalItemsFromPage({
+        countCandidates: [countResult.count],
+        limit: query.limit,
+        page: pageFetch.page,
+        pageSize,
+        rowCount: 0
+      })
+    };
+  }
+  if ((query.mode ?? "findMany") === "select") {
+    const selectBuilder = applyAthenaReadQuerySelectOrder(
+      applyAthenaReadQueryFilters(baseBuilder, query.filters),
+      query.orderBy
+    );
+    const result2 = await selectBuilder.currentPage(pageFetch.page).pageSize(pageFetch.pageSize).select(buildAthenaReadQuerySelectString(query.columns), {
+      count: "exact"
+    });
+    const rows2 = flattenAthenaReadQueryRows(
+      Array.isArray(result2.data) ? result2.data : [],
+      query.columns,
+      query.rowKey
+    );
+    return {
+      debugAst: getAthenaDebugAst(result2) ?? void 0,
+      rows: rows2,
+      totalItems: resolveTotalItemsFromPage({
+        countCandidates: [countResult.count, result2.count],
+        limit: query.limit,
+        page: pageFetch.page,
+        pageSize,
+        rowCount: rows2.length
+      })
+    };
+  }
+  const findManyOrderBy = buildAthenaReadQueryFindManyOrderBy(query.orderBy);
+  const findManyOptions = {
+    ...findManyOrderBy ? { orderBy: findManyOrderBy } : {},
+    select: buildAthenaReadQueryFindManySelect(query.columns),
+    ...query.filters?.length ? { where: buildAthenaReadQueryFindManyWhere(query.filters) } : {}
+  };
+  const result = await baseBuilder.currentPage(pageFetch.page).pageSize(pageFetch.pageSize).findMany(findManyOptions);
+  const rows = flattenAthenaReadQueryRows(
+    Array.isArray(result.data) ? result.data : [],
+    query.columns,
+    query.rowKey
+  );
+  return {
+    debugAst: getAthenaDebugAst(result) ?? void 0,
+    rows,
+    totalItems: resolveTotalItemsFromPage({
+      countCandidates: [countResult.count, result.count],
+      limit: query.limit,
+      page: pageFetch.page,
+      pageSize,
+      rowCount: rows.length
+    })
+  };
+}
+var executeAthenaTableQuery = executeAthenaReadQuery;
+
+// src/tables/catalog.ts
+var POSTGRES_CATALOG_SQL = {
+  columns: `
+    SELECT
+      n.nspname AS schema_name,
+      c.relname AS table_name,
+      a.attname AS column_name,
+      format_type(a.atttypid, a.atttypmod) AS data_type,
+      NOT a.attnotnull AS is_nullable
+    FROM pg_attribute a
+    JOIN pg_class c ON c.oid = a.attrelid
+    JOIN pg_namespace n ON n.oid = c.relnamespace
+    WHERE c.relkind IN ('r', 'p')
+      AND a.attnum > 0
+      AND NOT a.attisdropped
+      AND n.nspname = ANY($1::text[])
+    ORDER BY n.nspname, c.relname, a.attnum;
+  `,
+  foreignKeys: `
+    SELECT
+      sn.nspname AS source_schema,
+      sc.relname AS source_table,
+      con.conname AS constraint_name,
+      ARRAY_AGG(sa.attname ORDER BY cols.ordinality) AS source_columns,
+      tn.nspname AS target_schema,
+      tc.relname AS target_table,
+      ARRAY_AGG(ta.attname ORDER BY cols.ordinality) AS target_columns,
+      EXISTS (
+        SELECT 1
+        FROM pg_constraint uq
+        WHERE uq.conrelid = con.conrelid
+          AND uq.contype IN ('p', 'u')
+          AND uq.conkey = con.conkey
+      ) AS source_is_unique
+    FROM pg_constraint con
+    JOIN pg_class sc ON sc.oid = con.conrelid
+    JOIN pg_namespace sn ON sn.oid = sc.relnamespace
+    JOIN pg_class tc ON tc.oid = con.confrelid
+    JOIN pg_namespace tn ON tn.oid = tc.relnamespace
+    JOIN unnest(con.conkey, con.confkey) WITH ORDINALITY AS cols(source_attnum, target_attnum, ordinality) ON TRUE
+    JOIN pg_attribute sa ON sa.attrelid = con.conrelid AND sa.attnum = cols.source_attnum
+    JOIN pg_attribute ta ON ta.attrelid = con.confrelid AND ta.attnum = cols.target_attnum
+    WHERE con.contype = 'f'
+      AND sn.nspname = ANY($1::text[])
+      AND tn.nspname = ANY($1::text[])
+    GROUP BY
+      sn.nspname,
+      sc.relname,
+      con.conname,
+      tn.nspname,
+      tc.relname,
+      con.conkey,
+      con.conrelid
+    ORDER BY sn.nspname, sc.relname, con.conname;
+  `,
+  primaryKeys: `
+    SELECT
+      n.nspname AS schema_name,
+      c.relname AS table_name,
+      ARRAY_AGG(a.attname ORDER BY ck.ordinality) AS columns
+    FROM pg_constraint con
+    JOIN pg_class c ON c.oid = con.conrelid
+    JOIN pg_namespace n ON n.oid = c.relnamespace
+    JOIN unnest(con.conkey) WITH ORDINALITY AS ck(attnum, ordinality) ON TRUE
+    JOIN pg_attribute a ON a.attrelid = c.oid AND a.attnum = ck.attnum
+    WHERE con.contype = 'p'
+      AND n.nspname = ANY($1::text[])
+    GROUP BY n.nspname, c.relname
+    ORDER BY n.nspname, c.relname;
+  `
+};
+function parseAthenaTableSchemaScope(value) {
+  return value.split(",").map((entry) => entry.trim()).filter(
+    (entry, index, values) => entry.length > 0 && values.indexOf(entry) === index
+  );
+}
+function escapeSqlLiteral(value) {
+  return value.replace(/'/g, "''");
+}
+function buildSchemaArrayLiteral(schemas) {
+  const literals = schemas.map((schema) => `'${escapeSqlLiteral(schema)}'`).join(", ");
+  return `ARRAY[${literals}]`;
+}
+function inlineSchemaLiteral(sql, schemas) {
+  return sql.replace(
+    /\$1::text\[\]/g,
+    `${buildSchemaArrayLiteral(schemas)}::text[]`
+  );
+}
+function buildAthenaTableCatalogQueries(schemas) {
+  return {
+    columns: inlineSchemaLiteral(POSTGRES_CATALOG_SQL.columns, schemas),
+    foreignKeys: inlineSchemaLiteral(POSTGRES_CATALOG_SQL.foreignKeys, schemas),
+    primaryKeys: inlineSchemaLiteral(POSTGRES_CATALOG_SQL.primaryKeys, schemas)
+  };
+}
+function tableKey(schema, table2) {
+  return `${schema}.${table2}`;
+}
+function relationKey(...parts) {
+  const base = parts.join("_").replace(/[^A-Za-z0-9_]+/g, "_").replace(/^_+|_+$/g, "");
+  return base.length > 0 ? base : "relation";
+}
+function parsePostgresArrayLiteral(text) {
+  const body = text.slice(1, -1).trim();
+  if (!body) {
+    return [];
+  }
+  const values = [];
+  let current = "";
+  let inQuotes = false;
+  let escaped = false;
+  for (const char of body) {
+    if (escaped) {
+      current += char;
+      escaped = false;
+      continue;
+    }
+    if (char === "\\") {
+      escaped = true;
+      continue;
+    }
+    if (char === '"') {
+      inQuotes = !inQuotes;
+      continue;
+    }
+    if (char === "," && !inQuotes) {
+      values.push(current);
+      current = "";
+      continue;
+    }
+    current += char;
+  }
+  values.push(current);
+  return values.map((value) => value.trim()).filter((value) => value.length > 0);
+}
+function coerceStringArray(value) {
+  if (value == null) {
+    return [];
+  }
+  if (Array.isArray(value)) {
+    return value.map((entry) => entry.trim()).filter(Boolean);
+  }
+  if (typeof value !== "string") {
+    return [];
+  }
+  const trimmedValue = value.trim();
+  if (!trimmedValue) {
+    return [];
+  }
+  if (trimmedValue.startsWith("{") && trimmedValue.endsWith("}")) {
+    return parsePostgresArrayLiteral(trimmedValue);
+  }
+  return trimmedValue.split(",").map((entry) => entry.trim()).filter(Boolean);
+}
+function createTableCatalog() {
+  const tables = /* @__PURE__ */ new Map();
+  const ensureTable = (schema, name) => {
+    const id = tableKey(schema, name);
+    const existingTable = tables.get(id);
+    if (existingTable) {
+      return existingTable;
+    }
+    const nextTable = {
+      columns: [],
+      id,
+      name,
+      primaryKey: [],
+      relationMap: /* @__PURE__ */ new Map(),
+      schema
+    };
+    tables.set(id, nextTable);
+    return nextTable;
+  };
+  const upsertRelation = (table2, key, relation) => {
+    table2.relationMap.set(key, relation);
+  };
+  return {
+    addColumnRows(columnRows) {
+      for (const row of columnRows) {
+        const table2 = ensureTable(row.schema_name, row.table_name);
+        table2.columns.push({
+          dataType: row.data_type,
+          isNullable: row.is_nullable,
+          isPrimaryKey: false,
+          name: row.column_name
+        });
+      }
+    },
+    addForeignKeyRows(foreignKeyRows) {
+      for (const row of foreignKeyRows) {
+        const sourceTable = ensureTable(row.source_schema, row.source_table);
+        const targetTable = ensureTable(row.target_schema, row.target_table);
+        upsertRelation(
+          sourceTable,
+          relationKey(row.constraint_name, row.target_table),
+          {
+            name: row.constraint_name,
+            targetSchema: row.target_schema,
+            targetTable: row.target_table
+          }
+        );
+        upsertRelation(targetTable, relationKey(row.source_table), {
+          name: relationKey(row.source_table, row.constraint_name),
+          targetSchema: row.source_schema,
+          targetTable: row.source_table
+        });
+      }
+    },
+    addManyToManyRows(foreignKeyRows) {
+      const foreignKeysBySourceTable = /* @__PURE__ */ new Map();
+      for (const foreignKey of foreignKeyRows) {
+        const key = tableKey(foreignKey.source_schema, foreignKey.source_table);
+        const current = foreignKeysBySourceTable.get(key) ?? {
+          foreignKeys: [],
+          schema: foreignKey.source_schema,
+          table: foreignKey.source_table
+        };
+        current.foreignKeys.push(foreignKey);
+        foreignKeysBySourceTable.set(key, current);
+      }
+      for (const candidate of foreignKeysBySourceTable.values()) {
+        const bridgeTable = tables.get(
+          tableKey(candidate.schema, candidate.table)
+        );
+        if (!bridgeTable || candidate.foreignKeys.length !== 2) {
+          continue;
+        }
+        const combinedForeignColumns = Array.from(
+          new Set(
+            candidate.foreignKeys.flatMap(
+              (foreignKey) => coerceStringArray(foreignKey.source_columns)
+            )
+          )
+        );
+        if (bridgeTable.primaryKey.length === 0 || combinedForeignColumns.length !== bridgeTable.primaryKey.length || !bridgeTable.primaryKey.every(
+          (column) => combinedForeignColumns.includes(column)
+        )) {
+          continue;
+        }
+        const [firstForeignKey, secondForeignKey] = candidate.foreignKeys;
+        const firstTarget = tables.get(
+          tableKey(firstForeignKey.target_schema, firstForeignKey.target_table)
+        );
+        const secondTarget = tables.get(
+          tableKey(
+            secondForeignKey.target_schema,
+            secondForeignKey.target_table
+          )
+        );
+        if (!(firstTarget && secondTarget)) {
+          continue;
+        }
+        upsertRelation(
+          firstTarget,
+          relationKey(candidate.table, secondForeignKey.target_table),
+          {
+            name: relationKey(
+              candidate.table,
+              secondForeignKey.constraint_name
+            ),
+            targetSchema: secondForeignKey.target_schema,
+            targetTable: secondForeignKey.target_table
+          }
+        );
+        upsertRelation(
+          secondTarget,
+          relationKey(candidate.table, firstForeignKey.target_table),
+          {
+            name: relationKey(candidate.table, firstForeignKey.constraint_name),
+            targetSchema: firstForeignKey.target_schema,
+            targetTable: firstForeignKey.target_table
+          }
+        );
+      }
+    },
+    addPrimaryKeyRows(primaryKeyRows) {
+      for (const row of primaryKeyRows) {
+        const table2 = ensureTable(row.schema_name, row.table_name);
+        const primaryKey = coerceStringArray(row.columns);
+        table2.primaryKey = primaryKey;
+        for (const columnName of primaryKey) {
+          const column = table2.columns.find(
+            (candidate) => candidate.name === columnName
+          );
+          if (column) {
+            column.isPrimaryKey = true;
+          }
+        }
+      }
+    },
+    toResponse(database) {
+      return {
+        database,
+        generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        tables: [...tables.values()].map((table2) => ({
+          columns: [...table2.columns].sort(
+            (left, right) => left.name.localeCompare(right.name)
+          ),
+          id: table2.id,
+          name: table2.name,
+          primaryKey: [...table2.primaryKey],
+          relations: [...table2.relationMap.values()].map((relation) => ({
+            columns: tables.get(
+              tableKey(relation.targetSchema, relation.targetTable)
+            )?.columns ?? [],
+            name: relation.name,
+            targetSchema: relation.targetSchema,
+            targetTable: relation.targetTable
+          })).sort(
+            (left, right) => left.name.localeCompare(right.name)
+          ),
+          schema: table2.schema
+        })).sort(
+          (left, right) => left.id.localeCompare(right.id)
+        )
+      };
+    }
+  };
+}
+async function queryRows(client, query) {
+  const result = await client.query(query);
+  if (result.error || result.status < 200 || result.status >= 300) {
+    const errorMessage = typeof result.error === "string" ? result.error : result.error && typeof result.error === "object" && "message" in result.error && typeof result.error.message === "string" ? result.error.message : `Athena gateway query failed with status ${result.status}.`;
+    throw new Error(errorMessage);
+  }
+  return Array.isArray(result.data) ? result.data : [];
+}
+function isAthenaTableSchemaConfig(value) {
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+  const config = value;
+  return typeof config.gatewayUrl === "string" && typeof config.gatewayKey === "string" && typeof config.gatewayDatabase === "string" && typeof config.schemaScope === "string" && typeof config.clientName === "string";
+}
+function hasAthenaTableSchemaCredentials(config) {
+  return config.gatewayUrl.trim().length > 0 && config.gatewayKey.trim().length > 0 && config.gatewayDatabase.trim().length > 0;
+}
+async function fetchAthenaTableCatalog(config, options = {}) {
+  const schemas = parseAthenaTableSchemaScope(config.schemaScope);
+  if (schemas.length === 0) {
+    return {
+      database: config.gatewayDatabase,
+      generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      tables: []
+    };
+  }
+  const queries = buildAthenaTableCatalogQueries(schemas);
+  const client = options.client ?? createClient({
+    url: config.gatewayUrl.trim(),
+    key: config.gatewayKey.trim(),
+    client: config.clientName.trim() || void 0
+  });
+  const [columnRows, primaryKeyRows, foreignKeyRows] = await Promise.all([
+    queryRows(client, queries.columns),
+    queryRows(client, queries.primaryKeys),
+    queryRows(client, queries.foreignKeys)
+  ]);
+  const catalog = createTableCatalog();
+  catalog.addColumnRows(columnRows);
+  catalog.addPrimaryKeyRows(primaryKeyRows);
+  catalog.addForeignKeyRows(foreignKeyRows);
+  catalog.addManyToManyRows(foreignKeyRows);
+  return catalog.toResponse(config.gatewayDatabase);
+}
+var fetchTableCatalog = fetchAthenaTableCatalog;
+
+// src/tables/schema-handlers.ts
+var ATHENA_TABLE_SCHEMA_ROUTE = "/api/tables/schema";
+function json2(body, init) {
+  const headers = new Headers(init?.headers);
+  if (!headers.has("content-type")) {
+    headers.set("content-type", "application/json; charset=utf-8");
+  }
+  return new Response(JSON.stringify(body), {
+    status: init?.status ?? 200,
+    headers
+  });
+}
+async function handleAthenaTableSchemaPost(request2, options) {
+  const payload = await request2.json().catch(() => null);
+  let config = isAthenaTableSchemaConfig(
+    payload?.config
+  ) ? payload.config : null;
+  if (config && options?.resolveConfig) {
+    config = await options.resolveConfig(config, request2);
+  }
+  if (!config || !isAthenaTableSchemaConfig(config)) {
+    return json2(
+      {
+        error: "The Athena tables showcase config is invalid."
+      },
+      { status: 400 }
+    );
+  }
+  if (!hasAthenaTableSchemaCredentials(config)) {
+    return json2(
+      {
+        error: "Gateway URL, API key, and database are required for schema introspection."
+      },
+      { status: 400 }
+    );
+  }
+  try {
+    const response = await fetchAthenaTableCatalog(
+      config,
+      {
+        client: options?.client
+      }
+    );
+    return json2(response);
+  } catch (error) {
+    return json2(
+      {
+        error: error instanceof Error ? error.message : "Athena schema introspection failed."
+      },
+      { status: 500 }
+    );
+  }
+}
+function createAthenaTableSchemaHandlers(options) {
+  return {
+    POST: (request2) => handleAthenaTableSchemaPost(request2, options)
+  };
+}
+
 // src/browser.ts
 function throwBrowserUnsupported(apiName) {
   throw new Error(
@@ -11920,6 +12795,7 @@ exports.ATHENA_AUTH_MAX_ADMIN_JSON_BYTES = ATHENA_AUTH_MAX_ADMIN_JSON_BYTES;
 exports.ATHENA_AUTH_MAX_ADMIN_JSON_DEPTH = ATHENA_AUTH_MAX_ADMIN_JSON_DEPTH;
 exports.ATHENA_AUTH_MAX_TEMPLATE_VARIABLES = ATHENA_AUTH_MAX_TEMPLATE_VARIABLES;
 exports.ATHENA_AUTH_MAX_TEMPLATE_VARIABLE_LENGTH = ATHENA_AUTH_MAX_TEMPLATE_VARIABLE_LENGTH;
+exports.ATHENA_TABLE_SCHEMA_ROUTE = ATHENA_TABLE_SCHEMA_ROUTE;
 exports.AthenaBillingError = AthenaBillingError;
 exports.AthenaChatError = AthenaChatError;
 exports.AthenaConfigurationError = AthenaConfigurationError;
@@ -11932,13 +12808,31 @@ exports.AthenaStorageError = AthenaStorageError;
 exports.AthenaStorageErrorCode = AthenaStorageErrorCode;
 exports.Backend = Backend;
 exports.DEFAULT_POSTGRES_SCHEMAS = DEFAULT_POSTGRES_SCHEMAS;
+exports.applyAthenaReadQueryFilters = applyAthenaReadQueryFilters;
+exports.applyAthenaReadQuerySelectLimit = applyAthenaReadQuerySelectLimit;
+exports.applyAthenaReadQuerySelectOrder = applyAthenaReadQuerySelectOrder;
+exports.applyAthenaTableFilters = applyAthenaTableFilters;
+exports.applyAthenaTableSelectLimit = applyAthenaTableSelectLimit;
+exports.applyAthenaTableSelectOrder = applyAthenaTableSelectOrder;
 exports.assertInt = assertInt;
 exports.athenaAuth = athenaAuth;
 exports.billingSdkManifest = billingSdkManifest;
 exports.boolean = boolean;
+exports.buildAthenaReadQueryFindManyOrderBy = buildAthenaReadQueryFindManyOrderBy;
+exports.buildAthenaReadQueryFindManySelect = buildAthenaReadQueryFindManySelect;
+exports.buildAthenaReadQueryFindManyWhere = buildAthenaReadQueryFindManyWhere;
+exports.buildAthenaReadQuerySelectString = buildAthenaReadQuerySelectString;
+exports.buildAthenaTableCatalogQueries = buildAthenaTableCatalogQueries;
+exports.buildAthenaTableFindManyOrderBy = buildAthenaTableFindManyOrderBy;
+exports.buildAthenaTableFindManySelect = buildAthenaTableFindManySelect;
+exports.buildAthenaTableFindManyWhere = buildAthenaTableFindManyWhere;
+exports.buildAthenaTableSelectString = buildAthenaTableSelectString;
 exports.chatSdkManifest = chatSdkManifest;
+exports.clampAthenaReadQueryTotalItems = clampAthenaReadQueryTotalItems;
+exports.clampAthenaTableTotalItems = clampAthenaTableTotalItems;
 exports.coerceInt = coerceInt;
 exports.createAthenaStorageError = createAthenaStorageError;
+exports.createAthenaTableSchemaHandlers = createAthenaTableSchemaHandlers;
 exports.createAuthReactEmailInput = createAuthReactEmailInput;
 exports.createBillingModule = createBillingModule;
 exports.createClient = createClient;
@@ -11952,26 +12846,39 @@ exports.defineModel = defineModel;
 exports.defineRegistry = defineRegistry;
 exports.defineSchema = defineSchema;
 exports.enumeration = enumeration;
+exports.executeAthenaReadQuery = executeAthenaReadQuery;
+exports.executeAthenaTableQuery = executeAthenaTableQuery;
+exports.fetchAthenaTableCatalog = fetchAthenaTableCatalog;
+exports.fetchTableCatalog = fetchTableCatalog;
 exports.filterIntrospectionSnapshot = filterIntrospectionSnapshot;
 exports.findGeneratorConfigPath = findGeneratorConfigPath;
+exports.flattenAthenaReadQueryRows = flattenAthenaReadQueryRows;
+exports.flattenAthenaRows = flattenAthenaRows;
 exports.generateArtifactsFromSnapshot = generateArtifactsFromSnapshot;
 exports.generatorEnv = generatorEnv;
 exports.getAthenaDebugAst = getAthenaDebugAst;
+exports.handleAthenaTableSchemaPost = handleAthenaTableSchemaPost;
+exports.hasAthenaTableSchemaCredentials = hasAthenaTableSchemaCredentials;
 exports.identifier = identifier;
 exports.isAthenaGatewayError = isAthenaGatewayError;
+exports.isAthenaTableSchemaConfig = isAthenaTableSchemaConfig;
 exports.isOk = isOk;
 exports.json = json;
 exports.loadGeneratorConfig = loadGeneratorConfig;
 exports.normalizeAthenaError = normalizeAthenaError;
 exports.normalizeAthenaGatewayBaseUrl = normalizeAthenaGatewayBaseUrl;
+exports.normalizeAthenaReadQueryOrderBy = normalizeAthenaReadQueryOrderBy;
+exports.normalizeAthenaTableOrderBy = normalizeAthenaTableOrderBy;
 exports.normalizeGeneratorConfig = normalizeGeneratorConfig;
 exports.normalizeSchemaSelection = normalizeSchemaSelection;
 exports.normalizeTableSelection = normalizeTableSelection;
 exports.number = number;
+exports.parseAthenaTableSchemaScope = parseAthenaTableSchemaScope;
 exports.parseBooleanFlag = parseBooleanFlag2;
 exports.renderAthenaReactEmail = renderAthenaReactEmail;
 exports.requireAffected = requireAffected;
 exports.requireSuccess = requireSuccess;
+exports.resolveAthenaReadQueryPageFetch = resolveAthenaReadQueryPageFetch;
 exports.resolveGeneratorProvider = resolveGeneratorProvider;
 exports.resolvePostgresColumnType = resolvePostgresColumnType;
 exports.resolveProviderSchemas = resolveProviderSchemas;