@fragno-dev/db 0.1.11 → 0.1.13

package/src/schema/serialize.test.ts

@@ -342,6 +342,229 @@ describe("serialize", () => {
         const time = Date.now();
         expect(deserialize(time, dateCol, "sqlite")).toEqual(new Date(time));
       });
+
+      it("should handle ISO string timestamps with positive timezone offset", () => {
+        const timestampCol = column("timestamp");
+        const time = "2024-06-15T14:30:00+05:30"; // India Standard Time
+        const result = deserialize(time, timestampCol, "sqlite");
+        expect(result).toBeInstanceOf(Date);
+        expect(result.toISOString()).toBe("2024-06-15T09:00:00.000Z");
+      });
+
+      it("should handle ISO string timestamps with negative timezone offset", () => {
+        const timestampCol = column("timestamp");
+        const time = "2024-06-15T14:30:00-08:00"; // Pacific Time
+        const result = deserialize(time, timestampCol, "sqlite");
+        expect(result).toBeInstanceOf(Date);
+        expect(result.toISOString()).toBe("2024-06-15T22:30:00.000Z");
+      });
+
+      it("should preserve absolute time when deserializing numeric timestamps", () => {
+        const timestampCol = column("timestamp");
+        // Create a specific date and get its numeric representation
+        const specificDate = new Date("2024-06-15T12:00:00Z");
+        const numericTimestamp = specificDate.getTime();
+
+        const result = deserialize(numericTimestamp, timestampCol, "sqlite");
+        expect(result).toBeInstanceOf(Date);
+        expect(result.getTime()).toBe(numericTimestamp);
+        expect(result.toISOString()).toBe("2024-06-15T12:00:00.000Z");
+      });
+
+      it("should handle round-trip serialization/deserialization with timezones", () => {
+        const timestampCol = column("timestamp");
+        // Start with a date with timezone info
+        const originalTime = "2024-06-15T14:30:00+02:00";
+        const deserialized = deserialize(originalTime, timestampCol, "sqlite");
+
+        // SQLite would store this as a number
+        const numericValue = deserialized.getTime();
+
+        // Deserialize the numeric value back
+        const roundTrip = deserialize(numericValue, timestampCol, "sqlite");
+
+        expect(roundTrip).toBeInstanceOf(Date);
+        expect(roundTrip.getTime()).toBe(deserialized.getTime());
+        expect(roundTrip.toISOString()).toBe(deserialized.toISOString());
+      });
+    });
+
+    describe("postgresql date handling", () => {
+      it("should convert string timestamps to Date", () => {
+        const timestampCol = column("timestamp");
+        const time = "2024-01-01 12:30:45.123";
+        expect(deserialize(time, timestampCol, "postgresql")).toEqual(new Date(time));
+      });
+
+      it("should convert ISO string timestamps to Date", () => {
+        const timestampCol = column("timestamp");
+        const time = "2024-01-01T00:00:00.000Z";
+        expect(deserialize(time, timestampCol, "postgresql")).toEqual(new Date(time));
+      });
+
+      it("should convert date strings to Date", () => {
+        const dateCol = column("date");
+        const time = "2024-01-01";
+        expect(deserialize(time, dateCol, "postgresql")).toEqual(new Date(time));
+      });
+
+      it("should handle timestamps with positive timezone offset", () => {
+        const timestampCol = column("timestamp");
+        const time = "2024-06-15T14:30:00+05:30"; // India Standard Time
+        const result = deserialize(time, timestampCol, "postgresql");
+        expect(result).toBeInstanceOf(Date);
+        expect(result.toISOString()).toBe("2024-06-15T09:00:00.000Z");
+      });
+
+      it("should handle timestamps with negative timezone offset", () => {
+        const timestampCol = column("timestamp");
+        const time = "2024-06-15T14:30:00-08:00"; // Pacific Time
+        const result = deserialize(time, timestampCol, "postgresql");
+        expect(result).toBeInstanceOf(Date);
+        expect(result.toISOString()).toBe("2024-06-15T22:30:00.000Z");
+      });
+
+      it("should handle timestamps with fractional seconds and timezone", () => {
+        const timestampCol = column("timestamp");
+        const time = "2024-06-15T14:30:45.123+01:00"; // Central European Time
+        const result = deserialize(time, timestampCol, "postgresql");
+        expect(result).toBeInstanceOf(Date);
+        expect(result.toISOString()).toBe("2024-06-15T13:30:45.123Z");
+        expect(result.getTime()).toBe(new Date("2024-06-15T13:30:45.123Z").getTime());
+      });
+
+      it("should preserve absolute time across timezone conversions", () => {
+        const timestampCol = column("timestamp");
+        // Same absolute time in different timezones
+        const utcTime = "2024-06-15T12:00:00Z";
+        const estTime = "2024-06-15T08:00:00-04:00";
+        const jstTime = "2024-06-15T21:00:00+09:00";
+
+        const utcResult = deserialize(utcTime, timestampCol, "postgresql");
+        const estResult = deserialize(estTime, timestampCol, "postgresql");
+        const jstResult = deserialize(jstTime, timestampCol, "postgresql");
+
+        // All should represent the same absolute time
+        expect(utcResult.getTime()).toBe(estResult.getTime());
+        expect(utcResult.getTime()).toBe(jstResult.getTime());
+        expect(estResult.getTime()).toBe(jstResult.getTime());
+      });
+    });
+
+    describe("mysql date handling", () => {
+      it("should convert string timestamps to Date", () => {
+        const timestampCol = column("timestamp");
+        const time = "2024-01-01 12:30:45";
+        expect(deserialize(time, timestampCol, "mysql")).toEqual(new Date(time));
+      });
+
+      it("should convert ISO string timestamps to Date", () => {
+        const timestampCol = column("timestamp");
+        const time = "2024-01-01T00:00:00.000Z";
+        expect(deserialize(time, timestampCol, "mysql")).toEqual(new Date(time));
+      });
+
+      it("should convert date strings to Date", () => {
+        const dateCol = column("date");
+        const time = "2024-01-01";
+        expect(deserialize(time, dateCol, "mysql")).toEqual(new Date(time));
+      });
+
+      it("should handle timestamps with positive timezone offset", () => {
+        const timestampCol = column("timestamp");
+        const time = "2024-06-15T14:30:00+05:30"; // India Standard Time
+        const result = deserialize(time, timestampCol, "mysql");
+        expect(result).toBeInstanceOf(Date);
+        expect(result.toISOString()).toBe("2024-06-15T09:00:00.000Z");
+      });
+
+      it("should handle timestamps with negative timezone offset", () => {
+        const timestampCol = column("timestamp");
+        const time = "2024-06-15T14:30:00-08:00"; // Pacific Time
+        const result = deserialize(time, timestampCol, "mysql");
+        expect(result).toBeInstanceOf(Date);
+        expect(result.toISOString()).toBe("2024-06-15T22:30:00.000Z");
+      });
+
+      it("should handle timestamps with fractional seconds and timezone", () => {
+        const timestampCol = column("timestamp");
+        const time = "2024-06-15T14:30:45.123+01:00"; // Central European Time
+        const result = deserialize(time, timestampCol, "mysql");
+        expect(result).toBeInstanceOf(Date);
+        expect(result.toISOString()).toBe("2024-06-15T13:30:45.123Z");
+      });
+
+      it("should preserve absolute time across timezone conversions", () => {
+        const timestampCol = column("timestamp");
+        // Same absolute time in different timezones
+        const utcTime = "2024-06-15T12:00:00Z";
+        const cstTime = "2024-06-15T20:00:00+08:00"; // China Standard Time
+        const pstTime = "2024-06-15T04:00:00-08:00"; // Pacific Time
+
+        const utcResult = deserialize(utcTime, timestampCol, "mysql");
+        const cstResult = deserialize(cstTime, timestampCol, "mysql");
+        const pstResult = deserialize(pstTime, timestampCol, "mysql");
+
+        // All should represent the same absolute time
+        expect(utcResult.getTime()).toBe(cstResult.getTime());
+        expect(utcResult.getTime()).toBe(pstResult.getTime());
+        expect(cstResult.getTime()).toBe(pstResult.getTime());
+      });
+    });
+
+    describe("cockroachdb date handling", () => {
+      it("should convert string timestamps to Date", () => {
+        const timestampCol = column("timestamp");
+        const time = "2024-01-01 12:30:45.123";
+        expect(deserialize(time, timestampCol, "cockroachdb")).toEqual(new Date(time));
+      });
+
+      it("should convert date strings to Date", () => {
+        const dateCol = column("date");
+        const time = "2024-01-01";
+        expect(deserialize(time, dateCol, "cockroachdb")).toEqual(new Date(time));
+      });
+
+      it("should handle timestamps with positive timezone offset", () => {
+        const timestampCol = column("timestamp");
+        const time = "2024-06-15T14:30:00+05:30"; // India Standard Time
+        const result = deserialize(time, timestampCol, "cockroachdb");
+        expect(result).toBeInstanceOf(Date);
+        expect(result.toISOString()).toBe("2024-06-15T09:00:00.000Z");
+      });
+
+      it("should handle timestamps with negative timezone offset", () => {
+        const timestampCol = column("timestamp");
+        const time = "2024-06-15T14:30:00-08:00"; // Pacific Time
+        const result = deserialize(time, timestampCol, "cockroachdb");
+        expect(result).toBeInstanceOf(Date);
+        expect(result.toISOString()).toBe("2024-06-15T22:30:00.000Z");
+      });
+
+      it("should handle timestamps with fractional seconds and timezone", () => {
+        const timestampCol = column("timestamp");
+        const time = "2024-06-15T14:30:45.123+01:00"; // Central European Time
+        const result = deserialize(time, timestampCol, "cockroachdb");
+        expect(result).toBeInstanceOf(Date);
+        expect(result.toISOString()).toBe("2024-06-15T13:30:45.123Z");
+      });
+
+      it("should preserve absolute time across timezone conversions", () => {
+        const timestampCol = column("timestamp");
+        // Same absolute time in different timezones
+        const utcTime = "2024-06-15T12:00:00Z";
+        const aestTime = "2024-06-15T22:00:00+10:00"; // Australian Eastern Standard Time
+        const brtTime = "2024-06-15T09:00:00-03:00"; // Brasilia Time
+
+        const utcResult = deserialize(utcTime, timestampCol, "cockroachdb");
+        const aestResult = deserialize(aestTime, timestampCol, "cockroachdb");
+        const brtResult = deserialize(brtTime, timestampCol, "cockroachdb");
+
+        // All should represent the same absolute time
+        expect(utcResult.getTime()).toBe(aestResult.getTime());
+        expect(utcResult.getTime()).toBe(brtResult.getTime());
+        expect(aestResult.getTime()).toBe(brtResult.getTime());
+      });
     });
 
     describe("boolean handling", () => {

package/src/schema/serialize.ts

@@ -300,6 +300,22 @@ export function deserialize(value: unknown, col: AnyColumn, provider: SQLProvide
     return new Date(value);
   }
 
+  if (
+    (provider === "postgresql" || provider === "cockroachdb") &&
+    (col.type === "timestamp" || col.type === "date") &&
+    typeof value === "string"
+  ) {
+    return new Date(value);
+  }
+
+  if (
+    provider === "mysql" &&
+    (col.type === "timestamp" || col.type === "date") &&
+    typeof value === "string"
+  ) {
+    return new Date(value);
+  }
+
   if (col.type === "bool" && typeof value === "number") {
     return value === 1;
   }