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

package/src/cli/commands/dev.ts

@@ -1,15 +1,16 @@
 import { type ChildProcess, spawn } from "node:child_process";
+import { checkForUnknownArgs, commonArgs } from "apibara/common";
 import { build, createApibara, prepare, writeTypes } from "apibara/core";
 import { runtimeDir } from "apibara/runtime/meta";
 import type { Apibara } from "apibara/types";
 import { defineCommand } from "citty";
 import { colors } from "consola/utils";
 import { join, resolve } from "pathe";
-import { commonArgs } from "../common";
+import { blueBright, gray } from "../../create/colors";
 
 // Hot module reloading key regex
-// for only runtimeConfig.* keys
-const hmrKeyRe = /^runtimeConfig\./;
+// for only runtimeConfig.*, presets.* keys & preset key
+const hmrKeyRe = /^(runtimeConfig\.|presets\.|preset$)/;
 
 export default defineCommand({
   meta: {
@@ -26,10 +27,29 @@ export default defineCommand({
       type: "string",
       description: "Preset to use",
     },
+    "always-reindex": {
+      type: "boolean",
+      default: false,
+      description:
+        "Reindex the indexers from the starting block on every restart | default: `false`",
+    },
   },
-  async run({ args }) {
+  async run({ args, data, cmd, rawArgs }) {
+    await checkForUnknownArgs(args, cmd);
+
     const rootDir = resolve((args.dir || args._dir || ".") as string);
 
+    if (args["always-reindex"]) {
+      process.env.APIBARA_ALWAYS_REINDEX = "true";
+    }
+
+    const selectedIndexers = new Set(
+      args.indexers
+        ?.split(",")
+        .map((i) => i.trim())
+        .sort() ?? [],
+    );
+
     let apibara: Apibara;
     let childProcess: ChildProcess | undefined;
 
@@ -46,6 +66,7 @@ export default defineCommand({
       apibara = await createApibara(
         {
           rootDir,
+          preset: args.preset,
         },
         {
           watch: true,
@@ -58,12 +79,12 @@ export default defineCommand({
               }
 
               apibara.logger.info(
-                `Config updated:
-                  ${diff.map((entry) => `  ${entry.toString()}`).join("\n")}`,
+                `Config updated: \n${diff.map((entry) => `  ${entry.toString()}`).join("\n")}`,
               );
 
               await (diff.every((e) => hmrKeyRe.test(e.key))
-                ? apibara.updateConfig(newConfig.config || {}) // Hot reload
+                ? // in hot reload we only update the runtime values & restart indexers,no build step, apibara instance remains the same
+                  apibara.updateConfig(newConfig.config || {}) // Hot reload
                 : reload()); // Full reload
             },
           },
@@ -71,7 +92,9 @@ export default defineCommand({
         true,
       );
 
-      apibara.hooks.hookOnce("restart", reload);
+      apibara.hooks.hookOnce("restart", async () => {
+        await reload();
+      });
 
       apibara.options.entry = join(runtimeDir, "dev.mjs");
 
@@ -79,38 +102,50 @@ export default defineCommand({
       await writeTypes(apibara);
       await build(apibara);
 
-      apibara.hooks.hook("dev:restart", () => {
+      apibara.hooks.hook("dev:restart", async () => {
         if (childProcess) {
           apibara.logger.info("Change detected, stopping indexers to restart");
-          childProcess.kill();
+          await killProcess(childProcess);
           childProcess = undefined;
         }
       });
 
-      apibara.hooks.hook("dev:reload", () => {
+      apibara.hooks.hook("dev:reload", async () => {
         if (childProcess) {
-          childProcess.kill();
+          await killProcess(childProcess);
+          childProcess = undefined;
+          apibara.logger.info("Restarting indexers");
         } else {
-          apibara.logger.success("Restarting indexers");
+          apibara.logger.info("Starting indexers");
+
+          const indexersText = apibara.indexers
+            .map((i) =>
+              selectedIndexers.has(i.name) || selectedIndexers.size === 0
+                ? blueBright(i.name)
+                : gray(i.name),
+            )
+            .join(", ");
+          apibara.logger.info("Indexers:", indexersText);
         }
 
         const childArgs = [
           resolve(apibara.options.outputDir || "./.apibara/build", "dev.mjs"),
           "start",
           ...(args.indexers ? ["--indexers", args.indexers] : []),
-          ...(args.preset ? ["--preset", args.preset] : []),
         ];
 
         childProcess = spawn("node", childArgs, {
           stdio: "inherit",
         });
 
-        childProcess.on("close", (code) => {
-          if (code !== null) {
-            apibara.logger.log(
-              `Indexers process exited with code ${colors.red(code)}`,
-            );
-          }
+        childProcess.on("close", (code, signal) => {
+          childProcess = undefined;
+          console.log();
+          apibara.logger.info(
+            `Indexers process exited${
+              code !== null ? ` with code ${colors.red(code)}` : ""
+            }`,
+          );
         });
       });
     };
@@ -118,3 +153,12 @@ export default defineCommand({
     await reload();
   },
 });
+
+async function killProcess(childProcess: ChildProcess | undefined) {
+  if (childProcess) {
+    await new Promise((resolve) => {
+      childProcess.once("exit", resolve);
+      childProcess.kill();
+    });
+  }
+}

package/src/cli/commands/init.ts

@@ -1,3 +1,4 @@
+import { checkForUnknownArgs } from "apibara/common";
 import { initializeProject } from "apibara/create";
 import { defineCommand } from "citty";
 
@@ -14,23 +15,27 @@ export default defineCommand({
     },
     language: {
       type: "string",
-      description: "Language to use: typescript, ts or javascript, js",
+      description:
+        "Language to use: typescript, ts or javascript, js | default: `ts`",
       default: "ts",
       alias: "l",
     },
-    noIndexer: {
+    "create-indexer": {
       type: "boolean",
-      description: "Do not create an indexer after initialization",
-      default: false,
+      name: "create-indexer",
+      default: true,
+      description: "TODO",
     },
   },
-  async run({ args }) {
-    const { dir: targetDir, noIndexer, language } = args;
+  async run({ args, cmd }) {
+    await checkForUnknownArgs(args, cmd);
+
+    const { dir: targetDir, "create-indexer": createIndexer, language } = args;
 
     await initializeProject({
       argTargetDir: targetDir,
       argLanguage: language,
-      argNoCreateIndexer: noIndexer,
+      argNoCreateIndexer: !createIndexer,
     });
   },
 });

package/src/cli/commands/prepare.ts

@@ -1,8 +1,7 @@
+import { checkForUnknownArgs, commonArgs } from "apibara/common";
 import { createApibara, writeTypes } from "apibara/core";
-import {} from "apibara/types";
 import { defineCommand } from "citty";
 import { resolve } from "pathe";
-import { commonArgs } from "../common";
 
 export default defineCommand({
   meta: {
@@ -12,7 +11,9 @@ export default defineCommand({
   args: {
     ...commonArgs,
   },
-  async run({ args }) {
+  async run({ args, cmd }) {
+    await checkForUnknownArgs(args, cmd);
+
     const rootDir = resolve((args.dir || ".") as string);
     const apibara = await createApibara({ rootDir });
     await writeTypes(apibara);

package/src/cli/commands/start.ts

@@ -1,9 +1,10 @@
 import { spawn } from "node:child_process";
+import { checkForUnknownArgs, commonArgs } from "apibara/common";
 import { createApibara } from "apibara/core";
 import { defineCommand } from "citty";
+import { colors } from "consola/utils";
 import fse from "fs-extra";
 import { resolve } from "pathe";
-import { commonArgs } from "../common";
 
 export default defineCommand({
   meta: {
@@ -22,12 +23,15 @@ export default defineCommand({
       description: "The preset to use",
     },
   },
-  async run({ args }) {
+  async run({ args, cmd }) {
     const { indexer, preset } = args;
     const rootDir = resolve((args.dir || args._dir || ".") as string);
 
+    await checkForUnknownArgs(args, cmd);
+
     const apibara = await createApibara({
       rootDir,
+      preset,
     });
 
     apibara.logger.start(
@@ -51,11 +55,22 @@ export default defineCommand({
       "start",
       "--indexer",
       indexer,
+      // important: this is required to run the indexer with apibara cli to load runtime values correctly
+      "--no-standalone",
       ...(preset ? ["--preset", preset] : []),
     ];
 
-    spawn("node", childArgs, {
+    const childProcess = spawn("node", childArgs, {
       stdio: "inherit",
     });
+
+    childProcess.on("close", (code, signal) => {
+      console.log();
+      apibara.logger.info(
+        `Indexers process exited${
+          code !== null ? ` with code ${colors.red(code)}` : ""
+        }`,
+      );
+    });
   },
 });

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)",
+];