apibara 2.1.0-beta.5 → 2.1.0-beta.50

package/src/cli/commands/write-project-info.ts

@@ -0,0 +1,56 @@
+import { spawn } from "node:child_process";
+import { join } from "node:path";
+import { checkForUnknownArgs, commonArgs } from "apibara/common";
+import { build, createApibara, prepare, writeTypes } from "apibara/core";
+import { runtimeDir } from "apibara/runtime/meta";
+import { defineCommand } from "citty";
+import consola from "consola";
+import { resolve } from "pathe";
+
+export default defineCommand({
+  meta: {
+    name: "write-project-info",
+    description: "Write json-encoded information about the project.",
+  },
+  args: {
+    ...commonArgs,
+  },
+  async run({ args, cmd }) {
+    await checkForUnknownArgs(args, cmd);
+
+    consola.start("Generating `project-info.json`");
+
+    const rootDir = resolve((args.dir || ".") as string);
+    const apibara = await createApibara({ rootDir, disableLogs: true });
+
+    apibara.options.entry = join(runtimeDir, "project-info.mjs");
+
+    await prepare(apibara);
+    await writeTypes(apibara);
+    await build(apibara);
+
+    const childArgs = [
+      resolve(
+        apibara.options.outputDir || "./.apibara/build",
+        "project-info.mjs",
+      ),
+      "start",
+      "--build-dir",
+      apibara.options.buildDir,
+    ];
+
+    const child = spawn("node", childArgs, {
+      stdio: "inherit",
+    });
+
+    child.on("close", (code) => {
+      if (code === 0) {
+        consola.success("Project info written to `.apibara/project-info.json`");
+      }
+    });
+
+    child.on("error", (error) => {
+      consola.error(`Failed to write project info: ${error.message}`, error);
+    });
+  },
+});

package/src/cli/index.ts

@@ -13,6 +13,8 @@ export const mainCli = defineCommand({
     prepare: () => import("./commands/prepare").then((r) => r.default),
     init: () => import("./commands/init").then((r) => r.default),
     add: () => import("./commands/add").then((r) => r.default),
+    "write-project-info": () =>
+      import("./commands/write-project-info").then((r) => r.default),
   },
 });
 

package/src/common/cli.ts

@@ -0,0 +1,40 @@
+import {
+  type ArgsDef,
+  type CommandDef,
+  type ParsedArgs,
+  renderUsage,
+} from "citty";
+import consola from "consola";
+
+export const commonArgs = <ArgsDef>{
+  dir: {
+    type: "string",
+    description: "project root directory",
+  },
+};
+
+export const checkForUnknownArgs = async <T extends ArgsDef = ArgsDef>(
+  args: ParsedArgs<T>,
+  cmd: CommandDef<T>,
+) => {
+  // Create a list of defined args including both the main arg names and their aliases
+  const definedArgs: string[] = [];
+  if (cmd.args) {
+    for (const [argName, argDef] of Object.entries(cmd.args)) {
+      definedArgs.push(argName);
+      // Add alias to definedArgs if it exists
+      if (argDef.alias) {
+        definedArgs.push(argDef.alias);
+      }
+    }
+  }
+
+  const providedArgs = Object.keys(args).filter((arg) => arg !== "_");
+  const wrongArgs = providedArgs.filter((arg) => !definedArgs.includes(arg));
+
+  if (wrongArgs.length > 0) {
+    consola.error(`Unknown arguments: ${wrongArgs.join(", ")}`);
+    consola.info(await renderUsage(cmd));
+    process.exit(1);
+  }
+};

package/src/common/constants.ts

@@ -0,0 +1,6 @@
+export const ENV_INTERNAL_APIBARA_RUNTIME = "_APIBARA_RUNTIME";
+export const ENV_INTERNAL_APIBARA_PRESET = "_APIBARA_PRESET";
+export const ENV_INTERNAL_APIBARA_PRESETS = "_APIBARA_PRESETS";
+export const ENV_INTERNAL_APIBARA_PROCESSED_RUNTIME =
+  "_APIBARA_PROCESSED_RUNTIME";
+export const USER_ENV_APIBARA_RUNTIME_CONFIG = "APIBARA_RUNTIME_CONFIG";

package/src/common/helper.ts

@@ -0,0 +1,86 @@
+import defu from "defu";
+import {
+  ENV_INTERNAL_APIBARA_PRESET,
+  ENV_INTERNAL_APIBARA_PRESETS,
+  ENV_INTERNAL_APIBARA_PROCESSED_RUNTIME,
+  ENV_INTERNAL_APIBARA_RUNTIME,
+  USER_ENV_APIBARA_RUNTIME_CONFIG,
+} from "./constants";
+
+export function getRuntimeDataFromEnv() {
+  const processedRuntimeConfig: Record<string, unknown> = JSON.parse(
+    process.env[ENV_INTERNAL_APIBARA_PROCESSED_RUNTIME] ?? "{}",
+  );
+  const preset: string | undefined = process.env[ENV_INTERNAL_APIBARA_PRESET];
+  const presets: Record<string, unknown> | undefined = JSON.parse(
+    process.env[ENV_INTERNAL_APIBARA_PRESETS] ?? "{}",
+  );
+  const runtimeConfig: Record<string, unknown> | undefined = JSON.parse(
+    process.env[ENV_INTERNAL_APIBARA_RUNTIME] ?? "{}",
+  );
+  const userEnvRuntimeConfig: Record<string, unknown> | undefined = JSON.parse(
+    process.env[USER_ENV_APIBARA_RUNTIME_CONFIG] ?? "{}",
+  );
+
+  return {
+    userEnvRuntimeConfig,
+    processedRuntimeConfig,
+    preset,
+    presets,
+    runtimeConfig,
+  };
+}
+
+/**
+ * Get the merged runtime config from the user env overrided runtime config, presets and defaults.
+ * Priority (Highest to lowest):
+ * 1. User env overrided runtime config
+ * 2. Preset
+ * 3. Defaults
+ */
+export function getProcessedRuntimeConfig({
+  preset,
+  presets,
+  runtimeConfig,
+  userEnvRuntimeConfig,
+}: {
+  preset?: string;
+  presets?: Record<string, unknown>;
+  runtimeConfig?: Record<string, unknown>;
+  userEnvRuntimeConfig?: Record<string, unknown>;
+}) {
+  let _runtimeConfig: Record<string, unknown> = { ...runtimeConfig };
+
+  if (preset) {
+    if (presets === undefined) {
+      throw new Error(
+        `Specified preset "${preset}" but no presets were defined`,
+      );
+    }
+
+    if (presets[preset] === undefined) {
+      throw new Error(`Specified preset "${preset}" but it was not defined`);
+    }
+
+    const presetValue = presets[preset] as {
+      runtimeConfig: Record<string, unknown>;
+    };
+
+    // Preset applied
+    _runtimeConfig = defu(presetValue.runtimeConfig, _runtimeConfig);
+  }
+
+  if (userEnvRuntimeConfig) {
+    try {
+      // Environment runtime config applied
+      _runtimeConfig = defu(userEnvRuntimeConfig, _runtimeConfig);
+    } catch (error) {
+      throw new Error(
+        "Failed to parse runtime config from process.env.APIBARA_RUNTIME_CONFIG. Please ensure it is a valid JSON string.",
+        { cause: error },
+      );
+    }
+  }
+
+  return _runtimeConfig;
+}

package/src/common/index.ts

@@ -0,0 +1,3 @@
+export * from "./constants";
+export * from "./helper";
+export * from "./cli";

package/src/core/apibara.ts

@@ -17,14 +17,19 @@ export async function createApibara(
 ): Promise<Apibara> {
   const options = await loadOptions(config, opts, dev);
 
+  // Enable source map support in Node
+  process.env.NODE_OPTIONS = process.env.NODE_OPTIONS
+    ? `${process.env.NODE_OPTIONS} --enable-source-maps`
+    : "--enable-source-maps";
+
   const apibara: Apibara = {
     options,
     indexers: [],
     hooks: createHooks(),
     close: () => apibara.hooks.callHook("close"),
     logger: consola.withTag("apibara"),
-    async updateConfig(config: ApibaraDynamicConfig) {
-      updateApibaraConfig(apibara, config);
+    async updateConfig(newConfig: ApibaraDynamicConfig) {
+      updateApibaraConfig(apibara, newConfig);
     },
   };
 

package/src/core/build/build.ts

@@ -1,14 +1,22 @@
-import { getRollupConfig } from "apibara/rollup";
+import { getRolldownConfig } from "apibara/rolldown";
 import type { Apibara } from "apibara/types";
+import { colors } from "consola/utils";
 import { watchDev } from "./dev";
 import { buildProduction } from "./prod";
 
 export async function build(apibara: Apibara) {
-  const rollupConfig = getRollupConfig(apibara);
+  const rolldownConfig = getRolldownConfig(apibara);
 
-  await apibara.hooks.callHook("rollup:before", apibara, rollupConfig);
+  await apibara.hooks.callHook("rolldown:before", apibara, rolldownConfig);
+
+  if (apibara.options.rollupConfig) {
+    apibara.logger.error(
+      `\n${colors.cyan("apibara.config:")} rollupConfig is deprecated. Use rolldownConfig instead`,
+    );
+    process.exit(1);
+  }
 
   return apibara.options.dev
-    ? await watchDev(apibara, rollupConfig)
-    : await buildProduction(apibara, rollupConfig);
+    ? await watchDev(apibara, rolldownConfig)
+    : await buildProduction(apibara, rolldownConfig);
 }

package/src/core/build/dev.ts

@@ -1,59 +1,67 @@
-import type { Apibara, RollupConfig } from "apibara/types";
+import type { Apibara } from "apibara/types";
 import { watch } from "chokidar";
 import defu from "defu";
 import { join } from "pathe";
 import { debounce } from "perfect-debounce";
-import * as rollup from "rollup";
-import { formatRollupError } from "./error";
-
-export async function watchDev(apibara: Apibara, rollupConfig: RollupConfig) {
-  let rollupWatcher: rollup.RollupWatcher;
+import * as rolldown from "rolldown";
+import { formatRolldownError } from "./error";
 
+export async function watchDev(
+  apibara: Apibara,
+  rolldownConfig: rolldown.RolldownOptions,
+) {
+  let rolldownWatcher: rolldown.RolldownWatcher;
   async function load() {
-    if (rollupWatcher) {
-      await rollupWatcher.close();
+    apibara.logger.start("Setting up a dev server");
+    if (rolldownWatcher) {
+      await rolldownWatcher.close();
     }
-    rollupWatcher = startRollupWatcher(apibara, rollupConfig);
+    rolldownWatcher = startRolldownWatcher(apibara, rolldownConfig);
   }
-  const reload = debounce(load);
+  const reload = debounce(async () => await load());
 
-  const watchPatterns = [join(apibara.options.rootDir, "indexers")];
+  const watchPatterns = getWatchPatterns(apibara);
 
   const watchReloadEvents = new Set(["add", "addDir", "unlink", "unlinkDir"]);
   const reloadWatcher = watch(watchPatterns, { ignoreInitial: true }).on(
     "all",
-    (event) => {
+    async (event) => {
       if (watchReloadEvents.has(event)) {
-        reload();
+        await reload();
       }
     },
   );
 
   apibara.hooks.hook("close", () => {
-    rollupWatcher.close();
+    rolldownWatcher.close();
     reloadWatcher.close();
   });
 
-  apibara.hooks.hook("rollup:reload", () => reload());
+  apibara.hooks.hook("rolldown:reload", async () => await reload());
 
   await load();
 }
 
-function startRollupWatcher(apibara: Apibara, rollupConfig: RollupConfig) {
-  const watcher = rollup.watch(
-    defu(rollupConfig, {
+function startRolldownWatcher(
+  apibara: Apibara,
+  rolldownConfig: rolldown.RolldownOptions,
+) {
+  const ignorePatterns = getIgnorePatterns(apibara);
+  const watcher = rolldown.watch(
+    defu(rolldownConfig, {
       watch: {
-        chokidar: apibara.options.watchOptions,
+        exclude: ignorePatterns,
+        ...((apibara.options.watchOptions ?? {}) as rolldown.WatchOptions),
       },
     }),
   );
   let start: number;
 
-  watcher.on("event", (event) => {
+  watcher.on("event", async (event) => {
     switch (event.code) {
       // The watcher is (re)starting
       case "START": {
-        apibara.hooks.callHook("dev:restart");
+        await apibara.hooks.callHook("dev:restart");
         return;
       }
 
@@ -70,15 +78,30 @@ function startRollupWatcher(apibara: Apibara, rollupConfig: RollupConfig) {
           "Indexers built",
           start ? `in ${Date.now() - start} ms` : "",
         );
-        apibara.hooks.callHook("dev:reload");
+        await apibara.hooks.callHook("dev:reload");
         return;
       }
 
       // Encountered an error while bundling
       case "ERROR": {
-        apibara.logger.error(formatRollupError(event.error));
+        apibara.logger.error(formatRolldownError(event.error));
       }
     }
   });
   return watcher;
 }
+
+const getWatchPatterns = (apibara: Apibara) => [
+  join(apibara.options.rootDir, "indexers"),
+];
+
+const getIgnorePatterns = (apibara: Apibara) => [
+  "**/.apibara/**",
+  "**/.git/**",
+  "**/.DS_Store",
+  "**/node_modules/**",
+  "**/dist/**",
+  "**/.turbo/**",
+  // changes to apibara.config is handled by c12 itself so we dont need rolldown to handle this
+  "**/apibara.config?(.ts|.js|.mjs)",
+];

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");