@xylex-group/athena 1.6.0 → 1.6.2

package/dist/index.d.ts

@@ -1,5 +1,8 @@
-import { B as BackendConfig, a as BackendType, A as AthenaConditionValue, b as AthenaConditionCastType, c as AthenaConditionArrayValue, d as AthenaConditionOperator, e as AthenaGatewayCallOptions, f as AthenaGatewayErrorDetails, g as AthenaRpcCallOptions } from './errors-DQerAaXC.js';
-export { h as AthenaGatewayError, i as AthenaGatewayErrorCode, j as AthenaRpcFilter, k as AthenaRpcFilterOperator, l as AthenaRpcOrder, m as AthenaRpcPayload, n as Backend, o as isAthenaGatewayError } from './errors-DQerAaXC.js';
+import { A as AthenaGatewayCallOptions, a as AthenaConditionValue, b as AthenaConditionCastType, c as AthenaConditionArrayValue, d as AthenaConditionOperator, e as AthenaGatewayErrorDetails, f as AthenaRpcCallOptions, B as BackendConfig, g as BackendType } from './types-v6UyGg-x.js';
+export { m as AthenaGatewayErrorCode, i as AthenaRpcFilter, j as AthenaRpcFilterOperator, k as AthenaRpcOrder, l as AthenaRpcPayload, h as Backend } from './types-v6UyGg-x.js';
+export { A as AthenaGatewayError, i as isAthenaGatewayError } from './errors-1b-LSTum.js';
+import { S as SchemaDef, A as AnyModelDef, D as DatabaseDef, M as ModelMetadata, a as ModelDef, R as RegistryDef, T as TenantKeyMap, b as TenantContext, c as RowOf, d as ModelAt, e as SchemaIntrospectionProvider, f as AthenaGeneratorConfig, L as LoadGeneratorConfigOptions, g as LoadedGeneratorConfig, N as NormalizedAthenaGeneratorConfig, I as IntrospectionSnapshot, G as GeneratedArtifacts, h as IntrospectionColumn, i as GeneratorProviderConfig, j as GeneratorExperimentalFlags } from './pipeline-BQzpSLD3.js';
+export { u as GeneratedArtifact, v as GeneratorArtifactKind, w as GeneratorFeatureFlags, x as GeneratorNamingConfig, y as GeneratorOutputConfig, z as GeneratorOutputTargets, k as InsertOf, l as IntrospectionInspectOptions, m as IntrospectionRelation, n as IntrospectionSchema, o as IntrospectionTable, p as IntrospectionTypeKind, q as ModelRelationKind, s as ModelRelationMetadata, B as NamingStyle, C as RunGeneratorOptions, E as RunGeneratorResult, t as TenantContextValue, U as UpdateOf, r as runSchemaGenerator } from './pipeline-BQzpSLD3.js';
 
 interface AthenaResult<T> {
     data: T | null;
@@ -314,185 +317,6 @@ interface SqlIdentifier {
  */
 declare function identifier(...segments: string[]): SqlIdentifier;
 
-type ModelKey = string;
-type ColumnKey = string;
-/**
- * Runtime values that can safely be serialized into tenant-scoped headers.
- */
-type TenantContextValue = string | number | boolean | null | undefined;
-/**
- * Compile-time map of tenant context keys to outbound header names.
- */
-type TenantKeyMap = Record<string, string>;
-/**
- * Partial tenant context keyed by `TenantKeyMap`.
- */
-type TenantContext<TMap extends TenantKeyMap> = Partial<Record<keyof TMap, TenantContextValue>>;
-/**
- * Supported relationship cardinalities for model metadata and introspection snapshots.
- */
-type ModelRelationKind = 'one-to-one' | 'one-to-many' | 'many-to-one' | 'many-to-many';
-/**
- * Base metadata shape shared by typed model definitions and introspection snapshots.
- * This type is intentionally row-agnostic so it can be used for generic registries.
- */
-interface ModelMetadataBase {
-    database?: string;
-    schema?: string;
-    model?: string;
-    tableName?: string;
-    primaryKey: string[];
-    nullable?: Partial<Record<string, boolean>>;
-    relations?: Record<string, ModelRelationMetadata>;
-}
-/**
- * Strongly-typed model metadata linked to a row shape.
- */
-type ModelMetadata<Row> = Omit<ModelMetadataBase, 'primaryKey' | 'nullable'> & {
-    primaryKey: Array<Extract<keyof Row, string>>;
-    nullable?: Partial<Record<Extract<keyof Row, string>, boolean>>;
-};
-/**
- * Relation metadata for model contracts and introspection snapshots.
- */
-interface ModelRelationMetadata {
-    kind: ModelRelationKind;
-    sourceColumns: ColumnKey[];
-    targetSchema: string;
-    targetModel: ModelKey;
-    targetColumns: ColumnKey[];
-    targetDatabase?: string;
-    through?: {
-        schema: string;
-        model: string;
-        sourceColumns: ColumnKey[];
-        targetColumns: ColumnKey[];
-    };
-}
-/**
- * Core model definition contract used by typed registries.
- */
-interface ModelDef<Row, Insert = Partial<Row>, Update = Partial<Insert>, Meta extends ModelMetadataBase = ModelMetadata<Row>> {
-    readonly meta: Meta;
-    readonly __types?: {
-        row: Row;
-        insert: Insert;
-        update: Update;
-    };
-}
-/**
- * Row-agnostic model definition used as a generic constraint.
- */
-type AnyModelDef = ModelDef<unknown, unknown, unknown, ModelMetadataBase>;
-/**
- * Schema-level model registry.
- */
-interface SchemaDef<Models extends Record<ModelKey, AnyModelDef>> {
-    readonly models: Models;
-}
-/**
- * Database-level schema registry.
- */
-interface DatabaseDef<Schemas extends Record<string, SchemaDef<Record<ModelKey, AnyModelDef>>>> {
-    readonly schemas: Schemas;
-}
-/**
- * Top-level registry keyed by logical database names.
- */
-type RegistryDef<Databases extends Record<string, DatabaseDef<Record<string, SchemaDef<Record<ModelKey, AnyModelDef>>>>>> = Databases;
-/**
- * Extracts row type from a model definition.
- */
-type RowOf<TModel extends AnyModelDef> = TModel extends ModelDef<infer TRow, unknown, unknown, ModelMetadataBase> ? TRow : never;
-/**
- * Extracts insert type from a model definition.
- */
-type InsertOf<TModel extends AnyModelDef> = TModel extends ModelDef<unknown, infer TInsert, unknown, ModelMetadataBase> ? TInsert : never;
-/**
- * Extracts update type from a model definition.
- */
-type UpdateOf<TModel extends AnyModelDef> = TModel extends ModelDef<unknown, unknown, infer TUpdate, ModelMetadataBase> ? TUpdate : never;
-/**
- * Resolves a model definition from a registry path.
- */
-type ModelAt<TRegistry extends RegistryDef<Record<string, DatabaseDef<Record<string, SchemaDef<Record<ModelKey, AnyModelDef>>>>>>, TDatabase extends keyof TRegistry & string, TSchema extends keyof TRegistry[TDatabase]['schemas'] & string, TModel extends keyof TRegistry[TDatabase]['schemas'][TSchema]['models'] & string> = TRegistry[TDatabase]['schemas'][TSchema]['models'][TModel];
-/**
- * Introspection-level column type families.
- */
-type IntrospectionTypeKind = 'scalar' | 'enum' | 'domain' | 'range' | 'multirange' | 'composite';
-/**
- * Introspected column metadata.
- */
-interface IntrospectionColumn {
-    name: string;
-    dataType: string;
-    udtName: string;
-    typeKind: IntrospectionTypeKind;
-    isNullable: boolean;
-    isPrimaryKey: boolean;
-    hasDefault: boolean;
-    isGenerated: boolean;
-    arrayDimensions: number;
-    enumValues?: string[];
-}
-/**
- * Introspected relationship metadata.
- */
-interface IntrospectionRelation {
-    name: string;
-    kind: ModelRelationKind;
-    sourceColumns: string[];
-    targetSchema: string;
-    targetModel: string;
-    targetColumns: string[];
-    targetDatabase?: string;
-    through?: {
-        schema: string;
-        model: string;
-        sourceColumns: string[];
-        targetColumns: string[];
-    };
-}
-/**
- * Introspected table metadata.
- */
-interface IntrospectionTable {
-    schema: string;
-    name: string;
-    columns: Record<string, IntrospectionColumn>;
-    primaryKey: string[];
-    relations: Record<string, IntrospectionRelation>;
-}
-/**
- * Introspected schema metadata.
- */
-interface IntrospectionSchema {
-    name: string;
-    tables: Record<string, IntrospectionTable>;
-}
-/**
- * Normalized output of a schema introspection pass.
- */
-interface IntrospectionSnapshot {
-    backend: BackendType;
-    database: string;
-    generatedAt: string;
-    schemas: Record<string, IntrospectionSchema>;
-}
-/**
- * Options accepted by introspection providers.
- */
-interface IntrospectionInspectOptions {
-    schemas?: string[];
-}
-/**
- * Provider contract implemented by backend-specific introspection adapters.
- */
-interface SchemaIntrospectionProvider {
-    readonly backend: BackendType;
-    inspect(options?: IntrospectionInspectOptions): Promise<IntrospectionSnapshot>;
-}
-
 /**
  * Declares a model contract with explicit metadata and typed row/insert/update shapes.
  */
@@ -547,157 +371,6 @@ interface PostgresIntrospectionProviderOptions {
  */
 declare function createPostgresIntrospectionProvider(options: PostgresIntrospectionProviderOptions): SchemaIntrospectionProvider;
 
-/**
- * Supported case transformations for generated symbols and path token variants.
- */
-type NamingStyle = 'preserve' | 'camel' | 'pascal' | 'snake' | 'kebab';
-/**
- * Naming configuration for generated TypeScript identifiers.
- */
-interface GeneratorNamingConfig {
-    modelType: NamingStyle;
-    modelConst: NamingStyle;
-    schemaConst: NamingStyle;
-    databaseConst: NamingStyle;
-    registryConst: NamingStyle;
-}
-/**
- * Stable feature flags for generator output behavior.
- */
-interface GeneratorFeatureFlags {
-    emitRelations: boolean;
-    emitRegistry: boolean;
-}
-/**
- * Experimental toggles for optional/forward-compatible generator behavior.
- */
-interface GeneratorExperimentalFlags {
-    /**
-     * Legacy compatibility toggle from the initial scaffold.
-     * Gateway introspection is now implemented; this flag is retained for additive config compatibility.
-     */
-    postgresGatewayIntrospection: boolean;
-    /**
-     * Enables contract placeholders for future Scylla provider work.
-     */
-    scyllaProviderContracts: boolean;
-}
-/**
- * Path templates for each generated artifact category.
- */
-interface GeneratorOutputTargets {
-    model: string;
-    schema: string;
-    database: string;
-    registry: string;
-}
-/**
- * Output configuration including dynamic placeholder aliases.
- */
-interface GeneratorOutputConfig {
-    targets: GeneratorOutputTargets;
-    placeholderMap: Record<string, string>;
-}
-/**
- * Direct PostgreSQL introspection mode (implemented).
- */
-interface PostgresDirectProviderConfig {
-    kind: 'postgres';
-    mode: 'direct';
-    connectionString: string;
-    database?: string;
-    schemas?: string[];
-}
-/**
- * Athena gateway-backed PostgreSQL introspection mode using `/gateway/query`.
- */
-interface PostgresGatewayProviderConfig {
-    kind: 'postgres';
-    mode: 'gateway';
-    gatewayUrl: string;
-    apiKey: string;
-    database: string;
-    schemas?: string[];
-    backend?: BackendType;
-}
-/**
- * Scylla introspection provider contract placeholder (phase-two scaffold).
- */
-interface ScyllaDirectProviderConfig {
-    kind: 'scylla';
-    mode: 'direct';
-    contactPoints: string[];
-    keyspace: string;
-    datacenter?: string;
-}
-type GeneratorProviderConfig = PostgresDirectProviderConfig | PostgresGatewayProviderConfig | ScyllaDirectProviderConfig;
-/**
- * Root config contract loaded from `athena.config.ts`.
- */
-interface AthenaGeneratorConfig {
-    provider: GeneratorProviderConfig;
-    output: GeneratorOutputConfig;
-    naming?: Partial<GeneratorNamingConfig>;
-    features?: Partial<GeneratorFeatureFlags>;
-    experimental?: Partial<GeneratorExperimentalFlags>;
-}
-/**
- * Normalized generator config with defaults applied.
- */
-interface NormalizedAthenaGeneratorConfig {
-    provider: GeneratorProviderConfig;
-    output: GeneratorOutputConfig;
-    naming: GeneratorNamingConfig;
-    features: GeneratorFeatureFlags;
-    experimental: GeneratorExperimentalFlags;
-}
-/**
- * Config loader options for CLI/programmatic usage.
- */
-interface LoadGeneratorConfigOptions {
-    cwd?: string;
-    configPath?: string;
-}
-/**
- * Fully loaded config result including resolved file path.
- */
-interface LoadedGeneratorConfig {
-    configPath: string;
-    config: NormalizedAthenaGeneratorConfig;
-}
-type GeneratorArtifactKind = 'model' | 'schema' | 'database' | 'registry';
-/**
- * One generated output file.
- */
-interface GeneratedArtifact {
-    kind: GeneratorArtifactKind;
-    path: string;
-    content: string;
-}
-/**
- * In-memory generator output payload.
- */
-interface GeneratedArtifacts {
-    snapshot: IntrospectionSnapshot;
-    files: GeneratedArtifact[];
-}
-/**
- * Runtime options for executing the generator pipeline.
- */
-interface RunGeneratorOptions {
-    cwd?: string;
-    configPath?: string;
-    dryRun?: boolean;
-    provider?: SchemaIntrospectionProvider;
-}
-/**
- * Generator execution result including files written to disk.
- */
-interface RunGeneratorResult extends GeneratedArtifacts {
-    configPath: string;
-    writtenFiles: string[];
-}
-
 declare function normalizeGeneratorConfig(input: AthenaGeneratorConfig): NormalizedAthenaGeneratorConfig;
 /**
  * Typed identity helper for authoring generator configs.
@@ -724,9 +397,4 @@ declare function resolvePostgresColumnType(column: IntrospectionColumn): string;
  */
 declare function resolveGeneratorProvider(providerConfig: GeneratorProviderConfig, experimentalFlags: GeneratorExperimentalFlags): SchemaIntrospectionProvider;
 
-/**
- * End-to-end generator execution: load config, introspect, render, and optionally write files.
- */
-declare function runSchemaGenerator(options?: RunGeneratorOptions): Promise<RunGeneratorResult>;
-
-export { AthenaClient, AthenaConditionCastType, AthenaError, AthenaErrorCategory, AthenaErrorCode, type AthenaErrorInput, AthenaErrorKind, AthenaGatewayCallOptions, AthenaGatewayErrorDetails, type AthenaGeneratorConfig, type AthenaOperationContext, type AthenaResult, AthenaRpcCallOptions, type AthenaSdkClient, BackendConfig, BackendType, type DatabaseDef, type GeneratedArtifact, type GeneratedArtifacts, type GeneratorArtifactKind, type GeneratorExperimentalFlags, type GeneratorFeatureFlags, type GeneratorNamingConfig, type GeneratorOutputConfig, type GeneratorOutputTargets, type GeneratorProviderConfig, type InsertOf, type IntCoercionOptions, type IntrospectionColumn, type IntrospectionInspectOptions, type IntrospectionRelation, type IntrospectionSchema, type IntrospectionSnapshot, type IntrospectionTable, type IntrospectionTypeKind, type LoadGeneratorConfigOptions, type LoadedGeneratorConfig, type ModelAt, type ModelDef, type ModelMetadata, type ModelRelationKind, type ModelRelationMetadata, type NamingStyle, type NormalizedAthenaError, type NormalizedAthenaGeneratorConfig, type PostgresIntrospectionProviderOptions, type RegistryDef, type RequireAffectedOptions, type RetryBackoffStrategy, type RetryConfig, type RowOf, type RpcOrderOptions, type RpcQueryBuilder, type RunGeneratorOptions, type RunGeneratorResult, type SchemaDef, type SchemaIntrospectionProvider, type TableQueryBuilder, type TenantContext, type TenantContextValue, type TenantKeyMap, type TypedAthenaClient, type TypedClientOptions, type UnwrapOneOptions, type UnwrapOptions, type UpdateOf, assertInt, coerceInt, createClient, createPostgresIntrospectionProvider, createTypedClient, defineDatabase, defineGeneratorConfig, defineModel, defineRegistry, defineSchema, findGeneratorConfigPath, generateArtifactsFromSnapshot, identifier, isOk, loadGeneratorConfig, normalizeAthenaError, normalizeGeneratorConfig, requireAffected, requireSuccess, resolveGeneratorProvider, resolvePostgresColumnType, runSchemaGenerator, unwrap, unwrapOne, unwrapRows, withRetry };
+export { AthenaClient, AthenaConditionCastType, AthenaError, AthenaErrorCategory, AthenaErrorCode, type AthenaErrorInput, AthenaErrorKind, AthenaGatewayCallOptions, AthenaGatewayErrorDetails, AthenaGeneratorConfig, type AthenaOperationContext, type AthenaResult, AthenaRpcCallOptions, type AthenaSdkClient, BackendConfig, BackendType, DatabaseDef, GeneratedArtifacts, GeneratorExperimentalFlags, GeneratorProviderConfig, type IntCoercionOptions, IntrospectionColumn, IntrospectionSnapshot, LoadGeneratorConfigOptions, LoadedGeneratorConfig, ModelAt, ModelDef, ModelMetadata, type NormalizedAthenaError, NormalizedAthenaGeneratorConfig, type PostgresIntrospectionProviderOptions, RegistryDef, type RequireAffectedOptions, type RetryBackoffStrategy, type RetryConfig, RowOf, type RpcOrderOptions, type RpcQueryBuilder, SchemaDef, SchemaIntrospectionProvider, type TableQueryBuilder, TenantContext, TenantKeyMap, type TypedAthenaClient, type TypedClientOptions, type UnwrapOneOptions, type UnwrapOptions, assertInt, coerceInt, createClient, createPostgresIntrospectionProvider, createTypedClient, defineDatabase, defineGeneratorConfig, defineModel, defineRegistry, defineSchema, findGeneratorConfigPath, generateArtifactsFromSnapshot, identifier, isOk, loadGeneratorConfig, normalizeAthenaError, normalizeGeneratorConfig, requireAffected, requireSuccess, resolveGeneratorProvider, resolvePostgresColumnType, unwrap, unwrapOne, unwrapRows, withRetry };

package/dist/index.js

@@ -1966,6 +1966,58 @@ function toTypeKind(code) {
 function escapeSqlLiteral(value) {
   return value.replace(/'/g, "''");
 }
+function parsePostgresArrayLiteral(text) {
+  const body = text.slice(1, -1).trim();
+  if (!body) return [];
+  const values = [];
+  let current = "";
+  let inQuotes = false;
+  let escaped = false;
+  for (const char of body) {
+    if (escaped) {
+      current += char;
+      escaped = false;
+      continue;
+    }
+    if (char === "\\") {
+      escaped = true;
+      continue;
+    }
+    if (char === '"') {
+      inQuotes = !inQuotes;
+      continue;
+    }
+    if (char === "," && !inQuotes) {
+      values.push(current);
+      current = "";
+      continue;
+    }
+    current += char;
+  }
+  values.push(current);
+  return values.map((value) => value.trim()).filter((value) => value.length > 0);
+}
+function coerceStringArray(value) {
+  if (Array.isArray(value)) {
+    return value.map((item) => typeof item === "string" ? item : String(item)).map((item) => item.trim()).filter((item) => item.length > 0);
+  }
+  if (typeof value === "string") {
+    const trimmed = value.trim();
+    if (!trimmed) return [];
+    if (trimmed.startsWith("[") && trimmed.endsWith("]")) {
+      try {
+        const parsed = JSON.parse(trimmed);
+        return coerceStringArray(parsed);
+      } catch {
+      }
+    }
+    if (trimmed.startsWith("{") && trimmed.endsWith("}")) {
+      return parsePostgresArrayLiteral(trimmed);
+    }
+    return trimmed.split(",").map((item) => item.trim()).filter((item) => item.length > 0);
+  }
+  return [];
+}
 function buildSchemaArrayLiteral(schemas) {
   const normalized = schemas.length > 0 ? schemas : ["public"];
   const literals = normalized.map((schema) => `'${escapeSqlLiteral(schema)}'`).join(", ");
@@ -2005,8 +2057,10 @@ var PostgresCatalogSnapshotAssembler = class {
   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 primaryKeyColumns = coerceStringArray(row.columns);
+      row.columns = primaryKeyColumns;
+      table.primaryKey = primaryKeyColumns;
+      for (const columnName of primaryKeyColumns) {
         const column = table.columns[columnName];
         if (column) {
           column.isPrimaryKey = true;
@@ -2018,23 +2072,27 @@ var PostgresCatalogSnapshotAssembler = class {
     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 sourceColumns = coerceStringArray(row.source_columns);
+      const targetColumns = coerceStringArray(row.target_columns);
+      row.source_columns = sourceColumns;
+      row.target_columns = targetColumns;
       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,
+        sourceColumns,
         targetSchema: row.target_schema,
         targetModel: row.target_table,
-        targetColumns: row.target_columns
+        targetColumns
       });
       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,
+        sourceColumns: targetColumns,
         targetSchema: row.source_schema,
         targetModel: row.source_table,
-        targetColumns: row.source_columns
+        targetColumns: sourceColumns
       });
     }
   }
@@ -2207,10 +2265,10 @@ var DEFAULT_CONFIG_CANDIDATES = [
   ".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"
+  model: "athena/models/{model_kebab}.ts",
+  schema: "athena/schema.ts",
+  database: "athena/relations.ts",
+  registry: "athena/config.ts"
 };
 var DEFAULT_NAMING = {
   modelType: "pascal",
@@ -2238,6 +2296,13 @@ function normalizeOutputConfig(output) {
     }
   };
 }
+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,
@@ -2269,18 +2334,41 @@ function findGeneratorConfigPath(cwd = process.cwd()) {
   return void 0;
 }
 function extractConfigExport(module) {
-  if (module && typeof module === "object") {
-    const record = 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") {
-      return defaultExport;
+      queue.push(defaultExport);
     }
     const namedConfigExport = record.config;
     if (namedConfigExport && typeof namedConfigExport === "object") {
-      return namedConfigExport;
+      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`.");
+  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();
@@ -2291,7 +2379,7 @@ async function loadGeneratorConfig(options = {}) {
     );
   }
   const moduleUrl = pathToFileURL(resolvedPath);
-  const module = await import(`${moduleUrl.href}?cacheBust=${Date.now()}`);
+  const module = await importConfigModule(`${moduleUrl.href}?cacheBust=${Date.now()}`);
   const rawConfig = extractConfigExport(module);
   return {
     configPath: resolvedPath,