apibara 2.1.0-beta.1 → 2.1.0-beta.11

package/dist/chunks/add.mjs

@@ -9,34 +9,39 @@ const add = defineCommand({
   args: {
     indexerId: {
       type: "positional",
-      description: "Indexer ID",
+      description: "Indexer ID - must be in kebab-case",
       required: false
     },
     chain: {
       type: "string",
-      description: "Chain"
+      description: "Blockchain - ethereum, beaconchain, starknet"
     },
     network: {
       type: "string",
-      description: "Network"
+      description: "Network - mainnet, sepolia, other"
     },
     storage: {
       type: "string",
-      description: "Storage"
+      description: "Storage - postgres, none"
     },
     dnaUrl: {
       type: "string",
-      description: "DNA URL"
+      description: "DNA URL - https://custom-dna-url.apibara.org"
+    },
+    dir: {
+      type: "string",
+      description: "Root directory - apibara project root where apibara.config is located | default: current working directory"
     }
   },
   async run({ args }) {
-    const { indexerId, chain, network, storage, dnaUrl } = args;
+    const { indexerId, chain, network, storage, dnaUrl, dir } = args;
     await addIndexer({
       argIndexerId: indexerId,
       argChain: chain,
       argNetwork: network,
       argStorage: storage,
-      argDnaUrl: dnaUrl
+      argDnaUrl: dnaUrl,
+      argRootDir: dir
     });
   }
 });

package/dist/chunks/dev.mjs

@@ -21,10 +21,18 @@ const dev = defineCommand({
     preset: {
       type: "string",
       description: "Preset to use"
+    },
+    alwaysReindex: {
+      type: "boolean",
+      default: false,
+      description: "Reindex the indexers from the starting block on every restart (default: false)"
     }
   },
   async run({ args }) {
     const rootDir = resolve(args.dir || args._dir || ".");
+    if (args.alwaysReindex) {
+      process.env.APIBARA_ALWAYS_REINDEX = "true";
+    }
     let apibara;
     let childProcess;
     const reload = async () => {
@@ -37,7 +45,8 @@ const dev = defineCommand({
       }
       apibara = await createApibara(
         {
-          rootDir
+          rootDir,
+          preset: args.preset
         },
         {
           watch: true,
@@ -62,18 +71,20 @@ const dev = defineCommand({
       await prepare(apibara);
       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 = void 0;
         }
       });
-      apibara.hooks.hook("dev:reload", () => {
+      apibara.hooks.hook("dev:reload", async () => {
         if (childProcess) {
-          childProcess.kill();
+          apibara.logger.info("Restarting indexers");
+          await killProcess(childProcess);
+          childProcess = void 0;
         } else {
-          apibara.logger.success("Restarting indexers");
+          apibara.logger.info("Starting indexers");
         }
         const childArgs = [
           resolve(apibara.options.outputDir || "./.apibara/build", "dev.mjs"),
@@ -96,5 +107,13 @@ const dev = defineCommand({
     await reload();
   }
 });
+async function killProcess(childProcess) {
+  if (childProcess) {
+    await new Promise((resolve2) => {
+      childProcess.once("exit", resolve2);
+      childProcess.kill();
+    });
+  }
+}
 
 export { dev as default };

package/dist/chunks/init.mjs

@@ -18,22 +18,18 @@ const init = defineCommand({
       default: "ts",
       alias: "l"
     },
-    "no-create-indexer": {
+    noIndexer: {
       type: "boolean",
       description: "Do not create an indexer after initialization",
       default: false
     }
   },
   async run({ args }) {
-    const {
-      dir: targetDir,
-      "no-create-indexer": noCreateIndexer,
-      language
-    } = args;
+    const { dir: targetDir, noIndexer, language } = args;
     await initializeProject({
       argTargetDir: targetDir,
       argLanguage: language,
-      argNoCreateIndexer: noCreateIndexer
+      argNoCreateIndexer: noIndexer
     });
   }
 });

package/dist/chunks/start.mjs

@@ -26,7 +26,8 @@ const start = defineCommand({
     const { indexer, preset } = args;
     const rootDir = resolve(args.dir || args._dir || ".");
     const apibara = await createApibara({
-      rootDir
+      rootDir,
+      preset
     });
     apibara.logger.start(
       `Starting indexer ${indexer}${preset ? ` with preset ${preset}` : ""}`

package/dist/core/index.mjs

@@ -4,13 +4,13 @@ import { watchConfig, loadConfig } from 'c12';
 import { klona } from 'klona/full';
 import { resolve, join, basename, isAbsolute, relative, dirname } from 'pathe';
 import defu from 'defu';
+import { s as serialize } from '../shared/apibara.af330c7d.mjs';
 import fse from 'fs-extra';
-import { getRollupConfig } from 'apibara/rollup';
+import { getRolldownConfig } from 'apibara/rolldown';
+import { colors } from 'consola/utils';
 import { watch } from 'chokidar';
 import { debounce } from 'perfect-debounce';
-import * as rollup from 'rollup';
-import { rollup as rollup$1 } from 'rollup';
-import { colors } from 'consola/utils';
+import * as rolldown from 'rolldown';
 import fsp from 'node:fs/promises';
 import { generateTypes, resolveSchema } from 'untyped';
 
@@ -24,7 +24,9 @@ const ApibaraDefaults = {
     strict: false,
     generateRuntimeConfigTypes: true,
     internalPaths: false
-  }
+  },
+  node: true,
+  exportConditions: ["node"]
 };
 
 async function resolvePathOptions(options) {
@@ -45,8 +47,21 @@ async function presetResolver(options) {
 }
 
 async function resolveRuntimeConfigOptions(options) {
-  options.runtimeConfig = { ...options.runtimeConfig };
-  process.env.APIBARA_RUNTIME_CONFIG = JSON.stringify(options.runtimeConfig);
+  const { preset, presets } = options;
+  let runtimeConfig = { ...options.runtimeConfig };
+  if (preset) {
+    if (presets === void 0) {
+      throw new Error(
+        `Specified preset "${preset}" but no presets were defined`
+      );
+    }
+    if (presets[preset] === void 0) {
+      throw new Error(`Specified preset "${preset}" but it was not defined`);
+    }
+    const presetValue = presets[preset];
+    runtimeConfig = { ...runtimeConfig, ...presetValue.runtimeConfig };
+  }
+  process.env.APIBARA_RUNTIME_CONFIG = serialize(runtimeConfig);
 }
 
 const configResolvers = [
@@ -83,7 +98,7 @@ async function _loadUserConfig(configOverrides = {}, opts = {}, dev = false) {
 }
 
 async function updateApibaraConfig(apibara, _config) {
-  await apibara.hooks.callHook("rollup:reload");
+  await apibara.hooks.callHook("rolldown:reload");
   apibara.logger.success("Apibara config hot reloaded!");
 }
 
@@ -134,20 +149,20 @@ async function createApibara(config = {}, opts = {}, dev = false) {
   return apibara;
 }
 
-function formatRollupError(_error) {
+function formatRolldownError(_error) {
   try {
     const logs = [_error.toString()];
     const errors = _error?.errors || [_error];
     for (const error of errors) {
       const id = error.path || error.id || _error.id;
       let path = isAbsolute(id) ? relative(process.cwd(), id) : id;
-      const location = error.loc || error.location;
+      const location = error.loc;
       if (location) {
         path += `:${location.line}:${location.column}`;
       }
-      const text = error.text || error.frame;
+      const text = error.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");
@@ -156,45 +171,48 @@ function formatRollupError(_error) {
   }
 }
 
-async function watchDev(apibara, rollupConfig) {
-  let rollupWatcher;
+async function watchDev(apibara, rolldownConfig) {
+  let 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 watchPatterns = [join(apibara.options.rootDir, "indexers")];
+  const reload = debounce(async () => await load());
+  const watchPatterns = getWatchPatterns(apibara);
   const watchReloadEvents = /* @__PURE__ */ 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, rollupConfig) {
-  const watcher = rollup.watch(
-    defu(rollupConfig, {
+function startRolldownWatcher(apibara, rolldownConfig) {
+  const ignorePatterns = getIgnorePatterns();
+  const watcher = rolldown.watch(
+    defu(rolldownConfig, {
       watch: {
-        chokidar: apibara.options.watchOptions
+        exclude: ignorePatterns,
+        ...apibara.options.watchOptions ?? {}
       }
     })
   );
   let start;
-  watcher.on("event", (event) => {
+  watcher.on("event", async (event) => {
     switch (event.code) {
       case "START": {
-        apibara.hooks.callHook("dev:restart");
+        await apibara.hooks.callHook("dev:restart");
         return;
       }
       case "BUNDLE_START": {
@@ -207,34 +225,48 @@ function startRollupWatcher(apibara, rollupConfig) {
           "Indexers built",
           start ? `in ${Date.now() - start} ms` : ""
         );
-        apibara.hooks.callHook("dev:reload");
+        await apibara.hooks.callHook("dev:reload");
         return;
       }
       case "ERROR": {
-        apibara.logger.error(formatRollupError(event.error));
+        apibara.logger.error(formatRolldownError(event.error));
       }
     }
   });
   return watcher;
 }
+const getWatchPatterns = (apibara) => [
+  join(apibara.options.rootDir, "indexers")
+];
+const getIgnorePatterns = (apibara) => [
+  "**/.apibara/**",
+  "**/.git/**",
+  "**/.DS_Store",
+  "**/node_modules/**",
+  "**/dist/**",
+  "**/.turbo/**"
+];
 
-async function buildProduction(apibara, rollupConfig) {
+async function buildProduction(apibara, rolldownConfig) {
   apibara.logger.start(
     `Building ${colors.cyan(apibara.indexers.length)} indexers`
   );
+  const startTime = Date.now();
   try {
-    const bundle = await rollup$1(rollupConfig);
-    if (Array.isArray(rollupConfig.output)) {
-      for (const outputOptions of rollupConfig.output) {
+    const bundle = await rolldown.rolldown(rolldownConfig);
+    if (Array.isArray(rolldownConfig.output)) {
+      for (const outputOptions of rolldownConfig.output) {
         await bundle.write(outputOptions);
       }
-    } else if (rollupConfig.output) {
-      await bundle.write(rollupConfig.output);
+    } else if (rolldownConfig.output) {
+      await bundle.write(rolldownConfig.output);
     } 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!");
+    const endTime = Date.now();
+    const duration = endTime - startTime;
+    apibara.logger.success(`Build succeeded in ${duration}ms`);
     apibara.logger.info(
       `You can start the indexers with ${colors.cyan("apibara start")}`
     );
@@ -245,9 +277,16 @@ async function buildProduction(apibara, rollupConfig) {
 }
 
 async function build(apibara) {
-  const rollupConfig = getRollupConfig(apibara);
-  await apibara.hooks.callHook("rollup:before", apibara, rollupConfig);
-  return apibara.options.dev ? await watchDev(apibara, rollupConfig) : await buildProduction(apibara, rollupConfig);
+  const rolldownConfig = getRolldownConfig(apibara);
+  await apibara.hooks.callHook("rolldown:before", apibara, rolldownConfig);
+  if (apibara.options.rollupConfig) {
+    apibara.logger.error(
+      `
+${colors.cyan("apibara.config:")} rollupConfig is deprecated. Use rolldownConfig instead`
+    );
+    process.exit(1);
+  }
+  return apibara.options.dev ? await watchDev(apibara, rolldownConfig) : await buildProduction(apibara, rolldownConfig);
 }
 
 function prettyPath(path, highlight = true) {
@@ -268,6 +307,10 @@ async function prepareDir(dir) {
 }
 
 async function writeTypes(apibara) {
+  const isTypeScript = apibara.options._c12.configFile?.endsWith(".ts");
+  if (!isTypeScript) {
+    return;
+  }
   const typesDir = resolve(apibara.options.buildDir, "types");
   const config = [
     "// Generated by apibara",

package/dist/create/index.d.mts

@@ -4,8 +4,9 @@ type Options$1 = {
     argNetwork?: string;
     argStorage?: string;
     argDnaUrl?: string;
+    argRootDir?: string;
 };
-declare function addIndexer({ argIndexerId, argChain, argNetwork, argStorage, argDnaUrl, }: Options$1): Promise<void>;
+declare function addIndexer({ argIndexerId, argChain, argNetwork, argStorage, argDnaUrl, argRootDir, }: Options$1): Promise<void>;
 
 type Options = {
     argTargetDir: string;

package/dist/create/index.d.ts

@@ -4,8 +4,9 @@ type Options$1 = {
     argNetwork?: string;
     argStorage?: string;
     argDnaUrl?: string;
+    argRootDir?: string;
 };
-declare function addIndexer({ argIndexerId, argChain, argNetwork, argStorage, argDnaUrl, }: Options$1): Promise<void>;
+declare function addIndexer({ argIndexerId, argChain, argNetwork, argStorage, argDnaUrl, argRootDir, }: Options$1): Promise<void>;
 
 type Options = {
     argTargetDir: string;