apibara 2.0.0-beta.9 → 2.1.0-beta.10

package/dist/core/index.mjs

@@ -1,31 +1,31 @@
-import consola__default from 'consola';
+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 { resolve, join, basename, isAbsolute, relative, dirname } from 'pathe';
 import defu from 'defu';
-import { getRollupConfig } from 'apibara/rollup';
+import fse from 'fs-extra';
+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 * as rolldown from 'rolldown';
 import fsp from 'node:fs/promises';
-import fse from 'fs-extra';
 import { generateTypes, resolveSchema } from 'untyped';
 
 const ApibaraDefaults = {
   rootDir: ".",
+  indexersDir: "indexers",
   runtimeConfig: {},
   hooks: {},
   buildDir: ".apibara",
   typescript: {
     strict: false,
-    generateTsConfig: true,
     generateRuntimeConfigTypes: true,
-    tsconfigPath: "types/tsconfig.json",
-    internalPaths: false,
-    tsConfig: {}
-  }
+    internalPaths: false
+  },
+  node: true,
+  exportConditions: ["node"]
 };
 
 async function resolvePathOptions(options) {
@@ -46,7 +46,7 @@ async function presetResolver(options) {
 }
 
 async function resolveRuntimeConfigOptions(options) {
-  options.runtimeConfig = { ...options.runtimeConfig, default: "value" };
+  options.runtimeConfig = { ...options.runtimeConfig };
   process.env.APIBARA_RUNTIME_CONFIG = JSON.stringify(options.runtimeConfig);
 }
 
@@ -83,41 +83,72 @@ async function _loadUserConfig(configOverrides = {}, opts = {}, dev = false) {
   return options;
 }
 
-async function updateApibaraConfig(apibara, config) {
-  await apibara.hooks.callHook("rollup:reload");
-  consola__default.success("Apibara config hot reloaded!");
+async function updateApibaraConfig(apibara, _config) {
+  await apibara.hooks.callHook("rolldown:reload");
+  apibara.logger.success("Apibara config hot reloaded!");
+}
+
+const INDEXER_EXTENSIONS = [".indexer.ts", ".indexer.js"];
+async function scanIndexers(apibara) {
+  apibara.logger.debug("Scanning indexers");
+  const indexersDir = join(
+    apibara.options.rootDir,
+    apibara.options.indexersDir
+  );
+  if (!fse.existsSync(indexersDir)) {
+    throw new Error(`Indexers directory not found: ${indexersDir}`);
+  }
+  apibara.indexers = [];
+  for (const file of fse.readdirSync(indexersDir)) {
+    const indexerName = indexerNameFromFile(file);
+    if (indexerName) {
+      apibara.indexers.push({
+        name: indexerName,
+        indexer: join(indexersDir, file)
+      });
+    }
+  }
+  apibara.logger.debug(`Found ${apibara.indexers.length} indexers`);
+}
+function indexerNameFromFile(file) {
+  for (const extension of INDEXER_EXTENSIONS) {
+    if (file.endsWith(extension)) {
+      return basename(file, extension);
+    }
+  }
 }
 
 async function createApibara(config = {}, opts = {}, dev = false) {
   const options = await loadOptions(config, opts, dev);
   const apibara = {
     options,
+    indexers: [],
     hooks: createHooks(),
     close: () => apibara.hooks.callHook("close"),
-    logger: consola__default.withTag("apibara"),
+    logger: consola.withTag("apibara"),
     async updateConfig(config2) {
       updateApibaraConfig(apibara);
     }
   };
   apibara.hooks.addHooks(apibara.options.hooks);
+  await scanIndexers(apibara);
   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(
-        // biome-ignore lint/style/useTemplate: <explanation>
-        `Rollup error while processing \`${path}\`` + text ? "\n\n" + text : ""
+        `Rolldown error while processing \`${path}\`` + text ? "\n\n" + text : ""
       );
     }
     return logs.join("\n");
@@ -126,44 +157,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": {
+        await apibara.hooks.callHook("dev:restart");
         return;
       }
       case "BUNDLE_START": {
@@ -176,47 +211,81 @@ 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();
-    consola__default.success("Build completed successfully!");
+    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")}`
+    );
   } catch (error) {
-    console.error("Build failed:", error);
+    apibara.logger.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);
+  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) {
+  const rel = relative(process.cwd(), path);
+  return highlight ? colors.cyan(rel) : rel;
 }
 
 async function prepare(apibara) {
   await prepareDir(apibara.options.buildDir);
   await prepareDir(apibara.options.outputDir);
-  consola__default.success("Output directory cleaned");
+  apibara.logger.success(
+    `Output directory ${prettyPath(apibara.options.outputDir)} cleaned`
+  );
 }
 async function prepareDir(dir) {
   await fsp.mkdir(dir, { recursive: true });
@@ -224,6 +293,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",
@@ -245,88 +318,13 @@ declare module "apibara/types" {`,
     ) : "",
     "}",
     // Makes this a module for augmentation purposes
-    "export type {}"
-  ];
-  const declarations = [
-    // local apibara augmentations
-    '/// <reference path="./apibara-config.d.ts" />'
+    "export type {};"
   ];
   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);
@@ -334,12 +332,7 @@ declare module "apibara/types" {`,
       await fsp.writeFile(_file, file.contents);
     })
   );
-  consola__default.success("Types generated");
-}
-const RELATIVE_RE = /^\.{1,2}\//;
-function relativeWithDot(from, to) {
-  const rel = relative(from, to);
-  return RELATIVE_RE.test(rel) ? rel : `./${rel}`;
+  apibara.logger.success(`Types written to ${prettyPath(typesDir)}`);
 }
 
 export { build, createApibara, prepare, writeTypes };

package/dist/create/index.d.mts

@@ -0,0 +1,18 @@
+type Options$1 = {
+    argIndexerId?: string;
+    argChain?: string;
+    argNetwork?: string;
+    argStorage?: string;
+    argDnaUrl?: string;
+    argRootDir?: string;
+};
+declare function addIndexer({ argIndexerId, argChain, argNetwork, argStorage, argDnaUrl, argRootDir, }: Options$1): Promise<void>;
+
+type Options = {
+    argTargetDir: string;
+    argLanguage?: string;
+    argNoCreateIndexer?: boolean;
+};
+declare function initializeProject({ argTargetDir, argLanguage, argNoCreateIndexer, }: Options): Promise<void>;
+
+export { addIndexer, initializeProject };

package/dist/create/index.d.ts

@@ -0,0 +1,18 @@
+type Options$1 = {
+    argIndexerId?: string;
+    argChain?: string;
+    argNetwork?: string;
+    argStorage?: string;
+    argDnaUrl?: string;
+    argRootDir?: string;
+};
+declare function addIndexer({ argIndexerId, argChain, argNetwork, argStorage, argDnaUrl, argRootDir, }: Options$1): Promise<void>;
+
+type Options = {
+    argTargetDir: string;
+    argLanguage?: string;
+    argNoCreateIndexer?: boolean;
+};
+declare function initializeProject({ argTargetDir, argLanguage, argNoCreateIndexer, }: Options): Promise<void>;
+
+export { addIndexer, initializeProject };