apibara 2.1.0-beta.3 → 2.1.0-beta.30

package/dist/chunks/add.mjs

@@ -1,5 +1,7 @@
 import { addIndexer } from 'apibara/create';
 import { defineCommand } from 'citty';
+import { a as checkForUnknownArgs } from '../shared/apibara.63c9a277.mjs';
+import 'consola';
 
 const add = defineCommand({
   meta: {
@@ -9,34 +11,40 @@ 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;
+  async run({ args, cmd }) {
+    await checkForUnknownArgs(args, cmd);
+    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/build.mjs

@@ -2,7 +2,8 @@ import { createApibara, prepare, writeTypes, build as build$1 } from 'apibara/co
 import { runtimeDir } from 'apibara/runtime/meta';
 import { defineCommand } from 'citty';
 import { resolve, join } from 'pathe';
-import { c as commonArgs } from '../shared/apibara.1b515d04.mjs';
+import { c as commonArgs, a as checkForUnknownArgs } from '../shared/apibara.63c9a277.mjs';
+import 'consola';
 
 const build = defineCommand({
   meta: {
@@ -12,7 +13,8 @@ const build = defineCommand({
   args: {
     ...commonArgs
   },
-  async run({ args }) {
+  async run({ args, cmd }) {
+    await checkForUnknownArgs(args, cmd);
     const rootDir = resolve(args.dir || args._dir || ".");
     const apibara = await createApibara({
       rootDir

package/dist/chunks/dev.mjs

@@ -4,7 +4,10 @@ import { runtimeDir } from 'apibara/runtime/meta';
 import { defineCommand } from 'citty';
 import { colors } from 'consola/utils';
 import { resolve, join } from 'pathe';
-import { c as commonArgs } from '../shared/apibara.1b515d04.mjs';
+import { b as blueBright, g as gray } from '../shared/apibara.730bb1e4.mjs';
+import { c as commonArgs, a as checkForUnknownArgs } from '../shared/apibara.63c9a277.mjs';
+import 'picocolors';
+import 'consola';
 
 const hmrKeyRe = /^runtimeConfig\./;
 const dev = defineCommand({
@@ -21,10 +24,22 @@ const dev = defineCommand({
     preset: {
       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 || ".");
+    if (args["always-reindex"]) {
+      process.env.APIBARA_ALWAYS_REINDEX = "true";
+    }
+    const selectedIndexers = new Set(
+      args.indexers?.split(",").map((i) => i.trim()).sort() ?? []
+    );
     let apibara;
     let childProcess;
     const reload = async () => {
@@ -37,7 +52,8 @@ const dev = defineCommand({
       }
       apibara = await createApibara(
         {
-          rootDir
+          rootDir,
+          preset: args.preset
         },
         {
           watch: true,
@@ -62,18 +78,24 @@ 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 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"),
@@ -84,17 +106,25 @@ const dev = defineCommand({
         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 = void 0;
+          console.log();
+          apibara.logger.log(
+            `Indexers process exited${code !== null ? ` with code ${colors.red(code)}` : ""}`
+          );
         });
       });
     };
     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

@@ -1,5 +1,7 @@
 import { initializeProject } from 'apibara/create';
 import { defineCommand } from 'citty';
+import { a as checkForUnknownArgs } from '../shared/apibara.63c9a277.mjs';
+import 'consola';
 
 const init = defineCommand({
   meta: {
@@ -14,22 +16,24 @@ const init = 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/dist/chunks/prepare.mjs

@@ -1,7 +1,8 @@
 import { createApibara, writeTypes } from 'apibara/core';
 import { defineCommand } from 'citty';
 import { resolve } from 'pathe';
-import { c as commonArgs } from '../shared/apibara.1b515d04.mjs';
+import { c as commonArgs, a as checkForUnknownArgs } from '../shared/apibara.63c9a277.mjs';
+import 'consola';
 
 const prepare = defineCommand({
   meta: {
@@ -11,7 +12,8 @@ const prepare = defineCommand({
   args: {
     ...commonArgs
   },
-  async run({ args }) {
+  async run({ args, cmd }) {
+    await checkForUnknownArgs(args, cmd);
     const rootDir = resolve(args.dir || ".");
     const apibara = await createApibara({ rootDir });
     await writeTypes(apibara);

package/dist/chunks/start.mjs

@@ -1,9 +1,11 @@
 import { spawn } from 'node:child_process';
 import { createApibara } from 'apibara/core';
 import { defineCommand } from 'citty';
+import { colors } from 'consola/utils';
 import fse from 'fs-extra';
 import { resolve } from 'pathe';
-import { c as commonArgs } from '../shared/apibara.1b515d04.mjs';
+import { c as commonArgs, a as checkForUnknownArgs } from '../shared/apibara.63c9a277.mjs';
+import 'consola';
 
 const start = defineCommand({
   meta: {
@@ -22,11 +24,13 @@ const start = defineCommand({
       description: "The preset to use"
     }
   },
-  async run({ args }) {
+  async run({ args, cmd }) {
     const { indexer, preset } = args;
     const rootDir = resolve(args.dir || args._dir || ".");
+    await checkForUnknownArgs(args, cmd);
     const apibara = await createApibara({
-      rootDir
+      rootDir,
+      preset
     });
     apibara.logger.start(
       `Starting indexer ${indexer}${preset ? ` with preset ${preset}` : ""}`
@@ -47,9 +51,15 @@ const start = defineCommand({
       indexer,
       ...preset ? ["--preset", preset] : []
     ];
-    spawn("node", childArgs, {
+    const childProcess = spawn("node", childArgs, {
       stdio: "inherit"
     });
+    childProcess.on("close", (code, signal) => {
+      console.log();
+      apibara.logger.log(
+        `Indexers process exited${code !== null ? ` with code ${colors.red(code)}` : ""}`
+      );
+    });
   }
 });
 

package/dist/chunks/write-project-info.mjs

@@ -0,0 +1,50 @@
+import { spawn } from 'node:child_process';
+import { join } from 'node:path';
+import { createApibara, prepare, writeTypes, build } from 'apibara/core';
+import { runtimeDir } from 'apibara/runtime/meta';
+import { defineCommand } from 'citty';
+import consola from 'consola';
+import { resolve } from 'pathe';
+import { c as commonArgs, a as checkForUnknownArgs } from '../shared/apibara.63c9a277.mjs';
+
+const writeProjectInfo = 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 || ".");
+    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);
+    });
+  }
+});
+
+export { writeProjectInfo as default };

package/dist/cli/index.mjs

@@ -13,7 +13,8 @@ const mainCli = defineCommand({
     start: () => import('../chunks/start.mjs').then((r) => r.default),
     prepare: () => import('../chunks/prepare.mjs').then((r) => r.default),
     init: () => import('../chunks/init.mjs').then((r) => r.default),
-    add: () => import('../chunks/add.mjs').then((r) => r.default)
+    add: () => import('../chunks/add.mjs').then((r) => r.default),
+    "write-project-info": () => import('../chunks/write-project-info.mjs').then((r) => r.default)
   }
 });
 runMain(mainCli);

package/dist/core/index.mjs

@@ -3,14 +3,13 @@ import { createHooks } from 'hookable';
 import { watchConfig, loadConfig } from 'c12';
 import { klona } from 'klona/full';
 import { resolve, join, basename, isAbsolute, relative, dirname } from 'pathe';
-import defu from 'defu';
 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 defu from 'defu';
 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 +23,9 @@ const ApibaraDefaults = {
     strict: false,
     generateRuntimeConfigTypes: true,
     internalPaths: false
-  }
+  },
+  node: true,
+  exportConditions: ["node"]
 };
 
 async function resolvePathOptions(options) {
@@ -37,25 +38,17 @@ async function resolvePathOptions(options) {
   }
 }
 
-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 };
-  process.env.APIBARA_RUNTIME_CONFIG = JSON.stringify(options.runtimeConfig);
-}
-
-const configResolvers = [
-  resolvePathOptions,
-  resolveRuntimeConfigOptions,
-  presetResolver
-];
+const configResolvers = [resolvePathOptions];
 async function loadOptions(configOverrides = {}, opts = {}, dev = false) {
   const options = await _loadUserConfig(configOverrides, opts, dev);
+  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);
   }
@@ -83,7 +76,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!");
 }
 
@@ -119,6 +112,7 @@ function indexerNameFromFile(file) {
 
 async function createApibara(config = {}, opts = {}, dev = false) {
   const options = await loadOptions(config, opts, dev);
+  process.env.NODE_OPTIONS = process.env.NODE_OPTIONS ? `${process.env.NODE_OPTIONS} --enable-source-maps` : "--enable-source-maps";
   const apibara = {
     options,
     indexers: [],
@@ -134,20 +128,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 +150,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,37 +204,55 @@ 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) {
-  apibara.logger.start(
-    `Building ${colors.cyan(apibara.indexers.length)} indexers`
-  );
+async function buildProduction(apibara, rolldownConfig) {
+  if (!apibara.options.disableLogs) {
+    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!");
-    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;
@@ -245,9 +260,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) {
@@ -258,9 +280,11 @@ function prettyPath(path, highlight = true) {
 async function prepare(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) {
   await fsp.mkdir(dir, { recursive: true });
@@ -268,6 +292,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",
@@ -303,7 +331,9 @@ declare module "apibara/types" {`,
       await fsp.writeFile(_file, file.contents);
     })
   );
-  apibara.logger.success(`Types written to ${prettyPath(typesDir)}`);
+  if (!apibara.options.disableLogs) {
+    apibara.logger.success(`Types written to ${prettyPath(typesDir)}`);
+  }
 }
 
 export { build, createApibara, prepare, writeTypes };

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;