@xylex-group/athena 1.6.1 → 1.6.2

package/dist/errors-1b-LSTum.d.ts

@@ -0,0 +1,31 @@
+import { m as AthenaGatewayErrorCode, u as AthenaGatewayEndpointPath, v as AthenaGatewayMethod, e as AthenaGatewayErrorDetails, t as AthenaGatewayResponse } from './types-v6UyGg-x.js';
+
+interface AthenaGatewayErrorInput {
+    code: AthenaGatewayErrorCode;
+    message: string;
+    status?: number;
+    endpoint?: AthenaGatewayEndpointPath;
+    method?: AthenaGatewayMethod;
+    requestId?: string;
+    hint?: string;
+    cause?: string;
+}
+/**
+ * Canonical error for gateway failures.
+ * Holds request context and machine-readable classification.
+ */
+declare class AthenaGatewayError extends Error {
+    readonly code: AthenaGatewayErrorCode;
+    readonly status: number;
+    readonly endpoint?: AthenaGatewayEndpointPath;
+    readonly method?: AthenaGatewayMethod;
+    readonly requestId?: string;
+    readonly hint?: string;
+    readonly causeDetail?: string;
+    constructor(input: AthenaGatewayErrorInput);
+    toDetails(): AthenaGatewayErrorDetails;
+    static fromResponse<T>(response: AthenaGatewayResponse<T>, fallback: Omit<AthenaGatewayErrorInput, 'code' | 'message' | 'status'>): AthenaGatewayError;
+}
+declare function isAthenaGatewayError(error: unknown): error is AthenaGatewayError;
+
+export { AthenaGatewayError as A, isAthenaGatewayError as i };

package/dist/errors-BYRK5phv.d.cts

@@ -0,0 +1,31 @@
+import { m as AthenaGatewayErrorCode, u as AthenaGatewayEndpointPath, v as AthenaGatewayMethod, e as AthenaGatewayErrorDetails, t as AthenaGatewayResponse } from './types-v6UyGg-x.cjs';
+
+interface AthenaGatewayErrorInput {
+    code: AthenaGatewayErrorCode;
+    message: string;
+    status?: number;
+    endpoint?: AthenaGatewayEndpointPath;
+    method?: AthenaGatewayMethod;
+    requestId?: string;
+    hint?: string;
+    cause?: string;
+}
+/**
+ * Canonical error for gateway failures.
+ * Holds request context and machine-readable classification.
+ */
+declare class AthenaGatewayError extends Error {
+    readonly code: AthenaGatewayErrorCode;
+    readonly status: number;
+    readonly endpoint?: AthenaGatewayEndpointPath;
+    readonly method?: AthenaGatewayMethod;
+    readonly requestId?: string;
+    readonly hint?: string;
+    readonly causeDetail?: string;
+    constructor(input: AthenaGatewayErrorInput);
+    toDetails(): AthenaGatewayErrorDetails;
+    static fromResponse<T>(response: AthenaGatewayResponse<T>, fallback: Omit<AthenaGatewayErrorInput, 'code' | 'message' | 'status'>): AthenaGatewayError;
+}
+declare function isAthenaGatewayError(error: unknown): error is AthenaGatewayError;
+
+export { AthenaGatewayError as A, isAthenaGatewayError as i };

package/dist/index.cjs

@@ -1968,6 +1968,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(", ");
@@ -2007,8 +2059,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;
@@ -2020,23 +2074,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
       });
     }
   }
@@ -2209,10 +2267,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",