Split DevServer.zig into multiple files (#21299)

Co-authored-by: autofix-ci[bot] <114827586+autofix-ci[bot]@users.noreply.github.com>

src/bake/DevServer/SerializedFailure.zig

@@ -0,0 +1,239 @@
+/// Errors sent to the HMR client in the browser are serialized. The same format
+/// is used for thrown JavaScript exceptions as well as bundler errors.
+/// Serialized failures contain a handle on what file or route they came from,
+/// which allows the bundler to dismiss or update stale failures via index as
+/// opposed to re-sending a new payload. This also means only changed files are
+/// rebuilt, instead of all of the failed files.
+///
+/// The HMR client in the browser is expected to sort the final list of errors
+/// for deterministic output; there is code in DevServer that uses `swapRemove`.
+pub const SerializedFailure = @This();
+
+/// Serialized data is always owned by dev.allocator
+/// The first 32 bits of this slice contain the owner
+data: []u8,
+
+pub fn deinit(f: SerializedFailure, dev: *DevServer) void {
+    dev.allocator.free(f.data);
+}
+
+/// The metaphorical owner of an incremental file error. The packed variant
+/// is given to the HMR runtime as an opaque handle.
+pub const Owner = union(enum) {
+    none,
+    route: RouteBundle.Index,
+    client: IncrementalGraph(.client).FileIndex,
+    server: IncrementalGraph(.server).FileIndex,
+
+    pub fn encode(owner: Owner) Packed {
+        return switch (owner) {
+            .none => .{ .kind = .none, .data = 0 },
+            .client => |data| .{ .kind = .client, .data = data.get() },
+            .server => |data| .{ .kind = .server, .data = data.get() },
+            .route => |data| .{ .kind = .route, .data = data.get() },
+        };
+    }
+
+    pub const Packed = packed struct(u32) {
+        data: u30,
+        kind: enum(u2) { none, route, client, server },
+
+        pub fn decode(owner: Packed) Owner {
+            return switch (owner.kind) {
+                .none => .none,
+                .client => .{ .client = IncrementalGraph(.client).FileIndex.init(owner.data) },
+                .server => .{ .server = IncrementalGraph(.server).FileIndex.init(owner.data) },
+                .route => .{ .route = RouteBundle.Index.init(owner.data) },
+            };
+        }
+
+        comptime {
+            assert(@as(u32, @bitCast(Packed{ .kind = .none, .data = 1 })) == 1);
+        }
+    };
+};
+
+pub fn getOwner(failure: SerializedFailure) Owner {
+    return std.mem.bytesAsValue(Owner.Packed, failure.data[0..4]).decode();
+}
+
+/// This assumes the hash map contains only one SerializedFailure per owner.
+/// This is okay since SerializedFailure can contain more than one error.
+pub const ArrayHashContextViaOwner = struct {
+    pub fn hash(_: ArrayHashContextViaOwner, k: SerializedFailure) u32 {
+        return std.hash.uint32(@bitCast(k.getOwner().encode()));
+    }
+
+    pub fn eql(_: ArrayHashContextViaOwner, a: SerializedFailure, b: SerializedFailure, _: usize) bool {
+        return @as(u32, @bitCast(a.getOwner().encode())) == @as(u32, @bitCast(b.getOwner().encode()));
+    }
+};
+
+pub const ArrayHashAdapter = struct {
+    pub fn hash(_: ArrayHashAdapter, own: Owner) u32 {
+        return std.hash.uint32(@bitCast(own.encode()));
+    }
+
+    pub fn eql(_: ArrayHashAdapter, a: Owner, b: SerializedFailure, _: usize) bool {
+        return @as(u32, @bitCast(a.encode())) == @as(u32, @bitCast(b.getOwner().encode()));
+    }
+};
+
+pub const ErrorKind = enum(u8) {
+    // A log message. The `logger.Kind` is encoded here.
+    bundler_log_err = 0,
+    bundler_log_warn = 1,
+    bundler_log_note = 2,
+    bundler_log_debug = 3,
+    bundler_log_verbose = 4,
+
+    /// new Error(message)
+    js_error,
+    /// new TypeError(message)
+    js_error_type,
+    /// new RangeError(message)
+    js_error_range,
+    /// Other forms of `Error` objects, including when an error has a
+    /// `code`, and other fields.
+    js_error_extra,
+    /// Non-error with a stack trace
+    js_primitive_exception,
+    /// Non-error JS values
+    js_primitive,
+    /// new AggregateError(errors, message)
+    js_aggregate,
+};
+
+pub fn initFromJs(dev: *DevServer, owner: Owner, value: JSValue) !SerializedFailure {
+    {
+        _ = value;
+        @panic("TODO");
+    }
+    // Avoid small re-allocations without requesting so much from the heap
+    var sfb = std.heap.stackFallback(65536, dev.allocator);
+    var payload = std.ArrayList(u8).initCapacity(sfb.get(), 65536) catch
+        unreachable; // enough space
+    const w = payload.writer();
+
+    try w.writeInt(u32, @bitCast(owner.encode()), .little);
+    // try writeJsValue(value);
+
+    // Avoid-recloning if it is was moved to the hap
+    const data = if (payload.items.ptr == &sfb.buffer)
+        try dev.allocator.dupe(u8, payload.items)
+    else
+        payload.items;
+
+    return .{ .data = data };
+}
+
+pub fn initFromLog(
+    dev: *DevServer,
+    owner: Owner,
+    // for .client and .server, these are meant to be relative file paths
+    owner_display_name: []const u8,
+    messages: []const bun.logger.Msg,
+) !SerializedFailure {
+    assert(messages.len > 0);
+
+    // Avoid small re-allocations without requesting so much from the heap
+    var sfb = std.heap.stackFallback(65536, dev.allocator);
+    var payload = std.ArrayList(u8).initCapacity(sfb.get(), 65536) catch
+        unreachable; // enough space
+    const w = payload.writer();
+
+    try w.writeInt(u32, @bitCast(owner.encode()), .little);
+
+    try writeString32(owner_display_name, w);
+
+    try w.writeInt(u32, @intCast(messages.len), .little);
+
+    for (messages) |*msg| {
+        try writeLogMsg(msg, w);
+    }
+
+    // Avoid-recloning if it is was moved to the hap
+    const data = if (payload.items.ptr == &sfb.buffer)
+        try dev.allocator.dupe(u8, payload.items)
+    else
+        payload.items;
+
+    return .{ .data = data };
+}
+
+// All "write" functions get a corresponding "read" function in ./client/error.ts
+
+const Writer = std.ArrayList(u8).Writer;
+
+fn writeLogMsg(msg: *const bun.logger.Msg, w: Writer) !void {
+    try w.writeByte(switch (msg.kind) {
+        inline else => |k| @intFromEnum(@field(ErrorKind, "bundler_log_" ++ @tagName(k))),
+    });
+    try writeLogData(msg.data, w);
+    const notes = msg.notes;
+    try w.writeInt(u32, @intCast(notes.len), .little);
+    for (notes) |note| {
+        try writeLogData(note, w);
+    }
+}
+
+fn writeLogData(data: bun.logger.Data, w: Writer) !void {
+    try writeString32(data.text, w);
+    if (data.location) |loc| {
+        if (loc.line < 0) {
+            try w.writeInt(u32, 0, .little);
+            return;
+        }
+        assert(loc.column >= 0); // zero based and not negative
+
+        try w.writeInt(i32, @intCast(loc.line), .little);
+        try w.writeInt(u32, @intCast(loc.column), .little);
+        try w.writeInt(u32, @intCast(loc.length), .little);
+
+        // TODO: syntax highlighted line text + give more context lines
+        try writeString32(loc.line_text orelse "", w);
+
+        // The file is not specified here. Since the transpiler runs every file
+        // in isolation, it would be impossible to reference any other file
+        // in this Log. Thus, it is not serialized.
+    } else {
+        try w.writeInt(u32, 0, .little);
+    }
+}
+
+fn writeString32(data: []const u8, w: Writer) !void {
+    try w.writeInt(u32, @intCast(data.len), .little);
+    try w.writeAll(data);
+}
+
+// fn writeJsValue(value: JSValue, global: *jsc.JSGlobalObject, w: *Writer) !void {
+//     if (value.isAggregateError(global)) {
+//         //
+//     }
+//     if (value.jsType() == .DOMWrapper) {
+//         if (value.as(bun.api.BuildMessage)) |build_error| {
+//             _ = build_error; // autofix
+//             //
+//         } else if (value.as(bun.api.ResolveMessage)) |resolve_error| {
+//             _ = resolve_error; // autofix
+//             @panic("TODO");
+//         }
+//     }
+//     _ = w; // autofix
+
+//     @panic("TODO");
+// }
+
+const std = @import("std");
+
+const bun = @import("bun");
+const assert = bun.assert;
+const bake = bun.bake;
+const Log = bun.logger.Log;
+
+const DevServer = bake.DevServer;
+const IncrementalGraph = DevServer.IncrementalGraph;
+const RouteBundle = DevServer.RouteBundle;
+
+const jsc = bun.jsc;
+const JSValue = jsc.JSValue;