apibara 2.1.0-beta.1 → 2.1.0-beta.10

package/dist/runtime/internal/app.mjs

@@ -6,6 +6,7 @@ import {
   inMemoryPersistence,
   logger
 } from "@apibara/indexer/plugins";
+import consola from "consola";
 import { config } from "#apibara-internal-virtual/config";
 import { indexers } from "#apibara-internal-virtual/indexers";
 import { createLogger } from "./logger.mjs";
@@ -30,7 +31,14 @@ export function createIndexer(indexerName, preset) {
       `Specified indexer "${indexerName}" but it was not defined`
     );
   }
-  const definition = typeof indexerDefinition.indexer === "function" ? indexerDefinition.indexer(runtimeConfig) : indexerDefinition.indexer;
+  const indexerModule = indexerDefinition.indexer?.default;
+  if (indexerModule === void 0) {
+    consola.warn(
+      `Specified indexer "${indexerName}" but it does not export a default. Ignoring.`
+    );
+    return;
+  }
+  const definition = typeof indexerModule === "function" ? indexerModule(runtimeConfig) : indexerModule;
   let reporter = createLogger({
     indexer: indexerName,
     preset,
@@ -48,9 +56,9 @@ export function createIndexer(indexerName, preset) {
       indexerName,
       availableIndexers
     }),
+    logger({ logger: reporter }),
     inMemoryPersistence(),
-    ...definition.plugins ?? [],
-    logger({ logger: reporter })
+    ...definition.plugins ?? []
   ];
   return _createIndexer(definition);
 }

package/dist/runtime/start.mjs

@@ -1,6 +1,7 @@
 import { runWithReconnect } from "@apibara/indexer";
 import { createClient } from "@apibara/protocol";
 import { defineCommand, runMain } from "citty";
+import consola from "consola";
 import { createIndexer } from "./internal/app.mjs";
 const startCommand = defineCommand({
   meta: {
@@ -21,6 +22,10 @@ const startCommand = defineCommand({
   async run({ args }) {
     const { indexer, preset } = args;
     const indexerInstance = createIndexer(indexer, preset);
+    if (!indexerInstance) {
+      consola.error(`Specified indexer "${indexer}" but it was not defined`);
+      process.exit(1);
+    }
     const client = createClient(
       indexerInstance.streamConfig,
       indexerInstance.options.streamUrl

package/dist/types/index.d.mts

@@ -1,25 +1,19 @@
 import { ConsolaInstance } from 'consola';
 import { NestedHooks, Hookable } from 'hookable';
 import { ConsolaReporter } from '@apibara/indexer/plugins';
-import { RollupCommonJSOptions } from '@rollup/plugin-commonjs';
 import { C12InputConfig, WatchConfigOptions, ResolvedConfig, ConfigWatcher } from 'c12';
-import { WatchOptions } from 'chokidar';
-import { InputOptions, OutputOptions } from 'rollup';
+import { RolldownOptions, WatchOptions, InputOptions, OutputOptions } from 'rolldown';
 
 type DeepPartial<T> = T extends Record<string, any> ? {
     [P in keyof T]?: DeepPartial<T[P]> | T[P];
 } : T;
 
-type RollupConfig = InputOptions & {
-    output: OutputOptions;
-};
-
 interface ApibaraHooks {
-    "rollup:before": (apibara: Apibara, rollupConfig: RollupConfig) => void;
+    "rolldown:before": (apibara: Apibara, rolldownConfig: RolldownOptions) => void;
     compiled: (apibara: Apibara) => void;
-    "dev:restart": () => void;
-    "dev:reload": () => void;
-    "rollup:reload": () => void;
+    "dev:restart": () => Promise<void>;
+    "dev:reload": () => Promise<void>;
+    "rolldown:reload": () => Promise<void>;
     restart: () => void;
     close: () => void;
 }
@@ -58,13 +52,18 @@ interface ApibaraOptions<T extends Record<string, DeepPartial<Pick<ApibaraConfig
     outputDir: string;
     indexersDir: string;
     dev: boolean;
-    watchOptions: WatchOptions;
+    watchOptions: WatchOptions["watch"];
     hooks: NestedHooks<ApibaraHooks>;
     logger?: LoggerFactory;
-    rollupConfig?: Partial<RollupConfig>;
+    rolldownConfig?: Partial<RolldownOptions>;
+    /**
+     * @deprecated Use rolldownConfig instead. This option will be removed in future releases.
+     */
+    rollupConfig?: unknown;
     sourceMap?: boolean;
     entry: string;
-    commonJS?: RollupCommonJSOptions;
+    node: boolean;
+    exportConditions?: string[];
     typescript: {
         strict?: boolean;
         internalPaths?: boolean;
@@ -85,6 +84,10 @@ interface Apibara {
     updateConfig: (config: ApibaraDynamicConfig) => void | Promise<void>;
 }
 
+type RolldownConfig = InputOptions & {
+    output: OutputOptions;
+};
+
 type ApibaraRuntimeConfig = Record<string, unknown>;
 
-export type { Apibara, ApibaraConfig, ApibaraDynamicConfig, ApibaraHooks, ApibaraOptions, ApibaraRuntimeConfig, DeepPartial, IndexerDefinition, LoadConfigOptions, LoggerFactory, RollupConfig };
+export type { Apibara, ApibaraConfig, ApibaraDynamicConfig, ApibaraHooks, ApibaraOptions, ApibaraRuntimeConfig, DeepPartial, IndexerDefinition, LoadConfigOptions, LoggerFactory, RolldownConfig };

package/dist/types/index.d.ts

@@ -1,25 +1,19 @@
 import { ConsolaInstance } from 'consola';
 import { NestedHooks, Hookable } from 'hookable';
 import { ConsolaReporter } from '@apibara/indexer/plugins';
-import { RollupCommonJSOptions } from '@rollup/plugin-commonjs';
 import { C12InputConfig, WatchConfigOptions, ResolvedConfig, ConfigWatcher } from 'c12';
-import { WatchOptions } from 'chokidar';
-import { InputOptions, OutputOptions } from 'rollup';
+import { RolldownOptions, WatchOptions, InputOptions, OutputOptions } from 'rolldown';
 
 type DeepPartial<T> = T extends Record<string, any> ? {
     [P in keyof T]?: DeepPartial<T[P]> | T[P];
 } : T;
 
-type RollupConfig = InputOptions & {
-    output: OutputOptions;
-};
-
 interface ApibaraHooks {
-    "rollup:before": (apibara: Apibara, rollupConfig: RollupConfig) => void;
+    "rolldown:before": (apibara: Apibara, rolldownConfig: RolldownOptions) => void;
     compiled: (apibara: Apibara) => void;
-    "dev:restart": () => void;
-    "dev:reload": () => void;
-    "rollup:reload": () => void;
+    "dev:restart": () => Promise<void>;
+    "dev:reload": () => Promise<void>;
+    "rolldown:reload": () => Promise<void>;
     restart: () => void;
     close: () => void;
 }
@@ -58,13 +52,18 @@ interface ApibaraOptions<T extends Record<string, DeepPartial<Pick<ApibaraConfig
     outputDir: string;
     indexersDir: string;
     dev: boolean;
-    watchOptions: WatchOptions;
+    watchOptions: WatchOptions["watch"];
     hooks: NestedHooks<ApibaraHooks>;
     logger?: LoggerFactory;
-    rollupConfig?: Partial<RollupConfig>;
+    rolldownConfig?: Partial<RolldownOptions>;
+    /**
+     * @deprecated Use rolldownConfig instead. This option will be removed in future releases.
+     */
+    rollupConfig?: unknown;
     sourceMap?: boolean;
     entry: string;
-    commonJS?: RollupCommonJSOptions;
+    node: boolean;
+    exportConditions?: string[];
     typescript: {
         strict?: boolean;
         internalPaths?: boolean;
@@ -85,6 +84,10 @@ interface Apibara {
     updateConfig: (config: ApibaraDynamicConfig) => void | Promise<void>;
 }
 
+type RolldownConfig = InputOptions & {
+    output: OutputOptions;
+};
+
 type ApibaraRuntimeConfig = Record<string, unknown>;
 
-export type { Apibara, ApibaraConfig, ApibaraDynamicConfig, ApibaraHooks, ApibaraOptions, ApibaraRuntimeConfig, DeepPartial, IndexerDefinition, LoadConfigOptions, LoggerFactory, RollupConfig };
+export type { Apibara, ApibaraConfig, ApibaraDynamicConfig, ApibaraHooks, ApibaraOptions, ApibaraRuntimeConfig, DeepPartial, IndexerDefinition, LoadConfigOptions, LoggerFactory, RolldownConfig };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "apibara",
-  "version": "2.1.0-beta.1",
+  "version": "2.1.0-beta.10",
   "type": "module",
   "main": "./dist/core/index.mjs",
   "exports": {
@@ -20,9 +20,9 @@
       "types": "./dist/core/index.d.ts",
       "import": "./dist/core/index.mjs"
     },
-    "./rollup": {
-      "types": "./dist/rollup/index.d.ts",
-      "import": "./dist/rollup/index.mjs"
+    "./rolldown": {
+      "types": "./dist/rolldown/index.d.ts",
+      "import": "./dist/rolldown/index.mjs"
     },
     "./types": {
       "types": "./dist/types/index.d.ts",
@@ -73,10 +73,12 @@
     "playground:prepare": "pnpm playground prepare --dir playground",
     "playground:dev": "pnpm playground dev --dir playground",
     "playground:build": "pnpm playground build --dir playground",
-    "playground:start": "pnpm playground start --dir playground --indexer starknet"
+    "playground:start": "pnpm playground start --dir playground --indexer starknet",
+    "playground:init": "pnpm playground init playground",
+    "playground:add": "pnpm playground add --dir playground"
   },
   "devDependencies": {
-    "@apibara/starknet": "2.1.0-beta.1",
+    "@apibara/starknet": "2.1.0-beta.10",
     "@types/fs-extra": "^11.0.4",
     "@types/node": "^20.14.0",
     "@types/prompts": "^2.4.9",
@@ -87,19 +89,14 @@
     "vitest": "^1.6.0"
   },
   "dependencies": {
-    "@apibara/indexer": "2.1.0-beta.1",
-    "@apibara/protocol": "2.1.0-beta.1",
-    "@rollup/plugin-commonjs": "^26.0.1",
-    "@rollup/plugin-json": "^6.1.0",
-    "@rollup/plugin-node-resolve": "^15.2.3",
-    "@rollup/plugin-typescript": "^11.1.6",
+    "@apibara/indexer": "2.1.0-beta.10",
+    "@apibara/protocol": "2.1.0-beta.10",
     "@rollup/plugin-virtual": "^3.0.2",
     "c12": "^1.11.1",
     "chokidar": "^3.6.0",
     "citty": "^0.1.6",
     "consola": "^3.2.3",
     "defu": "^6.1.4",
-    "esbuild": "^0.23.0",
     "fs-extra": "^11.2.0",
     "hookable": "^5.5.3",
     "klona": "^2.0.6",
@@ -109,9 +106,9 @@
     "perfect-debounce": "^1.0.0",
     "picocolors": "^1.1.1",
     "pkg-types": "^1.1.3",
+    "prettier": "^3.5.2",
     "prompts": "^2.4.2",
-    "rollup": "^4.18.1",
-    "rollup-plugin-esbuild": "^6.1.1",
+    "rolldown": "1.0.0-beta.3",
     "ts-morph": "^25.0.1",
     "tslib": "^2.6.3",
     "untyped": "^1.4.2"

package/src/cli/commands/add.ts

@@ -10,28 +10,33 @@ export default 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,
@@ -39,6 +44,7 @@ export default defineCommand({
       argNetwork: network,
       argStorage: storage,
       argDnaUrl: dnaUrl,
+      argRootDir: dir,
     });
   },
 });

package/src/cli/commands/dev.ts

@@ -26,10 +26,20 @@ export default defineCommand({
       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 || ".") as string);
 
+    if (args.alwaysReindex) {
+      process.env.APIBARA_ALWAYS_REINDEX = "true";
+    }
+
     let apibara: Apibara;
     let childProcess: ChildProcess | undefined;
 
@@ -79,19 +89,21 @@ 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();
+          apibara.logger.info("Restarting indexers");
+          await killProcess(childProcess);
+          childProcess = undefined;
         } else {
-          apibara.logger.success("Restarting indexers");
+          apibara.logger.info("Starting indexers");
         }
 
         const childArgs = [
@@ -118,3 +130,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

@@ -18,23 +18,19 @@ export default 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/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,28 @@ 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/**",
+];

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/prod.ts

@@ -1,31 +1,36 @@
-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`,
   );
 
+  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!");
+    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")}`,
     );

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 = [

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/update.ts

@@ -4,6 +4,6 @@ export async function updateApibaraConfig(
   apibara: Apibara,
   _config: ApibaraDynamicConfig,
 ) {
-  await apibara.hooks.callHook("rollup:reload");
+  await apibara.hooks.callHook("rolldown:reload");
   apibara.logger.success("Apibara config hot reloaded!");
 }