apibara 2.0.0-beta.4 → 2.0.0-beta.40

package/src/cli/commands/build.ts

@@ -1,7 +1,7 @@
 import { build, createApibara, prepare, writeTypes } from "apibara/core";
+import { runtimeDir } from "apibara/runtime/meta";
 import { defineCommand } from "citty";
-import consola from "consola";
-import { resolve } from "pathe";
+import { join, resolve } from "pathe";
 import { commonArgs } from "../common";
 
 export default defineCommand({
@@ -13,11 +13,13 @@ export default defineCommand({
     ...commonArgs,
   },
   async run({ args }) {
-    consola.start("Building");
     const rootDir = resolve((args.dir || args._dir || ".") as string);
     const apibara = await createApibara({
       rootDir,
     });
+
+    apibara.options.entry = join(runtimeDir, "start.mjs");
+
     await prepare(apibara);
     await writeTypes(apibara);
     await build(apibara);

package/src/cli/commands/dev.ts

@@ -1,17 +1,16 @@
 import { type ChildProcess, spawn } from "node:child_process";
 import { build, createApibara, prepare, writeTypes } from "apibara/core";
+import { runtimeDir } from "apibara/runtime/meta";
 import type { Apibara } from "apibara/types";
 import { defineCommand } from "citty";
-import consola from "consola";
-import { resolve } from "pathe";
+import { colors } from "consola/utils";
+import { join, resolve } from "pathe";
 import { commonArgs } from "../common";
 
 // Hot module reloading key regex
 // for only runtimeConfig.* keys
 const hmrKeyRe = /^runtimeConfig\./;
 
-let childProcess: ChildProcess | undefined;
-
 export default defineCommand({
   meta: {
     name: "dev",
@@ -27,24 +26,23 @@ export default defineCommand({
       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 || ".") as string);
+
     let apibara: Apibara;
+    let childProcess: ChildProcess | undefined;
 
     const reload = async () => {
       if (apibara) {
-        consola.info("Restarting dev server");
+        apibara.logger.info("Restarting dev server");
         if ("unwatch" in apibara.options._c12) {
           await apibara.options._c12.unwatch();
         }
+
         await apibara.close();
       }
+
       apibara = await createApibara(
         {
           rootDir,
@@ -59,10 +57,11 @@ export default defineCommand({
                 return; // No changes
               }
 
-              consola.info(
-                `Nitro config updated:
+              apibara.logger.info(
+                `Config updated:
                   ${diff.map((entry) => `  ${entry.toString()}`).join("\n")}`,
               );
+
               await (diff.every((e) => hmrKeyRe.test(e.key))
                 ? apibara.updateConfig(newConfig.config || {}) // Hot reload
                 : reload()); // Full reload
@@ -71,35 +70,46 @@ export default defineCommand({
         },
         true,
       );
+
       apibara.hooks.hookOnce("restart", reload);
 
+      apibara.options.entry = join(runtimeDir, "dev.mjs");
+
       await prepare(apibara);
       await writeTypes(apibara);
       await build(apibara);
 
+      apibara.hooks.hook("dev:restart", () => {
+        if (childProcess) {
+          apibara.logger.info("Change detected, stopping indexers to restart");
+          childProcess.kill();
+          childProcess = undefined;
+        }
+      });
+
       apibara.hooks.hook("dev:reload", () => {
         if (childProcess) {
-          consola.start("Restarting indexers");
           childProcess.kill();
         } else {
-          consola.success("Dev server started");
-          consola.success("Starting indexers");
+          apibara.logger.success("Restarting indexers");
         }
 
         const childArgs = [
-          resolve(apibara.options.outputDir || "./.apibara/build", "main.mjs"),
+          resolve(apibara.options.outputDir || "./.apibara/build", "dev.mjs"),
+          "start",
           ...(args.indexers ? ["--indexers", args.indexers] : []),
           ...(args.preset ? ["--preset", args.preset] : []),
-          ...(args.sink ? ["--sink", args.sink] : []),
         ];
 
-        childProcess = spawn("jiti", childArgs, {
+        childProcess = spawn("node", childArgs, {
           stdio: "inherit",
         });
 
         childProcess.on("close", (code) => {
           if (code !== null) {
-            consola.log(`Indexers process exited with code ${code}`);
+            apibara.logger.log(
+              `Indexers process exited with code ${colors.red(code)}`,
+            );
           }
         });
       });

package/src/cli/commands/prepare.ts

@@ -1,7 +1,6 @@
 import { createApibara, writeTypes } from "apibara/core";
 import {} from "apibara/types";
 import { defineCommand } from "citty";
-import consola from "consola";
 import { resolve } from "pathe";
 import { commonArgs } from "../common";
 
@@ -14,7 +13,6 @@ export default defineCommand({
     ...commonArgs,
   },
   async run({ args }) {
-    consola.start("Preparing Types");
     const rootDir = resolve((args.dir || ".") as string);
     const apibara = await createApibara({ rootDir });
     await writeTypes(apibara);

package/src/cli/commands/start.ts

@@ -0,0 +1,61 @@
+import { spawn } from "node:child_process";
+import { createApibara } from "apibara/core";
+import { defineCommand } from "citty";
+import fse from "fs-extra";
+import { resolve } from "pathe";
+import { commonArgs } from "../common";
+
+export default defineCommand({
+  meta: {
+    name: "start",
+    description: "Start one indexer",
+  },
+  args: {
+    ...commonArgs,
+    indexer: {
+      type: "string",
+      description: "The indexer to start",
+      required: true,
+    },
+    preset: {
+      type: "string",
+      description: "The preset to use",
+    },
+  },
+  async run({ args }) {
+    const { indexer, preset } = args;
+    const rootDir = resolve((args.dir || args._dir || ".") as string);
+
+    const apibara = await createApibara({
+      rootDir,
+    });
+
+    apibara.logger.start(
+      `Starting indexer ${indexer}${preset ? ` with preset ${preset}` : ""}`,
+    );
+
+    const outputDir = apibara.options.outputDir || "./.apibara/build";
+    const entry = resolve(outputDir, "start.mjs");
+
+    if (!fse.existsSync(entry)) {
+      apibara.logger.error(
+        `Output directory ${outputDir} does not exist. Try building the indexer with "apibara build" first.`,
+      );
+      return process.exit(1);
+    }
+
+    await apibara.close();
+
+    const childArgs = [
+      entry,
+      "start",
+      "--indexer",
+      indexer,
+      ...(preset ? ["--preset", preset] : []),
+    ];
+
+    spawn("node", childArgs, {
+      stdio: "inherit",
+    });
+  },
+});

package/src/cli/index.ts

@@ -9,6 +9,7 @@ export const mainCli = defineCommand({
   subCommands: {
     dev: () => import("./commands/dev").then((r) => r.default),
     build: () => import("./commands/build").then((r) => r.default),
+    start: () => import("./commands/start").then((r) => r.default),
     prepare: () => import("./commands/prepare").then((r) => r.default),
   },
 });

package/src/config/index.ts

@@ -1,10 +1,11 @@
 import type { ApibaraConfig, DeepPartial } from "apibara/types";
 
 export function defineConfig<
-  // biome-ignore lint/complexity/noBannedTypes: <explanation>
-  T extends Record<string, DeepPartial<ApibaraConfig<T, R>>> = {},
-  // biome-ignore lint/complexity/noBannedTypes: <explanation>
-  R extends Record<string, unknown> = {},
+  T extends Record<
+    string,
+    DeepPartial<Pick<ApibaraConfig<T, R>, "runtimeConfig">>
+  > = Record<string, never>,
+  R extends Record<string, unknown> = Record<string, never>,
 >(config: ApibaraConfig<T, R>): ApibaraConfig<T, R> {
   return config;
 }

package/src/core/apibara.ts

@@ -8,18 +8,18 @@ import consola from "consola";
 import { createHooks } from "hookable";
 import { loadOptions } from "./config/loader";
 import { updateApibaraConfig } from "./config/update";
+import { scanIndexers } from "./scan";
 
 export async function createApibara(
   config: ApibaraConfig = {},
   opts: LoadConfigOptions = {},
   dev = false,
 ): Promise<Apibara> {
-  // load options
   const options = await loadOptions(config, opts, dev);
 
-  // create apibara context
   const apibara: Apibara = {
     options,
+    indexers: [],
     hooks: createHooks(),
     close: () => apibara.hooks.callHook("close"),
     logger: consola.withTag("apibara"),
@@ -30,5 +30,7 @@ export async function createApibara(
 
   apibara.hooks.addHooks(apibara.options.hooks);
 
+  await scanIndexers(apibara);
+
   return apibara;
 }

package/src/core/build/build.ts

@@ -5,7 +5,9 @@ import { buildProduction } from "./prod";
 
 export async function build(apibara: 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);

package/src/core/build/dev.ts

@@ -53,6 +53,7 @@ function startRollupWatcher(apibara: Apibara, rollupConfig: RollupConfig) {
     switch (event.code) {
       // The watcher is (re)starting
       case "START": {
+        apibara.hooks.callHook("dev:restart");
         return;
       }
 

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,16 +1,18 @@
 import type { Apibara, RollupConfig } from "apibara/types";
-import consola from "consola";
+import { colors } from "consola/utils";
 import { type OutputOptions, rollup } from "rollup";
 
 export async function buildProduction(
   apibara: Apibara,
   rollupConfig: RollupConfig,
 ) {
+  apibara.logger.start(
+    `Building ${colors.cyan(apibara.indexers.length)} indexers`,
+  );
+
   try {
-    // Create a bundle
     const bundle = await rollup(rollupConfig);
 
-    // Generate output
     if (Array.isArray(rollupConfig.output)) {
       for (const outputOptions of rollupConfig.output) {
         await bundle.write(outputOptions);
@@ -21,12 +23,14 @@ export async function buildProduction(
       throw new Error("No output options specified in Rollup config");
     }
 
-    // Close the bundle
     await bundle.close();
 
-    consola.success("Build completed successfully!");
+    apibara.logger.success("Build succeeded!");
+    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,10 +1,8 @@
 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) {
   const typesDir = resolve(apibara.options.buildDir, "types");
@@ -31,12 +29,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 +39,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 +47,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,7 @@ export const ApibaraDefaults: ApibaraConfig = {
 
   typescript: {
     strict: false,
-    generateTsConfig: true,
     generateRuntimeConfigTypes: true,
-    tsconfigPath: "types/tsconfig.json",
     internalPaths: false,
-    tsConfig: {},
   },
 };

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