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

package/src/core/build/error.ts

@@ -1,30 +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(
-        // 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");

package/src/core/build/prepare.ts

@@ -1,12 +1,15 @@
 import fsp from "node:fs/promises";
 import type { Apibara } from "apibara/types";
-import consola from "consola";
 import fse from "fs-extra";
+import { prettyPath } from "../path";
 
 export async function prepare(apibara: Apibara) {
   await prepareDir(apibara.options.buildDir);
   await prepareDir(apibara.options.outputDir);
-  consola.success("Output directory cleaned");
+
+  apibara.logger.success(
+    `Output directory ${prettyPath(apibara.options.outputDir)} cleaned`,
+  );
 }
 
 async function prepareDir(dir: string) {

package/src/core/build/prod.ts

@@ -1,32 +1,41 @@
-import type { Apibara, RollupConfig } from "apibara/types";
-import consola from "consola";
-import { type OutputOptions, rollup } from "rollup";
+import type { Apibara } from "apibara/types";
+import { colors } from "consola/utils";
+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 {
-    // Create a bundle
-    const bundle = await rollup(rollupConfig);
+    const bundle = await rolldown.rolldown(rolldownConfig);
 
-    // Generate output
-    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");
     }
 
-    // Close the bundle
     await bundle.close();
 
-    consola.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;
   }
 }

package/src/core/build/types.ts

@@ -1,12 +1,18 @@
 import fsp from "node:fs/promises";
 import type { Apibara } from "apibara/types";
-import consola from "consola";
-import defu from "defu";
-import { dirname, isAbsolute, join, relative, resolve } from "pathe";
-import type { TSConfig } from "pkg-types";
+import { dirname, join, resolve } from "pathe";
 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 = [
@@ -31,12 +37,7 @@ 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: { path: string; contents: string }[] = [];
@@ -46,83 +47,6 @@ declare module "apibara/types" {`,
     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: 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: string) => {
-          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, "") /* remove extension */
-              : 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);
@@ -131,12 +55,5 @@ declare module "apibara/types" {`,
     }),
   );
 
-  consola.success("Types generated");
-}
-
-const RELATIVE_RE = /^\.{1,2}\//;
-
-export function relativeWithDot(from: string, to: string) {
-  const rel = relative(from, to);
-  return RELATIVE_RE.test(rel) ? rel : `./${rel}`;
+  apibara.logger.success(`Types written to ${prettyPath(typesDir)}`);
 }

package/src/core/config/defaults.ts

@@ -1,8 +1,8 @@
-// import { defaultSink } from "@apibara/indexer";
 import type { ApibaraConfig } from "apibara/types";
 
 export const ApibaraDefaults: ApibaraConfig = {
   rootDir: ".",
+  indexersDir: "indexers",
 
   runtimeConfig: {},
   hooks: {},
@@ -11,10 +11,10 @@ export const ApibaraDefaults: ApibaraConfig = {
 
   typescript: {
     strict: false,
-    generateTsConfig: true,
     generateRuntimeConfigTypes: true,
-    tsconfigPath: "types/tsconfig.json",
     internalPaths: false,
-    tsConfig: {},
   },
+
+  node: true,
+  exportConditions: ["node"],
 };

package/src/core/config/loader.ts

@@ -53,6 +53,7 @@ async function _loadUserConfig(
 
   options._config = configOverrides;
   options._c12 = loadedConfig;
+
   if (dev) {
     options.dev = dev;
   }

package/src/core/config/resolvers/runtime-config.resolver.ts

@@ -1,6 +1,6 @@
 import type { ApibaraOptions } from "apibara/types";
 
 export async function resolveRuntimeConfigOptions(options: ApibaraOptions) {
-  options.runtimeConfig = { ...options.runtimeConfig, default: "value" };
+  options.runtimeConfig = { ...options.runtimeConfig };
   process.env.APIBARA_RUNTIME_CONFIG = JSON.stringify(options.runtimeConfig);
 }

package/src/core/config/update.ts

@@ -1,10 +1,9 @@
 import type { Apibara, ApibaraDynamicConfig } from "apibara/types";
-import consola from "consola";
 
 export async function updateApibaraConfig(
   apibara: Apibara,
-  config: ApibaraDynamicConfig,
+  _config: ApibaraDynamicConfig,
 ) {
-  await apibara.hooks.callHook("rollup:reload");
-  consola.success("Apibara config hot reloaded!");
+  await apibara.hooks.callHook("rolldown:reload");
+  apibara.logger.success("Apibara config hot reloaded!");
 }

package/src/core/path.ts

@@ -0,0 +1,11 @@
+import { colors } from "consola/utils";
+import { relative } from "pathe";
+
+/** Return a (possibly highlighted) path relative to the current working directory.
+ *
+ * From nitrojs/nitro.
+ */
+export function prettyPath(path: string, highlight = true) {
+  const rel = relative(process.cwd(), path);
+  return highlight ? colors.cyan(rel) : rel;
+}

package/src/core/scan.ts

@@ -0,0 +1,40 @@
+import type { Apibara } from "apibara/types";
+import fse from "fs-extra";
+import { basename, join } from "pathe";
+
+const INDEXER_EXTENSIONS = [".indexer.ts", ".indexer.js"];
+
+export async function scanIndexers(apibara: 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: string) {
+  for (const extension of INDEXER_EXTENSIONS) {
+    if (file.endsWith(extension)) {
+      return basename(file, extension);
+    }
+  }
+}

package/src/create/add.ts

@@ -0,0 +1,239 @@
+import path from "node:path";
+import consola from "consola";
+import prompts from "prompts";
+import { cyan, red, reset } from "./colors";
+import {
+  type ChainDataType,
+  type NetworkDataType,
+  type StorageDataType,
+  chains,
+  storages,
+} from "./constants";
+import { initializeProject } from "./init";
+import {
+  createIndexerFile,
+  createStorageRelatedFiles,
+  updateApibaraConfigFile,
+  updatePackageJson,
+} from "./templates";
+import type { Chain, IndexerOptions, Network, Storage } from "./types";
+import {
+  cancelOperation,
+  checkFileExists,
+  convertKebabToCamelCase,
+  getApibaraConfigLanguage,
+  getPackageManager,
+  hasApibaraConfig,
+  validateChain,
+  validateDnaUrl,
+  validateIndexerId,
+  validateNetwork,
+  validateStorage,
+} from "./utils";
+
+type Options = {
+  argIndexerId?: string;
+  argChain?: string;
+  argNetwork?: string;
+  argStorage?: string;
+  argDnaUrl?: string;
+  argRootDir?: string;
+};
+
+export async function addIndexer({
+  argIndexerId,
+  argChain,
+  argNetwork,
+  argStorage,
+  argDnaUrl,
+  argRootDir,
+}: Options) {
+  const cwd = path.join(process.cwd(), argRootDir ?? ".");
+  const configExists = hasApibaraConfig(cwd);
+
+  if (!configExists) {
+    consola.error("No apibara.config found in the current directory.");
+
+    const prompt_initialize = await prompts({
+      type: "confirm",
+      name: "prompt_initialize",
+      message: reset(
+        "Do you want to initialize a apibara project here before adding an indexer?",
+      ),
+    });
+
+    if (prompt_initialize.prompt_initialize) {
+      await initializeProject({
+        argTargetDir: process.cwd(),
+        argNoCreateIndexer: true,
+      });
+    } else {
+      consola.info(
+        `Initialize a project with ${cyan("apibara init")} before adding an indexer`,
+      );
+      throw new Error(
+        red("✖") + " Operation cancelled: No apibara.config found",
+      );
+    }
+  }
+
+  const language = getApibaraConfigLanguage(cwd);
+
+  validateIndexerId(argIndexerId, true);
+  validateChain(argChain, true);
+  validateNetwork(argChain, argNetwork, true);
+  validateStorage(argStorage, true);
+  validateDnaUrl(argDnaUrl, true);
+
+  const result = await prompts(
+    [
+      {
+        type: argIndexerId ? null : "text",
+        name: "prompt_indexerId",
+        message: reset("Indexer ID:"),
+        initial: argIndexerId ?? "my-indexer",
+        validate: (id) =>
+          validateIndexerId(id)
+            ? checkFileExists(
+                path.join(
+                  cwd,
+                  "indexers",
+                  `${id}.indexer.${language === "typescript" ? "ts" : "js"}`,
+                ),
+              ).then(({ exists }) =>
+                exists
+                  ? `Indexer ${cyan(`${id}.indexer.${language === "typescript" ? "ts" : "js"}`)} already exists`
+                  : true,
+              )
+            : "Invalid indexer ID, it cannot be empty and must be in kebab-case format",
+      },
+      {
+        type: argChain ? null : "select",
+        name: "prompt_chain",
+        message: reset("Select a chain:"),
+        choices: chains.map((chain) => ({
+          title: chain.color(chain.display),
+          value: chain,
+        })),
+      },
+      {
+        type: argNetwork ? null : "select",
+        name: "prompt_network",
+        message: reset("Select a network:"),
+        choices: (chain: ChainDataType | undefined) => [
+          ...(
+            chain?.networks ??
+            chains.find((c) => c.name === argChain)?.networks ??
+            []
+          ).map((network) => ({
+            title: network.color(network.display),
+            value: network,
+          })),
+          {
+            title: cyan("Other"),
+            value: {
+              color: cyan,
+              display: "Other",
+              name: "other",
+            } as NetworkDataType,
+          },
+        ],
+      },
+      {
+        type: (network: NetworkDataType | undefined) => {
+          if (network || argNetwork) {
+            return network?.name === "other" || argNetwork === "other"
+              ? "text"
+              : null;
+          }
+          return null;
+        },
+        name: "prompt_dnaUrl",
+        message: reset("Enter a DNA URL:"),
+        validate: (url) => validateDnaUrl(url) || "Provide a valid DNA Url",
+      },
+      {
+        type: argStorage ? null : "select",
+        name: "prompt_storage",
+        message: reset("Select a storage:"),
+        choices: storages.map((storage) => ({
+          title: storage.color(storage.display),
+          value: storage,
+        })),
+      },
+    ],
+    {
+      onCancel: () => {
+        cancelOperation();
+      },
+    },
+  );
+
+  const {
+    prompt_indexerId,
+    prompt_chain,
+    prompt_network,
+    prompt_storage,
+    prompt_dnaUrl,
+  } = result as {
+    prompt_indexerId: string | undefined;
+    prompt_chain: ChainDataType | undefined;
+    prompt_network: NetworkDataType | undefined;
+    prompt_storage: StorageDataType | undefined;
+    prompt_dnaUrl: string | undefined;
+  };
+
+  if (!argIndexerId && !prompt_indexerId) {
+    throw new Error(red("✖") + " Indexer ID is required");
+  }
+
+  if (!argChain && !prompt_chain) {
+    throw new Error(red("✖") + " Chain is required");
+  }
+
+  if (!argNetwork && !prompt_network) {
+    throw new Error(red("✖") + " Network is required");
+  }
+
+  const indexerFileId = argIndexerId! ?? prompt_indexerId!;
+
+  const pkgManager = getPackageManager();
+
+  const options: IndexerOptions = {
+    cwd: cwd,
+    indexerFileId,
+    indexerId: convertKebabToCamelCase(indexerFileId),
+    chain: (argChain as Chain) ?? prompt_chain?.name!,
+    network: (argNetwork as Network) ?? prompt_network?.name!,
+    storage: (argStorage as Storage) ?? prompt_storage?.name!,
+    dnaUrl: argDnaUrl ?? prompt_dnaUrl,
+    language,
+    packageManager: pkgManager.name,
+  };
+
+  await updateApibaraConfigFile(options);
+
+  consola.success(
+    `Updated ${cyan("apibara.config." + (language === "typescript" ? "ts" : "js"))}`,
+  );
+
+  await updatePackageJson(options);
+
+  consola.success(`Updated ${cyan("package.json")}`);
+
+  await createIndexerFile(options);
+
+  consola.success(
+    `Created ${cyan(`${indexerFileId}.indexer.${language === "typescript" ? "ts" : "js"}`)}`,
+  );
+
+  await createStorageRelatedFiles(options);
+
+  console.log();
+
+  const baseCommand = `${options.packageManager} install`;
+  const tsCommand = `${baseCommand} && ${options.packageManager} run prepare`;
+  consola.info(
+    `Before running the indexer, run ${cyan(language === "typescript" ? tsCommand : baseCommand)}`,
+  );
+}

package/src/create/colors.ts

@@ -0,0 +1,15 @@
+import colors from "picocolors";
+
+export const {
+  blue,
+  blueBright,
+  cyan,
+  gray,
+  green,
+  greenBright,
+  magenta,
+  red,
+  redBright,
+  reset,
+  yellow,
+} = colors;