@xylex-group/athena 1.5.0 → 1.6.1

package/dist/index.cjs

@@ -1,5 +1,11 @@
 'use strict';
 
+var pg = require('pg');
+var fs = require('fs');
+var path = require('path');
+var url = require('url');
+var promises = require('fs/promises');
+
 // src/gateway/errors.ts
 var AthenaGatewayError = class _AthenaGatewayError extends Error {
   code;
@@ -366,6 +372,137 @@ function createAthenaGatewayClient(config = {}) {
   };
 }
 
+// src/sql-identifiers.ts
+var SIMPLE_IDENTIFIER_PATTERN = /^[A-Za-z_][A-Za-z0-9_]*$/;
+var COMPOSITE_IDENTIFIER_PATTERN = /^[A-Za-z_][A-Za-z0-9_]*(?:\.[A-Za-z_][A-Za-z0-9_]*)*$/;
+var ALIAS_PATTERN = /^([A-Za-z_][A-Za-z0-9_.]*)\s+(?:as\s+)?([A-Za-z_][A-Za-z0-9_]*)$/i;
+function quoteIdentifierSegment(identifier2) {
+  return `"${identifier2.replace(/"/g, '""')}"`;
+}
+function quoteQualifiedIdentifier(identifier2) {
+  return identifier2.split(".").map((segment) => quoteIdentifierSegment(segment)).join(".");
+}
+function quoteSelectToken(token) {
+  if (token === "*") return token;
+  if (COMPOSITE_IDENTIFIER_PATTERN.test(token)) {
+    return quoteQualifiedIdentifier(token);
+  }
+  const aliasMatch = ALIAS_PATTERN.exec(token);
+  if (!aliasMatch) {
+    return token;
+  }
+  const [, baseIdentifier, aliasIdentifier] = aliasMatch;
+  if (!COMPOSITE_IDENTIFIER_PATTERN.test(baseIdentifier) || !SIMPLE_IDENTIFIER_PATTERN.test(aliasIdentifier)) {
+    return token;
+  }
+  return `${quoteQualifiedIdentifier(baseIdentifier)} AS ${quoteIdentifierSegment(aliasIdentifier)}`;
+}
+function canAutoQuoteToken(token) {
+  if (token === "*") return true;
+  if (COMPOSITE_IDENTIFIER_PATTERN.test(token)) return true;
+  const aliasMatch = ALIAS_PATTERN.exec(token);
+  if (!aliasMatch) return false;
+  const [, baseIdentifier, aliasIdentifier] = aliasMatch;
+  return COMPOSITE_IDENTIFIER_PATTERN.test(baseIdentifier) && SIMPLE_IDENTIFIER_PATTERN.test(aliasIdentifier);
+}
+function splitTopLevelCommaSeparated(input) {
+  const parts = [];
+  let buffer = "";
+  let singleQuoted = false;
+  let doubleQuoted = false;
+  let depth = 0;
+  for (let index = 0; index < input.length; index += 1) {
+    const char = input[index];
+    const next = index + 1 < input.length ? input[index + 1] : "";
+    if (singleQuoted) {
+      buffer += char;
+      if (char === "'" && next === "'") {
+        buffer += next;
+        index += 1;
+        continue;
+      }
+      if (char === "'") {
+        singleQuoted = false;
+      }
+      continue;
+    }
+    if (doubleQuoted) {
+      buffer += char;
+      if (char === '"' && next === '"') {
+        buffer += next;
+        index += 1;
+        continue;
+      }
+      if (char === '"') {
+        doubleQuoted = false;
+      }
+      continue;
+    }
+    if (char === "'") {
+      singleQuoted = true;
+      buffer += char;
+      continue;
+    }
+    if (char === '"') {
+      doubleQuoted = true;
+      buffer += char;
+      continue;
+    }
+    if (char === "(") {
+      depth += 1;
+      buffer += char;
+      continue;
+    }
+    if (char === ")") {
+      depth -= 1;
+      if (depth < 0) return null;
+      buffer += char;
+      continue;
+    }
+    if (char === "," && depth === 0) {
+      parts.push(buffer.trim());
+      buffer = "";
+      continue;
+    }
+    buffer += char;
+  }
+  if (singleQuoted || doubleQuoted || depth !== 0) {
+    return null;
+  }
+  if (buffer.trim().length > 0) {
+    parts.push(buffer.trim());
+  }
+  return parts;
+}
+function quoteSelectColumnsExpression(columns) {
+  const trimmed = columns.trim();
+  if (!trimmed || trimmed === "*") return trimmed || "*";
+  const tokens = splitTopLevelCommaSeparated(trimmed);
+  if (!tokens || tokens.length === 0) {
+    return trimmed;
+  }
+  if (!tokens.every(canAutoQuoteToken)) {
+    return trimmed;
+  }
+  return tokens.map(quoteSelectToken).join(", ");
+}
+var SqlIdentifierPath = class {
+  segments;
+  constructor(segments) {
+    this.segments = segments;
+  }
+  toSql() {
+    return this.segments.map(quoteIdentifierSegment).join(".");
+  }
+  toString() {
+    return this.toSql();
+  }
+};
+function identifier(...segments) {
+  const expandedSegments = segments.flatMap((segment) => segment.split(".")).map((segment) => segment.trim()).filter((segment) => segment.length > 0);
+  return new SqlIdentifierPath(expandedSegments);
+}
+
 // src/client.ts
 var DEFAULT_COLUMNS = "*";
 var UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
@@ -469,12 +606,6 @@ function normalizeCast(cast) {
 function escapeSqlStringLiteral(value) {
   return value.replace(/'/g, "''");
 }
-function quoteIdentifier(identifier) {
-  return `"${identifier.replace(/"/g, '""')}"`;
-}
-function quoteQualifiedIdentifier(identifier) {
-  return identifier.split(".").map((segment) => quoteIdentifier(segment)).join(".");
-}
 function toSqlLiteral(value) {
   if (value === null) return "NULL";
   if (typeof value === "number") return Number.isFinite(value) ? String(value) : "NULL";
@@ -489,7 +620,7 @@ function buildSelectColumnsClause(columns) {
   if (Array.isArray(columns)) {
     return columns.map((column) => quoteQualifiedIdentifier(column)).join(", ");
   }
-  return columns;
+  return quoteSelectColumnsExpression(columns);
 }
 function conditionToSqlClause(condition) {
   if (!condition.column) return null;
@@ -1174,6 +1305,56 @@ var Backend = {
 };
 
 // src/auxiliaries.ts
+var AthenaErrorKind = {
+  UniqueViolation: "unique_violation",
+  NotFound: "not_found",
+  Validation: "validation",
+  Auth: "auth",
+  RateLimit: "rate_limit",
+  Transient: "transient",
+  Unknown: "unknown"
+};
+var AthenaErrorCode = {
+  UniqueViolation: "UNIQUE_VIOLATION",
+  NotFound: "NOT_FOUND",
+  ValidationFailed: "VALIDATION_FAILED",
+  AuthUnauthorized: "AUTH_UNAUTHORIZED",
+  AuthForbidden: "AUTH_FORBIDDEN",
+  RateLimited: "RATE_LIMITED",
+  NetworkUnavailable: "NETWORK_UNAVAILABLE",
+  TransientFailure: "TRANSIENT_FAILURE",
+  HttpFailure: "HTTP_FAILURE",
+  Unknown: "UNKNOWN"
+};
+var AthenaErrorCategory = {
+  Transport: "transport",
+  Client: "client",
+  Server: "server",
+  Database: "database",
+  Unknown: "unknown"
+};
+var AthenaError = class extends Error {
+  code;
+  kind;
+  category;
+  status;
+  retryable;
+  requestId;
+  context;
+  raw;
+  constructor(input) {
+    super(input.message);
+    this.name = "AthenaError";
+    this.code = input.code;
+    this.kind = input.kind;
+    this.category = input.category;
+    this.status = input.status;
+    this.retryable = input.retryable ?? false;
+    this.requestId = input.requestId;
+    this.context = input.context;
+    this.raw = input.raw;
+  }
+};
 function isRecord2(value) {
   return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
@@ -1239,6 +1420,44 @@ function classifyKind(status, code, message) {
   }
   return "unknown";
 }
+function toAthenaErrorCode(kind, status, gatewayCode) {
+  if (gatewayCode === "NETWORK_ERROR" || kind === "transient" && status === 0) {
+    return AthenaErrorCode.NetworkUnavailable;
+  }
+  switch (kind) {
+    case "unique_violation":
+      return AthenaErrorCode.UniqueViolation;
+    case "not_found":
+      return AthenaErrorCode.NotFound;
+    case "validation":
+      return AthenaErrorCode.ValidationFailed;
+    case "rate_limit":
+      return AthenaErrorCode.RateLimited;
+    case "auth":
+      if (status === 403) {
+        return AthenaErrorCode.AuthForbidden;
+      }
+      return AthenaErrorCode.AuthUnauthorized;
+    case "transient":
+      return status !== void 0 && status >= 500 ? AthenaErrorCode.HttpFailure : AthenaErrorCode.TransientFailure;
+    case "unknown":
+    default:
+      return status !== void 0 && status >= 400 ? AthenaErrorCode.HttpFailure : AthenaErrorCode.Unknown;
+  }
+}
+function toAthenaErrorCategory(kind, status) {
+  if (kind === "transient" && (status === 0 || status === void 0)) {
+    return AthenaErrorCategory.Transport;
+  }
+  if (kind === "unique_violation") return AthenaErrorCategory.Database;
+  if (kind === "validation" || kind === "auth" || kind === "not_found") return AthenaErrorCategory.Client;
+  if (kind === "rate_limit" || kind === "transient") return AthenaErrorCategory.Server;
+  return AthenaErrorCategory.Unknown;
+}
+function isRetryable(kind, status) {
+  if (kind === "rate_limit" || kind === "transient") return true;
+  return status !== void 0 && status >= 500;
+}
 function toGatewayCode(kind, status) {
   if (kind === "transient" && (status === 0 || status === void 0)) return "NETWORK_ERROR";
   if (kind === "validation") return "INVALID_JSON";
@@ -1281,9 +1500,14 @@ function normalizeAthenaError(resultOrError, context) {
     const operation = context?.operation ?? operationFromDetails(details);
     const table = context?.table ?? extractTable(message2);
     const constraint = extractConstraint(message2);
-    const kind = classifyKind(resultOrError.status, details?.code, message2);
+    const kind2 = classifyKind(resultOrError.status, details?.code, message2);
+    const code = toAthenaErrorCode(kind2, resultOrError.status, details?.code);
+    const category = toAthenaErrorCategory(kind2, resultOrError.status);
     return {
-      kind,
+      kind: kind2,
+      code,
+      category,
+      retryable: isRetryable(kind2, resultOrError.status),
       status: resultOrError.status,
       constraint,
       table,
@@ -1297,9 +1521,14 @@ function normalizeAthenaError(resultOrError, context) {
     const operation = context?.operation ?? operationFromDetails(details);
     const table = context?.table ?? extractTable(resultOrError.message);
     const constraint = extractConstraint(resultOrError.message);
-    const kind = classifyKind(resultOrError.status, resultOrError.code, resultOrError.message);
+    const kind2 = classifyKind(resultOrError.status, resultOrError.code, resultOrError.message);
+    const code = toAthenaErrorCode(kind2, resultOrError.status, resultOrError.code);
+    const category = toAthenaErrorCategory(kind2, resultOrError.status);
     return {
-      kind,
+      kind: kind2,
+      code,
+      category,
+      retryable: isRetryable(kind2, resultOrError.status),
       status: resultOrError.status,
       constraint,
       table,
@@ -1310,8 +1539,12 @@ function normalizeAthenaError(resultOrError, context) {
   }
   if (resultOrError instanceof Error) {
     const maybeStatus = isRecord2(resultOrError) && typeof resultOrError.status === "number" ? resultOrError.status : void 0;
+    const kind2 = classifyKind(maybeStatus, void 0, resultOrError.message);
     return {
-      kind: classifyKind(maybeStatus, void 0, resultOrError.message),
+      kind: kind2,
+      code: toAthenaErrorCode(kind2, maybeStatus),
+      category: toAthenaErrorCategory(kind2, maybeStatus),
+      retryable: isRetryable(kind2, maybeStatus),
       status: maybeStatus,
       constraint: extractConstraint(resultOrError.message),
       table: context?.table ?? extractTable(resultOrError.message),
@@ -1321,8 +1554,12 @@ function normalizeAthenaError(resultOrError, context) {
     };
   }
   const message = typeof resultOrError === "string" ? resultOrError : "Unknown Athena error";
+  const kind = classifyKind(void 0, void 0, message);
   return {
-    kind: classifyKind(void 0, void 0, message),
+    kind,
+    code: toAthenaErrorCode(kind, void 0),
+    category: toAthenaErrorCategory(kind, void 0),
+    retryable: isRetryable(kind, void 0),
     status: void 0,
     constraint: extractConstraint(message),
     table: context?.table ?? extractTable(message),
@@ -1455,8 +1692,8 @@ function computeDelayMs(attempt, error, config) {
 }
 function sleep(ms) {
   if (ms <= 0) return Promise.resolve();
-  return new Promise((resolve) => {
-    setTimeout(resolve, ms);
+  return new Promise((resolve3) => {
+    setTimeout(resolve3, ms);
   });
 }
 async function withRetry(config, fn) {
@@ -1487,17 +1724,1319 @@ async function withRetry(config, fn) {
   throw new Error("withRetry reached an unexpected state");
 }
 
+// src/schema/definitions.ts
+function defineModel(input) {
+  return input;
+}
+function defineSchema(models) {
+  return { models };
+}
+function defineDatabase(schemas) {
+  return { schemas };
+}
+function defineRegistry(databases) {
+  return databases;
+}
+
+// src/schema/typed-client.ts
+var TenantHeaderMapper = class {
+  constructor(tenantKeyMap) {
+    this.tenantKeyMap = tenantKeyMap;
+  }
+  apply(baseHeaders, tenantContext) {
+    const headers = {
+      ...baseHeaders ?? {}
+    };
+    for (const [tenantKey, headerName] of Object.entries(this.tenantKeyMap)) {
+      const tenantValue = tenantContext[tenantKey];
+      if (tenantValue === void 0 || tenantValue === null) {
+        continue;
+      }
+      headers[headerName] = String(tenantValue);
+    }
+    return Object.keys(headers).length > 0 ? headers : void 0;
+  }
+};
+var RegistryNavigator = class {
+  constructor(registry) {
+    this.registry = registry;
+  }
+  resolveModel(database, schema, model) {
+    const databaseDef = this.registry[database];
+    if (!databaseDef) {
+      throw new Error(`Unknown database "${database}"`);
+    }
+    const schemaDef = databaseDef.schemas[schema];
+    if (!schemaDef) {
+      throw new Error(`Unknown schema "${schema}" in database "${database}"`);
+    }
+    const modelDef = schemaDef.models[model];
+    if (!modelDef) {
+      throw new Error(`Unknown model "${model}" in schema "${schema}"`);
+    }
+    return modelDef;
+  }
+  resolveTableName(schema, model, modelDef) {
+    if (modelDef.meta.tableName) {
+      return modelDef.meta.tableName;
+    }
+    const schemaName = modelDef.meta.schema ?? schema;
+    const modelName = modelDef.meta.model ?? model;
+    return `${schemaName}.${modelName}`;
+  }
+};
+var TypedAthenaClientImpl = class _TypedAthenaClientImpl {
+  registry;
+  tenantKeyMap;
+  tenantContext;
+  baseClient;
+  registryNavigator;
+  tenantHeaderMapper;
+  clientOptions;
+  url;
+  apiKey;
+  constructor(input) {
+    this.registry = input.registry;
+    this.url = input.url;
+    this.apiKey = input.apiKey;
+    const tenantKeyMap = input.options?.tenantKeyMap ?? {};
+    const tenantContext = input.options?.tenantContext ?? {};
+    this.tenantKeyMap = tenantKeyMap;
+    this.tenantContext = tenantContext;
+    this.tenantHeaderMapper = new TenantHeaderMapper(tenantKeyMap);
+    this.registryNavigator = new RegistryNavigator(input.registry);
+    this.clientOptions = {
+      backend: input.options?.backend,
+      client: input.options?.client,
+      headers: input.options?.headers
+    };
+    this.baseClient = createClient(this.url, this.apiKey, {
+      backend: this.clientOptions.backend,
+      client: this.clientOptions.client,
+      headers: this.tenantHeaderMapper.apply(this.clientOptions.headers, tenantContext)
+    });
+  }
+  from(table) {
+    return this.baseClient.from(table);
+  }
+  rpc(fn, args, options) {
+    return this.baseClient.rpc(fn, args, options);
+  }
+  query(query, options) {
+    return this.baseClient.query(query, options);
+  }
+  withTenantContext(context) {
+    return new _TypedAthenaClientImpl({
+      registry: this.registry,
+      url: this.url,
+      apiKey: this.apiKey,
+      options: {
+        ...this.clientOptions,
+        tenantKeyMap: this.tenantKeyMap,
+        tenantContext: {
+          ...this.tenantContext,
+          ...context ?? {}
+        }
+      }
+    });
+  }
+  fromModel(database, schema, model) {
+    const modelDef = this.registryNavigator.resolveModel(database, schema, model);
+    const tableName = this.registryNavigator.resolveTableName(schema, model, modelDef);
+    return this.baseClient.from(tableName);
+  }
+};
+function createTypedClient(registry, url, apiKey, options) {
+  return new TypedAthenaClientImpl({
+    registry,
+    url,
+    apiKey,
+    options
+  });
+}
+
+// src/schema/postgres-introspection-core.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,
+      t.typname AS udt_name,
+      t.typtype AS type_kind_code,
+      t.oid AS type_oid,
+      NOT a.attnotnull AS is_nullable,
+      (ad.adbin IS NOT NULL) AS has_default,
+      (a.attgenerated <> '') AS is_generated,
+      a.attndims AS array_dimensions
+    FROM pg_attribute a
+    JOIN pg_class c ON c.oid = a.attrelid
+    JOIN pg_namespace n ON n.oid = c.relnamespace
+    JOIN pg_type t ON t.oid = a.atttypid
+    LEFT JOIN pg_attrdef ad ON ad.adrelid = a.attrelid AND ad.adnum = a.attnum
+    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;
+  `,
+  enums: `
+    SELECT
+      t.oid AS type_oid,
+      e.enumlabel AS enum_label
+    FROM pg_type t
+    JOIN pg_enum e ON e.enumtypid = t.oid
+    ORDER BY t.oid, e.enumsortorder;
+  `,
+  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;
+  `,
+  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;
+  `
+};
+function tableKey(schema, table) {
+  return `${schema}.${table}`;
+}
+function relationKey(...parts) {
+  const base = parts.join("_").replace(/[^A-Za-z0-9_]+/g, "_").replace(/^_+|_+$/g, "");
+  return base.length > 0 ? base : "relation";
+}
+function toTypeKind(code) {
+  switch (code) {
+    case "e":
+      return "enum";
+    case "d":
+      return "domain";
+    case "r":
+      return "range";
+    case "m":
+      return "multirange";
+    case "c":
+      return "composite";
+    default:
+      return "scalar";
+  }
+}
+function escapeSqlLiteral(value) {
+  return value.replace(/'/g, "''");
+}
+function buildSchemaArrayLiteral(schemas) {
+  const normalized = schemas.length > 0 ? schemas : ["public"];
+  const literals = normalized.map((schema) => `'${escapeSqlLiteral(schema)}'`).join(", ");
+  return `ARRAY[${literals}]`;
+}
+function inlineSchemaLiteral(sql, schemas) {
+  const schemaArray = `${buildSchemaArrayLiteral(schemas)}::text[]`;
+  return sql.replace(/\$1::text\[\]/g, schemaArray);
+}
+function buildGatewayCatalogQueries(schemas) {
+  return {
+    columns: inlineSchemaLiteral(POSTGRES_CATALOG_SQL.columns, schemas),
+    enums: POSTGRES_CATALOG_SQL.enums,
+    primaryKeys: inlineSchemaLiteral(POSTGRES_CATALOG_SQL.primaryKeys, schemas),
+    foreignKeys: inlineSchemaLiteral(POSTGRES_CATALOG_SQL.foreignKeys, schemas)
+  };
+}
+var PostgresCatalogSnapshotAssembler = class {
+  schemas = {};
+  addColumnRows(columnRows, enumMap) {
+    for (const row of columnRows) {
+      const table = this.ensureTable(row.schema_name, row.table_name);
+      table.columns[row.column_name] = {
+        name: row.column_name,
+        dataType: row.data_type,
+        udtName: row.udt_name,
+        typeKind: toTypeKind(row.type_kind_code),
+        isNullable: row.is_nullable,
+        isPrimaryKey: false,
+        hasDefault: row.has_default,
+        isGenerated: row.is_generated,
+        arrayDimensions: row.array_dimensions ?? 0,
+        enumValues: enumMap.get(row.type_oid)
+      };
+    }
+  }
+  addPrimaryKeyRows(primaryKeyRows) {
+    for (const row of primaryKeyRows) {
+      const table = this.ensureTable(row.schema_name, row.table_name);
+      table.primaryKey = row.columns;
+      for (const columnName of row.columns) {
+        const column = table.columns[columnName];
+        if (column) {
+          column.isPrimaryKey = true;
+        }
+      }
+    }
+  }
+  addForeignKeyRows(foreignKeyRows) {
+    for (const row of foreignKeyRows) {
+      const sourceTable = this.ensureTable(row.source_schema, row.source_table);
+      const targetTable = this.ensureTable(row.target_schema, row.target_table);
+      const sourceRelationKind = row.source_is_unique ? "one-to-one" : "many-to-one";
+      this.upsertRelation(sourceTable, relationKey(row.constraint_name, row.target_table), {
+        name: row.constraint_name,
+        kind: sourceRelationKind,
+        sourceColumns: row.source_columns,
+        targetSchema: row.target_schema,
+        targetModel: row.target_table,
+        targetColumns: row.target_columns
+      });
+      const targetRelationKind = row.source_is_unique ? "one-to-one" : "one-to-many";
+      this.upsertRelation(targetTable, relationKey(row.source_table), {
+        name: relationKey(row.source_table, row.constraint_name),
+        kind: targetRelationKind,
+        sourceColumns: row.target_columns,
+        targetSchema: row.source_schema,
+        targetModel: row.source_table,
+        targetColumns: row.source_columns
+      });
+    }
+  }
+  addManyToManyRows(foreignKeyRows) {
+    const bySourceTable = /* @__PURE__ */ new Map();
+    for (const fk of foreignKeyRows) {
+      const key = tableKey(fk.source_schema, fk.source_table);
+      const current = bySourceTable.get(key) ?? {
+        schema: fk.source_schema,
+        table: fk.source_table,
+        foreignKeys: []
+      };
+      current.foreignKeys.push(fk);
+      bySourceTable.set(key, current);
+    }
+    for (const candidate of bySourceTable.values()) {
+      const bridgeTable = this.schemas[candidate.schema]?.tables[candidate.table];
+      if (!bridgeTable) continue;
+      const primaryKey = bridgeTable.primaryKey;
+      if (candidate.foreignKeys.length !== 2 || primaryKey.length === 0) continue;
+      const combinedForeignColumns = Array.from(
+        new Set(candidate.foreignKeys.flatMap((fk) => fk.source_columns))
+      );
+      if (combinedForeignColumns.length !== primaryKey.length || !primaryKey.every((column) => combinedForeignColumns.includes(column))) {
+        continue;
+      }
+      const [first, second] = candidate.foreignKeys;
+      const firstTarget = this.schemas[first.target_schema]?.tables[first.target_table];
+      const secondTarget = this.schemas[second.target_schema]?.tables[second.target_table];
+      if (!firstTarget || !secondTarget) {
+        continue;
+      }
+      this.upsertRelation(firstTarget, relationKey(second.target_table), {
+        name: relationKey(candidate.table, first.constraint_name, second.constraint_name),
+        kind: "many-to-many",
+        sourceColumns: first.target_columns,
+        targetSchema: second.target_schema,
+        targetModel: second.target_table,
+        targetColumns: second.target_columns,
+        through: {
+          schema: candidate.schema,
+          model: candidate.table,
+          sourceColumns: first.source_columns,
+          targetColumns: second.source_columns
+        }
+      });
+      this.upsertRelation(secondTarget, relationKey(first.target_table), {
+        name: relationKey(candidate.table, second.constraint_name, first.constraint_name),
+        kind: "many-to-many",
+        sourceColumns: second.target_columns,
+        targetSchema: first.target_schema,
+        targetModel: first.target_table,
+        targetColumns: first.target_columns,
+        through: {
+          schema: candidate.schema,
+          model: candidate.table,
+          sourceColumns: second.source_columns,
+          targetColumns: first.source_columns
+        }
+      });
+    }
+  }
+  toSchemas() {
+    return this.schemas;
+  }
+  ensureTable(schemaName, tableName) {
+    if (!this.schemas[schemaName]) {
+      this.schemas[schemaName] = {
+        name: schemaName,
+        tables: {}
+      };
+    }
+    const schema = this.schemas[schemaName];
+    if (!schema.tables[tableName]) {
+      schema.tables[tableName] = {
+        schema: schemaName,
+        name: tableName,
+        columns: {},
+        primaryKey: [],
+        relations: {}
+      };
+    }
+    return schema.tables[tableName];
+  }
+  upsertRelation(table, baseKey, relation) {
+    let key = baseKey;
+    let suffix = 2;
+    while (table.relations[key]) {
+      key = `${baseKey}_${suffix}`;
+      suffix += 1;
+    }
+    table.relations[key] = relation;
+  }
+};
+
+// src/schema/postgres-provider.ts
+var PgCatalogClient = class {
+  constructor(pool) {
+    this.pool = pool;
+  }
+  async queryColumns(schemas) {
+    const result = await this.pool.query(POSTGRES_CATALOG_SQL.columns, [schemas]);
+    return result.rows;
+  }
+  async queryEnums() {
+    const result = await this.pool.query(POSTGRES_CATALOG_SQL.enums);
+    const enumMap = /* @__PURE__ */ new Map();
+    for (const row of result.rows) {
+      const existing = enumMap.get(row.type_oid) ?? [];
+      existing.push(row.enum_label);
+      enumMap.set(row.type_oid, existing);
+    }
+    return enumMap;
+  }
+  async queryPrimaryKeys(schemas) {
+    const result = await this.pool.query(POSTGRES_CATALOG_SQL.primaryKeys, [schemas]);
+    return result.rows;
+  }
+  async queryForeignKeys(schemas) {
+    const result = await this.pool.query(POSTGRES_CATALOG_SQL.foreignKeys, [schemas]);
+    return result.rows;
+  }
+};
+var PostgresIntrospectionProvider = class {
+  backend = "postgresql";
+  connectionString;
+  database;
+  constructor(options) {
+    this.connectionString = options.connectionString;
+    this.database = options.database ?? "postgres";
+  }
+  async inspect(options) {
+    const schemas = options?.schemas && options.schemas.length > 0 ? options.schemas : ["public"];
+    const pool = new pg.Pool({
+      connectionString: this.connectionString
+    });
+    const catalogClient = new PgCatalogClient(pool);
+    try {
+      const [columnRows, enumMap, primaryKeyRows, foreignKeyRows] = await Promise.all([
+        catalogClient.queryColumns(schemas),
+        catalogClient.queryEnums(),
+        catalogClient.queryPrimaryKeys(schemas),
+        catalogClient.queryForeignKeys(schemas)
+      ]);
+      const assembler = new PostgresCatalogSnapshotAssembler();
+      assembler.addColumnRows(columnRows, enumMap);
+      assembler.addPrimaryKeyRows(primaryKeyRows);
+      assembler.addForeignKeyRows(foreignKeyRows);
+      assembler.addManyToManyRows(foreignKeyRows);
+      return {
+        backend: "postgresql",
+        database: this.database,
+        generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        schemas: assembler.toSchemas()
+      };
+    } finally {
+      await pool.end();
+    }
+  }
+};
+function createPostgresIntrospectionProvider(options) {
+  return new PostgresIntrospectionProvider(options);
+}
+var DEFAULT_CONFIG_CANDIDATES = [
+  "athena.config.ts",
+  "athena.config.js",
+  "athena-js.config.ts",
+  "athena-js.config.js",
+  ".athena.config.ts",
+  ".athena.config.js"
+];
+var DEFAULT_TARGETS = {
+  model: "src/generated/{database_kebab}/{schema_kebab}/{model_kebab}.model.ts",
+  schema: "src/generated/{database_kebab}/{schema_kebab}/index.ts",
+  database: "src/generated/{database_kebab}/index.ts",
+  registry: "src/generated/index.ts"
+};
+var DEFAULT_NAMING = {
+  modelType: "pascal",
+  modelConst: "camel",
+  schemaConst: "camel",
+  databaseConst: "camel",
+  registryConst: "camel"
+};
+var DEFAULT_FEATURES = {
+  emitRelations: true,
+  emitRegistry: true
+};
+var DEFAULT_EXPERIMENTAL_FLAGS = {
+  postgresGatewayIntrospection: false,
+  scyllaProviderContracts: true
+};
+function normalizeOutputConfig(output) {
+  return {
+    targets: {
+      ...DEFAULT_TARGETS,
+      ...output.targets ?? {}
+    },
+    placeholderMap: {
+      ...output.placeholderMap ?? {}
+    }
+  };
+}
+function isAthenaGeneratorConfig(value) {
+  if (!value || typeof value !== "object") {
+    return false;
+  }
+  const record = value;
+  return Boolean(record.provider && typeof record.provider === "object") && Boolean(record.output && typeof record.output === "object");
+}
+function normalizeGeneratorConfig(input) {
+  return {
+    provider: input.provider,
+    output: normalizeOutputConfig(input.output),
+    naming: {
+      ...DEFAULT_NAMING,
+      ...input.naming ?? {}
+    },
+    features: {
+      ...DEFAULT_FEATURES,
+      ...input.features ?? {}
+    },
+    experimental: {
+      ...DEFAULT_EXPERIMENTAL_FLAGS,
+      ...input.experimental ?? {}
+    }
+  };
+}
+function defineGeneratorConfig(config) {
+  return config;
+}
+function findGeneratorConfigPath(cwd = process.cwd()) {
+  for (const candidate of DEFAULT_CONFIG_CANDIDATES) {
+    const absolutePath = path.resolve(cwd, candidate);
+    if (fs.existsSync(absolutePath)) {
+      return absolutePath;
+    }
+  }
+  return void 0;
+}
+function extractConfigExport(module) {
+  const visited = /* @__PURE__ */ new Set();
+  const queue = [module];
+  while (queue.length > 0) {
+    const current = queue.shift();
+    if (!current || typeof current !== "object" || visited.has(current)) {
+      continue;
+    }
+    visited.add(current);
+    const record = current;
+    if (isAthenaGeneratorConfig(record)) {
+      return record;
+    }
+    const defaultExport = record.default;
+    if (defaultExport && typeof defaultExport === "object") {
+      queue.push(defaultExport);
+    }
+    const namedConfigExport = record.config;
+    if (namedConfigExport && typeof namedConfigExport === "object") {
+      queue.push(namedConfigExport);
+    }
+    const moduleExports = record["module.exports"];
+    if (moduleExports && typeof moduleExports === "object") {
+      queue.push(moduleExports);
+    }
+  }
+  throw new Error(
+    "Generator config file must export a config object as default export or `config`."
+  );
+}
+function importConfigModule(moduleSpecifier) {
+  const runtimeImport = new Function(
+    "moduleSpecifier",
+    "return import(moduleSpecifier)"
+  );
+  return runtimeImport(moduleSpecifier);
+}
+async function loadGeneratorConfig(options = {}) {
+  const cwd = options.cwd ?? process.cwd();
+  const resolvedPath = options.configPath ? path.resolve(cwd, options.configPath) : findGeneratorConfigPath(cwd);
+  if (!resolvedPath) {
+    throw new Error(
+      `No generator config found in ${cwd}. Expected one of: ${DEFAULT_CONFIG_CANDIDATES.join(", ")}`
+    );
+  }
+  const moduleUrl = url.pathToFileURL(resolvedPath);
+  const module = await importConfigModule(`${moduleUrl.href}?cacheBust=${Date.now()}`);
+  const rawConfig = extractConfigExport(module);
+  return {
+    configPath: resolvedPath,
+    config: normalizeGeneratorConfig(rawConfig)
+  };
+}
+
+// src/generator/naming.ts
+var IDENTIFIER_PATTERN = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
+var RESERVED_IDENTIFIERS = /* @__PURE__ */ new Set([
+  "break",
+  "case",
+  "catch",
+  "class",
+  "const",
+  "continue",
+  "debugger",
+  "default",
+  "delete",
+  "do",
+  "else",
+  "enum",
+  "export",
+  "extends",
+  "false",
+  "finally",
+  "for",
+  "function",
+  "if",
+  "import",
+  "in",
+  "instanceof",
+  "new",
+  "null",
+  "return",
+  "super",
+  "switch",
+  "this",
+  "throw",
+  "true",
+  "try",
+  "typeof",
+  "var",
+  "void",
+  "while",
+  "with",
+  "as",
+  "implements",
+  "interface",
+  "let",
+  "package",
+  "private",
+  "protected",
+  "public",
+  "static",
+  "yield",
+  "any",
+  "boolean",
+  "constructor",
+  "declare",
+  "get",
+  "module",
+  "require",
+  "number",
+  "set",
+  "string",
+  "symbol",
+  "type",
+  "from",
+  "of"
+]);
+function splitWords(input) {
+  return input.trim().replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/([A-Z]+)([A-Z][a-z0-9]+)/g, "$1 $2").replace(/[^A-Za-z0-9]+/g, " ").split(" ").map((word) => word.trim()).filter((word) => word.length > 0);
+}
+function capitalize(word) {
+  return word.length > 0 ? `${word[0].toUpperCase()}${word.slice(1).toLowerCase()}` : word;
+}
+function ensureValidIdentifier(candidate, fallback) {
+  const normalized = candidate.length > 0 ? candidate : fallback;
+  const prefixed = /^[0-9]/.test(normalized) ? `_${normalized}` : normalized;
+  if (RESERVED_IDENTIFIERS.has(prefixed)) {
+    return `${prefixed}_value`;
+  }
+  return prefixed;
+}
+function applyNamingStyle(input, style) {
+  const words = splitWords(input);
+  if (words.length === 0) {
+    return "";
+  }
+  switch (style) {
+    case "preserve":
+      return input;
+    case "camel": {
+      const [first, ...rest] = words;
+      return `${first.toLowerCase()}${rest.map(capitalize).join("")}`;
+    }
+    case "pascal":
+      return words.map(capitalize).join("");
+    case "snake":
+      return words.map((word) => word.toLowerCase()).join("_");
+    case "kebab":
+      return words.map((word) => word.toLowerCase()).join("-");
+    default:
+      return input;
+  }
+}
+function toSafeIdentifier(input, style, fallback = "value") {
+  const transformed = applyNamingStyle(input, style);
+  const normalized = transformed.replace(/[^A-Za-z0-9_$]+/g, "_").replace(/^_+|_+$/g, "");
+  const fallbackValue = splitWords(input).join("");
+  return ensureValidIdentifier(
+    normalized.length > 0 ? normalized : fallbackValue,
+    fallback
+  );
+}
+function escapeTypePropertyName(propertyName) {
+  if (IDENTIFIER_PATTERN.test(propertyName) && !RESERVED_IDENTIFIERS.has(propertyName)) {
+    return propertyName;
+  }
+  return `'${propertyName.replace(/\\/g, "\\\\").replace(/'/g, "\\'")}'`;
+}
+function escapeStringLiteral(value) {
+  return `'${value.replace(/\\/g, "\\\\").replace(/'/g, "\\'")}'`;
+}
+
+// src/generator/placeholders.ts
+function createStyleTokens(prefix, value) {
+  return {
+    [prefix]: value,
+    [`${prefix}_camel`]: applyNamingStyle(value, "camel"),
+    [`${prefix}_pascal`]: applyNamingStyle(value, "pascal"),
+    [`${prefix}_snake`]: applyNamingStyle(value, "snake"),
+    [`${prefix}_kebab`]: applyNamingStyle(value, "kebab")
+  };
+}
+function renderTemplate(template, tokenMap) {
+  return template.replace(/\{([A-Za-z0-9_]+)\}/g, (_match, token) => {
+    if (!(token in tokenMap)) {
+      throw new Error(`Unknown placeholder token "${token}" in template "${template}"`);
+    }
+    return tokenMap[token];
+  });
+}
+function resolvePlaceholderMap(baseTokens, outputConfig) {
+  const resolved = {
+    ...baseTokens
+  };
+  const entries = Object.entries(outputConfig.placeholderMap ?? {});
+  for (let index = 0; index < entries.length; index += 1) {
+    const [key, value] = entries[index];
+    let current = value;
+    for (let depth = 0; depth < 8; depth += 1) {
+      const next = renderTemplate(current, resolved);
+      if (next === current) {
+        break;
+      }
+      current = next;
+    }
+    resolved[key] = current;
+  }
+  return resolved;
+}
+function renderOutputPath(template, context, outputConfig) {
+  const baseTokens = {
+    provider: context.provider,
+    kind: context.kind,
+    ...createStyleTokens("database", context.database),
+    ...createStyleTokens("schema", context.schema),
+    ...createStyleTokens("model", context.model)
+  };
+  const tokens = resolvePlaceholderMap(baseTokens, outputConfig);
+  return renderTemplate(template, tokens);
+}
+
+// src/generator/postgres-type-mapping.ts
+var NUMBER_TYPES = /* @__PURE__ */ new Set([
+  "int2",
+  "int4",
+  "float4",
+  "float8",
+  "smallint",
+  "integer",
+  "real",
+  "double precision"
+]);
+var STRING_NUMERIC_TYPES = /* @__PURE__ */ new Set([
+  "int8",
+  "bigint",
+  "serial8",
+  "bigserial",
+  "numeric",
+  "decimal",
+  "money"
+]);
+var TEXT_TYPES = /* @__PURE__ */ new Set([
+  "char",
+  "bpchar",
+  "varchar",
+  "character varying",
+  "text",
+  "citext",
+  "name",
+  "uuid",
+  "date",
+  "time",
+  "timetz",
+  "timestamp",
+  "timestamptz",
+  "interval",
+  "inet",
+  "cidr",
+  "macaddr",
+  "macaddr8",
+  "point",
+  "line",
+  "lseg",
+  "box",
+  "path",
+  "polygon",
+  "circle",
+  "bit",
+  "varbit",
+  "xml",
+  "tsvector",
+  "tsquery",
+  "jsonpath"
+]);
+function normalizeTypeLabel(column) {
+  const preferred = (column.udtName || column.dataType).toLowerCase().trim();
+  if (column.arrayDimensions > 0 && preferred.startsWith("_")) {
+    return preferred.slice(1);
+  }
+  return preferred;
+}
+function wrapArrayType(baseType, depth) {
+  let wrapped = baseType;
+  for (let index = 0; index < depth; index += 1) {
+    wrapped = `Array<${wrapped}>`;
+  }
+  return wrapped;
+}
+function resolveScalarType(column) {
+  const label = normalizeTypeLabel(column);
+  if (NUMBER_TYPES.has(label)) {
+    return "number";
+  }
+  if (STRING_NUMERIC_TYPES.has(label)) {
+    return "string";
+  }
+  if (label === "bool" || label === "boolean") {
+    return "boolean";
+  }
+  if (label === "bytea") {
+    return "Buffer";
+  }
+  if (label === "json" || label === "jsonb") {
+    return "Record<string, unknown>";
+  }
+  if (TEXT_TYPES.has(label)) {
+    return "string";
+  }
+  if (label.endsWith("range") || label.endsWith("multirange")) {
+    return "string";
+  }
+  return "unknown";
+}
+function resolveKindAwareType(column) {
+  if (column.typeKind === "enum") {
+    const values = column.enumValues ?? [];
+    if (values.length === 0) {
+      return "string";
+    }
+    return values.map((value) => `'${value.replace(/\\/g, "\\\\").replace(/'/g, "\\'")}'`).join(" | ");
+  }
+  if (column.typeKind === "composite") {
+    return "Record<string, unknown>";
+  }
+  if (column.typeKind === "domain" || column.typeKind === "range" || column.typeKind === "multirange") {
+    return "string";
+  }
+  return resolveScalarType(column);
+}
+function resolvePostgresColumnType(column) {
+  const baseType = resolveKindAwareType(column);
+  if (!column.arrayDimensions || column.arrayDimensions <= 0) {
+    return baseType;
+  }
+  return wrapArrayType(baseType, column.arrayDimensions);
+}
+
+// src/generator/renderer.ts
+function normalizePath(pathValue) {
+  return pathValue.replace(/\\/g, "/");
+}
+function withoutTypeScriptExtension(pathValue) {
+  return pathValue.replace(/\.tsx?$/i, "");
+}
+function toModuleImportPath(fromFile, targetFile) {
+  const relativePath = withoutTypeScriptExtension(
+    normalizePath(path.posix.relative(path.posix.dirname(fromFile), targetFile))
+  );
+  return relativePath.startsWith(".") ? relativePath : `./${relativePath}`;
+}
+function renderObjectKey(key) {
+  const escaped = escapeTypePropertyName(key);
+  return escaped.startsWith("'") ? escaped : escaped;
+}
+function renderRelation(relation) {
+  const through = relation.through ? `,
+      through: {
+        schema: ${escapeStringLiteral(relation.through.schema)},
+        model: ${escapeStringLiteral(relation.through.model)},
+        sourceColumns: [${relation.through.sourceColumns.map((value) => escapeStringLiteral(value)).join(", ")}],
+        targetColumns: [${relation.through.targetColumns.map((value) => escapeStringLiteral(value)).join(", ")}],
+      }` : "";
+  return `{
+      kind: ${escapeStringLiteral(relation.kind)},
+      sourceColumns: [${relation.sourceColumns.map((value) => escapeStringLiteral(value)).join(", ")}],
+      targetSchema: ${escapeStringLiteral(relation.targetSchema)},
+      targetModel: ${escapeStringLiteral(relation.targetModel)},
+      targetColumns: [${relation.targetColumns.map((value) => escapeStringLiteral(value)).join(", ")}]${through}
+    }`;
+}
+function renderModelArtifact(snapshot, descriptor, config) {
+  const columnLines = Object.values(descriptor.table.columns).map((column) => {
+    const propertyName = escapeTypePropertyName(column.name);
+    const baseType = resolvePostgresColumnType(column);
+    const isOptional = column.isNullable;
+    const typeWithNullability = column.isNullable ? `${baseType} | null` : baseType;
+    return `  ${propertyName}${isOptional ? "?" : ""}: ${typeWithNullability}`;
+  }).join("\n");
+  const nullableLines = Object.values(descriptor.table.columns).map((column) => `      ${renderObjectKey(column.name)}: ${column.isNullable ? "true" : "false"}`).join(",\n");
+  const relationEntries = Object.entries(descriptor.table.relations);
+  const relationBlock = config.features.emitRelations && relationEntries.length > 0 ? `,
+    relations: {
+${relationEntries.map(([relationKey2, relationValue]) => `      ${renderObjectKey(relationKey2)}: ${renderRelation(relationValue)}`).join(",\n")}
+    }` : "";
+  const content = `import { defineModel } from '@xylex-group/athena'
+
+export interface ${descriptor.rowTypeName} {
+${columnLines}
+}
+
+export type ${descriptor.insertTypeName} = Partial<${descriptor.rowTypeName}>
+export type ${descriptor.updateTypeName} = Partial<${descriptor.insertTypeName}>
+
+export const ${descriptor.modelConstName} = defineModel<${descriptor.rowTypeName}, ${descriptor.insertTypeName}, ${descriptor.updateTypeName}>({
+  meta: {
+    database: ${escapeStringLiteral(snapshot.database)},
+    schema: ${escapeStringLiteral(descriptor.schemaName)},
+    model: ${escapeStringLiteral(descriptor.tableName)},
+    tableName: ${escapeStringLiteral(`${descriptor.schemaName}.${descriptor.tableName}`)},
+    primaryKey: [${descriptor.table.primaryKey.map((value) => escapeStringLiteral(value)).join(", ")}],
+    nullable: {
+${nullableLines}
+    }${relationBlock}
+  }
+})
+`;
+  return {
+    kind: "model",
+    path: descriptor.filePath,
+    content
+  };
+}
+function renderSchemaArtifact(descriptor) {
+  const importLines = descriptor.models.map((modelDescriptor) => {
+    const importPath = toModuleImportPath(descriptor.filePath, modelDescriptor.filePath);
+    return `import { ${modelDescriptor.modelConstName} } from '${importPath}'`;
+  }).join("\n");
+  const modelEntries = descriptor.models.map((modelDescriptor) => `  ${renderObjectKey(modelDescriptor.tableName)}: ${modelDescriptor.modelConstName}`).join(",\n");
+  const content = `import { defineSchema } from '@xylex-group/athena'
+${importLines ? `
+${importLines}
+` : "\n"}
+export const ${descriptor.schemaConstName} = defineSchema({
+${modelEntries}
+})
+`;
+  return {
+    kind: "schema",
+    path: descriptor.filePath,
+    content
+  };
+}
+function renderDatabaseArtifact(descriptor) {
+  const importLines = descriptor.schemas.map((schemaDescriptor) => {
+    const importPath = toModuleImportPath(descriptor.filePath, schemaDescriptor.filePath);
+    return `import { ${schemaDescriptor.schemaConstName} } from '${importPath}'`;
+  }).join("\n");
+  const schemaEntries = descriptor.schemas.map((schemaDescriptor) => `  ${renderObjectKey(schemaDescriptor.schemaName)}: ${schemaDescriptor.schemaConstName}`).join(",\n");
+  const content = `import { defineDatabase } from '@xylex-group/athena'
+${importLines ? `
+${importLines}
+` : "\n"}
+export const ${descriptor.databaseConstName} = defineDatabase({
+${schemaEntries}
+})
+`;
+  return {
+    kind: "database",
+    path: descriptor.filePath,
+    content
+  };
+}
+function renderRegistryArtifact(registryPath, databasePath, databaseConstName, registryConstName, databaseName) {
+  const databaseImportPath = toModuleImportPath(registryPath, databasePath);
+  const content = `import { defineRegistry } from '@xylex-group/athena'
+import { ${databaseConstName} } from '${databaseImportPath}'
+
+export const ${registryConstName} = defineRegistry({
+  ${renderObjectKey(databaseName)}: ${databaseConstName}
+})
+`;
+  return {
+    kind: "registry",
+    path: registryPath,
+    content
+  };
+}
+function assertNoDuplicatePaths(files) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const file of files) {
+    if (seen.has(file.path)) {
+      throw new Error(`Generator output collision detected for path: ${file.path}`);
+    }
+    seen.add(file.path);
+  }
+}
+var ArtifactComposer = class {
+  constructor(snapshot, config) {
+    this.snapshot = snapshot;
+    this.config = config;
+  }
+  compose() {
+    const providerName = this.snapshot.backend;
+    const databaseName = this.snapshot.database;
+    const modelDescriptors = [];
+    for (const schemaName of Object.keys(this.snapshot.schemas).sort()) {
+      const schema = this.snapshot.schemas[schemaName];
+      for (const tableName of Object.keys(schema.tables).sort()) {
+        const table = schema.tables[tableName];
+        const rowTypeName = `${toSafeIdentifier(`${schemaName} ${tableName}`, this.config.naming.modelType, "Model")}Row`;
+        const insertTypeName = `${toSafeIdentifier(`${schemaName} ${tableName}`, this.config.naming.modelType, "Model")}Insert`;
+        const updateTypeName = `${toSafeIdentifier(`${schemaName} ${tableName}`, this.config.naming.modelType, "Model")}Update`;
+        const modelConstName = `${toSafeIdentifier(`${schemaName} ${tableName} model`, this.config.naming.modelConst, "model")}`;
+        const modelPath = normalizePath(
+          renderOutputPath(this.config.output.targets.model, {
+            provider: providerName,
+            kind: "model",
+            database: databaseName,
+            schema: schemaName,
+            model: tableName
+          }, this.config.output)
+        );
+        modelDescriptors.push({
+          schemaName,
+          tableName,
+          filePath: modelPath,
+          rowTypeName,
+          insertTypeName,
+          updateTypeName,
+          modelConstName,
+          table
+        });
+      }
+    }
+    const schemaDescriptors = Object.keys(this.snapshot.schemas).sort().map((schemaName) => {
+      const schemaPath = normalizePath(
+        renderOutputPath(this.config.output.targets.schema, {
+          provider: providerName,
+          kind: "schema",
+          database: databaseName,
+          schema: schemaName,
+          model: "index"
+        }, this.config.output)
+      );
+      return {
+        schemaName,
+        filePath: schemaPath,
+        schemaConstName: toSafeIdentifier(
+          `${schemaName} schema`,
+          this.config.naming.schemaConst,
+          "schema"
+        ),
+        models: modelDescriptors.filter((model) => model.schemaName === schemaName)
+      };
+    });
+    const databasePath = normalizePath(
+      renderOutputPath(this.config.output.targets.database, {
+        provider: providerName,
+        kind: "database",
+        database: databaseName,
+        schema: "index",
+        model: "index"
+      }, this.config.output)
+    );
+    const databaseDescriptor = {
+      filePath: databasePath,
+      databaseConstName: toSafeIdentifier(
+        `${databaseName} database`,
+        this.config.naming.databaseConst,
+        "database"
+      ),
+      schemas: schemaDescriptors
+    };
+    const files = [];
+    for (const modelDescriptor of modelDescriptors) {
+      files.push(renderModelArtifact(this.snapshot, modelDescriptor, this.config));
+    }
+    for (const schemaDescriptor of schemaDescriptors) {
+      files.push(renderSchemaArtifact(schemaDescriptor));
+    }
+    files.push(renderDatabaseArtifact(databaseDescriptor));
+    if (this.config.features.emitRegistry) {
+      const registryPath = normalizePath(
+        renderOutputPath(this.config.output.targets.registry, {
+          provider: providerName,
+          kind: "registry",
+          database: databaseName,
+          schema: "index",
+          model: "index"
+        }, this.config.output)
+      );
+      files.push(
+        renderRegistryArtifact(
+          registryPath,
+          databaseDescriptor.filePath,
+          databaseDescriptor.databaseConstName,
+          toSafeIdentifier("registry", this.config.naming.registryConst, "registry"),
+          databaseName
+        )
+      );
+    }
+    assertNoDuplicatePaths(files);
+    return {
+      snapshot: this.snapshot,
+      files
+    };
+  }
+};
+function generateArtifactsFromSnapshot(snapshot, config) {
+  const normalizedConfig = "naming" in config && "features" in config && "experimental" in config ? config : normalizeGeneratorConfig(config);
+  return new ArtifactComposer(snapshot, normalizedConfig).compose();
+}
+
+// src/generator/providers.ts
+var AthenaGatewayCatalogClient = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async queryRows(query) {
+    const result = await this.client.query(query);
+    if (result.error || result.status < 200 || result.status >= 300) {
+      throw new Error(result.error ?? `Gateway query failed with status ${result.status}`);
+    }
+    return result.data ?? [];
+  }
+  async queryColumns(query) {
+    return this.queryRows(query);
+  }
+  async queryEnums(query) {
+    const rows = await this.queryRows(query);
+    const enumMap = /* @__PURE__ */ new Map();
+    for (const row of rows) {
+      const existing = enumMap.get(row.type_oid) ?? [];
+      existing.push(row.enum_label);
+      enumMap.set(row.type_oid, existing);
+    }
+    return enumMap;
+  }
+  async queryPrimaryKeys(query) {
+    return this.queryRows(query);
+  }
+  async queryForeignKeys(query) {
+    return this.queryRows(query);
+  }
+};
+var AthenaGatewayPostgresIntrospectionProvider = class {
+  constructor(config) {
+    this.config = config;
+    this.client = createClient(this.config.gatewayUrl, this.config.apiKey, {
+      backend: {
+        type: this.config.backend ?? "postgresql"
+      }
+    });
+  }
+  backend = "postgresql";
+  client;
+  async inspect(options) {
+    const schemas = options?.schemas && options.schemas.length > 0 ? options.schemas : this.config.schemas && this.config.schemas.length > 0 ? this.config.schemas : ["public"];
+    const catalogClient = new AthenaGatewayCatalogClient(this.client);
+    const queries = buildGatewayCatalogQueries(schemas);
+    const [columnRows, enumMap, primaryKeyRows, foreignKeyRows] = await Promise.all([
+      catalogClient.queryColumns(queries.columns),
+      catalogClient.queryEnums(queries.enums),
+      catalogClient.queryPrimaryKeys(queries.primaryKeys),
+      catalogClient.queryForeignKeys(queries.foreignKeys)
+    ]);
+    const assembler = new PostgresCatalogSnapshotAssembler();
+    assembler.addColumnRows(columnRows, enumMap);
+    assembler.addPrimaryKeyRows(primaryKeyRows);
+    assembler.addForeignKeyRows(foreignKeyRows);
+    assembler.addManyToManyRows(foreignKeyRows);
+    return {
+      backend: "postgresql",
+      database: this.config.database,
+      generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      schemas: assembler.toSchemas()
+    };
+  }
+};
+var ScyllaIntrospectionProvider = class {
+  constructor(config) {
+    this.config = config;
+  }
+  backend = "scylladb";
+  async inspect() {
+    throw new Error(
+      `Scylla introspection provider is not implemented yet for keyspace ${this.config.keyspace}.`
+    );
+  }
+};
+function createPostgresProvider(config) {
+  return createPostgresIntrospectionProvider({
+    connectionString: config.connectionString,
+    database: config.database
+  });
+}
+function resolveGeneratorProvider(providerConfig, experimentalFlags) {
+  if (providerConfig.kind === "postgres" && providerConfig.mode === "direct") {
+    return createPostgresProvider(providerConfig);
+  }
+  if (providerConfig.kind === "postgres" && providerConfig.mode === "gateway") {
+    return new AthenaGatewayPostgresIntrospectionProvider(providerConfig);
+  }
+  if (providerConfig.kind === "scylla") {
+    if (!experimentalFlags.scyllaProviderContracts) {
+      throw new Error(
+        "Scylla provider contracts are disabled. Set experimental.scyllaProviderContracts=true to enable placeholders."
+      );
+    }
+    return new ScyllaIntrospectionProvider(providerConfig);
+  }
+  throw new Error(`Unsupported generator provider kind: ${providerConfig.kind ?? "unknown"}`);
+}
+function extractProviderSchemas(providerConfig) {
+  if (!("schemas" in providerConfig) || !providerConfig.schemas || providerConfig.schemas.length === 0) {
+    return void 0;
+  }
+  return providerConfig.schemas;
+}
+async function writeArtifacts(files, cwd) {
+  const writtenFiles = [];
+  for (const file of files) {
+    const absolutePath = path.resolve(cwd, file.path);
+    await promises.mkdir(path.dirname(absolutePath), { recursive: true });
+    await promises.writeFile(absolutePath, file.content, "utf8");
+    writtenFiles.push(file.path);
+  }
+  return writtenFiles;
+}
+async function runSchemaGenerator(options = {}) {
+  const cwd = options.cwd ?? process.cwd();
+  const configOptions = {
+    cwd,
+    configPath: options.configPath
+  };
+  const { configPath, config } = await loadGeneratorConfig(configOptions);
+  const provider = options.provider ?? resolveGeneratorProvider(config.provider, config.experimental);
+  const snapshot = await provider.inspect({
+    schemas: extractProviderSchemas(config.provider)
+  });
+  const generated = generateArtifactsFromSnapshot(snapshot, config);
+  const writtenFiles = options.dryRun ? [] : await writeArtifacts(generated.files, cwd);
+  return {
+    ...generated,
+    configPath,
+    writtenFiles
+  };
+}
+
 exports.AthenaClient = AthenaClient;
+exports.AthenaError = AthenaError;
+exports.AthenaErrorCategory = AthenaErrorCategory;
+exports.AthenaErrorCode = AthenaErrorCode;
+exports.AthenaErrorKind = AthenaErrorKind;
 exports.AthenaGatewayError = AthenaGatewayError;
 exports.Backend = Backend;
 exports.assertInt = assertInt;
 exports.coerceInt = coerceInt;
 exports.createClient = createClient;
+exports.createPostgresIntrospectionProvider = createPostgresIntrospectionProvider;
+exports.createTypedClient = createTypedClient;
+exports.defineDatabase = defineDatabase;
+exports.defineGeneratorConfig = defineGeneratorConfig;
+exports.defineModel = defineModel;
+exports.defineRegistry = defineRegistry;
+exports.defineSchema = defineSchema;
+exports.findGeneratorConfigPath = findGeneratorConfigPath;
+exports.generateArtifactsFromSnapshot = generateArtifactsFromSnapshot;
+exports.identifier = identifier;
 exports.isAthenaGatewayError = isAthenaGatewayError;
 exports.isOk = isOk;
+exports.loadGeneratorConfig = loadGeneratorConfig;
 exports.normalizeAthenaError = normalizeAthenaError;
+exports.normalizeGeneratorConfig = normalizeGeneratorConfig;
 exports.requireAffected = requireAffected;
 exports.requireSuccess = requireSuccess;
+exports.resolveGeneratorProvider = resolveGeneratorProvider;
+exports.resolvePostgresColumnType = resolvePostgresColumnType;
+exports.runSchemaGenerator = runSchemaGenerator;
 exports.unwrap = unwrap;
 exports.unwrapOne = unwrapOne;
 exports.unwrapRows = unwrapRows;