@xylex-group/athena 1.6.1 → 1.7.0

package/dist/cli/index.d.cts

@@ -1,6 +1,25 @@
+import { F as runSchemaGenerator } from '../pipeline-BsKuBqmE.cjs';
+import '../types-wPA1Z4vQ.cjs';
+
+interface GenerateCommand {
+    command: 'generate';
+    configPath?: string;
+    dryRun: boolean;
+}
+interface HelpCommand {
+    command: 'help';
+    topic: 'root' | 'generate';
+}
+type CliCommand = GenerateCommand | HelpCommand;
+interface CliRuntime {
+    runGenerator?: typeof runSchemaGenerator;
+    log?: (message: string) => void;
+}
+declare function usage(topic?: HelpCommand['topic']): string;
+declare function parseCommand(argv: string[]): CliCommand;
 /**
  * CLI entrypoint used by `bin/athena-js.js`.
  */
-declare function runCLI(argv: string[]): Promise<void>;
+declare function runCLI(argv: string[], runtime?: CliRuntime): Promise<void>;
 
-export { runCLI };
+export { type CliRuntime, parseCommand, runCLI, usage };

package/dist/cli/index.d.ts

@@ -1,6 +1,25 @@
+import { F as runSchemaGenerator } from '../pipeline-xQSjGbqF.js';
+import '../types-wPA1Z4vQ.js';
+
+interface GenerateCommand {
+    command: 'generate';
+    configPath?: string;
+    dryRun: boolean;
+}
+interface HelpCommand {
+    command: 'help';
+    topic: 'root' | 'generate';
+}
+type CliCommand = GenerateCommand | HelpCommand;
+interface CliRuntime {
+    runGenerator?: typeof runSchemaGenerator;
+    log?: (message: string) => void;
+}
+declare function usage(topic?: HelpCommand['topic']): string;
+declare function parseCommand(argv: string[]): CliCommand;
 /**
  * CLI entrypoint used by `bin/athena-js.js`.
  */
-declare function runCLI(argv: string[]): Promise<void>;
+declare function runCLI(argv: string[], runtime?: CliRuntime): Promise<void>;
 
-export { runCLI };
+export { type CliRuntime, parseCommand, runCLI, usage };

package/dist/cli/index.js

@@ -289,6 +289,37 @@ function resolvePostgresColumnType(column) {
   }
   return wrapArrayType(baseType, column.arrayDimensions);
 }
+
+// src/generator/schema-selection.ts
+var DEFAULT_POSTGRES_SCHEMAS = ["public"];
+function collectSchemaNames(input) {
+  if (!input) {
+    return [];
+  }
+  const values = typeof input === "string" ? [input] : input;
+  return values.flatMap((value) => String(value).split(","));
+}
+function normalizeSchemaSelection(input) {
+  const schemas = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const value of collectSchemaNames(input)) {
+    const schema = value.trim();
+    if (!schema || seen.has(schema)) {
+      continue;
+    }
+    seen.add(schema);
+    schemas.push(schema);
+  }
+  return schemas.length > 0 ? schemas : [...DEFAULT_POSTGRES_SCHEMAS];
+}
+function resolveProviderSchemas(providerConfig) {
+  if (providerConfig.kind === "postgres") {
+    return normalizeSchemaSelection(providerConfig.schemas);
+  }
+  return [...DEFAULT_POSTGRES_SCHEMAS];
+}
+
+// src/generator/config.ts
 var DEFAULT_CONFIG_CANDIDATES = [
   "athena.config.ts",
   "athena.config.js",
@@ -298,10 +329,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/{schema_kebab}/{model_kebab}.ts",
+  schema: "athena/schemas/{schema_kebab}.ts",
+  database: "athena/relations.ts",
+  registry: "athena/config.ts"
 };
 var DEFAULT_NAMING = {
   modelType: "pascal",
@@ -329,6 +360,15 @@ function normalizeOutputConfig(output) {
     }
   };
 }
+function normalizeProviderConfig(provider) {
+  if (provider.kind === "postgres") {
+    return {
+      ...provider,
+      schemas: normalizeSchemaSelection(provider.schemas)
+    };
+  }
+  return provider;
+}
 function isAthenaGeneratorConfig(value) {
   if (!value || typeof value !== "object") {
     return false;
@@ -338,7 +378,7 @@ function isAthenaGeneratorConfig(value) {
 }
 function normalizeGeneratorConfig(input) {
   return {
-    provider: input.provider,
+    provider: normalizeProviderConfig(input.provider),
     output: normalizeOutputConfig(input.output),
     naming: {
       ...DEFAULT_NAMING,
@@ -548,12 +588,19 @@ export const ${registryConstName} = defineRegistry({
   };
 }
 function assertNoDuplicatePaths(files) {
-  const seen = /* @__PURE__ */ new Set();
+  const seen = /* @__PURE__ */ new Map();
   for (const file of files) {
-    if (seen.has(file.path)) {
-      throw new Error(`Generator output collision detected for path: ${file.path}`);
+    const existing = seen.get(file.path);
+    if (existing) {
+      throw new Error(
+        [
+          `Generator output collision detected for path: ${file.path}`,
+          `Collision: ${existing.kind} and ${file.kind}.`,
+          "When syncing multiple schemas, include a schema placeholder such as {schema} or {schema_kebab} in model/schema output targets."
+        ].join(" ")
+      );
     }
-    seen.add(file.path);
+    seen.set(file.path, file);
   }
 }
 var ArtifactComposer = class {
@@ -2057,8 +2104,73 @@ 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 normalizePostgresCatalogSchemas(schemas) {
+  const normalized = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const value of schemas ?? []) {
+    const schema = value.trim();
+    if (!schema || seen.has(schema)) {
+      continue;
+    }
+    seen.add(schema);
+    normalized.push(schema);
+  }
+  return normalized.length > 0 ? normalized : ["public"];
+}
 function buildSchemaArrayLiteral(schemas) {
-  const normalized = schemas.length > 0 ? schemas : ["public"];
+  const normalized = normalizePostgresCatalogSchemas(schemas);
   const literals = normalized.map((schema) => `'${escapeSqlLiteral(schema)}'`).join(", ");
   return `ARRAY[${literals}]`;
 }
@@ -2096,8 +2208,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;
@@ -2109,23 +2223,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
       });
     }
   }
@@ -2251,12 +2369,14 @@ var PostgresIntrospectionProvider = class {
   backend = "postgresql";
   connectionString;
   database;
+  schemas;
   constructor(options) {
     this.connectionString = options.connectionString;
     this.database = options.database ?? "postgres";
+    this.schemas = normalizePostgresCatalogSchemas(options.schemas);
   }
   async inspect(options) {
-    const schemas = options?.schemas && options.schemas.length > 0 ? options.schemas : ["public"];
+    const schemas = options?.schemas && options.schemas.length > 0 ? normalizePostgresCatalogSchemas(options.schemas) : this.schemas;
     const pool = new Pool({
       connectionString: this.connectionString
     });
@@ -2328,11 +2448,13 @@ var AthenaGatewayPostgresIntrospectionProvider = class {
         type: this.config.backend ?? "postgresql"
       }
     });
+    this.schemas = normalizeSchemaSelection(this.config.schemas);
   }
   backend = "postgresql";
   client;
+  schemas;
   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 schemas = options?.schemas && options.schemas.length > 0 ? normalizeSchemaSelection(options.schemas) : this.schemas;
     const catalogClient = new AthenaGatewayCatalogClient(this.client);
     const queries = buildGatewayCatalogQueries(schemas);
     const [columnRows, enumMap, primaryKeyRows, foreignKeyRows] = await Promise.all([
@@ -2368,7 +2490,8 @@ var ScyllaIntrospectionProvider = class {
 function createPostgresProvider(config) {
   return createPostgresIntrospectionProvider({
     connectionString: config.connectionString,
-    database: config.database
+    database: config.database,
+    schemas: normalizeSchemaSelection(config.schemas)
   });
 }
 function resolveGeneratorProvider(providerConfig, experimentalFlags) {
@@ -2390,12 +2513,6 @@ function resolveGeneratorProvider(providerConfig, experimentalFlags) {
 }
 
 // src/generator/pipeline.ts
-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) {
@@ -2415,7 +2532,7 @@ async function runSchemaGenerator(options = {}) {
   const { configPath, config } = await loadGeneratorConfig(configOptions);
   const provider = options.provider ?? resolveGeneratorProvider(config.provider, config.experimental);
   const snapshot = await provider.inspect({
-    schemas: extractProviderSchemas(config.provider)
+    schemas: resolveProviderSchemas(config.provider)
   });
   const generated = generateArtifactsFromSnapshot(snapshot, config);
   const writtenFiles = options.dryRun ? [] : await writeArtifacts(generated.files, cwd);
@@ -2427,7 +2544,7 @@ async function runSchemaGenerator(options = {}) {
 }
 
 // src/cli/index.ts
-function usage() {
+function rootUsage() {
   return [
     "athena-js CLI",
     "",
@@ -2436,12 +2553,42 @@ function usage() {
     "",
     "Examples:",
     "  athena-js generate",
+    "  athena-js generate --config ./athena.config.ts --dry-run",
+    "  athena-js generate --help"
+  ].join("\n");
+}
+function generateUsage() {
+  return [
+    "athena-js generate",
+    "",
+    "Usage:",
+    "  athena-js generate [--config <path>] [--dry-run]",
+    "",
+    "Options:",
+    "  --config <path>  Explicit path to athena.config.ts or athena-js.config.ts",
+    "  --dry-run        Build generated files in memory without writing them to disk",
+    "  -h, --help       Show help for generate",
+    "",
+    "Examples:",
+    "  athena-js generate",
     "  athena-js generate --config ./athena.config.ts --dry-run"
   ].join("\n");
 }
+function usage(topic = "root") {
+  return topic === "generate" ? generateUsage() : rootUsage();
+}
 function parseCommand(argv) {
-  if (argv.length === 0 || argv[0] === "help" || argv[0] === "--help" || argv[0] === "-h") {
-    return { command: "help" };
+  if (argv.length === 0 || argv[0] === "--help" || argv[0] === "-h") {
+    return { command: "help", topic: "root" };
+  }
+  if (argv[0] === "help") {
+    if (argv.length === 1) {
+      return { command: "help", topic: "root" };
+    }
+    if (argv[1] === "generate") {
+      return { command: "help", topic: "generate" };
+    }
+    throw new Error(`Unknown command "${argv[1]}".`);
   }
   const [command, ...rest] = argv;
   if (command !== "generate") {
@@ -2451,13 +2598,16 @@ function parseCommand(argv) {
   let dryRun = false;
   for (let index = 0; index < rest.length; index += 1) {
     const token = rest[index];
+    if (token === "--help" || token === "-h") {
+      return { command: "help", topic: "generate" };
+    }
     if (token === "--dry-run") {
       dryRun = true;
       continue;
     }
     if (token === "--config") {
       const nextValue = rest[index + 1];
-      if (!nextValue) {
+      if (!nextValue || nextValue.startsWith("-")) {
         throw new Error("Missing value for --config option.");
       }
       configPath = nextValue;
@@ -2472,29 +2622,70 @@ function parseCommand(argv) {
     dryRun
   };
 }
-async function runCLI(argv) {
+function normalizeErrorMessage(error) {
+  if (error instanceof Error) {
+    return error.message;
+  }
+  if (typeof error === "string") {
+    return error;
+  }
+  return "Unknown generator error.";
+}
+function extractMissingDatabaseName(message) {
+  const match = message.match(/database "([^"]+)" does not exist/i);
+  return match?.[1];
+}
+function isErrorWithCode(error) {
+  return typeof error === "object" && error !== null && "code" in error;
+}
+function formatGeneratorError(error, configPath) {
+  if (isErrorWithCode(error) && error.code === "3D000") {
+    const message = normalizeErrorMessage(error);
+    const databaseName = extractMissingDatabaseName(message);
+    const databaseLabel = databaseName ? `PostgreSQL database "${databaseName}" does not exist` : "The target PostgreSQL database does not exist";
+    const configLabel = configPath ? `config "${configPath}"` : "the resolved athena config";
+    return new Error(
+      [
+        `${databaseLabel} (code 3D000).`,
+        `Update provider.connectionString (and provider.database, if set) in ${configLabel}, or create that database before running generate.`
+      ].join("\n")
+    );
+  }
+  if (error instanceof Error) {
+    return error;
+  }
+  return new Error(normalizeErrorMessage(error));
+}
+async function runCLI(argv, runtime = {}) {
+  const log = runtime.log ?? console.log;
+  const runGenerator = runtime.runGenerator ?? runSchemaGenerator;
   const parsed = parseCommand(argv);
   if (parsed.command === "help") {
-    console.log(usage());
+    log(usage(parsed.topic));
     return;
   }
-  const result = await runSchemaGenerator({
-    configPath: parsed.configPath,
-    dryRun: parsed.dryRun
-  });
+  let result;
+  try {
+    result = await runGenerator({
+      configPath: parsed.configPath,
+      dryRun: parsed.dryRun
+    });
+  } catch (error) {
+    throw formatGeneratorError(error, parsed.configPath);
+  }
   if (parsed.dryRun) {
-    console.log(`[dry-run] Generated ${result.files.length} files from ${result.configPath}`);
+    log(`[dry-run] Generated ${result.files.length} files from ${result.configPath}`);
     for (const file of result.files) {
-      console.log(` - ${file.path}`);
+      log(` - ${file.path}`);
     }
     return;
   }
-  console.log(`Generated ${result.writtenFiles.length} files from ${result.configPath}`);
+  log(`Generated ${result.writtenFiles.length} files from ${result.configPath}`);
   for (const filePath of result.writtenFiles) {
-    console.log(` - ${filePath}`);
+    log(` - ${filePath}`);
   }
 }
 
-export { runCLI };
+export { parseCommand, runCLI, usage };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map