work so far

oven-sh · Jarred-Sumner · Oct 11, 2023 · Oct 3, 2023 · Oct 3, 2023 · Oct 4, 2023
commit 5847b417bfc25b1a1045d1ed37914604ee6dbb59
diff --git a/.vscode/launch.json b/.vscode/launch.json
diff --git a/src/install/dependency.zig b/src/install/dependency.zig
@@ -648,7 +648,8 @@ pub inline fn parse(
     sliced: *const SlicedString,
     log: ?*logger.Log,
 ) ?Version {
-    return parseWithOptionalTag(allocator, alias, dependency, null, sliced, log);
+    const dep = std.mem.trimLeft(u8, dependency, " \t\n\r");
+    return parseWithTag(allocator, alias, dep, Version.Tag.infer(dep), sliced, log);
 }
 
 pub fn parseWithOptionalTag(

diff --git a/src/install/install.zig b/src/install/install.zig
@@ -7625,6 +7625,9 @@ pub const PackageManager = struct {
                         .read_file => Output.prettyError("<r><red>error<r> reading lockfile:<r> {s}\n<r>", .{
                             @errorName(cause.value),
                         }),
+                        .migrating => Output.prettyError("<r><red>error<r> migrating lockfile:<r> {s}\n<r>", .{
+                            @errorName(cause.value),
+                        }),
                     }
 
                     if (manager.options.enable.fail_early) {

diff --git a/src/install/lockfile.zig b/src/install/lockfile.zig
@@ -21,6 +21,7 @@ const json_parser = bun.JSON;
 const JSPrinter = bun.js_printer;
 
 const linker = @import("../linker.zig");
+const migration = @import("./migration.zig");
 
 const sync = @import("../sync.zig");
 const Api = @import("../api/schema.zig").Api;
@@ -167,7 +168,7 @@ pub const LoadFromDiskResult = union(Tag) {
     },
     ok: *Lockfile,
 
-    pub const Step = enum { open_file, read_file, parse_file };
+    pub const Step = enum { open_file, read_file, parse_file, migrating };
 
     pub const Tag = enum {
         not_found,
@@ -183,7 +184,16 @@ pub fn loadFromDisk(this: *Lockfile, allocator: Allocator, log: *logger.Log, fil
     if (filename.len > 0)
         file = std.fs.cwd().openFileZ(filename, .{ .mode = .read_only }) catch |err| {
             return switch (err) {
-                error.FileNotFound, error.AccessDenied, error.BadPathName => LoadFromDiskResult{ .not_found = {} },
+                error.FileNotFound => {
+                    // Attempt to load from "package-lock.json", "yarn.lock", etc.
+                    return migration.detectAndLoadOtherLockfile(
+                        this,
+                        allocator,
+                        log,
+                        filename[0 .. strings.lastIndexOfChar(filename, std.fs.path.sep) orelse 0],
+                    );
+                },
+                error.AccessDenied, error.BadPathName => LoadFromDiskResult{ .not_found = {} },
                 else => LoadFromDiskResult{ .err = .{ .step = .open_file, .value = err } },
             };
         };
@@ -936,6 +946,9 @@ pub const Printer = struct {
                     .read_file => Output.prettyErrorln("<r><red>error<r> reading lockfile:<r> {s}", .{
                         @errorName(cause.value),
                     }),
+                    .migrating => Output.prettyErrorln("<r><red>error<r> while migrating lockfile:<r> {s}", .{
+                        @errorName(cause.value),
+                    }),
                 }
                 if (log.errors > 0) {
                     switch (Output.enable_ansi_colors) {
@@ -1824,8 +1837,13 @@ pub const Package = extern struct {
     dependencies: DependencySlice = .{},
 
     /// The resolved package IDs for the dependencies
+    /// Each index in this array corresponds to the same index in dependencies
+    /// So this is how you say "what package ID for lodash does this other package depend on?"
+    /// By default, its "invalid_id" which means the package ID was not resolved
     resolutions: DependencyIDSlice = .{},
 
+    // "dependencies_resolutions" { int dependency_id, int resolved_package_id, int package_id }
+
     meta: Meta = .{},
     bin: Bin = .{},
     scripts: Package.Scripts = .{},

diff --git a/src/install/migration.zig b/src/install/migration.zig
@@ -0,0 +1,190 @@
+const std = @import("std");
+const Allocator = std.mem.Allocator;
+
+const bun = @import("root").bun;
+const string = bun.string;
+const Output = bun.Output;
+const Global = bun.Global;
+const Environment = bun.Environment;
+const strings = bun.strings;
+const MutableString = bun.MutableString;
+const stringZ = bun.stringZ;
+const logger = bun.logger;
+
+const install = @import("./install.zig");
+const Resolution = @import("./resolution.zig").Resolution;
+const Dependency = @import("./dependency.zig");
+const VersionedURL = @import("./versioned_url.zig");
+const Semver = @import("./semver.zig");
+
+const Lockfile = @import("./lockfile.zig");
+const LoadFromDiskResult = Lockfile.LoadFromDiskResult;
+
+const JSAst = bun.JSAst;
+const Expr = JSAst.Expr;
+const B = JSAst.B;
+const E = JSAst.E;
+const G = JSAst.G;
+const S = JSAst.S;
+
+const debug = Output.scoped(.migrate, false);
+
+pub fn detectAndLoadOtherLockfile(this: *Lockfile, allocator: Allocator, log: *logger.Log, dirname: string) LoadFromDiskResult {
+    // check for package-lock.json, yarn.lock, etc...
+    // if it exists, do an in-memory migration
+    var buf: [bun.MAX_PATH_BYTES]u8 = undefined;
+    @memcpy(buf[0..dirname.len], dirname);
+
+    npm: {
+        const npm_lockfile_name = "package-lock.json";
+        @memcpy(buf[dirname.len .. dirname.len + npm_lockfile_name.len], npm_lockfile_name);
+        buf[dirname.len + npm_lockfile_name.len] = 0;
+        const lockfile_path = buf[0 .. dirname.len + npm_lockfile_name.len :0];
+        const file = std.fs.cwd().openFileZ(lockfile_path, .{ .mode = .read_only }) catch break :npm;
+        defer file.close();
+        var data = file.readToEndAlloc(allocator, std.math.maxInt(usize)) catch |err| {
+            return LoadFromDiskResult{ .err = .{ .step = .migrating, .value = err } };
+        };
+        return migrateNPMLockfile(this, allocator, log, data, lockfile_path) catch |err| {
+            return LoadFromDiskResult{ .err = .{ .step = .migrating, .value = err } };
+        };
+    }
+
+    return LoadFromDiskResult{ .not_found = {} };
+}
+
+const IdMap = std.StringHashMapUnmanaged(u32);
+
+pub fn migrateNPMLockfile(this: *Lockfile, allocator: Allocator, log: *logger.Log, data: string, path: string) !LoadFromDiskResult {
+    debug("begin lockfile migration", .{});
+
+    try this.initEmpty(allocator);
+    install.initializeStore();
+
+    const json_src = logger.Source.initPathString(path, data);
+    const json = try bun.JSON.ParseJSON(&json_src, log, allocator);
+
+    if (json.data != .e_object) {
+        return error.InvalidNPMPackageLockfile;
+    }
+    if (json.get("lockfileVersion")) |version| {
+        if (!(version.data == .e_number and version.data.e_number.value == 3)) {
+            return error.InvalidNPMPackageLockfile;
+        }
+    } else {
+        return error.InvalidNPMPackageLockfile;
+    }
+
+    // Count pass
+    var builder_ = this.stringBuilder();
+    var builder = &builder_;
+    const name = (if (json.get("name")) |expr| expr.asString(allocator) else null) orelse "";
+    builder.count(name);
+
+    var packages_properties = brk: {
+        const obj = json.get("packages") orelse return error.InvalidNPMPackageLockfile;
+        if (obj.data != .e_object) return error.InvalidNPMPackageLockfile;
+        if (obj.data.e_object.properties.len == 0) return error.InvalidNPMPackageLockfile;
+        // if (obj.data.e_object.properties.at(0).key) |k| {
+        //     if (k.data != .e_string) return error.InvalidNPMPackageLockfile;
+        //     // first key must be the "", self reference
+        //     if (k.data.e_string.data.len == 0) return error.InvalidNPMPackageLockfile;
+        // } else return error.InvalidNPMPackageLockfile;
+        break :brk obj.data.e_object.properties;
+    };
+
+    // for faster lookups
+    var id_map = IdMap{};
+    try id_map.ensureTotalCapacity(allocator, packages_properties.len);
+    var num_deps: u32 = 0;
+    for (packages_properties.slice(), 0..) |prop, i| {
+        id_map.putAssumeCapacity(prop.key.?.asString(allocator).?, @truncate(i));
+
+        if (prop.value.?.data != .e_object) {
+            return error.InvalidNPMPackageLockfile;
+        }
+        if (prop.value.?.data.e_object.get("dependencies")) |deps| {
+            if (deps.data != .e_object) {
+                return error.InvalidNPMPackageLockfile;
+            }
+            num_deps +|= @as(u32, deps.data.e_object.properties.len);
+        }
+    }
+    if (num_deps == std.math.maxInt(u32)) return error.TooManyDependencies; // lol
+
+    debug("num_deps: {d}", .{num_deps});
+
+    try this.buffers.dependencies.ensureUnusedCapacity(allocator, num_deps);
+    try this.buffers.resolutions.ensureUnusedCapacity(allocator, num_deps);
+
+    try recursiveWalk(
+        this,
+        log,
+        &id_map,
+        &packages_properties,
+        packages_properties.at(0).value.?,
+        name,
+        "",
+        .{},
+    );
+
+    return error.NotImplementedYet;
+}
+
+fn recursiveWalk(
+    this: *Lockfile,
+    log: *logger.Log,
+    id_map: *IdMap,
+    all_packages_properties: *G.Property.List,
+    value: Expr,
+    pkg_name: string,
+    pkg_path: string,
+    resolution: Dependency.Version,
+) !void {
+    debug("recursiveWalk {s} @ {s}", .{ pkg_name, pkg_path });
+    _ = resolution;
+
+    if (value.get("dependencies")) |deps| {
+        if (value.data == .e_object) {
+            var name_checking_buf: [bun.MAX_PATH_BYTES]u8 = undefined;
+            dep_loop: for (deps.data.e_object.properties.slice(), 0..) |prop, i| {
+                _ = i;
+                const name = prop.key.?.asString(this.allocator).?;
+                const dependency = prop.value.?;
+                const sliced = Semver.SlicedString.init(name, name);
+                const version = Dependency.parse(this.allocator, Semver.String.init(name, name), dependency.asString(this.allocator).?, &sliced, log) orelse {
+                    return error.InvalidLockfileSemver;
+                };
+
+                // TODO: this buffer can totally be avoided
+                bun.copy(u8, name_checking_buf[0..pkg_name.len], pkg_name);
+                const str_node_modules = if (pkg_path.len == 0) "node_modules/" else "/node_modules/";
+                bun.copy(u8, name_checking_buf[pkg_name.len .. pkg_name.len + str_node_modules.len], str_node_modules);
+                const suffix_len = str_node_modules.len + name.len;
+                bun.copy(u8, name_checking_buf[pkg_name.len + str_node_modules.len .. pkg_name.len + suffix_len], name);
+                var j: u32 = @as(u32, @intCast(pkg_name.len + suffix_len));
+                while (true) {
+                    if (id_map.get(name_checking_buf[0..j])) |existing| {
+                        try recursiveWalk(
+                            this,
+                            log,
+                            id_map,
+                            all_packages_properties,
+                            all_packages_properties.at(existing).value.?,
+                            pkg_path[0..j],
+                            name_checking_buf[0..j],
+                            version,
+                        );
+                        continue :dep_loop;
+                    }
+                    if (strings.lastIndexOf(name_checking_buf[0 .. j - suffix_len], "node_modules/")) |idx| {
+                        j = @intCast(idx - "node_modules/".len + name.len);
+                        bun.copy(u8, name_checking_buf[j .. j + name.len], name);
+                    } else {
+                        return error.MissingLockfileDependency;
+                    }
+                }
+            }
+        }
+    }
+}