@latticexyz/cli 1.40.0 → 1.41.0

package/dist/chunk-YZATC2M3.js

@@ -0,0 +1,397 @@
+import {
+  NotESMConfigError,
+  NotInsideProjectError,
+  SchemaType,
+  UnrecognizedSystemErrorFactory,
+  fromZodErrorCustom,
+  getStaticByteLength
+} from "./chunk-GR245KYP.js";
+
+// src/config/validation.ts
+import { ethers } from "ethers";
+import { ZodIssueCode } from "zod";
+function validateName(name, ctx) {
+  if (!/^\w+$/.test(name)) {
+    ctx.addIssue({
+      code: ZodIssueCode.custom,
+      message: `Name must contain only alphanumeric & underscore characters`
+    });
+  }
+}
+function validateCapitalizedName(name, ctx) {
+  validateName(name, ctx);
+  if (!/^[A-Z]/.test(name)) {
+    ctx.addIssue({
+      code: ZodIssueCode.custom,
+      message: `Name must start with a capital letter`
+    });
+  }
+}
+function validateUncapitalizedName(name, ctx) {
+  validateName(name, ctx);
+  if (!/^[a-z]/.test(name)) {
+    ctx.addIssue({
+      code: ZodIssueCode.custom,
+      message: `Name must start with a lowercase letter`
+    });
+  }
+}
+function validateEnum(members, ctx) {
+  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, requireSingleLevel) {
+  return (route, ctx) => {
+    if (route === "") {
+      if (requireNonEmpty) {
+        ctx.addIssue({
+          code: ZodIssueCode.custom,
+          message: `Route must not be empty`
+        });
+      }
+      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")`
+      });
+    }
+    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`
+        });
+      }
+    }
+  };
+}
+var validateRoute = _factoryForValidateRoute(true, false);
+var validateBaseRoute = _factoryForValidateRoute(false, false);
+var validateSingleLevelRoute = _factoryForValidateRoute(true, true);
+function validateEthereumAddress(address, ctx) {
+  if (!ethers.utils.isAddress(address)) {
+    ctx.addIssue({
+      code: ZodIssueCode.custom,
+      message: `Address must be a valid Ethereum address`
+    });
+  }
+}
+function getDuplicates(array) {
+  const checked = /* @__PURE__ */ new Set();
+  const duplicates = /* @__PURE__ */ new Set();
+  for (const element of array) {
+    if (checked.has(element)) {
+      duplicates.add(element);
+    }
+    checked.add(element);
+  }
+  return [...duplicates];
+}
+
+// src/config/commonSchemas.ts
+import { z } from "zod";
+var ObjectName = z.string().superRefine(validateCapitalizedName);
+var ValueName = z.string().superRefine(validateUncapitalizedName);
+var AnyCaseName = z.string().superRefine(validateName);
+var UserEnum = z.array(ObjectName).superRefine(validateEnum);
+var OrdinaryRoute = z.string().superRefine(validateRoute);
+var SingleLevelRoute = z.string().superRefine(validateSingleLevelRoute);
+var BaseRoute = z.string().superRefine(validateBaseRoute);
+var EthereumAddress = z.string().superRefine(validateEthereumAddress);
+var StaticSchemaType = z.nativeEnum(SchemaType).refine((arg) => getStaticByteLength(arg) > 0, "SchemaType must be static");
+
+// src/config/parseStoreConfig.ts
+import { z as z2, ZodIssueCode as ZodIssueCode2 } from "zod";
+var TableName = ObjectName;
+var KeyName = ValueName;
+var ColumnName = ValueName;
+var UserEnumName = ObjectName;
+var FieldData = z2.union([z2.nativeEnum(SchemaType), UserEnumName]);
+var PrimaryKey = z2.union([StaticSchemaType, UserEnumName]);
+var PrimaryKeys = z2.record(KeyName, PrimaryKey).default({ key: 95 /* BYTES32 */ });
+var Schema = z2.record(ColumnName, FieldData).refine((arg) => Object.keys(arg).length > 0, "Table schema may not be empty");
+var TableDataFull = z2.object({
+  directory: OrdinaryRoute.default("/tables"),
+  route: BaseRoute.optional(),
+  tableIdArgument: z2.boolean().default(false),
+  storeArgument: z2.boolean().default(false),
+  primaryKeys: PrimaryKeys,
+  schema: Schema,
+  dataStruct: z2.boolean().optional()
+}).transform((arg) => {
+  if (Object.keys(arg.schema).length === 1) {
+    arg.dataStruct ??= false;
+  } else {
+    arg.dataStruct ??= true;
+  }
+  return arg;
+});
+var TableDataShorthand = FieldData.transform((fieldData) => {
+  return TableDataFull.parse({
+    schema: {
+      value: fieldData
+    }
+  });
+});
+var TablesRecord = z2.record(TableName, z2.union([TableDataShorthand, TableDataFull])).transform((tables) => {
+  for (const tableName of Object.keys(tables)) {
+    const table = tables[tableName];
+    table.route ??= `/${tableName}`;
+    tables[tableName] = table;
+  }
+  return tables;
+});
+var StoreConfigUnrefined = z2.object({
+  baseRoute: BaseRoute.default(""),
+  storeImportPath: z2.string().default("@latticexyz/store/src/"),
+  tables: TablesRecord,
+  userTypes: z2.object({
+    path: OrdinaryRoute.default("/types"),
+    enums: z2.record(UserEnumName, UserEnum).default({})
+  }).default({})
+});
+var StoreConfig = StoreConfigUnrefined.superRefine(validateStoreConfig);
+async function parseStoreConfig(config) {
+  return StoreConfig.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: ZodIssueCode2.custom,
+        message: `Field and primary key names within one table must be unique: ${duplicateVariableNames.join(", ")}`
+      });
+    }
+  }
+  const tableNames = Object.keys(config.tables);
+  const userTypeNames = Object.keys(config.userTypes.enums);
+  const globalNames = [...tableNames, ...userTypeNames];
+  const duplicateGlobalNames = getDuplicates(globalNames);
+  if (duplicateGlobalNames.length > 0) {
+    ctx.addIssue({
+      code: ZodIssueCode2.custom,
+      message: `Table and enum names must be globally unique: ${duplicateGlobalNames.join(", ")}`
+    });
+  }
+  for (const table of Object.values(config.tables)) {
+    for (const primaryKeyType of Object.values(table.primaryKeys)) {
+      validateIfUserType(userTypeNames, primaryKeyType, ctx);
+    }
+    for (const fieldType of Object.values(table.schema)) {
+      validateIfUserType(userTypeNames, fieldType, ctx);
+    }
+  }
+}
+function validateIfUserType(userTypeNames, type, ctx) {
+  if (typeof type === "string" && !userTypeNames.includes(type)) {
+    ctx.addIssue({
+      code: ZodIssueCode2.custom,
+      message: `User type ${type} is not defined in userTypes`
+    });
+  }
+}
+
+// src/config/loadConfig.ts
+import { findUp } from "find-up";
+import path from "path";
+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 } from "zod";
+async function loadStoreConfig(configPath) {
+  const config = await loadConfig(configPath);
+  try {
+    return parseStoreConfig(config);
+  } catch (error) {
+    if (error instanceof ZodError) {
+      throw fromZodErrorCustom(error, "StoreConfig Validation Error");
+    } else {
+      throw error;
+    }
+  }
+}
+
+// src/config/loadWorldConfig.ts
+import { z as z3, ZodError as ZodError2 } from "zod";
+var SystemName = ObjectName;
+var SystemRoute = BaseRoute.optional();
+var SystemAccessList = z3.array(SystemName.or(EthereumAddress)).default([]);
+var SystemConfig = z3.intersection(
+  z3.object({
+    route: SystemRoute
+  }),
+  z3.discriminatedUnion("openAccess", [
+    z3.object({
+      openAccess: z3.literal(true)
+    }),
+    z3.object({
+      openAccess: z3.literal(false),
+      accessList: SystemAccessList
+    })
+  ])
+);
+var WorldConfig = z3.object({
+  baseRoute: BaseRoute.default(""),
+  worldContractName: z3.string().optional(),
+  overrideSystems: z3.record(SystemName, SystemConfig).default({}),
+  excludeSystems: z3.array(SystemName).default([]),
+  postDeployScript: z3.string().default("PostDeploy"),
+  deploymentInfoDirectory: z3.string().default(".")
+});
+function resolveSystemConfig(systemName, config, existingContracts) {
+  const route = config?.route ?? `/${systemName}`;
+  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 { route, openAccess, accessListAddresses, accessListSystems };
+}
+function resolveWorldConfig(config, existingContracts) {
+  const defaultSystemNames = existingContracts?.filter((name) => name.endsWith("System") && name !== "System") ?? [];
+  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 };
+}
+async function loadWorldConfig(configPath, existingContracts) {
+  const config = await loadConfig(configPath);
+  try {
+    const parsedConfig = WorldConfig.parse(config);
+    return resolveWorldConfig(parsedConfig, existingContracts);
+  } catch (error) {
+    if (error instanceof ZodError2) {
+      throw fromZodErrorCustom(error, "WorldConfig Validation Error");
+    } else {
+      throw error;
+    }
+  }
+}
+async function parseWorldConfig(config) {
+  return WorldConfig.parse(config);
+}
+
+export {
+  validateName,
+  validateCapitalizedName,
+  validateUncapitalizedName,
+  validateEnum,
+  validateRoute,
+  validateBaseRoute,
+  validateSingleLevelRoute,
+  validateEthereumAddress,
+  getDuplicates,
+  ObjectName,
+  ValueName,
+  AnyCaseName,
+  UserEnum,
+  OrdinaryRoute,
+  SingleLevelRoute,
+  BaseRoute,
+  EthereumAddress,
+  StaticSchemaType,
+  StoreConfig,
+  parseStoreConfig,
+  loadConfig,
+  loadStoreConfig,
+  WorldConfig,
+  resolveSystemConfig,
+  resolveWorldConfig,
+  loadWorldConfig,
+  parseWorldConfig
+};