feat(msgpack): add Timestamp.fromNanos() method

- Implement fromNanos() to convert nanoseconds to Timestamp
- Add Payload.timestampFromNanos() convenience method
- Add comprehensive tests for edge cases and negative timestamps

Author: jinzhongjia

src/msgpack.zig

@@ -201,6 +201,19 @@ pub const Timestamp = struct {
         };
     }
 
+    /// Create timestamp from nanoseconds since Unix epoch
+    /// This is useful for converting from various time sources
+    /// Example: Timestamp.fromNanos(std.time.nanoTimestamp())
+    pub fn fromNanos(nanos: i128) Timestamp {
+        const ns_i64: i64 = @intCast(@divFloor(nanos, std.time.ns_per_s));
+        const nano_remainder: i64 = @intCast(@mod(nanos, std.time.ns_per_s));
+        const nanoseconds: u32 = @intCast(if (nano_remainder < 0) nano_remainder + std.time.ns_per_s else nano_remainder);
+        return Timestamp{
+            .seconds = if (nano_remainder < 0) ns_i64 - 1 else ns_i64,
+            .nanoseconds = nanoseconds,
+        };
+    }
+
     /// Get current timestamp (now)
     pub fn now() Timestamp {
         const ns = std.time.nanoTimestamp();
@@ -401,6 +414,13 @@ pub const Payload = union(enum) {
         };
     }
 
+    /// get a timestamp payload from nanoseconds since Unix epoch
+    pub inline fn timestampFromNanos(nanos: i128) Payload {
+        return Payload{
+            .timestamp = Timestamp.fromNanos(nanos),
+        };
+    }
+
     /// free all memory for this payload and sub payloads
     /// the allocator is payload's allocator
     /// This is an iterative implementation that avoids stack overflow from deep nesting

src/test.zig

@@ -2023,7 +2023,7 @@ test "timestamp now() function" {
 
     read_buffer = fixedBufferStream(&arr);
     p = pack.init(&write_buffer, &read_buffer);
-
+    
     const decoded = try p.read(allocator);
     defer decoded.free(allocator);
 
@@ -2044,6 +2044,64 @@ test "timestamp now() function" {
     try expect(float2 >= float1);
 }
 
+// Test timestamp fromNanos() function
+test "timestamp fromNanos() conversion" {
+    var arr: [0xfffff]u8 = std.mem.zeroes([0xfffff]u8);
+    var write_buffer = fixedBufferStream(&arr);
+    var read_buffer = fixedBufferStream(&arr);
+    var p = pack.init(&write_buffer, &read_buffer);
+
+    // Test with current time
+    const current_nanos = std.time.nanoTimestamp();
+    const ts = msgpack.Timestamp.fromNanos(current_nanos);
+    
+    // Verify seconds is reasonable (after 2020-01-01 and before 2100-01-01)
+    const year_2020: i64 = 1577836800;
+    const year_2100: i64 = 4102444800;
+    try expect(ts.seconds > year_2020);
+    try expect(ts.seconds < year_2100);
+    
+    // Verify nanoseconds is in valid range
+    try expect(ts.nanoseconds >= 0);
+    try expect(ts.nanoseconds <= 999_999_999);
+    
+    // Test with known values
+    const test_nanos: i128 = 1704067200_123456789; // 2024-01-01 00:00:00.123456789 UTC
+    const test_ts = msgpack.Timestamp.fromNanos(test_nanos);
+    try expect(test_ts.seconds == 1704067200);
+    try expect(test_ts.nanoseconds == 123456789);
+    
+    // Test with negative timestamp (before Unix epoch)
+    const negative_nanos: i128 = -1000000_500000000; // -1000000 seconds + 0.5 seconds
+    const negative_ts = msgpack.Timestamp.fromNanos(negative_nanos);
+    try expect(negative_ts.seconds == -1000001);
+    try expect(negative_ts.nanoseconds == 500000000);
+    
+    // Test Payload.timestampFromNanos() convenience method
+    const payload = msgpack.Payload.timestampFromNanos(current_nanos);
+    try expect(payload == .timestamp);
+    try expect(payload.timestamp.seconds == ts.seconds);
+    try expect(payload.timestamp.nanoseconds == ts.nanoseconds);
+    
+    // Test serialization and deserialization
+    try p.write(payload);
+    
+    read_buffer = fixedBufferStream(&arr);
+    p = pack.init(&write_buffer, &read_buffer);
+
+    const decoded = try p.read(allocator);
+    defer decoded.free(allocator);
+    
+    try expect(decoded == .timestamp);
+    try expect(decoded.timestamp.seconds == ts.seconds);
+    try expect(decoded.timestamp.nanoseconds == ts.nanoseconds);
+    
+    // Test that the toFloat() method works correctly
+    const float_original = ts.toFloat();
+    const float_decoded = decoded.timestamp.toFloat();
+    try expect(@abs(float_original - float_decoded) < 0.000000001);
+}
+
 // ============================================================================
 // Additional tests from test_additional.zig
 // ============================================================================