[bun install] Implement bunfig.toml config

4 files changed, 586 insertions, 1 deletions

diff --git a/src/api/schema.d.ts b/src/api/schema.d.ts
index 015f6af40..d896bc160 100644
--- a/src/api/schema.d.ts
+++ b/src/api/schema.d.ts
@@ -603,6 +603,37 @@ export interface WebsocketMessageResolveID {
   id: uint32;
 }
 
+export interface NPMRegistry {
+  url: string;
+  username: string;
+  password: string;
+  token: string;
+}
+
+export interface NPMRegistryMap {
+  scopes: string[];
+  registries: NPMRegistry[];
+}
+
+export interface BunInstall {
+  default_registry?: NPMRegistry;
+  scoped?: NPMRegistryMap;
+  lockfile_path?: string;
+  save_lockfile_path?: string;
+  cache_directory?: string;
+  dry_run?: boolean;
+  force?: boolean;
+  save_dev?: boolean;
+  save_optional?: boolean;
+  save_peer?: boolean;
+  save_lockfile?: boolean;
+  production?: boolean;
+  save_yarn_lockfile?: boolean;
+  native_bin_links?: string[];
+  disable_cache?: boolean;
+  disable_manifest_cache?: boolean;
+}
+
 export declare function encodeStackFrame(
   message: StackFrame,
   bb: ByteBuffer
@@ -869,3 +900,20 @@ export declare function encodeWebsocketMessageResolveID(
 export declare function decodeWebsocketMessageResolveID(
   buffer: ByteBuffer
 ): WebsocketMessageResolveID;
+export declare function encodeNPMRegistry(
+  message: NPMRegistry,
+  bb: ByteBuffer
+): void;
+export declare function decodeNPMRegistry(buffer: ByteBuffer): NPMRegistry;
+export declare function encodeNPMRegistryMap(
+  message: NPMRegistryMap,
+  bb: ByteBuffer
+): void;
+export declare function decodeNPMRegistryMap(
+  buffer: ByteBuffer
+): NPMRegistryMap;
+export declare function encodeBunInstall(
+  message: BunInstall,
+  bb: ByteBuffer
+): void;
+export declare function decodeBunInstall(buffer: ByteBuffer): BunInstall;
diff --git a/src/api/schema.js b/src/api/schema.js
index da91af252..67852d027 100644
--- a/src/api/schema.js
+++ b/src/api/schema.js
@@ -2748,6 +2748,271 @@ function encodeWebsocketMessageResolveID(message, bb) {
   }
 }
 
+function decodeNPMRegistry(bb) {
+  var result = {};
+
+  result["url"] = bb.readString();
+  result["username"] = bb.readString();
+  result["password"] = bb.readString();
+  result["token"] = bb.readString();
+  return result;
+}
+
+function encodeNPMRegistry(message, bb) {
+  var value = message["url"];
+  if (value != null) {
+    bb.writeString(value);
+  } else {
+    throw new Error('Missing required field "url"');
+  }
+
+  var value = message["username"];
+  if (value != null) {
+    bb.writeString(value);
+  } else {
+    throw new Error('Missing required field "username"');
+  }
+
+  var value = message["password"];
+  if (value != null) {
+    bb.writeString(value);
+  } else {
+    throw new Error('Missing required field "password"');
+  }
+
+  var value = message["token"];
+  if (value != null) {
+    bb.writeString(value);
+  } else {
+    throw new Error('Missing required field "token"');
+  }
+}
+
+function decodeNPMRegistryMap(bb) {
+  var result = {};
+
+  var length = bb.readVarUint();
+  var values = (result["scopes"] = Array(length));
+  for (var i = 0; i < length; i++) values[i] = bb.readString();
+  var length = bb.readVarUint();
+  var values = (result["registries"] = Array(length));
+  for (var i = 0; i < length; i++) values[i] = decodeNPMRegistry(bb);
+  return result;
+}
+
+function encodeNPMRegistryMap(message, bb) {
+  var value = message["scopes"];
+  if (value != null) {
+    var values = value,
+      n = values.length;
+    bb.writeVarUint(n);
+    for (var i = 0; i < n; i++) {
+      value = values[i];
+      bb.writeString(value);
+    }
+  } else {
+    throw new Error('Missing required field "scopes"');
+  }
+
+  var value = message["registries"];
+  if (value != null) {
+    var values = value,
+      n = values.length;
+    bb.writeVarUint(n);
+    for (var i = 0; i < n; i++) {
+      value = values[i];
+      encodeNPMRegistry(value, bb);
+    }
+  } else {
+    throw new Error('Missing required field "registries"');
+  }
+}
+
+function decodeBunInstall(bb) {
+  var result = {};
+
+  while (true) {
+    switch (bb.readByte()) {
+      case 0:
+        return result;
+
+      case 1:
+        result["default_registry"] = decodeNPMRegistry(bb);
+        break;
+
+      case 2:
+        result["scoped"] = decodeNPMRegistryMap(bb);
+        break;
+
+      case 3:
+        result["lockfile_path"] = bb.readString();
+        break;
+
+      case 4:
+        result["save_lockfile_path"] = bb.readString();
+        break;
+
+      case 5:
+        result["cache_directory"] = bb.readString();
+        break;
+
+      case 6:
+        result["dry_run"] = !!bb.readByte();
+        break;
+
+      case 7:
+        result["force"] = !!bb.readByte();
+        break;
+
+      case 8:
+        result["save_dev"] = !!bb.readByte();
+        break;
+
+      case 9:
+        result["save_optional"] = !!bb.readByte();
+        break;
+
+      case 10:
+        result["save_peer"] = !!bb.readByte();
+        break;
+
+      case 11:
+        result["save_lockfile"] = !!bb.readByte();
+        break;
+
+      case 12:
+        result["production"] = !!bb.readByte();
+        break;
+
+      case 13:
+        result["save_yarn_lockfile"] = !!bb.readByte();
+        break;
+
+      case 14:
+        var length = bb.readVarUint();
+        var values = (result["native_bin_links"] = Array(length));
+        for (var i = 0; i < length; i++) values[i] = bb.readString();
+        break;
+
+      case 15:
+        result["disable_cache"] = !!bb.readByte();
+        break;
+
+      case 16:
+        result["disable_manifest_cache"] = !!bb.readByte();
+        break;
+
+      default:
+        throw new Error("Attempted to parse invalid message");
+    }
+  }
+}
+
+function encodeBunInstall(message, bb) {
+  var value = message["default_registry"];
+  if (value != null) {
+    bb.writeByte(1);
+    encodeNPMRegistry(value, bb);
+  }
+
+  var value = message["scoped"];
+  if (value != null) {
+    bb.writeByte(2);
+    encodeNPMRegistryMap(value, bb);
+  }
+
+  var value = message["lockfile_path"];
+  if (value != null) {
+    bb.writeByte(3);
+    bb.writeString(value);
+  }
+
+  var value = message["save_lockfile_path"];
+  if (value != null) {
+    bb.writeByte(4);
+    bb.writeString(value);
+  }
+
+  var value = message["cache_directory"];
+  if (value != null) {
+    bb.writeByte(5);
+    bb.writeString(value);
+  }
+
+  var value = message["dry_run"];
+  if (value != null) {
+    bb.writeByte(6);
+    bb.writeByte(value);
+  }
+
+  var value = message["force"];
+  if (value != null) {
+    bb.writeByte(7);
+    bb.writeByte(value);
+  }
+
+  var value = message["save_dev"];
+  if (value != null) {
+    bb.writeByte(8);
+    bb.writeByte(value);
+  }
+
+  var value = message["save_optional"];
+  if (value != null) {
+    bb.writeByte(9);
+    bb.writeByte(value);
+  }
+
+  var value = message["save_peer"];
+  if (value != null) {
+    bb.writeByte(10);
+    bb.writeByte(value);
+  }
+
+  var value = message["save_lockfile"];
+  if (value != null) {
+    bb.writeByte(11);
+    bb.writeByte(value);
+  }
+
+  var value = message["production"];
+  if (value != null) {
+    bb.writeByte(12);
+    bb.writeByte(value);
+  }
+
+  var value = message["save_yarn_lockfile"];
+  if (value != null) {
+    bb.writeByte(13);
+    bb.writeByte(value);
+  }
+
+  var value = message["native_bin_links"];
+  if (value != null) {
+    bb.writeByte(14);
+    var values = value,
+      n = values.length;
+    bb.writeVarUint(n);
+    for (var i = 0; i < n; i++) {
+      value = values[i];
+      bb.writeString(value);
+    }
+  }
+
+  var value = message["disable_cache"];
+  if (value != null) {
+    bb.writeByte(15);
+    bb.writeByte(value);
+  }
+
+  var value = message["disable_manifest_cache"];
+  if (value != null) {
+    bb.writeByte(16);
+    bb.writeByte(value);
+  }
+  bb.writeByte(0);
+}
+
 export { Loader };
 export { LoaderKeys };
 export { FrameworkEntryPointType };
@@ -2874,3 +3139,9 @@ export { decodeWebsocketCommandBuildWithFilePath };
 export { encodeWebsocketCommandBuildWithFilePath };
 export { decodeWebsocketMessageResolveID };
 export { encodeWebsocketMessageResolveID };
+export { decodeNPMRegistry };
+export { encodeNPMRegistry };
+export { decodeNPMRegistryMap };
+export { encodeNPMRegistryMap };
+export { decodeBunInstall };
+export { encodeBunInstall };
diff --git a/src/api/schema.peechy b/src/api/schema.peechy
index 58ca3f013..a7284f713 100644
--- a/src/api/schema.peechy
+++ b/src/api/schema.peechy
@@ -344,7 +344,6 @@ message TransformOptions {
 
   uint16 port = 25;
   MessageLevel logLevel = 26;
-
 }
 
 struct FileHandle {
@@ -516,4 +515,36 @@ struct WebsocketCommandBuildWithFilePath {
 
 struct WebsocketMessageResolveID {
   uint32 id;
+}
+
+struct NPMRegistry {
+  string url;
+  string username;
+  string password;
+  string token;
+}
+
+struct NPMRegistryMap {
+  string[] scopes;
+  NPMRegistry[] registries;
+}
+
+message BunInstall {
+  NPMRegistry default_registry = 1;
+  NPMRegistryMap scoped = 2;
+  string lockfile_path = 3;
+  string save_lockfile_path = 4;
+  string cache_directory = 5;
+  bool dry_run = 6;
+  bool force = 7;
+  bool save_dev = 8;
+  bool save_optional = 9;
+  bool save_peer = 10;
+  bool save_lockfile = 11;
+  bool production = 12;
+  bool save_yarn_lockfile = 13;
+  string[] native_bin_links = 14;
+
+  bool disable_cache = 15;
+  bool disable_manifest_cache = 16;
 }
\ No newline at end of file
diff --git a/src/api/schema.zig b/src/api/schema.zig
index 8f21c350c..8879b34cb 100644
--- a/src/api/schema.zig
+++ b/src/api/schema.zig
@@ -2617,4 +2617,239 @@ pub const Api = struct {
             try writer.writeInt(this.id);
         }
     };
+
+    pub const NpmRegistry = struct {
+        /// url
+        url: []const u8,
+
+        /// username
+        username: []const u8,
+
+        /// password
+        password: []const u8,
+
+        /// token
+        token: []const u8,
+
+        pub fn decode(reader: anytype) anyerror!NpmRegistry {
+            var this = std.mem.zeroes(NpmRegistry);
+
+            this.url = try reader.readValue([]const u8);
+            this.username = try reader.readValue([]const u8);
+            this.password = try reader.readValue([]const u8);
+            this.token = try reader.readValue([]const u8);
+            return this;
+        }
+
+        pub fn encode(this: *const @This(), writer: anytype) anyerror!void {
+            try writer.writeValue(@TypeOf(this.url), this.url);
+            try writer.writeValue(@TypeOf(this.username), this.username);
+            try writer.writeValue(@TypeOf(this.password), this.password);
+            try writer.writeValue(@TypeOf(this.token), this.token);
+        }
+    };
+
+    pub const NpmRegistryMap = struct {
+        /// scopes
+        scopes: []const []const u8,
+
+        /// registries
+        registries: []const NpmRegistry,
+
+        pub fn decode(reader: anytype) anyerror!NpmRegistryMap {
+            var this = std.mem.zeroes(NpmRegistryMap);
+
+            this.scopes = try reader.readArray([]const u8);
+            this.registries = try reader.readArray(NpmRegistry);
+            return this;
+        }
+
+        pub fn encode(this: *const @This(), writer: anytype) anyerror!void {
+            try writer.writeArray([]const u8, this.scopes);
+            try writer.writeArray(NpmRegistry, this.registries);
+        }
+    };
+
+    pub const BunInstall = struct {
+        /// default_registry
+        default_registry: ?NpmRegistry = null,
+
+        /// scoped
+        scoped: ?NpmRegistryMap = null,
+
+        /// lockfile_path
+        lockfile_path: ?[]const u8 = null,
+
+        /// save_lockfile_path
+        save_lockfile_path: ?[]const u8 = null,
+
+        /// cache_directory
+        cache_directory: ?[]const u8 = null,
+
+        /// dry_run
+        dry_run: ?bool = null,
+
+        /// force
+        force: ?bool = null,
+
+        /// save_dev
+        save_dev: ?bool = null,
+
+        /// save_optional
+        save_optional: ?bool = null,
+
+        /// save_peer
+        save_peer: ?bool = null,
+
+        /// save_lockfile
+        save_lockfile: ?bool = null,
+
+        /// production
+        production: ?bool = null,
+
+        /// save_yarn_lockfile
+        save_yarn_lockfile: ?bool = null,
+
+        /// native_bin_links
+        native_bin_links: []const []const u8,
+
+        /// disable_cache
+        disable_cache: ?bool = null,
+
+        /// disable_manifest_cache
+        disable_manifest_cache: ?bool = null,
+
+        pub fn decode(reader: anytype) anyerror!BunInstall {
+            var this = std.mem.zeroes(BunInstall);
+
+            while (true) {
+                switch (try reader.readByte()) {
+                    0 => {
+                        return this;
+                    },
+
+                    1 => {
+                        this.default_registry = try reader.readValue(NpmRegistry);
+                    },
+                    2 => {
+                        this.scoped = try reader.readValue(NpmRegistryMap);
+                    },
+                    3 => {
+                        this.lockfile_path = try reader.readValue([]const u8);
+                    },
+                    4 => {
+                        this.save_lockfile_path = try reader.readValue([]const u8);
+                    },
+                    5 => {
+                        this.cache_directory = try reader.readValue([]const u8);
+                    },
+                    6 => {
+                        this.dry_run = try reader.readValue(bool);
+                    },
+                    7 => {
+                        this.force = try reader.readValue(bool);
+                    },
+                    8 => {
+                        this.save_dev = try reader.readValue(bool);
+                    },
+                    9 => {
+                        this.save_optional = try reader.readValue(bool);
+                    },
+                    10 => {
+                        this.save_peer = try reader.readValue(bool);
+                    },
+                    11 => {
+                        this.save_lockfile = try reader.readValue(bool);
+                    },
+                    12 => {
+                        this.production = try reader.readValue(bool);
+                    },
+                    13 => {
+                        this.save_yarn_lockfile = try reader.readValue(bool);
+                    },
+                    14 => {
+                        this.native_bin_links = try reader.readArray([]const u8);
+                    },
+                    15 => {
+                        this.disable_cache = try reader.readValue(bool);
+                    },
+                    16 => {
+                        this.disable_manifest_cache = try reader.readValue(bool);
+                    },
+                    else => {
+                        return error.InvalidMessage;
+                    },
+                }
+            }
+            unreachable;
+        }
+
+        pub fn encode(this: *const @This(), writer: anytype) anyerror!void {
+            if (this.default_registry) |default_registry| {
+                try writer.writeFieldID(1);
+                try writer.writeValue(@TypeOf(default_registry), default_registry);
+            }
+            if (this.scoped) |scoped| {
+                try writer.writeFieldID(2);
+                try writer.writeValue(@TypeOf(scoped), scoped);
+            }
+            if (this.lockfile_path) |lockfile_path| {
+                try writer.writeFieldID(3);
+                try writer.writeValue(@TypeOf(lockfile_path), lockfile_path);
+            }
+            if (this.save_lockfile_path) |save_lockfile_path| {
+                try writer.writeFieldID(4);
+                try writer.writeValue(@TypeOf(save_lockfile_path), save_lockfile_path);
+            }
+            if (this.cache_directory) |cache_directory| {
+                try writer.writeFieldID(5);
+                try writer.writeValue(@TypeOf(cache_directory), cache_directory);
+            }
+            if (this.dry_run) |dry_run| {
+                try writer.writeFieldID(6);
+                try writer.writeInt(@as(u8, @boolToInt(dry_run)));
+            }
+            if (this.force) |force| {
+                try writer.writeFieldID(7);
+                try writer.writeInt(@as(u8, @boolToInt(force)));
+            }
+            if (this.save_dev) |save_dev| {
+                try writer.writeFieldID(8);
+                try writer.writeInt(@as(u8, @boolToInt(save_dev)));
+            }
+            if (this.save_optional) |save_optional| {
+                try writer.writeFieldID(9);
+                try writer.writeInt(@as(u8, @boolToInt(save_optional)));
+            }
+            if (this.save_peer) |save_peer| {
+                try writer.writeFieldID(10);
+                try writer.writeInt(@as(u8, @boolToInt(save_peer)));
+            }
+            if (this.save_lockfile) |save_lockfile| {
+                try writer.writeFieldID(11);
+                try writer.writeInt(@as(u8, @boolToInt(save_lockfile)));
+            }
+            if (this.production) |production| {
+                try writer.writeFieldID(12);
+                try writer.writeInt(@as(u8, @boolToInt(production)));
+            }
+            if (this.save_yarn_lockfile) |save_yarn_lockfile| {
+                try writer.writeFieldID(13);
+                try writer.writeInt(@as(u8, @boolToInt(save_yarn_lockfile)));
+            }
+            if (this.native_bin_links) |native_bin_links| {
+                try writer.writeFieldID(14);
+                try writer.writeArray([]const u8, native_bin_links);
+            }
+            if (this.disable_cache) |disable_cache| {
+                try writer.writeFieldID(15);
+                try writer.writeInt(@as(u8, @boolToInt(disable_cache)));
+            }
+            if (this.disable_manifest_cache) |disable_manifest_cache| {
+                try writer.writeFieldID(16);
+                try writer.writeInt(@as(u8, @boolToInt(disable_manifest_cache)));
+            }
+            try writer.endMessage();
+        }
+    };
 };