@latticexyz/cli 2.0.0-next.1 → 2.0.0-next.11

package/src/commands/set-version.ts

@@ -1,11 +1,12 @@
 import chalk from "chalk";
-import { existsSync, readFileSync, rmSync, writeFileSync } from "fs";
+import { readFileSync, writeFileSync } from "fs";
 import path from "path";
 import type { CommandModule } from "yargs";
 import { MUDError } from "@latticexyz/common/errors";
 import { logError } from "../utils/errors";
 import localPackageJson from "../../package.json" assert { type: "json" };
 import glob from "glob";
+import { mudPackages } from "../mudPackages";
 
 type Options = {
   backup?: boolean;
@@ -17,9 +18,6 @@ type Options = {
   link?: string;
 };
 
-const BACKUP_FILE = ".mudbackup";
-const MUD_PREFIX = "@latticexyz";
-
 const commandModule: CommandModule<Options, Options> = {
   command: "set-version",
 
@@ -27,12 +25,6 @@ const commandModule: CommandModule<Options, Options> = {
 
   builder(yargs) {
     return yargs.options({
-      backup: { type: "boolean", description: `Back up the current MUD versions to "${BACKUP_FILE}"` },
-      force: {
-        type: "boolean",
-        description: `Backup fails if a "${BACKUP_FILE}" file is found, unless --force is provided`,
-      },
-      restore: { type: "boolean", description: `Restore the previous MUD versions from "${BACKUP_FILE}"` },
       mudVersion: { alias: "v", type: "string", description: "Set MUD to the given version" },
       tag: {
         alias: "t",
@@ -117,63 +109,39 @@ async function resolveVersion(options: Options) {
 }
 
 function updatePackageJson(filePath: string, options: Options): { workspaces?: string[] } {
-  const { restore, force, link } = options;
-  let { backup, mudVersion } = options;
-
-  const backupFilePath = path.join(path.dirname(filePath), BACKUP_FILE);
-  const backupFileExists = existsSync(backupFilePath);
-
-  // Create a backup file for previous MUD versions by default if linking to local MUD
-  if (link && !backupFileExists) backup = true;
-
-  // If `backup` is true and force not set, check if a backup file already exists and throw an error if it does
-  if (backup && !force && backupFileExists) {
-    throw new MUDError(
-      `A backup file already exists at ${backupFilePath}.\nUse --force to overwrite it or --restore to restore it.`
-    );
-  }
+  const { link } = options;
+  let { mudVersion } = options;
 
   const packageJson = readPackageJson(filePath);
-
-  // Load .mudbackup if `restore` is true
-  const backupJson = restore ? readPackageJson(backupFilePath) : undefined;
+  const mudPackageNames = Object.keys(mudPackages);
 
   // Find all MUD dependencies
   const mudDependencies: Record<string, string> = {};
-  for (const key in packageJson.dependencies) {
-    if (key.startsWith(MUD_PREFIX)) {
-      mudDependencies[key] = packageJson.dependencies[key];
+  for (const packageName in packageJson.dependencies) {
+    if (mudPackageNames.includes(packageName)) {
+      mudDependencies[packageName] = packageJson.dependencies[packageName];
     }
   }
 
   // Find all MUD devDependencies
   const mudDevDependencies: Record<string, string> = {};
-  for (const key in packageJson.devDependencies) {
-    if (key.startsWith(MUD_PREFIX)) {
-      mudDevDependencies[key] = packageJson.devDependencies[key];
+  for (const packageName in packageJson.devDependencies) {
+    if (mudPackageNames.includes(packageName)) {
+      mudDevDependencies[packageName] = packageJson.devDependencies[packageName];
     }
   }
 
-  // Back up the current dependencies if `backup` is true
-  if (backup) {
-    writeFileSync(
-      backupFilePath,
-      JSON.stringify({ dependencies: mudDependencies, devDependencies: mudDevDependencies }, null, 2)
-    );
-    console.log(chalk.green(`Backed up MUD dependencies from ${filePath} to ${backupFilePath}`));
-  }
-
   // Update the dependencies
-  for (const key in packageJson.dependencies) {
-    if (key.startsWith(MUD_PREFIX)) {
-      packageJson.dependencies[key] = resolveMudVersion(key, "dependencies");
+  for (const packageName in packageJson.dependencies) {
+    if (mudPackageNames.includes(packageName)) {
+      packageJson.dependencies[packageName] = resolveMudVersion(packageName, "dependencies");
     }
   }
 
   // Update the devDependencies
-  for (const key in packageJson.devDependencies) {
-    if (key.startsWith(MUD_PREFIX)) {
-      packageJson.devDependencies[key] = resolveMudVersion(key, "devDependencies");
+  for (const packageName in packageJson.devDependencies) {
+    if (mudPackageNames.includes(packageName)) {
+      packageJson.devDependencies[packageName] = resolveMudVersion(packageName, "devDependencies");
     }
   }
 
@@ -184,17 +152,9 @@ function updatePackageJson(filePath: string, options: Options): { workspaces?: s
   logComparison(mudDependencies, packageJson.dependencies);
   logComparison(mudDevDependencies, packageJson.devDependencies);
 
-  // Remove the backup file if `restore` is true and `backup` is false
-  // because the old backup file is no longer needed
-  if (restore && !backup) {
-    rmSync(backupFilePath);
-    console.log(chalk.green(`Cleaned up ${backupFilePath}`));
-  }
-
   return packageJson;
 
   function resolveMudVersion(key: string, type: "dependencies" | "devDependencies") {
-    if (restore && backupJson) return backupJson[type][key];
     if (link) mudVersion = resolveLinkPath(filePath, link, key);
     if (!mudVersion) return packageJson[type][key];
     return mudVersion;
@@ -225,10 +185,9 @@ function logComparison(prev: Record<string, string>, curr: Record<string, string
 /**
  * Returns path of the package to link, given a path to a local MUD clone and a package
  */
-function resolveLinkPath(packageJsonPath: string, mudLinkPath: string, pkg: string) {
-  const pkgName = pkg.replace(MUD_PREFIX, "");
+function resolveLinkPath(packageJsonPath: string, mudLinkPath: string, packageName: string) {
   const packageJsonToRootPath = path.relative(path.dirname(packageJsonPath), process.cwd());
-  const linkPath = path.join(packageJsonToRootPath, mudLinkPath, "packages", pkgName);
+  const linkPath = path.join(packageJsonToRootPath, mudLinkPath, mudPackages[packageName].localPath);
   return "link:" + linkPath;
 }
 

package/src/commands/tablegen.ts

@@ -3,7 +3,7 @@ import type { CommandModule } from "yargs";
 import { loadConfig } from "@latticexyz/config/node";
 import { StoreConfig } from "@latticexyz/store";
 import { tablegen } from "@latticexyz/store/codegen";
-import { getSrcDirectory } from "@latticexyz/common/foundry";
+import { getRemappings, getSrcDirectory } from "@latticexyz/common/foundry";
 
 type Options = {
   configPath?: string;
@@ -23,8 +23,9 @@ const commandModule: CommandModule<Options, Options> = {
   async handler({ configPath }) {
     const config = (await loadConfig(configPath)) as StoreConfig;
     const srcDir = await getSrcDirectory();
+    const remappings = await getRemappings();
 
-    await tablegen(config, path.join(srcDir, config.codegenDirectory));
+    await tablegen(config, path.join(srcDir, config.codegenDirectory), remappings);
 
     process.exit(0);
   },

package/src/commands/test.ts

@@ -3,7 +3,7 @@ import { anvil, forge, getRpcUrl } from "@latticexyz/common/foundry";
 import chalk from "chalk";
 import { rmSync, writeFileSync } from "fs";
 import { yDeployOptions } from "./deploy";
-import { deployHandler, DeployOptions } from "../utils";
+import { DeployOptions, deployHandler } from "../utils/deployHandler";
 
 type Options = DeployOptions & { port?: number; worldAddress?: string; forgeOptions?: string };
 
@@ -59,10 +59,11 @@ const commandModule: CommandModule<Options, Options> = {
       console.log(testResult);
     } catch (e) {
       console.error(e);
+      rmSync(WORLD_ADDRESS_FILE);
+      process.exit(1);
     }
 
     rmSync(WORLD_ADDRESS_FILE);
-
     process.exit(0);
   },
 };

package/src/commands/trace.ts

@@ -5,14 +5,20 @@ import { ethers } from "ethers";
 import { loadConfig } from "@latticexyz/config/node";
 import { MUDError } from "@latticexyz/common/errors";
 import { cast, getRpcUrl, getSrcDirectory } from "@latticexyz/common/foundry";
-import { TableId } from "@latticexyz/common/deprecated";
 import { StoreConfig } from "@latticexyz/store";
 import { resolveWorldConfig, WorldConfig } from "@latticexyz/world";
-import { IBaseWorld } from "@latticexyz/world/types/ethers-contracts/IBaseWorld";
-import IBaseWorldData from "@latticexyz/world/abi/IBaseWorld.sol/IBaseWorld.json" assert { type: "json" };
-import { getChainId, getExistingContracts } from "../utils";
-
-const systemsTableId = new TableId("", "Systems");
+import IBaseWorldAbi from "@latticexyz/world/out/IBaseWorld.sol/IBaseWorld.abi.json" assert { type: "json" };
+import worldConfig from "@latticexyz/world/mud.config.js";
+import { resourceIdToHex } from "@latticexyz/common";
+import { getExistingContracts } from "../utils/getExistingContracts";
+import { getChainId } from "../utils/utils/getChainId";
+
+// TODO account for multiple namespaces (https://github.com/latticexyz/mud/issues/994)
+const systemsTableId = resourceIdToHex({
+  type: "system",
+  namespace: worldConfig.namespace,
+  name: worldConfig.tables.Systems.name,
+});
 
 type Options = {
   tx: string;
@@ -64,17 +70,19 @@ const commandModule: CommandModule<Options, Options> = {
 
     // Create World contract instance from deployed address
     const provider = new ethers.providers.StaticJsonRpcProvider(rpc);
-    const WorldContract = new ethers.Contract(worldAddress, IBaseWorldData.abi, provider) as IBaseWorld;
+    const WorldContract = new ethers.Contract(worldAddress, IBaseWorldAbi, provider);
 
     // TODO account for multiple namespaces (https://github.com/latticexyz/mud/issues/994)
     const namespace = mudConfig.namespace;
     const names = Object.values(resolvedConfig.systems).map(({ name }) => name);
 
+    // Fetch system table field layout from chain
+    const systemTableFieldLayout = await WorldContract.getFieldLayout(systemsTableId);
     const labels: { name: string; address: string }[] = [];
     for (const name of names) {
-      const systemSelector = new TableId(namespace, name);
+      const systemSelector = resourceIdToHex({ type: "system", namespace, name });
       // Get the first field of `Systems` table (the table maps system name to its address and other data)
-      const address = await WorldContract.getField(systemsTableId.toHex(), [systemSelector.toHex()], 0);
+      const address = await WorldContract.getField(systemsTableId, [systemSelector], 0, systemTableFieldLayout);
       labels.push({ name, address });
     }
 

package/src/commands/worldgen.ts

@@ -6,7 +6,7 @@ import { worldgen } from "@latticexyz/world/node";
 import { getSrcDirectory } from "@latticexyz/common/foundry";
 import path from "path";
 import { rmSync } from "fs";
-import { getExistingContracts } from "../utils";
+import { getExistingContracts } from "../utils/getExistingContracts";
 
 type Options = {
   configPath?: string;

package/src/common.ts

@@ -0,0 +1 @@
+export type MudPackages = Record<string, { localPath: string }>;

package/src/index.ts

@@ -1,2 +1 @@
-export * from "./render-ts";
 export * from "./utils/deployHandler";

package/src/mud.ts

@@ -27,8 +27,11 @@ yargs(hideBin(process.argv))
       );
     }
     console.log("");
-    logError(err);
-    console.log("");
+    // Even though `.fail` type says we should get an `Error`, this can sometimes be undefined
+    if (err != null) {
+      logError(err);
+      console.log("");
+    }
 
     process.exit(1);
   })

package/src/mudPackages.ts

@@ -0,0 +1,24 @@
+import { ZodError, z } from "zod";
+import { MudPackages } from "./common";
+
+const envSchema = z.object({
+  MUD_PACKAGES: z.string().transform((value) => JSON.parse(value) as MudPackages),
+});
+
+function parseEnv(): z.infer<typeof envSchema> {
+  try {
+    return envSchema.parse({
+      // tsup replaces the env vars with their values at compile time
+      MUD_PACKAGES: process.env.MUD_PACKAGES,
+    });
+  } catch (error) {
+    if (error instanceof ZodError) {
+      const { _errors, ...invalidEnvVars } = error.format();
+      console.error(`\nMissing or invalid environment variables:\n\n  ${Object.keys(invalidEnvVars).join("\n  ")}\n`);
+      process.exit(1);
+    }
+    throw error;
+  }
+}
+
+export const mudPackages = parseEnv().MUD_PACKAGES;