@xylex-group/athena 1.6.1 → 1.6.2

package/dist/cli/index.d.cts

@@ -1,6 +1,25 @@
+import { r as runSchemaGenerator } from '../pipeline-CA2aexDl.cjs';
+import '../types-v6UyGg-x.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 { r as runSchemaGenerator } from '../pipeline-BQzpSLD3.js';
+import '../types-v6UyGg-x.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

@@ -298,10 +298,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",
@@ -2057,6 +2057,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(", ");
@@ -2096,8 +2148,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 +2163,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
       });
     }
   }
@@ -2427,7 +2485,7 @@ async function runSchemaGenerator(options = {}) {
 }
 
 // src/cli/index.ts
-function usage() {
+function rootUsage() {
   return [
     "athena-js CLI",
     "",
@@ -2436,12 +2494,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 +2539,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 +2563,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