apibara 2.0.0-beta.5 → 2.0.0-beta.6

package/dist/chunks/build.mjs

@@ -0,0 +1,28 @@
+import { createApibara, prepare, writeTypes, build as build$1 } from 'apibara/core';
+import { defineCommand } from 'citty';
+import consola from 'consola';
+import { resolve } from 'pathe';
+import { c as commonArgs } from '../shared/apibara.1b515d04.mjs';
+
+const build = defineCommand({
+  meta: {
+    name: "build",
+    description: "Build indexer"
+  },
+  args: {
+    ...commonArgs
+  },
+  async run({ args }) {
+    consola.start("Building");
+    const rootDir = resolve(args.dir || args._dir || ".");
+    const apibara = await createApibara({
+      rootDir
+    });
+    await prepare(apibara);
+    await writeTypes(apibara);
+    await build$1(apibara);
+    await apibara.close();
+  }
+});
+
+export { build as default };

package/dist/chunks/dev.mjs

@@ -0,0 +1,96 @@
+import { spawn } from 'node:child_process';
+import { createApibara, prepare, writeTypes, build } from 'apibara/core';
+import { defineCommand } from 'citty';
+import consola from 'consola';
+import { resolve } from 'pathe';
+import { c as commonArgs } from '../shared/apibara.1b515d04.mjs';
+
+const hmrKeyRe = /^runtimeConfig\./;
+let childProcess;
+const dev = defineCommand({
+  meta: {
+    name: "dev",
+    description: "Start the development server"
+  },
+  args: {
+    ...commonArgs,
+    indexers: {
+      type: "string",
+      description: "Comma-separated list of indexers to run"
+    },
+    preset: {
+      type: "string",
+      description: "Preset to use"
+    },
+    sink: {
+      type: "string",
+      description: "Sink to use"
+    }
+  },
+  async run({ args }) {
+    consola.start("Starting dev server");
+    const rootDir = resolve(args.dir || args._dir || ".");
+    let apibara;
+    const reload = async () => {
+      if (apibara) {
+        consola.info("Restarting dev server");
+        if ("unwatch" in apibara.options._c12) {
+          await apibara.options._c12.unwatch();
+        }
+        await apibara.close();
+      }
+      apibara = await createApibara(
+        {
+          rootDir
+        },
+        {
+          watch: true,
+          c12: {
+            async onUpdate({ getDiff, newConfig }) {
+              const diff = getDiff();
+              if (diff.length === 0) {
+                return;
+              }
+              consola.info(
+                `Nitro config updated:
+                  ${diff.map((entry) => `  ${entry.toString()}`).join("\n")}`
+              );
+              await (diff.every((e) => hmrKeyRe.test(e.key)) ? apibara.updateConfig(newConfig.config || {}) : reload());
+            }
+          }
+        },
+        true
+      );
+      apibara.hooks.hookOnce("restart", reload);
+      await prepare(apibara);
+      await writeTypes(apibara);
+      await build(apibara);
+      apibara.hooks.hook("dev:reload", () => {
+        if (childProcess) {
+          consola.start("Restarting indexers");
+          childProcess.kill();
+        } else {
+          consola.success("Dev server started");
+          consola.success("Starting indexers");
+        }
+        const childArgs = [
+          resolve(apibara.options.outputDir || "./.apibara/build", "main.mjs"),
+          ...args.indexers ? ["--indexers", args.indexers] : [],
+          ...args.preset ? ["--preset", args.preset] : [],
+          ...args.sink ? ["--sink", args.sink] : []
+        ];
+        childProcess = spawn("jiti", childArgs, {
+          stdio: "inherit"
+        });
+        childProcess.on("close", (code) => {
+          if (code !== null) {
+            consola.log(`Indexers process exited with code ${code}`);
+          }
+        });
+      });
+    };
+    await reload();
+  }
+});
+
+export { dev as default };

package/dist/chunks/prepare.mjs

@@ -0,0 +1,23 @@
+import { createApibara, writeTypes } from 'apibara/core';
+import { defineCommand } from 'citty';
+import consola from 'consola';
+import { resolve } from 'pathe';
+import { c as commonArgs } from '../shared/apibara.1b515d04.mjs';
+
+const prepare = defineCommand({
+  meta: {
+    name: "prepare",
+    description: "Generate types for the project"
+  },
+  args: {
+    ...commonArgs
+  },
+  async run({ args }) {
+    consola.start("Preparing Types");
+    const rootDir = resolve(args.dir || ".");
+    const apibara = await createApibara({ rootDir });
+    await writeTypes(apibara);
+  }
+});
+
+export { prepare as default };

package/dist/cli/index.d.mts

@@ -0,0 +1,5 @@
+import * as citty from 'citty';
+
+declare const mainCli: citty.CommandDef<citty.ArgsDef>;
+
+export { mainCli };

package/dist/cli/index.d.ts

@@ -0,0 +1,5 @@
+import * as citty from 'citty';
+
+declare const mainCli: citty.CommandDef<citty.ArgsDef>;
+
+export { mainCli };

package/dist/cli/index.mjs

@@ -0,0 +1,17 @@
+import { defineCommand, runMain } from 'citty';
+
+const mainCli = defineCommand({
+  meta: {
+    name: "apibara",
+    description: "Apibara CLI",
+    version: "2.0.0"
+  },
+  subCommands: {
+    dev: () => import('../chunks/dev.mjs').then((r) => r.default),
+    build: () => import('../chunks/build.mjs').then((r) => r.default),
+    prepare: () => import('../chunks/prepare.mjs').then((r) => r.default)
+  }
+});
+runMain(mainCli);
+
+export { mainCli };

package/dist/config/index.d.mts

@@ -0,0 +1,5 @@
+import { DeepPartial, ApibaraConfig } from 'apibara/types';
+
+declare function defineConfig<T extends Record<string, DeepPartial<ApibaraConfig<T, R>>> = {}, R extends Record<string, unknown> = {}>(config: ApibaraConfig<T, R>): ApibaraConfig<T, R>;
+
+export { defineConfig };

package/dist/config/index.d.ts

@@ -0,0 +1,5 @@
+import { DeepPartial, ApibaraConfig } from 'apibara/types';
+
+declare function defineConfig<T extends Record<string, DeepPartial<ApibaraConfig<T, R>>> = {}, R extends Record<string, unknown> = {}>(config: ApibaraConfig<T, R>): ApibaraConfig<T, R>;
+
+export { defineConfig };

package/dist/config/index.mjs

@@ -0,0 +1,5 @@
+function defineConfig(config) {
+  return config;
+}
+
+export { defineConfig };

package/dist/core/index.d.mts

@@ -0,0 +1,11 @@
+import { ApibaraConfig, LoadConfigOptions, Apibara } from 'apibara/types';
+
+declare function createApibara(config?: ApibaraConfig, opts?: LoadConfigOptions, dev?: boolean): Promise<Apibara>;
+
+declare function build(apibara: Apibara): Promise<void>;
+
+declare function prepare(apibara: Apibara): Promise<void>;
+
+declare function writeTypes(apibara: Apibara): Promise<void>;
+
+export { build, createApibara, prepare, writeTypes };

package/dist/core/index.d.ts

@@ -0,0 +1,11 @@
+import { ApibaraConfig, LoadConfigOptions, Apibara } from 'apibara/types';
+
+declare function createApibara(config?: ApibaraConfig, opts?: LoadConfigOptions, dev?: boolean): Promise<Apibara>;
+
+declare function build(apibara: Apibara): Promise<void>;
+
+declare function prepare(apibara: Apibara): Promise<void>;
+
+declare function writeTypes(apibara: Apibara): Promise<void>;
+
+export { build, createApibara, prepare, writeTypes };

package/dist/core/index.mjs

@@ -0,0 +1,345 @@
+import consola from 'consola';
+import { createHooks } from 'hookable';
+import { watchConfig, loadConfig } from 'c12';
+import { klona } from 'klona/full';
+import { resolve, isAbsolute, relative, join, dirname } from 'pathe';
+import defu from 'defu';
+import { getRollupConfig } from 'apibara/rollup';
+import { watch } from 'chokidar';
+import { debounce } from 'perfect-debounce';
+import * as rollup from 'rollup';
+import { rollup as rollup$1 } from 'rollup';
+import fsp from 'node:fs/promises';
+import fse from 'fs-extra';
+import { generateTypes, resolveSchema } from 'untyped';
+
+const ApibaraDefaults = {
+  rootDir: ".",
+  runtimeConfig: {},
+  hooks: {},
+  buildDir: ".apibara",
+  typescript: {
+    strict: false,
+    generateTsConfig: true,
+    generateRuntimeConfigTypes: true,
+    tsconfigPath: "types/tsconfig.json",
+    internalPaths: false,
+    tsConfig: {}
+  }
+};
+
+async function resolvePathOptions(options) {
+  options.rootDir = resolve(options.rootDir || ".");
+  for (const key of ["buildDir"]) {
+    options[key] = resolve(options.rootDir, options[key]);
+  }
+  if (!options.outputDir) {
+    options.outputDir = resolve(options.rootDir, ".apibara/build");
+  }
+}
+
+async function presetResolver(options) {
+  if (options.preset && options.presets?.[options.preset]) {
+    const new_options = defu(options.presets[options.preset], options);
+    Object.assign(options, new_options);
+  }
+}
+
+async function resolveRuntimeConfigOptions(options) {
+  options.runtimeConfig = { ...options.runtimeConfig, default: "value" };
+  process.env.APIBARA_RUNTIME_CONFIG = JSON.stringify(options.runtimeConfig);
+}
+
+const configResolvers = [
+  resolvePathOptions,
+  resolveRuntimeConfigOptions,
+  presetResolver
+];
+async function loadOptions(configOverrides = {}, opts = {}, dev = false) {
+  const options = await _loadUserConfig(configOverrides, opts, dev);
+  for (const resolver of configResolvers) {
+    await resolver(options);
+  }
+  return options;
+}
+async function _loadUserConfig(configOverrides = {}, opts = {}, dev = false) {
+  configOverrides = klona(configOverrides);
+  const loadedConfig = await (opts.watch ? watchConfig : loadConfig)({
+    name: "apibara",
+    dotenv: dev,
+    cwd: configOverrides.rootDir,
+    overrides: {
+      ...configOverrides
+    },
+    defaults: { ...ApibaraDefaults },
+    ...opts.c12
+  });
+  const options = klona(loadedConfig.config);
+  options._config = configOverrides;
+  options._c12 = loadedConfig;
+  if (dev) {
+    options.dev = dev;
+  }
+  return options;
+}
+
+async function updateApibaraConfig(apibara, config) {
+  await apibara.hooks.callHook("rollup:reload");
+  consola.success("Apibara config hot reloaded!");
+}
+
+async function createApibara(config = {}, opts = {}, dev = false) {
+  const options = await loadOptions(config, opts, dev);
+  const apibara = {
+    options,
+    hooks: createHooks(),
+    close: () => apibara.hooks.callHook("close"),
+    logger: consola.withTag("apibara"),
+    async updateConfig(config2) {
+      updateApibaraConfig(apibara);
+    }
+  };
+  apibara.hooks.addHooks(apibara.options.hooks);
+  return apibara;
+}
+
+function formatRollupError(_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;
+      if (location) {
+        path += `:${location.line}:${location.column}`;
+      }
+      const text = error.text || error.frame;
+      logs.push(
+        // biome-ignore lint/style/useTemplate: <explanation>
+        `Rollup error while processing \`${path}\`` + text ? "\n\n" + text : ""
+      );
+    }
+    return logs.join("\n");
+  } catch {
+    return _error?.toString();
+  }
+}
+
+async function watchDev(apibara, rollupConfig) {
+  let rollupWatcher;
+  async function load() {
+    if (rollupWatcher) {
+      await rollupWatcher.close();
+    }
+    rollupWatcher = startRollupWatcher(apibara, rollupConfig);
+  }
+  const reload = debounce(load);
+  const watchPatterns = [join(apibara.options.rootDir, "indexers")];
+  const watchReloadEvents = /* @__PURE__ */ new Set(["add", "addDir", "unlink", "unlinkDir"]);
+  const reloadWatcher = watch(watchPatterns, { ignoreInitial: true }).on(
+    "all",
+    (event) => {
+      if (watchReloadEvents.has(event)) {
+        reload();
+      }
+    }
+  );
+  apibara.hooks.hook("close", () => {
+    rollupWatcher.close();
+    reloadWatcher.close();
+  });
+  apibara.hooks.hook("rollup:reload", () => reload());
+  await load();
+}
+function startRollupWatcher(apibara, rollupConfig) {
+  const watcher = rollup.watch(
+    defu(rollupConfig, {
+      watch: {
+        chokidar: apibara.options.watchOptions
+      }
+    })
+  );
+  let start;
+  watcher.on("event", (event) => {
+    switch (event.code) {
+      case "START": {
+        return;
+      }
+      case "BUNDLE_START": {
+        start = Date.now();
+        return;
+      }
+      case "END": {
+        apibara.hooks.callHook("compiled", apibara);
+        apibara.logger.success(
+          "Indexers built",
+          start ? `in ${Date.now() - start} ms` : ""
+        );
+        apibara.hooks.callHook("dev:reload");
+        return;
+      }
+      case "ERROR": {
+        apibara.logger.error(formatRollupError(event.error));
+      }
+    }
+  });
+  return watcher;
+}
+
+async function buildProduction(apibara, rollupConfig) {
+  try {
+    const bundle = await rollup$1(rollupConfig);
+    if (Array.isArray(rollupConfig.output)) {
+      for (const outputOptions of rollupConfig.output) {
+        await bundle.write(outputOptions);
+      }
+    } else if (rollupConfig.output) {
+      await bundle.write(rollupConfig.output);
+    } else {
+      throw new Error("No output options specified in Rollup config");
+    }
+    await bundle.close();
+    consola.success("Build completed successfully!");
+  } catch (error) {
+    console.error("Build failed:", error);
+    throw error;
+  }
+}
+
+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);
+}
+
+async function prepare(apibara) {
+  await prepareDir(apibara.options.buildDir);
+  await prepareDir(apibara.options.outputDir);
+  consola.success("Output directory cleaned");
+}
+async function prepareDir(dir) {
+  await fsp.mkdir(dir, { recursive: true });
+  await fse.emptyDir(dir);
+}
+
+async function writeTypes(apibara) {
+  const typesDir = resolve(apibara.options.buildDir, "types");
+  const config = [
+    "// Generated by apibara",
+    `
+declare module "apibara/types" {`,
+    apibara.options.typescript.generateRuntimeConfigTypes ? generateTypes(
+      await resolveSchema(
+        Object.fromEntries(
+          Object.entries(apibara.options.runtimeConfig)
+        )
+      ),
+      {
+        interfaceName: "ApibaraRuntimeConfig",
+        addExport: false,
+        addDefaults: false,
+        allowExtraKeys: false,
+        indentation: 2
+      }
+    ) : "",
+    "}",
+    // Makes this a module for augmentation purposes
+    "export type {}"
+  ];
+  const declarations = [
+    // local apibara augmentations
+    '/// <reference path="./apibara-config.d.ts" />'
+  ];
+  const buildFiles = [];
+  buildFiles.push({
+    path: join(typesDir, "apibara-config.d.ts"),
+    contents: config.join("\n")
+  });
+  buildFiles.push({
+    path: join(typesDir, "apibara.d.ts"),
+    contents: declarations.join("\n")
+  });
+  if (apibara.options.typescript.generateTsConfig) {
+    const tsConfigPath = resolve(
+      apibara.options.buildDir,
+      apibara.options.typescript.tsconfigPath
+    );
+    const tsconfigDir = dirname(tsConfigPath);
+    const tsConfig = defu(apibara.options.typescript.tsConfig, {
+      compilerOptions: {
+        forceConsistentCasingInFileNames: true,
+        strict: apibara.options.typescript.strict,
+        noEmit: true,
+        target: "ESNext",
+        module: "ESNext",
+        moduleResolution: "Bundler",
+        allowJs: true,
+        resolveJsonModule: true,
+        jsx: "preserve",
+        allowSyntheticDefaultImports: true,
+        jsxFactory: "h",
+        jsxFragmentFactory: "Fragment"
+      },
+      include: [
+        relativeWithDot(tsconfigDir, join(typesDir, "apibara.d.ts")).replace(
+          /^(?=[^.])/,
+          "./"
+        )
+      ]
+    });
+    for (const alias in tsConfig.compilerOptions.paths) {
+      const paths = tsConfig.compilerOptions.paths[alias];
+      tsConfig.compilerOptions.paths[alias] = await Promise.all(
+        paths.map(async (path) => {
+          if (!isAbsolute(path)) {
+            return path;
+          }
+          const stats = await fsp.stat(path).catch(
+            () => null
+            /* file does not exist */
+          );
+          return relativeWithDot(
+            tsconfigDir,
+            stats?.isFile() ? path.replace(/(?<=\w)\.\w+$/g, "") : path
+          );
+        })
+      );
+    }
+    tsConfig.include = [
+      ...new Set(
+        tsConfig.include.map(
+          (p) => isAbsolute(p) ? relativeWithDot(tsconfigDir, p) : p
+        )
+      )
+    ];
+    if (tsConfig.exclude) {
+      tsConfig.exclude = [
+        ...new Set(
+          tsConfig.exclude.map(
+            (p) => isAbsolute(p) ? relativeWithDot(tsconfigDir, p) : p
+          )
+        )
+      ];
+    }
+    buildFiles.push({
+      path: tsConfigPath,
+      contents: JSON.stringify(tsConfig, null, 2)
+    });
+  }
+  await Promise.all(
+    buildFiles.map(async (file) => {
+      const _file = resolve(apibara.options.buildDir, file.path);
+      await fsp.mkdir(dirname(_file), { recursive: true });
+      await fsp.writeFile(_file, file.contents);
+    })
+  );
+  consola.success("Types generated");
+}
+const RELATIVE_RE = /^\.{1,2}\//;
+function relativeWithDot(from, to) {
+  const rel = relative(from, to);
+  return RELATIVE_RE.test(rel) ? rel : `./${rel}`;
+}
+
+export { build, createApibara, prepare, writeTypes };

package/dist/hooks/index.d.mts

@@ -0,0 +1,5 @@
+import { ApibaraRuntimeConfig } from 'apibara/types';
+
+declare function useRuntimeConfig(): ApibaraRuntimeConfig;
+
+export { useRuntimeConfig };

package/dist/hooks/index.d.ts

@@ -0,0 +1,5 @@
+import { ApibaraRuntimeConfig } from 'apibara/types';
+
+declare function useRuntimeConfig(): ApibaraRuntimeConfig;
+
+export { useRuntimeConfig };

package/dist/hooks/index.mjs

@@ -0,0 +1,5 @@
+function useRuntimeConfig() {
+  return JSON.parse(process.env.APIBARA_RUNTIME_CONFIG || "{}");
+}
+
+export { useRuntimeConfig };

package/dist/rollup/index.d.mts

@@ -0,0 +1,5 @@
+import { Apibara, RollupConfig } from 'apibara/types';
+
+declare const getRollupConfig: (apibara: Apibara, dev?: boolean) => RollupConfig;
+
+export { getRollupConfig };

package/dist/rollup/index.d.ts

@@ -0,0 +1,5 @@
+import { Apibara, RollupConfig } from 'apibara/types';
+
+declare const getRollupConfig: (apibara: Apibara, dev?: boolean) => RollupConfig;
+
+export { getRollupConfig };

package/dist/rollup/index.mjs

@@ -0,0 +1,186 @@
+import { existsSync } from 'node:fs';
+import { builtinModules } from 'node:module';
+import commonjs from '@rollup/plugin-commonjs';
+import json from '@rollup/plugin-json';
+import { nodeResolve } from '@rollup/plugin-node-resolve';
+import typescript from '@rollup/plugin-typescript';
+import fse from 'fs-extra';
+import { join, basename } from 'pathe';
+
+const getRollupConfig = (apibara, dev = false) => {
+  const extensions = [
+    ".ts",
+    ".mjs",
+    ".js",
+    ".json",
+    ".node",
+    ".tsx",
+    ".jsx"
+  ];
+  const indexerDir = join(apibara.options.rootDir, "indexers");
+  const configPath = join(apibara.options.rootDir, "./apibara.config.ts");
+  if (!existsSync(indexerDir)) {
+    throw new Error(`Indexers directory not found: ${indexerDir}`);
+  }
+  if (!existsSync(configPath)) {
+    throw new Error(`Config file not found: ${configPath}`);
+  }
+  let indexerFiles = [];
+  try {
+    indexerFiles = fse.readdirSync(indexerDir).filter((file) => file.endsWith(".indexer.ts"));
+    if (indexerFiles.length === 0) {
+      console.warn(`No indexer files found in ${indexerDir}`);
+    }
+  } catch (error) {
+    console.error(`Error reading indexers directory: ${error}`);
+  }
+  const indexerImports = indexerFiles.map(
+    (file, index) => `import indexer${index} from '${join(indexerDir, file)}';`
+  ).join("\n");
+  const mainContent = `
+import { createClient } from "@apibara/protocol";
+import { createIndexer, run } from "@apibara/indexer";
+import consola from "consola";
+import { defineCommand, runMain } from "citty";
+import config from './${configPath}';
+
+${indexerImports}
+
+const indexers = {
+  ${indexerFiles.map(
+    (file, index) => `'${basename(file, ".indexer.ts")}': indexer${index},`
+  ).join("\n  ")}
+};
+
+const command = defineCommand({
+  meta: {
+    name: "run-indexers",
+    description: "Run Apibara indexers",
+  },
+  args: {
+    indexers: {
+      type: "string",
+      description: "Comma-separated list of indexers to run",
+    },
+    preset: {
+      type: "string",
+      description: "Preset to use",
+    },
+    sink: {
+      type: "string",
+      description: "Sink to use",
+    },
+  },
+  async run({ args }) {
+    const selectedIndexers = args.indexers ? args.indexers.split(',') : Object.keys(indexers);
+    const preset = args.preset || config.preset || 'default';
+    const sinkName = args.sink || 'default';
+
+    // Apply preset
+    let runtimeConfig = { ...config.runtimeConfig };
+    if (preset && config.presets && config.presets[preset]) {
+      runtimeConfig = { ...runtimeConfig, ...config.presets[preset].runtimeConfig };
+    }
+
+    // Get sink function
+    const sinkFunction = config.sink?.[sinkName];
+    if (!sinkFunction) {
+      throw new Error(\`Sink \${sinkName} not found\`);
+    }
+
+    await Promise.all(selectedIndexers.map(async (name) => {
+      if (!indexers[name]) {
+        console.error(\`Indexer \${name} not found\`);
+        return;
+      }
+
+      const indexerConfig = indexers[name]
+      const indexer = typeof indexerConfig === 'function'
+        ? await createIndexer(indexerConfig(runtimeConfig))
+        : createIndexer(indexerConfig);
+
+      const client = createClient(indexer.streamConfig, indexer.options.streamUrl);
+      const sink = sinkFunction();
+
+      try {
+        consola.log("Running Indexer: ", name);
+        await run(client, indexer, sink);
+      } catch (error) {
+        consola.error(\`Error in indexer \${name}:\`, error);
+      }
+    }));
+  },
+});
+
+runMain(command);
+`;
+  return {
+    input: {
+      main: "virtual:main.ts"
+    },
+    output: {
+      dir: join(apibara.options.outputDir || "./.apibara/build"),
+      format: "esm",
+      exports: "auto",
+      entryFileNames: "[name].mjs",
+      chunkFileNames: "chunks/[name]-[hash].mjs",
+      generatedCode: {
+        constBindings: true
+      },
+      sourcemap: true,
+      sourcemapExcludeSources: true,
+      sourcemapIgnoreList(relativePath, sourcemapPath) {
+        return relativePath.includes("node_modules");
+      }
+    },
+    plugins: [
+      {
+        name: "virtual",
+        resolveId(id) {
+          if (id === "virtual:main.ts") {
+            return id;
+          }
+          return null;
+        },
+        load(id) {
+          if (id === "virtual:main.ts") {
+            return mainContent;
+          }
+          return null;
+        }
+      },
+      nodeResolve({
+        extensions,
+        preferBuiltins: true
+      }),
+      commonjs(),
+      json(),
+      typescript({
+        tsconfig: join(apibara.options.rootDir, "./tsconfig.json"),
+        compilerOptions: {
+          outDir: join(apibara.options.outputDir || "./.apibara/build"),
+          declarationDir: join(apibara.options.outputDir || "./.apibara/build"),
+          noEmit: false,
+          types: ["node"]
+        }
+      })
+    ],
+    onwarn(warning, rollupWarn) {
+      if (!["CIRCULAR_DEPENDENCY", "EVAL"].includes(warning.code || "") && !warning.message.includes("Unsupported source map comment") && !warning.message.includes("@__PURE__")) {
+        rollupWarn(warning);
+      }
+    },
+    treeshake: true,
+    external: [
+      ...builtinModules,
+      "@apibara/indexer",
+      "@apibara/protocol",
+      "@apibara/evm",
+      "@apibara/starknet",
+      "@apibara/beaconchain",
+      "@apibara/cli"
+    ]
+  };
+};
+
+export { getRollupConfig };

package/dist/shared/apibara.1b515d04.mjs

@@ -0,0 +1,8 @@
+const commonArgs = {
+  dir: {
+    type: "string",
+    description: "project root directory"
+  }
+};
+
+export { commonArgs as c };

package/dist/types/index.d.mts

@@ -0,0 +1,87 @@
+import { ConsolaInstance } from 'consola';
+import { NestedHooks, Hookable } from 'hookable';
+import { Sink } from '@apibara/indexer';
+import { C12InputConfig, WatchConfigOptions, ResolvedConfig, ConfigWatcher } from 'c12';
+import { WatchOptions } from 'chokidar';
+import { TSConfig } from 'pkg-types';
+import { InputOptions, OutputOptions } from 'rollup';
+
+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;
+    compiled: (apibara: Apibara) => void;
+    "dev:reload": () => void;
+    "rollup:reload": () => void;
+    restart: () => void;
+    close: () => void;
+}
+
+/**
+ * Apibara Config type (apibara.config)
+ */
+interface ApibaraConfig<T extends Record<string, DeepPartial<ApibaraConfig<T, R>>> = {}, R extends Record<string, unknown> = {}> extends DeepPartial<Omit<ApibaraOptions<T, R>, "preset" | "presets" | "dev">>, C12InputConfig<ApibaraConfig<T, R>> {
+    sink?: {
+        default: () => Sink;
+        [key: string]: () => Sink;
+    };
+    runtimeConfig?: R;
+    presets?: T;
+    preset?: keyof T;
+}
+type ApibaraDynamicConfig = Pick<ApibaraConfig, "runtimeConfig">;
+/**
+ * Config loader options
+ */
+interface LoadConfigOptions {
+    watch?: boolean;
+    c12?: WatchConfigOptions;
+}
+interface ApibaraOptions<T extends Record<string, DeepPartial<ApibaraConfig<T, R>>> = {}, R extends Record<string, unknown> = {}> {
+    _config: ApibaraConfig<T, R>;
+    _c12: ResolvedConfig<ApibaraConfig<T, R>> | ConfigWatcher<ApibaraConfig<T, R>>;
+    sink: {
+        default: () => Sink;
+        [key: string]: () => Sink;
+    };
+    presets?: T;
+    preset?: keyof T;
+    debug: boolean;
+    runtimeConfig: R;
+    rootDir: string;
+    buildDir: string;
+    outputDir: string;
+    dev: boolean;
+    watchOptions: WatchOptions;
+    hooks: NestedHooks<ApibaraHooks>;
+    rollupConfig?: RollupConfig;
+    entry: string;
+    minify: boolean;
+    typescript: {
+        strict?: boolean;
+        internalPaths?: boolean;
+        generateRuntimeConfigTypes?: boolean;
+        generateTsConfig?: boolean;
+        /** the path of the generated `tsconfig.json`, relative to buildDir */
+        tsconfigPath: string;
+        tsConfig?: Partial<TSConfig>;
+    };
+}
+
+interface Apibara {
+    options: ApibaraOptions;
+    hooks: Hookable<ApibaraHooks>;
+    logger: ConsolaInstance;
+    close: () => Promise<void>;
+    updateConfig: (config: ApibaraDynamicConfig) => void | Promise<void>;
+}
+
+type ApibaraRuntimeConfig = Record<string, unknown>;
+
+export type { Apibara, ApibaraConfig, ApibaraDynamicConfig, ApibaraHooks, ApibaraOptions, ApibaraRuntimeConfig, DeepPartial, LoadConfigOptions, RollupConfig };

package/dist/types/index.d.ts

@@ -0,0 +1,87 @@
+import { ConsolaInstance } from 'consola';
+import { NestedHooks, Hookable } from 'hookable';
+import { Sink } from '@apibara/indexer';
+import { C12InputConfig, WatchConfigOptions, ResolvedConfig, ConfigWatcher } from 'c12';
+import { WatchOptions } from 'chokidar';
+import { TSConfig } from 'pkg-types';
+import { InputOptions, OutputOptions } from 'rollup';
+
+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;
+    compiled: (apibara: Apibara) => void;
+    "dev:reload": () => void;
+    "rollup:reload": () => void;
+    restart: () => void;
+    close: () => void;
+}
+
+/**
+ * Apibara Config type (apibara.config)
+ */
+interface ApibaraConfig<T extends Record<string, DeepPartial<ApibaraConfig<T, R>>> = {}, R extends Record<string, unknown> = {}> extends DeepPartial<Omit<ApibaraOptions<T, R>, "preset" | "presets" | "dev">>, C12InputConfig<ApibaraConfig<T, R>> {
+    sink?: {
+        default: () => Sink;
+        [key: string]: () => Sink;
+    };
+    runtimeConfig?: R;
+    presets?: T;
+    preset?: keyof T;
+}
+type ApibaraDynamicConfig = Pick<ApibaraConfig, "runtimeConfig">;
+/**
+ * Config loader options
+ */
+interface LoadConfigOptions {
+    watch?: boolean;
+    c12?: WatchConfigOptions;
+}
+interface ApibaraOptions<T extends Record<string, DeepPartial<ApibaraConfig<T, R>>> = {}, R extends Record<string, unknown> = {}> {
+    _config: ApibaraConfig<T, R>;
+    _c12: ResolvedConfig<ApibaraConfig<T, R>> | ConfigWatcher<ApibaraConfig<T, R>>;
+    sink: {
+        default: () => Sink;
+        [key: string]: () => Sink;
+    };
+    presets?: T;
+    preset?: keyof T;
+    debug: boolean;
+    runtimeConfig: R;
+    rootDir: string;
+    buildDir: string;
+    outputDir: string;
+    dev: boolean;
+    watchOptions: WatchOptions;
+    hooks: NestedHooks<ApibaraHooks>;
+    rollupConfig?: RollupConfig;
+    entry: string;
+    minify: boolean;
+    typescript: {
+        strict?: boolean;
+        internalPaths?: boolean;
+        generateRuntimeConfigTypes?: boolean;
+        generateTsConfig?: boolean;
+        /** the path of the generated `tsconfig.json`, relative to buildDir */
+        tsconfigPath: string;
+        tsConfig?: Partial<TSConfig>;
+    };
+}
+
+interface Apibara {
+    options: ApibaraOptions;
+    hooks: Hookable<ApibaraHooks>;
+    logger: ConsolaInstance;
+    close: () => Promise<void>;
+    updateConfig: (config: ApibaraDynamicConfig) => void | Promise<void>;
+}
+
+type ApibaraRuntimeConfig = Record<string, unknown>;
+
+export type { Apibara, ApibaraConfig, ApibaraDynamicConfig, ApibaraHooks, ApibaraOptions, ApibaraRuntimeConfig, DeepPartial, LoadConfigOptions, RollupConfig };

package/dist/types/index.mjs

@@ -0,0 +1 @@
+

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "apibara",
-  "version": "2.0.0-beta.5",
+  "version": "2.0.0-beta.6",
   "type": "module",
   "source": "./src/core/index.ts",
   "main": "./dist/core/index.mjs",
@@ -64,10 +64,10 @@
     "vitest": "^1.6.0"
   },
   "dependencies": {
-    "@apibara/evm": "2.0.0-beta.5",
-    "@apibara/indexer": "2.0.0-beta.5",
-    "@apibara/protocol": "2.0.0-beta.5",
-    "@apibara/starknet": "2.0.0-beta.5",
+    "@apibara/evm": "2.0.0-beta.6",
+    "@apibara/indexer": "2.0.0-beta.6",
+    "@apibara/protocol": "2.0.0-beta.6",
+    "@apibara/starknet": "2.0.0-beta.6",
     "@rollup/plugin-commonjs": "^26.0.1",
     "@rollup/plugin-json": "^6.1.0",
     "@rollup/plugin-node-resolve": "^15.2.3",