@xylex-group/athena 1.6.2 → 1.7.0

package/dist/cli/index.d.cts

@@ -1,5 +1,5 @@
-import { r as runSchemaGenerator } from '../pipeline-CA2aexDl.cjs';
-import '../types-v6UyGg-x.cjs';
+import { F as runSchemaGenerator } from '../pipeline-BsKuBqmE.cjs';
+import '../types-wPA1Z4vQ.cjs';
 
 interface GenerateCommand {
     command: 'generate';

package/dist/cli/index.d.ts

@@ -1,5 +1,5 @@
-import { r as runSchemaGenerator } from '../pipeline-BQzpSLD3.js';
-import '../types-v6UyGg-x.js';
+import { F as runSchemaGenerator } from '../pipeline-xQSjGbqF.js';
+import '../types-wPA1Z4vQ.js';
 
 interface GenerateCommand {
     command: 'generate';

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,8 +329,8 @@ var DEFAULT_CONFIG_CANDIDATES = [
   ".athena.config.js"
 ];
 var DEFAULT_TARGETS = {
-  model: "athena/models/{model_kebab}.ts",
-  schema: "athena/schema.ts",
+  model: "athena/models/{schema_kebab}/{model_kebab}.ts",
+  schema: "athena/schemas/{schema_kebab}.ts",
   database: "athena/relations.ts",
   registry: "athena/config.ts"
 };
@@ -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 {
@@ -2109,8 +2156,21 @@ function coerceStringArray(value) {
   }
   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}]`;
 }
@@ -2309,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
     });
@@ -2386,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([
@@ -2426,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) {
@@ -2448,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) {
@@ -2473,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);