@arcote.tech/arc-adapter-db-postgres 0.3.0 → 0.3.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arcote.tech/arc-adapter-db-postgres",
-  "version": "0.3.0",
+  "version": "0.3.2",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -20,10 +20,9 @@
     "postgres": "^3.4.4"
   },
   "peerDependencies": {
-    "@arcote.tech/arc": "workspace:*"
+    "@arcote.tech/arc": "^0.3.0"
   },
   "devDependencies": {
-    "@arcote.tech/arc": "workspace:*",
     "@types/pg": "^8.11.0",
     "typescript": "^5.0.0"
   }

package/src/postgres-adapter.ts

@@ -67,8 +67,24 @@ class PostgreSQLReadTransaction implements ReadTransaction {
           }
         }
         return value;
+      case "date":
       case "datetime":
       case "timestamp":
+        // PostgreSQL returns Date objects directly via postgres.js driver
+        if (value instanceof Date) {
+          return value;
+        }
+        if (typeof value === "string") {
+          // If the string doesn't have timezone info, treat as UTC
+          if (
+            !value.endsWith("Z") &&
+            !value.includes("+") &&
+            !value.includes("-", 10)
+          ) {
+            return new Date(value + "Z");
+          }
+          return new Date(value);
+        }
         return new Date(value);
       default:
         return value;
@@ -99,6 +115,21 @@ class PostgreSQLReadTransaction implements ReadTransaction {
     const params: any[] = [];
     let paramIndex = 1;
 
+    // Debug logging
+    if (where && (Array.isArray(where) || typeof where !== "object")) {
+      console.error(
+        "[buildWhereClause] Invalid where clause type:",
+        typeof where,
+        Array.isArray(where) ? "(array)" : "",
+      );
+      console.error(
+        "[buildWhereClause] where value:",
+        JSON.stringify(where, null, 2),
+      );
+      console.error("[buildWhereClause] tableName:", tableName);
+      console.trace("[buildWhereClause] Stack trace:");
+    }
+
     // Only add deleted condition if table has soft delete enabled
     if (tableName && this.hasSoftDelete(tableName)) {
       conditions.push('"deleted" = $1');
@@ -160,7 +191,7 @@ class PostgreSQLReadTransaction implements ReadTransaction {
     });
 
     return {
-      sql: conditions.join(" AND "),
+      sql: conditions.length > 0 ? conditions.join(" AND ") : "1=1",
       params,
     };
   }
@@ -258,12 +289,30 @@ class PostgreSQLReadWriteTransaction
 
     const hasVersioning = this.adapter.hasVersioning(store);
 
-    if (hasVersioning) {
-      // For versioned tables, use a transaction with version increment
-      await this.setWithVersioning(store, item, table);
-    } else {
-      // For non-versioned tables, use simple insert
-      await this.setWithoutVersioning(store, item, table);
+    try {
+      if (hasVersioning) {
+        // For versioned tables, use a transaction with version increment
+        await this.setWithVersioning(store, item, table);
+      } else {
+        // For non-versioned tables, use simple insert
+        await this.setWithoutVersioning(store, item, table);
+      }
+    } catch (error) {
+      console.error(`[PostgreSQL] Error in set() for store "${store}":`);
+      console.error(
+        `[PostgreSQL] Item data:`,
+        JSON.stringify(
+          item,
+          (key, value) => {
+            if (value instanceof Date) {
+              return `[Date: ${value.toString()} | ISO: ${isNaN(value.getTime()) ? "Invalid Date" : value.toISOString()}]`;
+            }
+            return value;
+          },
+          2,
+        ),
+      );
+      throw error;
     }
   }
 
@@ -381,13 +430,31 @@ class PostgreSQLReadWriteTransaction
     switch (column.type.toLowerCase()) {
       case "timestamp":
       case "datetime":
+      case "timestamptz":
         // Handle various timestamp formats
         if (value instanceof Date) {
+          if (isNaN(value.getTime())) {
+            console.error(
+              `[PostgreSQL] Invalid Date in column "${column.name}":`,
+              value,
+            );
+            console.error(`[PostgreSQL] Column type: ${column.type}`);
+            throw new Error(`Invalid Date value in column "${column.name}"`);
+          }
           return value.toISOString();
         }
         if (typeof value === "number") {
           // Unix timestamp (seconds or milliseconds)
           const date = value > 1e10 ? new Date(value) : new Date(value * 1000);
+          if (isNaN(date.getTime())) {
+            console.error(
+              `[PostgreSQL] Invalid Date from number in column "${column.name}":`,
+              value,
+            );
+            throw new Error(
+              `Invalid Date value (from number) in column "${column.name}"`,
+            );
+          }
           return date.toISOString();
         }
         if (typeof value === "string") {
@@ -396,13 +463,34 @@ class PostgreSQLReadWriteTransaction
           if (!isNaN(date.getTime())) {
             return date.toISOString();
           }
+          console.error(
+            `[PostgreSQL] Invalid Date string in column "${column.name}":`,
+            value,
+          );
+          throw new Error(
+            `Invalid Date string in column "${column.name}": "${value}"`,
+          );
         }
-        return value; // Pass through if we can't convert
+        console.error(
+          `[PostgreSQL] Unexpected date value type in column "${column.name}":`,
+          typeof value,
+          value,
+        );
+        throw new Error(
+          `Unexpected date value type in column "${column.name}": ${typeof value}`,
+        );
       case "json":
       case "jsonb":
         return JSON.stringify(value);
       default:
         if (value instanceof Date) {
+          if (isNaN(value.getTime())) {
+            console.error(
+              `[PostgreSQL] Invalid Date in column "${column.name}" (default case):`,
+              value,
+            );
+            throw new Error(`Invalid Date value in column "${column.name}"`);
+          }
           return value.toISOString();
         }
         if (Array.isArray(value) || typeof value === "object") {
@@ -440,7 +528,7 @@ export class PostgreSQLAdapter implements DatabaseAdapter {
       case "boolean":
         return "BOOLEAN";
       case "date":
-        return "TIMESTAMP";
+        return "TIMESTAMPTZ";
       case "object":
       case "array":
       case "record":
@@ -452,7 +540,10 @@ export class PostgreSQLAdapter implements DatabaseAdapter {
     }
   }
 
-  private buildConstraints(storeData?: DatabaseStoreData): string[] {
+  private buildConstraints(
+    storeData?: DatabaseStoreData,
+    skipForeignKey = false,
+  ): string[] {
     const constraints: string[] = [];
 
     if (storeData?.isPrimaryKey) {
@@ -461,13 +552,8 @@ export class PostgreSQLAdapter implements DatabaseAdapter {
     if (storeData?.isUnique) {
       constraints.push("UNIQUE");
     }
-    if (storeData?.foreignKey) {
-      const { table, column, onDelete, onUpdate } = storeData.foreignKey;
-      let fkConstraint = `REFERENCES ${table}(${column})`;
-      if (onDelete) fkConstraint += ` ON DELETE ${onDelete}`;
-      if (onUpdate) fkConstraint += ` ON UPDATE ${onUpdate}`;
-      constraints.push(fkConstraint);
-    }
+    // Foreign keys are now added separately after all tables are created
+    // to avoid dependency ordering issues
 
     return constraints;
   }
@@ -500,7 +586,7 @@ export class PostgreSQLAdapter implements DatabaseAdapter {
   private generateCreateTableSQL(
     tableName: string,
     columns: (DatabaseAgnosticColumnInfo & { name: string })[],
-  ): string {
+  ): { createTableSql: string; foreignKeySql: string[] } {
     const columnDefinitions = columns.map((col) => this.generateColumnSQL(col));
     const indexes = columns
       .filter((col) => col.storeData?.hasIndex && !col.storeData?.isPrimaryKey)
@@ -509,13 +595,25 @@ export class PostgreSQLAdapter implements DatabaseAdapter {
           `CREATE INDEX IF NOT EXISTS idx_${tableName}_${col.name} ON "${tableName}"("${col.name}");`,
       );
 
+    // Collect foreign key constraints to add after table creation
+    const foreignKeySql: string[] = [];
+    for (const col of columns) {
+      if (col.storeData?.foreignKey) {
+        const { table, column, onDelete, onUpdate } = col.storeData.foreignKey;
+        let fkSql = `ALTER TABLE "${tableName}" ADD CONSTRAINT fk_${tableName}_${col.name} FOREIGN KEY ("${col.name}") REFERENCES "${table}"("${column}")`;
+        if (onDelete) fkSql += ` ON DELETE ${onDelete}`;
+        if (onUpdate) fkSql += ` ON UPDATE ${onUpdate}`;
+        foreignKeySql.push(fkSql);
+      }
+    }
+
     let sql = `CREATE TABLE IF NOT EXISTS "${tableName}" (\n  ${columnDefinitions.join(",\n  ")}\n)`;
 
     if (indexes.length > 0) {
       sql += ";\n" + indexes.join("\n");
     }
 
-    return sql;
+    return { createTableSql: sql, foreignKeySql };
   }
 
   constructor(
@@ -570,6 +668,8 @@ export class PostgreSQLAdapter implements DatabaseAdapter {
     });
   }
 
+  private pendingForeignKeys: string[] = [];
+
   public async initialize() {
     // Create the version counter table first
     await this.createVersionCounterTable();
@@ -579,6 +679,9 @@ export class PostgreSQLAdapter implements DatabaseAdapter {
     const processedSchemas = new Set<DatabaseStoreSchema>();
     const processedTables = new Set<string>();
 
+    // Clear pending foreign keys
+    this.pendingForeignKeys = [];
+
     for (const element of this.context.elements) {
       if (
         "databaseStoreSchema" in element &&
@@ -687,14 +790,34 @@ export class PostgreSQLAdapter implements DatabaseAdapter {
         }
       }
     }
+
+    // Apply all foreign key constraints after all tables are created
+    for (const fkSql of this.pendingForeignKeys) {
+      try {
+        await this.db.exec(fkSql);
+      } catch (error: any) {
+        // Ignore if constraint already exists
+        if (!error.message?.includes("already exists")) {
+          console.warn(
+            `Failed to add foreign key constraint: ${error.message}`,
+          );
+        }
+      }
+    }
+    this.pendingForeignKeys = [];
   }
 
   private async createTableIfNotExistsNew(
     tableName: string,
     columns: (DatabaseAgnosticColumnInfo & { name: string })[],
   ) {
-    const createTableSQL = this.generateCreateTableSQL(tableName, columns);
-    await this.db.exec(createTableSQL);
+    const { createTableSql, foreignKeySql } = this.generateCreateTableSQL(
+      tableName,
+      columns,
+    );
+    await this.db.exec(createTableSql);
+    // Collect foreign keys to be added after all tables are created
+    this.pendingForeignKeys.push(...foreignKeySql);
   }
 
   /**
@@ -834,6 +957,8 @@ class PostgresJsDatabase implements PostgreSQLDatabase {
       return Array.from(result);
     } catch (error) {
       console.error("PostgreSQL error:", error);
+      console.error("Failed SQL:", sql);
+      console.error("Failed params:", JSON.stringify(params, null, 2));
       throw error;
     }
   }