apibara 2.1.0-beta.1 → 2.1.0-beta.11

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/resolvers/runtime-config.resolver.ts

@@ -1,6 +1,25 @@
 import type { ApibaraOptions } from "apibara/types";
+import { serialize } from "../../../utils/helper";
 
 export async function resolveRuntimeConfigOptions(options: ApibaraOptions) {
-  options.runtimeConfig = { ...options.runtimeConfig };
-  process.env.APIBARA_RUNTIME_CONFIG = JSON.stringify(options.runtimeConfig);
+  const { preset, presets } = options;
+  let runtimeConfig: Record<string, unknown> = { ...options.runtimeConfig };
+
+  if (preset) {
+    if (presets === undefined) {
+      throw new Error(
+        `Specified preset "${preset}" but no presets were defined`,
+      );
+    }
+
+    if (presets[preset] === undefined) {
+      throw new Error(`Specified preset "${preset}" but it was not defined`);
+    }
+
+    const presetValue = presets[preset] as {
+      runtimeConfig: Record<string, unknown>;
+    };
+    runtimeConfig = { ...runtimeConfig, ...presetValue.runtimeConfig };
+  }
+  process.env.APIBARA_RUNTIME_CONFIG = serialize(runtimeConfig);
 }

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!");
 }

package/src/create/add.ts

@@ -1,3 +1,4 @@
+import path from "node:path";
 import consola from "consola";
 import prompts from "prompts";
 import { cyan, red, reset } from "./colors";
@@ -18,6 +19,7 @@ import {
 import type { Chain, IndexerOptions, Network, Storage } from "./types";
 import {
   cancelOperation,
+  checkFileExists,
   convertKebabToCamelCase,
   getApibaraConfigLanguage,
   getPackageManager,
@@ -35,6 +37,7 @@ type Options = {
   argNetwork?: string;
   argStorage?: string;
   argDnaUrl?: string;
+  argRootDir?: string;
 };
 
 export async function addIndexer({
@@ -43,8 +46,10 @@ export async function addIndexer({
   argNetwork,
   argStorage,
   argDnaUrl,
+  argRootDir,
 }: Options) {
-  const configExists = hasApibaraConfig(process.cwd());
+  const cwd = path.join(process.cwd(), argRootDir ?? ".");
+  const configExists = hasApibaraConfig(cwd);
 
   if (!configExists) {
     consola.error("No apibara.config found in the current directory.");
@@ -72,7 +77,7 @@ export async function addIndexer({
     }
   }
 
-  const language = getApibaraConfigLanguage(process.cwd());
+  const language = getApibaraConfigLanguage(cwd);
 
   validateIndexerId(argIndexerId, true);
   validateChain(argChain, true);
@@ -88,8 +93,19 @@ export async function addIndexer({
         message: reset("Indexer ID:"),
         initial: argIndexerId ?? "my-indexer",
         validate: (id) =>
-          validateIndexerId(id) ||
-          "Invalid indexer ID cannot be empty and must be in kebab-case format",
+          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",
@@ -184,7 +200,7 @@ export async function addIndexer({
   const pkgManager = getPackageManager();
 
   const options: IndexerOptions = {
-    cwd: process.cwd(),
+    cwd: cwd,
     indexerFileId,
     indexerId: convertKebabToCamelCase(indexerFileId),
     chain: (argChain as Chain) ?? prompt_chain?.name!,
@@ -195,13 +211,13 @@ export async function addIndexer({
     packageManager: pkgManager.name,
   };
 
-  updateApibaraConfigFile(options);
+  await updateApibaraConfigFile(options);
 
   consola.success(
     `Updated ${cyan("apibara.config." + (language === "typescript" ? "ts" : "js"))}`,
   );
 
-  updatePackageJson(options);
+  await updatePackageJson(options);
 
   consola.success(`Updated ${cyan("package.json")}`);
 
@@ -215,11 +231,9 @@ export async function addIndexer({
 
   console.log();
 
+  const baseCommand = `${options.packageManager} install`;
+  const tsCommand = `${baseCommand} && ${options.packageManager} run prepare`;
   consola.info(
-    `Before running the indexer, run ${cyan(`${options.packageManager} run install`)}${
-      language === "typescript"
-        ? " & " + cyan(`${options.packageManager} run prepare`)
-        : ""
-    }`,
+    `Before running the indexer, run ${cyan(language === "typescript" ? tsCommand : baseCommand)}`,
   );
 }

package/src/create/constants.ts

@@ -66,17 +66,17 @@ export const storages: StorageDataType[] = [
 
 export const packageVersions = {
   // Required Dependencies
-  apibara: "^2.1.0-beta.1",
-  "@apibara/indexer": "^2.1.0-beta.1",
-  "@apibara/protocol": "^2.1.0-beta.1",
+  apibara: "next",
+  "@apibara/indexer": "next",
+  "@apibara/protocol": "next",
   // Chain Dependencies
-  "@apibara/evm": "^2.1.0-beta.1",
-  "@apibara/beaconchain": "^2.1.0-beta.1",
-  "@apibara/starknet": "^2.1.0-beta.1",
+  "@apibara/evm": "next",
+  "@apibara/beaconchain": "next",
+  "@apibara/starknet": "next",
   // Storage Dependencies
-  "@apibara/plugin-drizzle": "^2.1.0-beta.1",
-  "@apibara/plugin-mongo": "^2.1.0-beta.1",
-  "@apibara/plugin-sqlite": "^2.1.0-beta.1",
+  "@apibara/plugin-drizzle": "next",
+  "@apibara/plugin-mongo": "next",
+  "@apibara/plugin-sqlite": "next",
   // Postgres Dependencies
   "@electric-sql/pglite": "^0.2.17",
   "drizzle-orm": "^0.37.0",
@@ -85,7 +85,6 @@ export const packageVersions = {
   "drizzle-kit": "^0.29.0",
   // Typescript Dependencies
   typescript: "^5.6.2",
-  "@rollup/plugin-typescript": "^11.1.6",
   "@types/node": "^20.5.2",
 };
 

package/src/create/init.ts

@@ -5,6 +5,7 @@ import prompts from "prompts";
 import { addIndexer } from "./add";
 import { cyan, green } from "./colors";
 import {
+  createGitIgnoreFile,
   generateApibaraConfig,
   generatePackageJson,
   generateTsConfig,
@@ -13,6 +14,7 @@ import type { Language } from "./types";
 import {
   cancelOperation,
   emptyDir,
+  formatFile,
   getLanguageFromAlias,
   getPackageManager,
   isEmpty,
@@ -121,30 +123,42 @@ export async function initializeProject({
   consola.info(`Initializing project in ${argTargetDir}\n\n`);
 
   // Generate package.json
+  const packageJsonPath = path.join(root, "package.json");
   const packageJson = generatePackageJson(isTs);
   fs.writeFileSync(
-    path.join(root, "package.json"),
+    packageJsonPath,
     JSON.stringify(packageJson, null, 2) + "\n",
   );
-  consola.success("Created ", cyan("package.json"));
+  await formatFile(packageJsonPath);
+  consola.success("Created", cyan("package.json"));
 
   // Generate tsconfig.json if TypeScript
   if (isTs) {
+    const tsConfigPath = path.join(root, "tsconfig.json");
     const tsConfig = generateTsConfig();
-    fs.writeFileSync(
-      path.join(root, "tsconfig.json"),
-      JSON.stringify(tsConfig, null, 2) + "\n",
-    );
-    consola.success("Created ", cyan("tsconfig.json"));
+    fs.writeFileSync(tsConfigPath, JSON.stringify(tsConfig, null, 2) + "\n");
+    await formatFile(tsConfigPath);
+    consola.success("Created", cyan("tsconfig.json"));
   }
 
+  const apibaraConfigPath = path.join(root, `apibara.config.${configExt}`);
   // Generate apibara.config
   const apibaraConfig = generateApibaraConfig(isTs);
-  fs.writeFileSync(
-    path.join(root, `apibara.config.${configExt}`),
-    apibaraConfig,
-  );
-  consola.success("Created ", cyan(`apibara.config.${configExt}`), "\n\n");
+  fs.writeFileSync(apibaraConfigPath, apibaraConfig);
+  await formatFile(apibaraConfigPath);
+  consola.success("Created", cyan(`apibara.config.${configExt}`));
+
+  // Create "indexers" directory if not exists
+  const indexersDir = path.join(root, "indexers");
+  if (!fs.existsSync(indexersDir)) {
+    fs.mkdirSync(indexersDir, { recursive: true });
+    consola.success(`Created ${cyan("indexers")} directory`);
+  }
+
+  await createGitIgnoreFile(root);
+
+  console.log("\n");
+
   consola.ready(green("Project initialized successfully"));
 
   console.log();
@@ -152,12 +166,12 @@ export async function initializeProject({
   if (!argNoCreateIndexer) {
     consola.info("Let's create an indexer\n");
 
-    await addIndexer({});
+    await addIndexer({ argRootDir: argTargetDir });
   } else {
     const pkgManager = getPackageManager();
     consola.info(
       "Run ",
-      green(`${pkgManager.name} run install`),
+      green(`${pkgManager.name} install`),
       " to install all dependencies",
     );
   }