@xylex-group/athena 3.0.3 → 3.1.0

package/dist/index.cjs

@@ -573,8 +573,8 @@ function computeDelayMs(attempt, error, config) {
 }
 function sleep(ms) {
   if (ms <= 0) return Promise.resolve();
-  return new Promise((resolve3) => {
-    setTimeout(resolve3, ms);
+  return new Promise((resolve4) => {
+    setTimeout(resolve4, ms);
   });
 }
 async function withRetry(config, fn) {
@@ -2009,7 +2009,7 @@ function buildAthenaGatewayUrl(baseUrl, path) {
 
 // package.json
 var package_default = {
-  version: "3.0.3"
+  version: "3.1.0"
 };
 
 // src/sdk-version.ts
@@ -5228,7 +5228,7 @@ async function putWithXhr(url, signed, body, signal, onProgress) {
   if (Xhr === void 0) {
     return Promise.reject(new Error("athena.storage.file.upload direct mode requires XMLHttpRequest in this runtime"));
   }
-  return new Promise((resolve3, reject) => {
+  return new Promise((resolve4, reject) => {
     const xhr = new Xhr();
     const abort = () => xhr.abort();
     xhr.open("PUT", url);
@@ -5241,7 +5241,7 @@ async function putWithXhr(url, signed, body, signal, onProgress) {
         return;
       }
       onProgress({ loaded: bodySize(body) });
-      resolve3(new Response(xhr.response, {
+      resolve4(new Response(xhr.response, {
         status: xhr.status,
         statusText: xhr.statusText,
         headers: parseXhrHeaders(xhr.getAllResponseHeaders())
@@ -5694,7 +5694,7 @@ function putUploadBodyWithXhr(url, source, headers, options, onProgress) {
   if (Xhr === void 0) {
     return Promise.reject(new Error("athena.storage.file.upload requires XMLHttpRequest in this runtime"));
   }
-  return new Promise((resolve3, reject) => {
+  return new Promise((resolve4, reject) => {
     const xhr = new Xhr();
     const abort = () => xhr.abort();
     xhr.open("PUT", url);
@@ -5711,7 +5711,7 @@ function putUploadBodyWithXhr(url, source, headers, options, onProgress) {
         return;
       }
       onProgress({ loaded: source.sizeBytes });
-      resolve3(new Response(xhr.response, {
+      resolve4(new Response(xhr.response, {
         status: xhr.status,
         statusText: xhr.statusText,
         headers: parseXhrHeaders2(xhr.getAllResponseHeaders())
@@ -10770,6 +10770,305 @@ var Backend = {
   ScyllaDB: { type: "scylladb" }
 };
 
+// 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 isRecord12(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) => isRecord12(entry) ? entry[column.column] : void 0).filter((entry) => entry !== void 0);
+  }
+  if (isRecord12(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 = isRecord12(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 && isRecord12(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);
+}
+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
+  });
+  if ((query.mode ?? "findMany") === "select") {
+    const selectBuilder = applyAthenaReadQuerySelectLimit(
+      applyAthenaReadQuerySelectOrder(
+        applyAthenaReadQueryFilters(baseBuilder, query.filters),
+        query.orderBy
+      ),
+      query.limit
+    );
+    const result2 = await selectBuilder.currentPage(page).pageSize(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,
+        pageSize,
+        rowCount: rows2.length
+      })
+    };
+  }
+  const findManyOrderBy = buildAthenaReadQueryFindManyOrderBy(query.orderBy);
+  const findManyOptions = {
+    ...query.limit ? { limit: query.limit } : {},
+    ...findManyOrderBy ? { orderBy: findManyOrderBy } : {},
+    select: buildAthenaReadQueryFindManySelect(query.columns),
+    ...query.filters?.length ? { where: buildAthenaReadQueryFindManyWhere(query.filters) } : {}
+  };
+  const result = await baseBuilder.currentPage(page).pageSize(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,
+      pageSize,
+      rowCount: rows.length
+    })
+  };
+}
+var executeAthenaTableQuery = executeAthenaReadQuery;
+
 // src/schema/definitions.ts
 function defineModel(input) {
   return input;
@@ -10790,7 +11089,7 @@ function resolveNullishValue(mode) {
   if (mode === "null") return null;
   return "";
 }
-function isRecord12(value) {
+function isRecord13(value) {
   return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
 function isNullableColumn(model, key) {
@@ -10799,7 +11098,7 @@ function isNullableColumn(model, key) {
 }
 function toModelFormDefaults(model, values, options) {
   const source = values;
-  if (!isRecord12(source)) {
+  if (!isRecord13(source)) {
     return {};
   }
   const mode = options?.nullishMode ?? "empty-string";
@@ -12316,6 +12615,486 @@ async function loadGeneratorConfig(options = {}) {
   }
 }
 
+// src/generator/schema-discovery.ts
+var DISCOVER_POSTGRES_SCHEMAS_SQL = `
+  SELECT DISTINCT n.nspname AS schema_name
+  FROM pg_namespace n
+  JOIN pg_class c ON c.relnamespace = n.oid
+  WHERE c.relkind IN ('r', 'p')
+    AND n.nspname NOT IN ('pg_catalog', 'information_schema')
+    AND n.nspname NOT LIKE 'pg_toast%'
+    AND n.nspname NOT LIKE 'pg_temp_%'
+    AND n.nspname NOT LIKE 'pg_toast_temp_%'
+  ORDER BY n.nspname;
+`.trim();
+var SYSTEM_SCHEMA_PREFIXES = ["pg_"];
+var SYSTEM_SCHEMAS = /* @__PURE__ */ new Set(["pg_catalog", "information_schema"]);
+function normalizeDiscoveredSchemas(input) {
+  const schemas = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const value of input) {
+    const schema = value.trim();
+    if (!schema || seen.has(schema)) {
+      continue;
+    }
+    if (SYSTEM_SCHEMAS.has(schema)) {
+      continue;
+    }
+    if (SYSTEM_SCHEMA_PREFIXES.some((prefix) => schema.startsWith(prefix))) {
+      continue;
+    }
+    seen.add(schema);
+    schemas.push(schema);
+  }
+  return schemas;
+}
+function mergeSchemaSelections(configured, discovered) {
+  const result = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const value of configured ?? []) {
+    const schema = value.trim();
+    if (!schema || seen.has(schema)) {
+      continue;
+    }
+    seen.add(schema);
+    result.push(schema);
+  }
+  for (const value of discovered) {
+    const schema = value.trim();
+    if (!schema || seen.has(schema)) {
+      continue;
+    }
+    seen.add(schema);
+    result.push(schema);
+  }
+  return result.length > 0 ? result : ["public"];
+}
+function schemasEqual(left, right) {
+  const a = normalizeDiscoveredSchemas(left ?? []);
+  const b = normalizeDiscoveredSchemas(right ?? []);
+  if (a.length !== b.length) {
+    return false;
+  }
+  const set = new Set(a);
+  return b.every((schema) => set.has(schema));
+}
+function coerceSchemaName(row) {
+  const raw = row.schema_name ?? row.schemaName ?? row.nspname;
+  if (typeof raw !== "string") {
+    return void 0;
+  }
+  const trimmed = raw.trim();
+  return trimmed.length > 0 ? trimmed : void 0;
+}
+async function loadPgPoolConstructor2() {
+  const module = await import('pg');
+  const poolConstructor = module.Pool ?? module.default?.Pool;
+  if (!poolConstructor) {
+    throw new Error(
+      '@xylex-group/athena: Unable to load the PostgreSQL driver for schema discovery. Ensure "pg" is installed and this API runs in a Node.js server runtime.'
+    );
+  }
+  return poolConstructor;
+}
+async function discoverDirectSchemas(config) {
+  const PoolConstructor = await loadPgPoolConstructor2();
+  const pool = new PoolConstructor({ connectionString: config.connectionString });
+  try {
+    const result = await pool.query(DISCOVER_POSTGRES_SCHEMAS_SQL);
+    const names = result.rows.map(coerceSchemaName).filter((value) => Boolean(value));
+    return normalizeDiscoveredSchemas(names);
+  } finally {
+    await pool.end();
+  }
+}
+async function discoverGatewaySchemas(config) {
+  const client = createClient({
+    db: { url: config.gatewayUrl },
+    key: config.apiKey,
+    backend: {
+      type: config.backend ?? "postgresql"
+    }
+  });
+  const result = await client.query(DISCOVER_POSTGRES_SCHEMAS_SQL);
+  if (result.error || result.status < 200 || result.status >= 300) {
+    throw new Error(
+      result.error?.message ?? `Gateway schema discovery failed with status ${result.status}`
+    );
+  }
+  const names = (result.data ?? []).map(coerceSchemaName).filter((value) => Boolean(value));
+  return normalizeDiscoveredSchemas(names);
+}
+async function discoverPostgresSchemas(provider) {
+  if (provider.kind === "postgres" && provider.mode === "direct") {
+    return discoverDirectSchemas(provider);
+  }
+  if (provider.kind === "postgres" && provider.mode === "gateway") {
+    return discoverGatewaySchemas(provider);
+  }
+  throw new Error(
+    `Schema discovery is only implemented for postgres direct/gateway providers (received ${provider.kind}/${"mode" in provider ? provider.mode : "unknown"}).`
+  );
+}
+
+// src/generator/config-file.ts
+function hasEnv(keys) {
+  for (const key of keys) {
+    const value = process.env[key];
+    if (typeof value === "string" && value.trim().length > 0) {
+      return true;
+    }
+  }
+  return false;
+}
+var DIRECT_CONNECTION_KEYS = [
+  "ATHENA_GENERATOR_PG_URL",
+  "DATABASE_URL",
+  "PG_URL",
+  "POSTGRES_URL",
+  "POSTGRESQL_URL"
+];
+var GATEWAY_URL_KEYS = ["ATHENA_URL", "ATHENA_GATEWAY_URL", "ATHENA_GENERATOR_URL"];
+var GATEWAY_KEY_KEYS = [
+  "ATHENA_API_KEY",
+  "ATHENA_GATEWAY_API_KEY",
+  "ATHENA_GENERATOR_API_KEY"
+];
+function detectGeneratorProviderMode(preferred = "auto") {
+  if (preferred === "direct" || preferred === "gateway") {
+    return preferred;
+  }
+  const hasDirect = hasEnv(DIRECT_CONNECTION_KEYS);
+  const hasGateway = hasEnv(GATEWAY_URL_KEYS) && hasEnv(GATEWAY_KEY_KEYS);
+  if (hasDirect) {
+    return "direct";
+  }
+  if (hasGateway) {
+    return "gateway";
+  }
+  return "direct";
+}
+function formatStringArray(values, indent) {
+  if (values.length === 0) {
+    return "[]";
+  }
+  const inner = values.map((value) => `${indent}  ${JSON.stringify(value)}`).join(",\n");
+  return `[
+${inner},
+${indent}]`;
+}
+function buildDirectProviderBlock(schemas) {
+  return `  provider: {
+    kind: "postgres",
+    mode: "direct",
+    connectionString: generatorEnv("DATABASE_URL"),
+    database: generatorEnv("ATHENA_GENERATOR_DB", { optional: true }),
+    schemas: ${formatStringArray(schemas, "    ")},
+  }`;
+}
+function buildGatewayProviderBlock(schemas) {
+  return `  provider: {
+    kind: "postgres",
+    mode: "gateway",
+    gatewayUrl: generatorEnv("ATHENA_URL"),
+    apiKey: generatorEnv("ATHENA_API_KEY"),
+    database: generatorEnv("ATHENA_GENERATOR_DB", { default: "postgres" }),
+    schemas: ${formatStringArray(schemas, "    ")},
+  }`;
+}
+function renderGeneratorConfigFile(options) {
+  const schemas = options.schemas && options.schemas.length > 0 ? [...options.schemas] : [...DEFAULT_POSTGRES_SCHEMAS];
+  const providerBlock = options.mode === "gateway" ? buildGatewayProviderBlock(schemas) : buildDirectProviderBlock(schemas);
+  return `import { defineGeneratorConfig, generatorEnv } from "@xylex-group/athena";
+
+export default defineGeneratorConfig({
+${providerBlock},
+  output: {
+    format: "table-builder",
+    preset: "athena-direct",
+    targets: {
+      model: "athena/models/{schema_kebab}/{model_kebab}.ts",
+      schema: "athena/schemas/{schema_kebab}.ts",
+      database: "athena/relations.ts",
+      registry: "athena/registry.generated.ts",
+    },
+    placeholderMap: {
+      namespace: "athena",
+    },
+  },
+  naming: {
+    modelType: "pascal",
+    modelConst: "camel",
+    schemaConst: "camel",
+    databaseConst: "camel",
+    registryConst: "camel",
+  },
+  features: {
+    emitRelations: true,
+    emitRegistry: true,
+  },
+  experimental: {
+    postgresGatewayIntrospection: false,
+    scyllaProviderContracts: true,
+  },
+});
+`;
+}
+function resolveConfigPath(cwd, configPath) {
+  if (configPath) {
+    const absolutePath2 = path.resolve(cwd, configPath);
+    return {
+      absolutePath: absolutePath2,
+      relativePath: configPath.replace(/\\/g, "/"),
+      exists: fs.existsSync(absolutePath2)
+    };
+  }
+  const discovered = findGeneratorConfigPath(cwd);
+  if (discovered) {
+    const relativePath = discovered.startsWith(cwd) ? discovered.slice(cwd.length).replace(/^[/\\]/, "").replace(/\\/g, "/") : "athena.config.ts";
+    return {
+      absolutePath: discovered,
+      relativePath,
+      exists: true
+    };
+  }
+  const absolutePath = path.resolve(cwd, "athena.config.ts");
+  return {
+    absolutePath,
+    relativePath: "athena.config.ts",
+    exists: false
+  };
+}
+function providerModeFromConfig(provider, preferred) {
+  if (provider && provider.kind === "postgres") {
+    if (provider.mode === "gateway") {
+      return "gateway";
+    }
+    if (provider.mode === "direct") {
+      return "direct";
+    }
+  }
+  return detectGeneratorProviderMode(preferred);
+}
+function schemasFromNormalized(config) {
+  if (config.provider.kind !== "postgres") {
+    return [...DEFAULT_POSTGRES_SCHEMAS];
+  }
+  return normalizeSchemaSelection(config.provider.schemas);
+}
+function patchSchemasInConfigSource(source, schemas) {
+  const formattedInline = `[${schemas.map((value) => JSON.stringify(value)).join(", ")}]`;
+  const formattedMultiline = formatStringArray(schemas, "    ");
+  const listDefaultPattern = /(schemas\s*:\s*generatorEnv\.list\s*\(\s*['"][^'"]+['"]\s*,\s*\{[\s\S]*?default\s*:\s*)(\[[^\]]*\])/m;
+  if (listDefaultPattern.test(source)) {
+    return source.replace(listDefaultPattern, `$1${formattedInline}`);
+  }
+  const literalPattern = /(schemas\s*:\s*)(\[[^\]]*\])/m;
+  if (literalPattern.test(source)) {
+    const usesMultiline = /schemas\s*:\s*\[\s*\n/.test(source);
+    return source.replace(
+      literalPattern,
+      `$1${usesMultiline ? formattedMultiline : formattedInline}`
+    );
+  }
+  const modeLine = /(mode\s*:\s*["'](?:direct|gateway)["']\s*,)/m;
+  if (modeLine.test(source)) {
+    return source.replace(
+      modeLine,
+      `$1
+    schemas: ${formattedInline},`
+    );
+  }
+  return void 0;
+}
+function extractLiteralSchemas(source) {
+  const listDefaultMatch = source.match(
+    /schemas\s*:\s*generatorEnv\.list\s*\(\s*['"][^'"]+['"]\s*,\s*\{[\s\S]*?default\s*:\s*(\[[^\]]*\])/m
+  );
+  const literalMatch = listDefaultMatch ?? source.match(/schemas\s*:\s*(\[[^\]]*\])/m);
+  if (!literalMatch) {
+    return void 0;
+  }
+  try {
+    const parsed = JSON.parse(literalMatch[1].replace(/'/g, '"'));
+    if (!Array.isArray(parsed)) {
+      return void 0;
+    }
+    return parsed.map((value) => typeof value === "string" ? value.trim() : "").filter((value) => value.length > 0);
+  } catch {
+    return void 0;
+  }
+}
+async function resolveDiscoveredSchemas(options) {
+  if (options.explicit && options.explicit.length > 0) {
+    return {
+      schemas: normalizeSchemaSelection(options.explicit),
+      discovered: false
+    };
+  }
+  if (!options.discoverSchemas) {
+    if (options.loaded) {
+      return {
+        schemas: schemasFromNormalized(options.loaded.config),
+        discovered: false
+      };
+    }
+    return {
+      schemas: [...DEFAULT_POSTGRES_SCHEMAS],
+      discovered: false
+    };
+  }
+  try {
+    let provider = options.provider;
+    if (!provider && options.loaded) {
+      provider = options.loaded.config.provider;
+    }
+    if (!provider) {
+      const probeConfig = {
+        provider: options.mode === "gateway" ? { kind: "postgres", mode: "gateway" } : { kind: "postgres", mode: "direct" }
+      };
+      const normalized = normalizeGeneratorConfig(probeConfig);
+      provider = normalized.provider;
+    }
+    const discovered = await discoverPostgresSchemas(provider);
+    if (discovered.length === 0) {
+      const fallback = options.loaded ? schemasFromNormalized(options.loaded.config) : [...DEFAULT_POSTGRES_SCHEMAS];
+      return { schemas: fallback, discovered: true };
+    }
+    if (options.loaded) {
+      return {
+        schemas: mergeSchemaSelections(schemasFromNormalized(options.loaded.config), discovered),
+        discovered: true
+      };
+    }
+    return { schemas: discovered, discovered: true };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    const fallback = options.loaded ? schemasFromNormalized(options.loaded.config) : [...DEFAULT_POSTGRES_SCHEMAS];
+    return {
+      schemas: fallback,
+      discovered: false,
+      discoveryError: message
+    };
+  }
+}
+async function ensureGeneratorConfigFile(options = {}) {
+  const cwd = options.cwd ?? process.cwd();
+  const dryRun = options.dryRun === true;
+  const discoverSchemas = options.discoverSchemas !== false;
+  const force = options.force === true;
+  const preferredMode = options.mode ?? "auto";
+  const pathInfo = resolveConfigPath(cwd, options.configPath);
+  const changes = [];
+  let loaded = options.loaded;
+  if (!loaded && pathInfo.exists && !force) {
+    try {
+      loaded = await loadGeneratorConfig({
+        cwd,
+        configPath: pathInfo.absolutePath
+      });
+    } catch {
+    }
+  }
+  const mode = providerModeFromConfig(loaded?.config.provider ?? options.provider, preferredMode);
+  const schemaResolution = await resolveDiscoveredSchemas({
+    discoverSchemas,
+    provider: options.provider ?? loaded?.config.provider,
+    loaded,
+    explicit: options.schemas,
+    mode
+  });
+  if (schemaResolution.discoveryError) {
+    changes.push(`schema-discovery-failed: ${schemaResolution.discoveryError}`);
+  } else if (schemaResolution.discovered) {
+    changes.push(`schemas-discovered: ${schemaResolution.schemas.join(",")}`);
+  }
+  if (!pathInfo.exists || force) {
+    const content = renderGeneratorConfigFile({
+      mode,
+      schemas: schemaResolution.schemas
+    });
+    if (!pathInfo.exists) {
+      changes.push("created-modern-config");
+    } else {
+      changes.push("force-rewrote-config");
+    }
+    if (!dryRun) {
+      await promises.mkdir(path.dirname(pathInfo.absolutePath), { recursive: true });
+      await promises.writeFile(pathInfo.absolutePath, content, "utf8");
+    }
+    return {
+      action: pathInfo.exists ? "updated" : "created",
+      path: pathInfo.relativePath,
+      absolutePath: pathInfo.absolutePath,
+      content,
+      schemas: schemaResolution.schemas,
+      changes,
+      mode,
+      reason: pathInfo.exists ? "force rewrite" : "config file missing"
+    };
+  }
+  const existingSource = await promises.readFile(pathInfo.absolutePath, "utf8");
+  const existingLiteralSchemas = extractLiteralSchemas(existingSource);
+  const existingSchemas = existingLiteralSchemas ?? (loaded ? schemasFromNormalized(loaded.config) : [...DEFAULT_POSTGRES_SCHEMAS]);
+  if (schemasEqual(existingSchemas, schemaResolution.schemas)) {
+    return {
+      action: "unchanged",
+      path: pathInfo.relativePath,
+      absolutePath: pathInfo.absolutePath,
+      content: existingSource,
+      schemas: existingSchemas,
+      changes: changes.length > 0 ? changes : ["schemas-already-current"],
+      mode,
+      reason: "schemas already match discovered/configured set"
+    };
+  }
+  const patched = patchSchemasInConfigSource(existingSource, schemaResolution.schemas);
+  if (!patched) {
+    return {
+      action: "skipped",
+      path: pathInfo.relativePath,
+      absolutePath: pathInfo.absolutePath,
+      content: existingSource,
+      schemas: existingSchemas,
+      changes: [
+        ...changes,
+        "could-not-patch-schemas-surgically",
+        "re-run with force=true to rewrite full template"
+      ],
+      mode,
+      reason: "existing config schemas could not be updated surgically without risking a destructive rewrite"
+    };
+  }
+  if (patched === existingSource) {
+    return {
+      action: "unchanged",
+      path: pathInfo.relativePath,
+      absolutePath: pathInfo.absolutePath,
+      content: existingSource,
+      schemas: existingSchemas,
+      changes: [...changes, "patch-noop"],
+      mode,
+      reason: "patch produced identical content"
+    };
+  }
+  changes.push(
+    `schemas-updated: ${existingSchemas.join(",")} -> ${schemaResolution.schemas.join(",")}`
+  );
+  if (!dryRun) {
+    await promises.writeFile(pathInfo.absolutePath, patched, "utf8");
+  }
+  return {
+    action: "updated",
+    path: pathInfo.relativePath,
+    absolutePath: pathInfo.absolutePath,
+    content: patched,
+    schemas: schemaResolution.schemas,
+    changes,
+    mode,
+    reason: "auto-filled provider.schemas"
+  };
+}
+
 // src/generator/env.ts
 function readEnvStringValue2(key) {
   if (typeof process === "undefined" || !process.env) {
@@ -14127,23 +14906,80 @@ async function writeArtifacts(files, cwd, config, dryRun) {
     skippedFiles
   };
 }
+function withPostgresSchemas(config, schemas) {
+  if (config.provider.kind !== "postgres") {
+    return config;
+  }
+  return {
+    ...config,
+    provider: {
+      ...config.provider,
+      schemas
+    }
+  };
+}
 async function runSchemaGenerator(options = {}) {
   const cwd = options.cwd ?? process.cwd();
+  const dryRun = options.dryRun === true;
+  const writeConfig = options.writeConfig !== false;
+  const discoverSchemas = options.discoverSchemas !== false;
   const configOptions = {
     cwd,
     configPath: options.configPath
   };
-  const { configPath, config } = await loadGeneratorConfig(configOptions);
+  const loaded = await loadGeneratorConfig(configOptions);
+  let { configPath, config } = loaded;
+  let configEnsure;
+  let effectiveSchemas = resolveProviderSchemas(config.provider);
+  const canDiscoverLive = discoverSchemas && config.provider.kind === "postgres" && !options.provider;
+  if (canDiscoverLive) {
+    try {
+      const discovered = await discoverPostgresSchemas(config.provider);
+      if (discovered.length > 0) {
+        effectiveSchemas = mergeSchemaSelections(effectiveSchemas, discovered);
+      }
+    } catch {
+    }
+  }
+  config = withPostgresSchemas(config, effectiveSchemas);
+  const shouldEnsureConfig = writeConfig && config.provider.kind === "postgres" && !options.provider;
+  if (shouldEnsureConfig) {
+    const ensureResult = await ensureGeneratorConfigFile({
+      cwd,
+      configPath: options.configPath,
+      dryRun,
+      // Schemas already resolved above — avoid a second discovery round-trip.
+      discoverSchemas: false,
+      provider: config.provider,
+      loaded: { configPath, config },
+      schemas: effectiveSchemas,
+      mode: config.provider.mode
+    });
+    configEnsure = {
+      action: ensureResult.action,
+      path: ensureResult.path,
+      schemas: ensureResult.schemas,
+      changes: ensureResult.changes,
+      reason: ensureResult.reason
+    };
+    if (ensureResult.action === "created" || ensureResult.action === "updated" || ensureResult.action === "unchanged" && configPath === "[environment defaults]") {
+      configPath = ensureResult.absolutePath;
+      if (ensureResult.schemas.length > 0) {
+        effectiveSchemas = ensureResult.schemas;
+        config = withPostgresSchemas(config, effectiveSchemas);
+      }
+    }
+  }
   const provider = options.provider ?? resolveGeneratorProvider(config.provider, config.experimental);
   const snapshot = await provider.inspect({
-    schemas: resolveProviderSchemas(config.provider)
+    schemas: effectiveSchemas
   });
   const generated = generateArtifactsFromSnapshot(snapshot, config);
   const writeResult = await writeArtifacts(
     generated.files,
     cwd,
     config,
-    options.dryRun === true
+    dryRun
   );
   return {
     ...generated,
@@ -14151,7 +14987,8 @@ async function runSchemaGenerator(options = {}) {
     config,
     writtenFiles: writeResult.writtenFiles,
     writtenDetails: writeResult.writtenDetails,
-    skippedFiles: writeResult.skippedFiles
+    skippedFiles: writeResult.skippedFiles,
+    configEnsure
   };
 }
 
@@ -14220,15 +15057,15 @@ function readCookieFromHeaders(headers, name) {
   }
   return parseCookies(cookieHeader).get(name);
 }
-function isRecord13(value) {
+function isRecord14(value) {
   return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
 function resolveSessionCandidate(value) {
-  if (!isRecord13(value)) {
+  if (!isRecord14(value)) {
     return null;
   }
-  const session = isRecord13(value.session) ? value.session : void 0;
-  const user = isRecord13(value.user) ? value.user : void 0;
+  const session = isRecord14(value.session) ? value.session : void 0;
+  const user = isRecord14(value.user) ? value.user : void 0;
   if (session && typeof session.token === "string" && session.token.length > 0 && user) {
     return {
       session,
@@ -14238,7 +15075,7 @@ function resolveSessionCandidate(value) {
   return null;
 }
 function inferSessionPair(returned) {
-  return resolveSessionCandidate(returned) ?? (isRecord13(returned) ? resolveSessionCandidate(returned.data) : null) ?? (isRecord13(returned) ? resolveSessionCandidate(returned.session) : null);
+  return resolveSessionCandidate(returned) ?? (isRecord14(returned) ? resolveSessionCandidate(returned.data) : null) ?? (isRecord14(returned) ? resolveSessionCandidate(returned.session) : null);
 }
 function resolveResponseHeaders(ctx) {
   if (ctx.context.responseHeaders instanceof Headers) {
@@ -14669,11 +15506,27 @@ exports.Backend = Backend;
 exports.DEFAULT_MULTIPART_PART_SIZE_BYTES = DEFAULT_MULTIPART_PART_SIZE_BYTES;
 exports.DEFAULT_MULTIPART_THRESHOLD_BYTES = DEFAULT_MULTIPART_THRESHOLD_BYTES;
 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.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.createAuthReactEmailInput = createAuthReactEmailInput;
@@ -14689,10 +15542,17 @@ exports.defineGeneratorConfig = defineGeneratorConfig;
 exports.defineModel = defineModel;
 exports.defineRegistry = defineRegistry;
 exports.defineSchema = defineSchema;
+exports.detectGeneratorProviderMode = detectGeneratorProviderMode;
+exports.discoverPostgresSchemas = discoverPostgresSchemas;
 exports.ensureActiveOrganization = ensureActiveOrganization;
+exports.ensureGeneratorConfigFile = ensureGeneratorConfigFile;
 exports.enumeration = enumeration;
+exports.executeAthenaReadQuery = executeAthenaReadQuery;
+exports.executeAthenaTableQuery = executeAthenaTableQuery;
 exports.filterIntrospectionSnapshot = filterIntrospectionSnapshot;
 exports.findGeneratorConfigPath = findGeneratorConfigPath;
+exports.flattenAthenaReadQueryRows = flattenAthenaReadQueryRows;
+exports.flattenAthenaRows = flattenAthenaRows;
 exports.generateArtifactsFromSnapshot = generateArtifactsFromSnapshot;
 exports.generatorEnv = generatorEnv;
 exports.getAthenaDebugAst = getAthenaDebugAst;
@@ -14701,14 +15561,20 @@ exports.isAthenaGatewayError = isAthenaGatewayError;
 exports.isOk = isOk;
 exports.json = json;
 exports.loadGeneratorConfig = loadGeneratorConfig;
+exports.mergeSchemaSelections = mergeSchemaSelections;
 exports.normalizeAthenaError = normalizeAthenaError;
 exports.normalizeAthenaGatewayBaseUrl = normalizeAthenaGatewayBaseUrl;
+exports.normalizeAthenaReadQueryOrderBy = normalizeAthenaReadQueryOrderBy;
+exports.normalizeAthenaTableOrderBy = normalizeAthenaTableOrderBy;
+exports.normalizeDiscoveredSchemas = normalizeDiscoveredSchemas;
 exports.normalizeGeneratorConfig = normalizeGeneratorConfig;
 exports.normalizeSchemaSelection = normalizeSchemaSelection;
 exports.normalizeTableSelection = normalizeTableSelection;
 exports.number = number;
 exports.parseBooleanFlag = parseBooleanFlag2;
+exports.patchSchemasInConfigSource = patchSchemasInConfigSource;
 exports.renderAthenaReactEmail = renderAthenaReactEmail;
+exports.renderGeneratorConfigFile = renderGeneratorConfigFile;
 exports.requireAffected = requireAffected;
 exports.requireSuccess = requireSuccess;
 exports.resolveGeneratorProvider = resolveGeneratorProvider;
@@ -14716,6 +15582,7 @@ exports.resolvePostgresColumnType = resolvePostgresColumnType;
 exports.resolveProviderSchemas = resolveProviderSchemas;
 exports.resolveStoragePath = resolveStoragePath;
 exports.runSchemaGenerator = runSchemaGenerator;
+exports.schemasEqual = schemasEqual;
 exports.storageSdkManifest = storageSdkManifest;
 exports.string = string;
 exports.table = table;