@latticexyz/cli 1.41.1-alpha.41 → 1.42.0

package/src/config/validation.ts

@@ -1,163 +0,0 @@
-import { ethers } from "ethers";
-import { ZodIssueCode, RefinementCtx } from "zod";
-
-export function validateName(name: string, ctx: RefinementCtx) {
-  if (!/^\w+$/.test(name)) {
-    ctx.addIssue({
-      code: ZodIssueCode.custom,
-      message: `Name must contain only alphanumeric & underscore characters`,
-    });
-  }
-}
-
-export function validateCapitalizedName(name: string, ctx: RefinementCtx) {
-  validateName(name, ctx);
-
-  if (!/^[A-Z]/.test(name)) {
-    ctx.addIssue({
-      code: ZodIssueCode.custom,
-      message: `Name must start with a capital letter`,
-    });
-  }
-}
-
-export function validateUncapitalizedName(name: string, ctx: RefinementCtx) {
-  validateName(name, ctx);
-
-  if (!/^[a-z]/.test(name)) {
-    ctx.addIssue({
-      code: ZodIssueCode.custom,
-      message: `Name must start with a lowercase letter`,
-    });
-  }
-}
-
-// validates only the enum array, not the names of enum members
-export function validateEnum(members: string[], ctx: RefinementCtx) {
-  if (members.length === 0) {
-    ctx.addIssue({
-      code: ZodIssueCode.custom,
-      message: `Enum must not be empty`,
-    });
-  }
-  if (members.length >= 256) {
-    ctx.addIssue({
-      code: ZodIssueCode.custom,
-      message: `Length of enum must be < 256`,
-    });
-  }
-
-  const duplicates = getDuplicates(members);
-  if (duplicates.length > 0) {
-    ctx.addIssue({
-      code: ZodIssueCode.custom,
-      message: `Enum must not have duplicate names for: ${duplicates.join(", ")}`,
-    });
-  }
-}
-
-function _factoryForValidateRoute(requireNonEmpty: boolean, requireSingleLevel: boolean) {
-  return (route: string, ctx: RefinementCtx) => {
-    if (route === "") {
-      if (requireNonEmpty) {
-        ctx.addIssue({
-          code: ZodIssueCode.custom,
-          message: `Route must not be empty`,
-        });
-      }
-      // we can skip further validation for empty routes
-      return;
-    }
-
-    if (route[0] !== "/") {
-      ctx.addIssue({
-        code: ZodIssueCode.custom,
-        message: `Route must start with "/"`,
-      });
-    }
-
-    if (route[route.length - 1] === "/") {
-      ctx.addIssue({
-        code: ZodIssueCode.custom,
-        message: `Route must not end with "/"`,
-      });
-    }
-
-    const parts = route.split("/");
-    if (requireSingleLevel && parts.length > 2) {
-      ctx.addIssue({
-        code: ZodIssueCode.custom,
-        message: `Route must only have one level (e.g. "/foo")`,
-      });
-    }
-
-    // start at 1 to skip the first empty part
-    for (let i = 1; i < parts.length; i++) {
-      if (parts[i] === "") {
-        ctx.addIssue({
-          code: ZodIssueCode.custom,
-          message: `Route must not contain empty route fragments (e.g. "//")`,
-        });
-      }
-
-      if (!/^\w+$/.test(parts[i])) {
-        ctx.addIssue({
-          code: ZodIssueCode.custom,
-          message: `Route must contain only alphanumeric & underscore characters`,
-        });
-      }
-    }
-  };
-}
-
-export const validateRoute = _factoryForValidateRoute(true, false);
-
-export const validateBaseRoute = _factoryForValidateRoute(false, false);
-
-export const validateSingleLevelRoute = _factoryForValidateRoute(true, true);
-
-export function validateEthereumAddress(address: string, ctx: RefinementCtx) {
-  if (!ethers.utils.isAddress(address)) {
-    ctx.addIssue({
-      code: ZodIssueCode.custom,
-      message: `Address must be a valid Ethereum address`,
-    });
-  }
-}
-
-export function getDuplicates<T>(array: T[]) {
-  const checked = new Set<T>();
-  const duplicates = new Set<T>();
-  for (const element of array) {
-    if (checked.has(element)) {
-      duplicates.add(element);
-    }
-    checked.add(element);
-  }
-  return [...duplicates];
-}
-
-export function validateSelector(name: string, ctx: RefinementCtx) {
-  if (name.length > 16) {
-    ctx.addIssue({
-      code: ZodIssueCode.custom,
-      message: `Selector must be <= 16 characters`,
-    });
-  }
-  if (!/^\w*$/.test(name)) {
-    ctx.addIssue({
-      code: ZodIssueCode.custom,
-      message: `Selector must contain only alphanumeric & underscore characters`,
-    });
-  }
-}
-
-/** Returns null if the type does not look like a static array, otherwise element and length data */
-export function parseStaticArray(abiType: string) {
-  const matches = abiType.match(/^(\w+)\[(\d+)\]$/);
-  if (!matches) return null;
-  return {
-    elementType: matches[1],
-    staticLength: Number.parseInt(matches[2]),
-  };
-}

package/src/config/world/index.ts

@@ -1,4 +0,0 @@
-export * from "./loadWorldConfig.js";
-export * from "./parseWorldConfig.js";
-export * from "./resolveWorldConfig.js";
-export * from "./userTypes.js";

package/src/config/world/loadWorldConfig.test-d.ts

@@ -1,11 +0,0 @@
-import { describe, expectTypeOf } from "vitest";
-import { z } from "zod";
-import { zWorldConfig, WorldUserConfig } from "./index.js";
-
-describe("loadWorldConfig", () => {
-  // Typecheck manual interfaces against zod
-  expectTypeOf<WorldUserConfig>().toEqualTypeOf<z.input<typeof zWorldConfig>>();
-  // type equality isn't deep for optionals
-  expectTypeOf<WorldUserConfig["overrideSystems"]>().toEqualTypeOf<z.input<typeof zWorldConfig>["overrideSystems"]>();
-  // TODO If more nested schemas are added, provide separate tests for them
-});

package/src/config/world/loadWorldConfig.ts

@@ -1,26 +0,0 @@
-import { ZodError } from "zod";
-import { fromZodErrorCustom } from "../../utils/errors.js";
-import { loadConfig } from "../loadConfig.js";
-import { zWorldConfig } from "./parseWorldConfig.js";
-import { resolveWorldConfig } from "./resolveWorldConfig.js";
-
-/**
- * Loads and resolves the world config.
- * @param configPath Path to load the config from. Defaults to "mud.config.mts" or "mud.config.ts"
- * @param existingContracts Optional list of existing contract names to validate system names against. If not provided, no validation is performed. Contract names ending in `System` will be added to the config with default values.
- * @returns Promise of ResolvedWorldConfig object
- */
-export async function loadWorldConfig(configPath?: string, existingContracts?: string[]) {
-  const config = await loadConfig(configPath);
-
-  try {
-    const parsedConfig = zWorldConfig.parse(config);
-    return resolveWorldConfig(parsedConfig, existingContracts);
-  } catch (error) {
-    if (error instanceof ZodError) {
-      throw fromZodErrorCustom(error, "WorldConfig Validation Error");
-    } else {
-      throw error;
-    }
-  }
-}

package/src/config/world/parseWorldConfig.ts

@@ -1,55 +0,0 @@
-import { z } from "zod";
-import { zEthereumAddress, zObjectName, zSelector } from "../commonSchemas.js";
-import { DynamicResolutionType } from "../dynamicResolution.js";
-
-const zSystemName = zObjectName;
-const zModuleName = zObjectName;
-const zSystemAccessList = z.array(zSystemName.or(zEthereumAddress)).default([]);
-
-// The system config is a combination of a fileSelector config and access config
-const zSystemConfig = z.intersection(
-  z.object({
-    fileSelector: zSelector,
-    registerFunctionSelectors: z.boolean().default(true),
-  }),
-  z.discriminatedUnion("openAccess", [
-    z.object({
-      openAccess: z.literal(true),
-    }),
-    z.object({
-      openAccess: z.literal(false),
-      accessList: zSystemAccessList,
-    }),
-  ])
-);
-
-const zValueWithType = z.object({
-  value: z.union([z.string(), z.number(), z.instanceof(Uint8Array)]),
-  type: z.string(),
-});
-const zDynamicResolution = z.object({ type: z.nativeEnum(DynamicResolutionType), input: z.string() });
-
-const zModuleConfig = z.object({
-  name: zModuleName,
-  root: z.boolean().default(false),
-  args: z.array(z.union([zValueWithType, zDynamicResolution])).default([]),
-});
-
-// The parsed world config is the result of parsing the user config
-export const zWorldConfig = z.object({
-  namespace: zSelector.default(""),
-  worldContractName: z.string().optional(),
-  overrideSystems: z.record(zSystemName, zSystemConfig).default({}),
-  excludeSystems: z.array(zSystemName).default([]),
-  postDeployScript: z.string().default("PostDeploy"),
-  deploysDirectory: z.string().default("./deploys"),
-  worldgenDirectory: z.string().default("world"),
-  worldImportPath: z.string().default("@latticexyz/world/src/"),
-  modules: z.array(zModuleConfig).default([]),
-});
-
-export async function parseWorldConfig(config: unknown) {
-  return zWorldConfig.parse(config);
-}
-
-export type ParsedWorldConfig = z.output<typeof zWorldConfig>;

package/src/config/world/resolveWorldConfig.ts

@@ -1,80 +0,0 @@
-import { UnrecognizedSystemErrorFactory } from "../../utils/errors.js";
-import { ParsedWorldConfig } from "./parseWorldConfig.js";
-import { SystemUserConfig } from "./userTypes.js";
-
-export type ResolvedSystemConfig = ReturnType<typeof resolveSystemConfig>;
-
-export type ResolvedWorldConfig = ReturnType<typeof resolveWorldConfig>;
-
-/**
- * Resolves the world config by combining the default and overridden system configs,
- * filtering out excluded systems, validate system names refer to existing contracts, and
- * splitting the access list into addresses and system names.
- */
-export function resolveWorldConfig(config: ParsedWorldConfig, existingContracts?: string[]) {
-  // Include contract names ending in "System", but not the base "System" contract, and not Interfaces
-  const defaultSystemNames =
-    existingContracts?.filter((name) => name.endsWith("System") && name !== "System" && !name.match(/^I[A-Z]/)) ?? [];
-  const overriddenSystemNames = Object.keys(config.overrideSystems);
-
-  // Validate every key in overrideSystems refers to an existing system contract (and is not called "World")
-  if (existingContracts) {
-    for (const systemName of overriddenSystemNames) {
-      if (!existingContracts.includes(systemName) || systemName === "World") {
-        throw UnrecognizedSystemErrorFactory(["overrideSystems", systemName], systemName);
-      }
-    }
-  }
-
-  // Combine the default and overridden system names and filter out excluded systems
-  const systemNames = [...new Set([...defaultSystemNames, ...overriddenSystemNames])].filter(
-    (name) => !config.excludeSystems.includes(name)
-  );
-
-  // Resolve the config
-  const resolvedSystems: Record<string, ResolvedSystemConfig> = systemNames.reduce((acc, systemName) => {
-    return {
-      ...acc,
-      [systemName]: resolveSystemConfig(systemName, config.overrideSystems[systemName], existingContracts),
-    };
-  }, {});
-
-  const { overrideSystems, excludeSystems, ...otherConfig } = config;
-  return { ...otherConfig, systems: resolvedSystems };
-}
-
-/**
- * Resolves the system config by combining the default and overridden system configs,
- * @param systemName name of the system
- * @param config optional SystemConfig object, if none is provided the default config is used
- * @param existingContracts optional list of existing contract names, used to validate system names in the access list. If not provided, no validation is performed.
- * @returns ResolvedSystemConfig object
- * Default value for fileSelector is `systemName`
- * Default value for registerFunctionSelectors is true
- * Default value for openAccess is true
- * Default value for accessListAddresses is []
- * Default value for accessListSystems is []
- */
-export function resolveSystemConfig(systemName: string, config?: SystemUserConfig, existingContracts?: string[]) {
-  const fileSelector = config?.fileSelector ?? systemName;
-  const registerFunctionSelectors = config?.registerFunctionSelectors ?? true;
-  const openAccess = config?.openAccess ?? true;
-  const accessListAddresses: string[] = [];
-  const accessListSystems: string[] = [];
-  const accessList = config && !config.openAccess ? config.accessList : [];
-
-  // Split the access list into addresses and system names
-  for (const accessListItem of accessList) {
-    if (accessListItem.startsWith("0x")) {
-      accessListAddresses.push(accessListItem);
-    } else {
-      // Validate every system refers to an existing system contract
-      if (existingContracts && !existingContracts.includes(accessListItem)) {
-        throw UnrecognizedSystemErrorFactory(["overrideSystems", systemName, "accessList"], accessListItem);
-      }
-      accessListSystems.push(accessListItem);
-    }
-  }
-
-  return { fileSelector, registerFunctionSelectors, openAccess, accessListAddresses, accessListSystems };
-}

package/src/config/world/userTypes.ts

@@ -1,72 +0,0 @@
-import { DynamicResolution } from "../dynamicResolution.js";
-
-// zod doesn't preserve doc comments
-export type SystemUserConfig =
-  | {
-      /** The full resource selector consists of namespace and fileSelector */
-      fileSelector?: string;
-      /**
-       * Register function selectors for the system in the World.
-       * Defaults to true.
-       * Note:
-       * - For root systems all World function selectors will correspond to the system's function selectors.
-       * - For non-root systems, the World function selectors will be <namespace>_<system>_<function>.
-       */
-      registerFunctionSelectors?: boolean;
-    } & (
-      | {
-          /** If openAccess is true, any address can call the system */
-          openAccess: true;
-        }
-      | {
-          /** If openAccess is false, only the addresses or systems in `access` can call the system */
-          openAccess: false;
-          /** An array of addresses or system names that can access the system */
-          accessList: string[];
-        }
-    );
-
-export type ValueWithType = {
-  value: string | number | Uint8Array;
-  type: string;
-};
-
-export type ModuleConfig = {
-  /** The name of the module */
-  name: string;
-  /** Should this module be installed as a root module? */
-  root?: boolean;
-  /** Arguments to be passed to the module's install method */
-  args?: (ValueWithType | DynamicResolution)[];
-};
-
-// zod doesn't preserve doc comments
-export interface WorldUserConfig {
-  /** The namespace to register tables and systems at. Defaults to the root namespace (empty string) */
-  namespace?: string;
-  /** The name of the World contract to deploy. If no name is provided, a vanilla World is deployed */
-  worldContractName?: string;
-  /**
-   * Contracts named *System will be deployed by default
-   * as public systems at `namespace/ContractName`, unless overridden
-   *
-   * The key is the system name (capitalized).
-   * The value is a SystemConfig object.
-   */
-  overrideSystems?: Record<string, SystemUserConfig>;
-  /** Systems to exclude from automatic deployment */
-  excludeSystems?: string[];
-  /**
-   * Script to execute after the deployment is complete (Default "PostDeploy").
-   * Script must be placed in the forge scripts directory (see foundry.toml) and have a ".s.sol" extension.
-   */
-  postDeployScript?: string;
-  /** Directory to write the deployment info to (Default "./deploys") */
-  deploysDirectory?: string;
-  /** Directory to output system and world interfaces of `worldgen` (Default "world") */
-  worldgenDirectory?: string;
-  /** Path for world package imports. Default is "@latticexyz/world/src/" */
-  worldImportPath?: string;
-  /** Modules to in the World */
-  modules?: ModuleConfig[];
-}

package/src/utils/typeUtils.ts

@@ -1,17 +0,0 @@
-import { AbiType, StaticAbiType } from "@latticexyz/schema-type";
-
-export type RequireKeys<T extends Record<string, unknown>, P extends string> = T & Required<Pick<T, P>>;
-
-// This allows unions between string literals and `string` without sacrificing autocompletion.
-// Workaround for https://github.com/Microsoft/TypeScript/issues/29729
-export type StringForUnion = string & Record<never, never>;
-
-export type StaticArray = `${StaticAbiType}[${number}]`;
-// static arrays and inferred enum names get mixed together - this helper separates them
-export type ExtractUserTypes<UnknownTypes extends StringForUnion> = Exclude<UnknownTypes, AbiType | StaticArray>;
-
-// When type inference sees multiple uses of 1 generic, it can only guess
-// which of those are supposed to define the generic (and it will be wrong in complex situations).
-// This helper explicitly makes a type that's dependent on some generic,
-// and will not be inferred as the generic's definition.
-export type AsDependent<T> = T extends infer P ? P : never;