@latticexyz/cli 2.0.0-alpha.37 → 2.0.0-alpha.41

package/dist/{chunk-KPBNUPK6.js → chunk-J4DJQNIC.js}

@@ -1,3 +1,6 @@
+// src/config/commonSchemas.ts
+import { z } from "zod";
+
 // src/config/validation.ts
 import { ethers } from "ethers";
 import { ZodIssueCode } from "zod";
@@ -140,6 +143,117 @@ function parseStaticArray(abiType) {
   };
 }
 
+// src/config/commonSchemas.ts
+var zObjectName = z.string().superRefine(validateCapitalizedName);
+var zValueName = z.string().superRefine(validateUncapitalizedName);
+var zAnyCaseName = z.string().superRefine(validateName);
+var zUserEnum = z.array(zObjectName).superRefine(validateEnum);
+var zOrdinaryRoute = z.string().superRefine(validateRoute);
+var zSingleLevelRoute = z.string().superRefine(validateSingleLevelRoute);
+var zBaseRoute = z.string().superRefine(validateBaseRoute);
+var zEthereumAddress = z.string().superRefine(validateEthereumAddress);
+var zSelector = z.string().superRefine(validateSelector);
+
+// src/config/loadConfig.ts
+import { findUp } from "find-up";
+import path from "path";
+
+// src/utils/errors.ts
+import chalk from "chalk";
+import { z as z2, ZodError, ZodIssueCode as ZodIssueCode2 } from "zod";
+import { fromZodError, ValidationError } from "zod-validation-error";
+function fromZodErrorCustom(error, prefix) {
+  return fromZodError(error, {
+    prefix: chalk.red(prefix),
+    prefixSeparator: "\n- ",
+    issueSeparator: "\n- "
+  });
+}
+var NotInsideProjectError = class extends Error {
+  constructor() {
+    super(...arguments);
+    this.name = "NotInsideProjectError";
+    this.message = "You are not inside a MUD project";
+  }
+};
+var NotESMConfigError = class extends Error {
+  constructor() {
+    super(...arguments);
+    this.name = "NotESMConfigError";
+    this.message = "MUD config must be an ES module";
+  }
+};
+var MUDError = class extends Error {
+  constructor() {
+    super(...arguments);
+    this.name = "MUDError";
+  }
+};
+function UnrecognizedSystemErrorFactory(path2, systemName) {
+  return new z2.ZodError([{ code: ZodIssueCode2.custom, path: path2, message: `Unrecognized system: "${systemName}"` }]);
+}
+function logError(error) {
+  if (error instanceof ValidationError) {
+    console.log(chalk.redBright(error.message));
+  } else if (error instanceof ZodError) {
+    const validationError = fromZodError(error, {
+      prefixSeparator: "\n- ",
+      issueSeparator: "\n- "
+    });
+    console.log(chalk.redBright(validationError.message));
+  } else if (error instanceof NotInsideProjectError) {
+    console.log(chalk.red(error.message));
+    console.log("");
+    console.log(chalk.blue(`To learn more about MUD's configuration, please go to https://mud.dev/packages/cli/`));
+  } else if (error instanceof NotESMConfigError) {
+    console.log(chalk.red(error.message));
+    console.log("");
+    console.log(
+      chalk.blue(`Please name your config file \`mud.config.mts\`, or use \`type: "module"\` in package.json`)
+    );
+  } else if (error instanceof MUDError) {
+    console.log(chalk.red(error));
+  } else {
+    console.log(error);
+  }
+}
+
+// src/config/loadConfig.ts
+var configFiles = ["mud.config.ts", "mud.config.mts"];
+async function loadConfig(configPath) {
+  configPath = await resolveConfigPath(configPath);
+  try {
+    return (await import(configPath)).default;
+  } catch (error) {
+    if (error instanceof SyntaxError && error.message === "Cannot use import statement outside a module") {
+      throw new NotESMConfigError();
+    } else {
+      throw error;
+    }
+  }
+}
+async function resolveConfigPath(configPath) {
+  if (configPath === void 0) {
+    configPath = await getUserConfigPath();
+  } else {
+    if (!path.isAbsolute(configPath)) {
+      configPath = path.join(process.cwd(), configPath);
+      configPath = path.normalize(configPath);
+    }
+  }
+  return configPath;
+}
+async function getUserConfigPath() {
+  const tsConfigPath = await findUp(configFiles);
+  if (tsConfigPath === void 0) {
+    throw new NotInsideProjectError();
+  }
+  return tsConfigPath;
+}
+
+// src/config/loadStoreConfig.ts
+import { ZodError as ZodError2 } from "zod";
+
 // ../schema-type/src/typescript/SchemaType.ts
 var SchemaType = /* @__PURE__ */ ((SchemaType2) => {
   SchemaType2[SchemaType2["UINT8"] = 0] = "UINT8";
@@ -707,15 +821,309 @@ var StaticAbiTypes = AbiTypes.filter(
   (abiType) => getStaticByteLength(AbiTypeToSchemaType[abiType]) > 0
 );
 
+// src/config/parseStoreConfig.ts
+import { z as z3, ZodIssueCode as ZodIssueCode3 } from "zod";
+var zTableName = zObjectName;
+var zKeyName = zValueName;
+var zColumnName = zValueName;
+var zUserEnumName = zObjectName;
+var zFieldData = z3.string();
+var zPrimaryKey = z3.string();
+var zPrimaryKeys = z3.record(zKeyName, zPrimaryKey).default({ key: "bytes32" });
+var zFullSchemaConfig = z3.record(zColumnName, zFieldData).refine((arg) => Object.keys(arg).length > 0, "Table schema may not be empty");
+var zShorthandSchemaConfig = zFieldData.transform((fieldData) => {
+  return zFullSchemaConfig.parse({
+    value: fieldData
+  });
+});
+var zSchemaConfig = zFullSchemaConfig.or(zShorthandSchemaConfig);
+var zFullTableConfig = z3.object({
+  directory: z3.string().default("tables"),
+  fileSelector: zSelector.optional(),
+  tableIdArgument: z3.boolean().default(false),
+  storeArgument: z3.boolean().default(false),
+  primaryKeys: zPrimaryKeys,
+  schema: zSchemaConfig,
+  dataStruct: z3.boolean().optional()
+}).transform((arg) => {
+  if (Object.keys(arg.schema).length === 1) {
+    arg.dataStruct ??= false;
+  } else {
+    arg.dataStruct ??= true;
+  }
+  return arg;
+});
+var zShorthandTableConfig = zFieldData.transform((fieldData) => {
+  return zFullTableConfig.parse({
+    schema: {
+      value: fieldData
+    }
+  });
+});
+var zTableConfig = zFullTableConfig.or(zShorthandTableConfig);
+var zTablesConfig = z3.record(zTableName, zTableConfig).transform((tables) => {
+  for (const tableName of Object.keys(tables)) {
+    const table = tables[tableName];
+    table.fileSelector ??= tableName;
+    tables[tableName] = table;
+  }
+  return tables;
+});
+var zEnumsConfig = z3.object({
+  enums: z3.record(zUserEnumName, zUserEnum).default({})
+});
+function storeConfig(config) {
+  return config;
+}
+var StoreConfigUnrefined = z3.object({
+  namespace: zSelector.default(""),
+  storeImportPath: z3.string().default("@latticexyz/store/src/"),
+  tables: zTablesConfig,
+  userTypesPath: z3.string().default("Types")
+}).merge(zEnumsConfig);
+var zStoreConfig = StoreConfigUnrefined.superRefine(validateStoreConfig);
+function parseStoreConfig(config) {
+  return zStoreConfig.parse(config);
+}
+function validateStoreConfig(config, ctx) {
+  for (const table of Object.values(config.tables)) {
+    const primaryKeyNames = Object.keys(table.primaryKeys);
+    const fieldNames = Object.keys(table.schema);
+    const duplicateVariableNames = getDuplicates([...primaryKeyNames, ...fieldNames]);
+    if (duplicateVariableNames.length > 0) {
+      ctx.addIssue({
+        code: ZodIssueCode3.custom,
+        message: `Field and primary key names within one table must be unique: ${duplicateVariableNames.join(", ")}`
+      });
+    }
+  }
+  const tableNames = Object.keys(config.tables);
+  const staticUserTypeNames = Object.keys(config.enums);
+  const userTypeNames = staticUserTypeNames;
+  const globalNames = [...tableNames, ...userTypeNames];
+  const duplicateGlobalNames = getDuplicates(globalNames);
+  if (duplicateGlobalNames.length > 0) {
+    ctx.addIssue({
+      code: ZodIssueCode3.custom,
+      message: `Table, enum names must be globally unique: ${duplicateGlobalNames.join(", ")}`
+    });
+  }
+  for (const table of Object.values(config.tables)) {
+    for (const primaryKeyType of Object.values(table.primaryKeys)) {
+      validateStaticAbiOrUserType(staticUserTypeNames, primaryKeyType, ctx);
+    }
+    for (const fieldType of Object.values(table.schema)) {
+      validateAbiOrUserType(userTypeNames, staticUserTypeNames, fieldType, ctx);
+    }
+  }
+}
+function validateAbiOrUserType(userTypeNames, staticUserTypeNames, type, ctx) {
+  if (!AbiTypes.includes(type) && !userTypeNames.includes(type)) {
+    const staticArray = parseStaticArray(type);
+    if (staticArray) {
+      validateStaticArray(staticUserTypeNames, staticArray.elementType, staticArray.staticLength, ctx);
+    } else {
+      ctx.addIssue({
+        code: ZodIssueCode3.custom,
+        message: `${type} is not a valid abi type, and is not defined in userTypes`
+      });
+    }
+  }
+}
+function validateStaticAbiOrUserType(staticUserTypeNames, type, ctx) {
+  if (!StaticAbiTypes.includes(type) && !staticUserTypeNames.includes(type)) {
+    ctx.addIssue({
+      code: ZodIssueCode3.custom,
+      message: `${type} is not a static type`
+    });
+  }
+}
+function validateStaticArray(staticUserTypeNames, elementType, staticLength, ctx) {
+  validateStaticAbiOrUserType(staticUserTypeNames, elementType, ctx);
+  if (staticLength === 0) {
+    ctx.addIssue({
+      code: ZodIssueCode3.custom,
+      message: `Static array length must not be 0`
+    });
+  } else if (staticLength >= 2 ** 16) {
+    ctx.addIssue({
+      code: ZodIssueCode3.custom,
+      message: `Static array length must be less than 2**16`
+    });
+  }
+}
+
+// src/config/loadStoreConfig.ts
+async function loadStoreConfig(configPath) {
+  const config = await loadConfig(configPath);
+  try {
+    return parseStoreConfig(config);
+  } catch (error) {
+    if (error instanceof ZodError2) {
+      throw fromZodErrorCustom(error, "StoreConfig Validation Error");
+    } else {
+      throw error;
+    }
+  }
+}
+
+// src/config/world/loadWorldConfig.ts
+import { ZodError as ZodError3 } from "zod";
+
+// src/config/world/parseWorldConfig.ts
+import { z as z4 } from "zod";
+
+// src/config/dynamicResolution.ts
+var DynamicResolutionType = /* @__PURE__ */ ((DynamicResolutionType2) => {
+  DynamicResolutionType2[DynamicResolutionType2["TABLE_ID"] = 0] = "TABLE_ID";
+  DynamicResolutionType2[DynamicResolutionType2["SYSTEM_ADDRESS"] = 1] = "SYSTEM_ADDRESS";
+  return DynamicResolutionType2;
+})(DynamicResolutionType || {});
+function resolveTableId(tableName) {
+  return {
+    type: 0 /* TABLE_ID */,
+    input: tableName
+  };
+}
+function isDynamicResolution(value) {
+  return typeof value === "object" && value !== null && "type" in value && "input" in value;
+}
+async function resolveWithContext(unresolved, context) {
+  if (!isDynamicResolution(unresolved))
+    return unresolved;
+  let resolved = void 0;
+  if (unresolved.type === 0 /* TABLE_ID */) {
+    const tableId = context.tableIds?.[unresolved.input];
+    resolved = tableId && { value: tableId, type: "bytes32" };
+  }
+  if (resolved === void 0) {
+    throw new MUDError(`Could not resolve dynamic resolution: 
+${JSON.stringify(unresolved, null, 2)}`);
+  }
+  return resolved;
+}
+
+// src/config/world/parseWorldConfig.ts
+var zSystemName = zObjectName;
+var zModuleName = zObjectName;
+var zSystemAccessList = z4.array(zSystemName.or(zEthereumAddress)).default([]);
+var zSystemConfig = z4.intersection(
+  z4.object({
+    fileSelector: zSelector,
+    registerFunctionSelectors: z4.boolean().default(true)
+  }),
+  z4.discriminatedUnion("openAccess", [
+    z4.object({
+      openAccess: z4.literal(true)
+    }),
+    z4.object({
+      openAccess: z4.literal(false),
+      accessList: zSystemAccessList
+    })
+  ])
+);
+var zValueWithType = z4.object({
+  value: z4.union([z4.string(), z4.number(), z4.instanceof(Uint8Array)]),
+  type: z4.string()
+});
+var zDynamicResolution = z4.object({ type: z4.nativeEnum(DynamicResolutionType), input: z4.string() });
+var zModuleConfig = z4.object({
+  name: zModuleName,
+  root: z4.boolean().default(false),
+  args: z4.array(z4.union([zValueWithType, zDynamicResolution])).default([])
+});
+var zWorldConfig = z4.object({
+  namespace: zSelector.default(""),
+  worldContractName: z4.string().optional(),
+  overrideSystems: z4.record(zSystemName, zSystemConfig).default({}),
+  excludeSystems: z4.array(zSystemName).default([]),
+  postDeployScript: z4.string().default("PostDeploy"),
+  deploysDirectory: z4.string().default("./deploys"),
+  worldgenDirectory: z4.string().default("world"),
+  worldImportPath: z4.string().default("@latticexyz/world/src/"),
+  modules: z4.array(zModuleConfig).default([])
+});
+async function parseWorldConfig(config) {
+  return zWorldConfig.parse(config);
+}
+
+// src/config/world/resolveWorldConfig.ts
+function resolveWorldConfig(config, existingContracts) {
+  const defaultSystemNames = existingContracts?.filter((name) => name.endsWith("System") && name !== "System" && !name.match(/^I[A-Z]/)) ?? [];
+  const overriddenSystemNames = Object.keys(config.overrideSystems);
+  if (existingContracts) {
+    for (const systemName of overriddenSystemNames) {
+      if (!existingContracts.includes(systemName) || systemName === "World") {
+        throw UnrecognizedSystemErrorFactory(["overrideSystems", systemName], systemName);
+      }
+    }
+  }
+  const systemNames = [.../* @__PURE__ */ new Set([...defaultSystemNames, ...overriddenSystemNames])].filter(
+    (name) => !config.excludeSystems.includes(name)
+  );
+  const resolvedSystems = systemNames.reduce((acc, systemName) => {
+    return {
+      ...acc,
+      [systemName]: resolveSystemConfig(systemName, config.overrideSystems[systemName], existingContracts)
+    };
+  }, {});
+  const { overrideSystems, excludeSystems, ...otherConfig } = config;
+  return { ...otherConfig, systems: resolvedSystems };
+}
+function resolveSystemConfig(systemName, config, existingContracts) {
+  const fileSelector = config?.fileSelector ?? systemName;
+  const registerFunctionSelectors = config?.registerFunctionSelectors ?? true;
+  const openAccess = config?.openAccess ?? true;
+  const accessListAddresses = [];
+  const accessListSystems = [];
+  const accessList = config && !config.openAccess ? config.accessList : [];
+  for (const accessListItem of accessList) {
+    if (accessListItem.startsWith("0x")) {
+      accessListAddresses.push(accessListItem);
+    } else {
+      if (existingContracts && !existingContracts.includes(accessListItem)) {
+        throw UnrecognizedSystemErrorFactory(["overrideSystems", systemName, "accessList"], accessListItem);
+      }
+      accessListSystems.push(accessListItem);
+    }
+  }
+  return { fileSelector, registerFunctionSelectors, openAccess, accessListAddresses, accessListSystems };
+}
+
+// src/config/world/loadWorldConfig.ts
+async function loadWorldConfig(configPath, existingContracts) {
+  const config = await loadConfig(configPath);
+  try {
+    const parsedConfig = zWorldConfig.parse(config);
+    return resolveWorldConfig(parsedConfig, existingContracts);
+  } catch (error) {
+    if (error instanceof ZodError3) {
+      throw fromZodErrorCustom(error, "WorldConfig Validation Error");
+    } else {
+      throw error;
+    }
+  }
+}
+
+// src/config/index.ts
+function mudConfig(config) {
+  return config;
+}
+
 export {
+  fromZodErrorCustom,
+  NotInsideProjectError,
+  NotESMConfigError,
+  MUDError,
+  UnrecognizedSystemErrorFactory,
+  logError,
+  loadConfig,
   SchemaType,
   getStaticByteLength,
   encodeSchema,
   SchemaTypeArrayToElement,
   SchemaTypeToAbiType,
   AbiTypeToSchemaType,
-  AbiTypes,
-  StaticAbiTypes,
   validateName,
   validateCapitalizedName,
   validateUncapitalizedName,
@@ -726,5 +1134,32 @@ export {
   validateEthereumAddress,
   getDuplicates,
   validateSelector,
-  parseStaticArray
+  parseStaticArray,
+  zObjectName,
+  zValueName,
+  zAnyCaseName,
+  zUserEnum,
+  zOrdinaryRoute,
+  zSingleLevelRoute,
+  zBaseRoute,
+  zEthereumAddress,
+  zSelector,
+  zSchemaConfig,
+  zTableConfig,
+  zTablesConfig,
+  zEnumsConfig,
+  storeConfig,
+  zStoreConfig,
+  parseStoreConfig,
+  loadStoreConfig,
+  DynamicResolutionType,
+  resolveTableId,
+  isDynamicResolution,
+  resolveWithContext,
+  zWorldConfig,
+  parseWorldConfig,
+  resolveWorldConfig,
+  resolveSystemConfig,
+  loadWorldConfig,
+  mudConfig
 };