apibara 2.1.0-beta.4 → 2.1.0-beta.41

package/src/core/build/error.ts

@@ -1,29 +1,24 @@
-import type esbuild from "esbuild";
 import { isAbsolute, relative } from "pathe";
-import type rollup from "rollup";
+import type * as rolldown from "rolldown";
 
-export function formatRollupError(
-  _error: rollup.RollupError | esbuild.OnResolveResult,
-) {
+export function formatRolldownError(_error: rolldown.RollupError) {
   try {
     const logs: string[] = [_error.toString()];
     // biome-ignore lint/suspicious/noExplicitAny: <explanation>
-    const errors = (_error as any)?.errors || [_error as rollup.RollupError];
+    const errors = (_error as any)?.errors || [_error as rolldown.RollupError];
     for (const error of errors) {
-      const id = error.path || error.id || (_error as rollup.RollupError).id;
+      const id = error.path || error.id || (_error as rolldown.RollupError).id;
       let path = isAbsolute(id) ? relative(process.cwd(), id) : id;
-      const location =
-        (error as rollup.RollupError).loc ||
-        (error as esbuild.PartialMessage).location;
+      const location = (error as rolldown.RollupError).loc;
       if (location) {
         path += `:${location.line}:${location.column}`;
       }
-      const text =
-        (error as esbuild.PartialMessage).text ||
-        (error as rollup.RollupError).frame;
+      const text = (error as rolldown.RollupError).frame;
 
       logs.push(
-        `Rollup error while processing \`${path}\`` + text ? "\n\n" + text : "",
+        `Rolldown error while processing \`${path}\`` + text
+          ? "\n\n" + text
+          : "",
       );
     }
     return logs.join("\n");

package/src/core/build/prepare.ts

@@ -7,9 +7,11 @@ export async function prepare(apibara: Apibara) {
   await prepareDir(apibara.options.buildDir);
   await prepareDir(apibara.options.outputDir);
 
-  apibara.logger.success(
-    `Output directory ${prettyPath(apibara.options.outputDir)} cleaned`,
-  );
+  if (!apibara.options.disableLogs) {
+    apibara.logger.success(
+      `Output directory ${prettyPath(apibara.options.outputDir)} cleaned`,
+    );
+  }
 }
 
 async function prepareDir(dir: string) {

package/src/core/build/prod.ts

@@ -1,34 +1,43 @@
-import type { Apibara, RollupConfig } from "apibara/types";
+import type { Apibara } from "apibara/types";
 import { colors } from "consola/utils";
-import { type OutputOptions, rollup } from "rollup";
+import * as rolldown from "rolldown";
 
 export async function buildProduction(
   apibara: Apibara,
-  rollupConfig: RollupConfig,
+  rolldownConfig: rolldown.RolldownOptions,
 ) {
-  apibara.logger.start(
-    `Building ${colors.cyan(apibara.indexers.length)} indexers`,
-  );
+  if (!apibara.options.disableLogs) {
+    apibara.logger.start(
+      `Building ${colors.cyan(apibara.indexers.length)} indexers`,
+    );
+  }
+
+  const startTime = Date.now();
 
   try {
-    const bundle = await rollup(rollupConfig);
+    const bundle = await rolldown.rolldown(rolldownConfig);
 
-    if (Array.isArray(rollupConfig.output)) {
-      for (const outputOptions of rollupConfig.output) {
+    if (Array.isArray(rolldownConfig.output)) {
+      for (const outputOptions of rolldownConfig.output) {
         await bundle.write(outputOptions);
       }
-    } else if (rollupConfig.output) {
-      await bundle.write(rollupConfig.output as OutputOptions);
+    } else if (rolldownConfig.output) {
+      await bundle.write(rolldownConfig.output as rolldown.OutputOptions);
     } else {
-      throw new Error("No output options specified in Rollup config");
+      throw new Error("No output options specified in Rolldown config");
     }
 
     await bundle.close();
 
-    apibara.logger.success("Build succeeded!");
-    apibara.logger.info(
-      `You can start the indexers with ${colors.cyan("apibara start")}`,
-    );
+    const endTime = Date.now();
+    const duration = endTime - startTime;
+
+    if (!apibara.options.disableLogs) {
+      apibara.logger.success(`Build succeeded in ${duration}ms`);
+      apibara.logger.info(
+        `You can start the indexers with ${colors.cyan("apibara start")}`,
+      );
+    }
   } catch (error) {
     apibara.logger.error("Build failed", error);
     throw error;

package/src/core/build/types.ts

@@ -5,6 +5,14 @@ import { type JSValue, generateTypes, resolveSchema } from "untyped";
 import { prettyPath } from "../path";
 
 export async function writeTypes(apibara: Apibara) {
+  // Check if the config file has a TypeScript extension so we assume it's a TypeScript project
+  const isTypeScript = apibara.options._c12.configFile?.endsWith(".ts");
+
+  if (!isTypeScript) {
+    // If it's not a TypeScript project, we don't need to generate the types
+    return;
+  }
+
   const typesDir = resolve(apibara.options.buildDir, "types");
 
   const config = [
@@ -47,5 +55,7 @@ declare module "apibara/types" {`,
     }),
   );
 
-  apibara.logger.success(`Types written to ${prettyPath(typesDir)}`);
+  if (!apibara.options.disableLogs) {
+    apibara.logger.success(`Types written to ${prettyPath(typesDir)}`);
+  }
 }

package/src/core/config/defaults.ts

@@ -14,4 +14,7 @@ export const ApibaraDefaults: ApibaraConfig = {
     generateRuntimeConfigTypes: true,
     internalPaths: false,
   },
+
+  node: true,
+  exportConditions: ["node"],
 };

package/src/core/config/loader.ts

@@ -7,14 +7,10 @@ import { loadConfig, watchConfig } from "c12";
 import { klona } from "klona/full";
 import { ApibaraDefaults } from "./defaults";
 import { resolvePathOptions } from "./resolvers/paths.resolver";
-import { presetResolver } from "./resolvers/preset.resolver";
-import { resolveRuntimeConfigOptions } from "./resolvers/runtime-config.resolver";
+import { runtimeConfigResolver } from "./resolvers/runtime.resolver";
 
-const configResolvers = [
-  resolvePathOptions,
-  resolveRuntimeConfigOptions,
-  presetResolver,
-] as const;
+// runtimeConfigResolver handles assigning runtime values to env
+const configResolvers = [resolvePathOptions, runtimeConfigResolver] as const;
 
 export async function loadOptions(
   configOverrides: ApibaraConfig = {},
@@ -22,9 +18,21 @@ export async function loadOptions(
   dev = false,
 ): Promise<ApibaraOptions> {
   const options = await _loadUserConfig(configOverrides, opts, dev);
+
+  // Check if the runtimeConfig is serializable
+  try {
+    JSON.stringify(options.runtimeConfig);
+  } catch (error) {
+    throw new Error(
+      "Non-serializable runtimeConfig. Please ensure the config is serializable.",
+      { cause: error },
+    );
+  }
+
   for (const resolver of configResolvers) {
     await resolver(options);
   }
+
   return options;
 }
 

package/src/core/config/resolvers/runtime.resolver.ts

@@ -0,0 +1,44 @@
+import {
+  ENV_INTERNAL_APIBARA_PRESET,
+  ENV_INTERNAL_APIBARA_PRESETS,
+  ENV_INTERNAL_APIBARA_PROCESSED_RUNTIME,
+  ENV_INTERNAL_APIBARA_RUNTIME,
+  USER_ENV_APIBARA_RUNTIME_CONFIG,
+  getProcessedRuntimeConfig,
+} from "apibara/common";
+import type { ApibaraOptions } from "apibara/types";
+
+export function runtimeConfigResolver(options: Partial<ApibaraOptions>) {
+  try {
+    const { runtimeConfig, preset, presets } = options;
+
+    if (runtimeConfig) {
+      process.env[ENV_INTERNAL_APIBARA_RUNTIME] = JSON.stringify(runtimeConfig);
+    }
+    if (preset) {
+      process.env[ENV_INTERNAL_APIBARA_PRESET] = preset;
+    }
+
+    if (presets) {
+      process.env[ENV_INTERNAL_APIBARA_PRESETS] = JSON.stringify(presets);
+    }
+
+    const userEnvRuntimeConfig = JSON.parse(
+      process.env[USER_ENV_APIBARA_RUNTIME_CONFIG] ?? "{}",
+    );
+
+    // This is final processed runtime config that will be used by the indexer and useRuntimeConfig hook
+    process.env[ENV_INTERNAL_APIBARA_PROCESSED_RUNTIME] = JSON.stringify(
+      getProcessedRuntimeConfig({
+        preset,
+        presets,
+        runtimeConfig,
+        userEnvRuntimeConfig,
+      }),
+    );
+  } catch (error) {
+    throw new Error("Failed to process & set runtime environment variables", {
+      cause: error,
+    });
+  }
+}

package/src/core/config/update.ts

@@ -1,9 +1,13 @@
 import type { Apibara, ApibaraDynamicConfig } from "apibara/types";
+import { runtimeConfigResolver } from "./resolvers/runtime.resolver";
 
 export async function updateApibaraConfig(
   apibara: Apibara,
-  _config: ApibaraDynamicConfig,
+  newConfig: ApibaraDynamicConfig,
 ) {
-  await apibara.hooks.callHook("rollup:reload");
+  // applies new config values to env again during hot reload
+  runtimeConfigResolver(newConfig);
   apibara.logger.success("Apibara config hot reloaded!");
+  // we simply stop indexers and restart them with updated runtime values
+  await apibara.hooks.callHook("dev:reload");
 }

package/src/core/scan.ts

@@ -2,7 +2,7 @@ import type { Apibara } from "apibara/types";
 import fse from "fs-extra";
 import { basename, join } from "pathe";
 
-const INDEXER_EXTENSIONS = [".indexer.ts", ".indexer.js"];
+const INDEXER_EXTENSIONS = [".indexer.ts", ".indexer.js", ".indexer.mjs"];
 
 export async function scanIndexers(apibara: Apibara) {
   apibara.logger.debug("Scanning indexers");

package/src/create/add.ts

@@ -37,6 +37,7 @@ type Options = {
   argNetwork?: string;
   argStorage?: string;
   argDnaUrl?: string;
+  argRootDir?: string;
 };
 
 export async function addIndexer({
@@ -45,8 +46,10 @@ export async function addIndexer({
   argNetwork,
   argStorage,
   argDnaUrl,
+  argRootDir,
 }: Options) {
-  const configExists = hasApibaraConfig(process.cwd());
+  const cwd = path.join(process.cwd(), argRootDir ?? ".");
+  const configExists = hasApibaraConfig(cwd);
 
   if (!configExists) {
     consola.error("No apibara.config found in the current directory.");
@@ -74,7 +77,7 @@ export async function addIndexer({
     }
   }
 
-  const language = getApibaraConfigLanguage(process.cwd());
+  const { language, extension } = getApibaraConfigLanguage(cwd);
 
   validateIndexerId(argIndexerId, true);
   validateChain(argChain, true);
@@ -92,14 +95,10 @@ export async function addIndexer({
         validate: (id) =>
           validateIndexerId(id)
             ? checkFileExists(
-                path.join(
-                  process.cwd(),
-                  "indexers",
-                  `${id}.indexer.${language === "typescript" ? "ts" : "js"}`,
-                ),
+                path.join(cwd, "indexers", `${id}.indexer.${extension}`),
               ).then(({ exists }) =>
                 exists
-                  ? `Indexer ${cyan(`${id}.indexer.${language === "typescript" ? "ts" : "js"}`)} already exists`
+                  ? `Indexer ${cyan(`${id}.indexer.${extension}`)} already exists`
                   : true,
               )
             : "Invalid indexer ID, it cannot be empty and must be in kebab-case format",
@@ -197,7 +196,7 @@ export async function addIndexer({
   const pkgManager = getPackageManager();
 
   const options: IndexerOptions = {
-    cwd: process.cwd(),
+    cwd: cwd,
     indexerFileId,
     indexerId: convertKebabToCamelCase(indexerFileId),
     chain: (argChain as Chain) ?? prompt_chain?.name!,
@@ -206,13 +205,12 @@ export async function addIndexer({
     dnaUrl: argDnaUrl ?? prompt_dnaUrl,
     language,
     packageManager: pkgManager.name,
+    extension,
   };
 
   await updateApibaraConfigFile(options);
 
-  consola.success(
-    `Updated ${cyan("apibara.config." + (language === "typescript" ? "ts" : "js"))}`,
-  );
+  consola.success(`Updated ${cyan(`apibara.config.${extension}`)}`);
 
   await updatePackageJson(options);
 
@@ -220,19 +218,15 @@ export async function addIndexer({
 
   await createIndexerFile(options);
 
-  consola.success(
-    `Created ${cyan(`${indexerFileId}.indexer.${language === "typescript" ? "ts" : "js"}`)}`,
-  );
+  consola.success(`Created ${cyan(`${indexerFileId}.indexer.${extension}`)}`);
 
   await createStorageRelatedFiles(options);
 
   console.log();
 
+  const baseCommand = `${options.packageManager} install`;
+  const tsCommand = `${baseCommand} && ${options.packageManager} run prepare`;
   consola.info(
-    `Before running the indexer, run ${cyan(`${options.packageManager} run install`)}${
-      language === "typescript"
-        ? " & " + cyan(`${options.packageManager} run prepare`)
-        : ""
-    }`,
+    `Before running the indexer, run ${cyan(language === "typescript" ? tsCommand : baseCommand)}`,
   );
 }

package/src/create/constants.ts

@@ -67,7 +67,6 @@ export const storages: StorageDataType[] = [
 export const packageVersions = {
   // Required Dependencies
   apibara: "next",
-  "@apibara/indexer": "next",
   "@apibara/protocol": "next",
   // Chain Dependencies
   "@apibara/evm": "next",
@@ -79,20 +78,19 @@ export const packageVersions = {
   "@apibara/plugin-sqlite": "next",
   // Postgres Dependencies
   "@electric-sql/pglite": "^0.2.17",
-  "drizzle-orm": "^0.37.0",
+  "drizzle-orm": "^0.40.1",
   pg: "^8.13.1",
   "@types/pg": "^8.11.10",
   "drizzle-kit": "^0.29.0",
   // Typescript Dependencies
   typescript: "^5.6.2",
-  "@rollup/plugin-typescript": "^11.1.6",
   "@types/node": "^20.5.2",
 };
 
 export const dnaUrls = {
-  ethereum: "https://ethereum.preview.apibara.org",
-  ethereumSepolia: "https://ethereum-sepolia.preview.apibara.org",
+  ethereum: "https://mainnet.ethereum.a5a.ch",
+  ethereumSepolia: "https://sepolia.ethereum.a5a.ch",
   beaconchain: "https://beaconchain.preview.apibara.org",
-  starknet: "https://starknet.preview.apibara.org",
-  starknetSepolia: "https://starknet-sepolia.preview.apibara.org",
+  starknet: "https://mainnet.starknet.a5a.ch",
+  starknetSepolia: "https://sepolia.starknet.a5a.ch",
 };

package/src/create/init.ts

@@ -5,6 +5,7 @@ import prompts from "prompts";
 import { addIndexer } from "./add";
 import { cyan, green } from "./colors";
 import {
+  createGitIgnoreFile,
   generateApibaraConfig,
   generatePackageJson,
   generateTsConfig,
@@ -129,7 +130,7 @@ export async function initializeProject({
     JSON.stringify(packageJson, null, 2) + "\n",
   );
   await formatFile(packageJsonPath);
-  consola.success("Created ", cyan("package.json"));
+  consola.success("Created", cyan("package.json"));
 
   // Generate tsconfig.json if TypeScript
   if (isTs) {
@@ -137,7 +138,7 @@ export async function initializeProject({
     const tsConfig = generateTsConfig();
     fs.writeFileSync(tsConfigPath, JSON.stringify(tsConfig, null, 2) + "\n");
     await formatFile(tsConfigPath);
-    consola.success("Created ", cyan("tsconfig.json"));
+    consola.success("Created", cyan("tsconfig.json"));
   }
 
   const apibaraConfigPath = path.join(root, `apibara.config.${configExt}`);
@@ -145,7 +146,7 @@ export async function initializeProject({
   const apibaraConfig = generateApibaraConfig(isTs);
   fs.writeFileSync(apibaraConfigPath, apibaraConfig);
   await formatFile(apibaraConfigPath);
-  consola.success("Created ", cyan(`apibara.config.${configExt}`));
+  consola.success("Created", cyan(`apibara.config.${configExt}`));
 
   // Create "indexers" directory if not exists
   const indexersDir = path.join(root, "indexers");
@@ -154,6 +155,8 @@ export async function initializeProject({
     consola.success(`Created ${cyan("indexers")} directory`);
   }
 
+  await createGitIgnoreFile(root);
+
   console.log("\n");
 
   consola.ready(green("Project initialized successfully"));
@@ -163,12 +166,12 @@ export async function initializeProject({
   if (!argNoCreateIndexer) {
     consola.info("Let's create an indexer\n");
 
-    await addIndexer({});
+    await addIndexer({ argRootDir: argTargetDir });
   } else {
     const pkgManager = getPackageManager();
     consola.info(
       "Run ",
-      green(`${pkgManager.name} run install`),
+      green(`${pkgManager.name} install`),
       " to install all dependencies",
     );
   }