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

package/dist/types/index.d.ts

@@ -1,9 +1,9 @@
 import { ConsolaInstance } from 'consola';
 import { NestedHooks, Hookable } from 'hookable';
-import { Sink } from '@apibara/indexer';
+import { ConsolaReporter } from '@apibara/indexer/plugins';
+import { RollupCommonJSOptions } from '@rollup/plugin-commonjs';
 import { C12InputConfig, WatchConfigOptions, ResolvedConfig, ConfigWatcher } from 'c12';
 import { WatchOptions } from 'chokidar';
-import { TSConfig } from 'pkg-types';
 import { InputOptions, OutputOptions } from 'rollup';
 
 type DeepPartial<T> = T extends Record<string, any> ? {
@@ -17,23 +17,26 @@ type RollupConfig = InputOptions & {
 interface ApibaraHooks {
     "rollup:before": (apibara: Apibara, rollupConfig: RollupConfig) => void;
     compiled: (apibara: Apibara) => void;
+    "dev:restart": () => void;
     "dev:reload": () => void;
     "rollup:reload": () => void;
     restart: () => void;
     close: () => void;
 }
 
+type LoggerFactory = ({ indexer, preset, }: {
+    indexer: string;
+    indexers: string[];
+    preset?: string;
+}) => ConsolaReporter;
 /**
  * Apibara Config type (apibara.config)
  */
-interface ApibaraConfig<T extends Record<string, DeepPartial<ApibaraConfig<T, R>>> = {}, R extends Record<string, unknown> = {}> extends DeepPartial<Omit<ApibaraOptions<T, R>, "preset" | "presets" | "dev">>, C12InputConfig<ApibaraConfig<T, R>> {
-    sink?: {
-        default: () => Sink;
-        [key: string]: () => Sink;
-    };
+interface ApibaraConfig<T extends Record<string, DeepPartial<Pick<ApibaraConfig<T, R>, "runtimeConfig">>> = Record<string, never>, R extends Record<string, unknown> = Record<string, never>> extends Partial<Omit<ApibaraOptions<T, R>, "preset" | "presets" | "dev">>, C12InputConfig<ApibaraConfig<T, R>> {
     runtimeConfig?: R;
     presets?: T;
     preset?: keyof T;
+    logger?: LoggerFactory;
 }
 type ApibaraDynamicConfig = Pick<ApibaraConfig, "runtimeConfig">;
 /**
@@ -43,13 +46,9 @@ interface LoadConfigOptions {
     watch?: boolean;
     c12?: WatchConfigOptions;
 }
-interface ApibaraOptions<T extends Record<string, DeepPartial<ApibaraConfig<T, R>>> = {}, R extends Record<string, unknown> = {}> {
+interface ApibaraOptions<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>;
     _c12: ResolvedConfig<ApibaraConfig<T, R>> | ConfigWatcher<ApibaraConfig<T, R>>;
-    sink: {
-        default: () => Sink;
-        [key: string]: () => Sink;
-    };
     presets?: T;
     preset?: keyof T;
     debug: boolean;
@@ -57,26 +56,30 @@ interface ApibaraOptions<T extends Record<string, DeepPartial<ApibaraConfig<T, R
     rootDir: string;
     buildDir: string;
     outputDir: string;
+    indexersDir: string;
     dev: boolean;
     watchOptions: WatchOptions;
     hooks: NestedHooks<ApibaraHooks>;
-    rollupConfig?: RollupConfig;
+    logger?: LoggerFactory;
+    rollupConfig?: Partial<RollupConfig>;
+    sourceMap?: boolean;
     entry: string;
-    minify: boolean;
+    commonJS?: RollupCommonJSOptions;
     typescript: {
         strict?: boolean;
         internalPaths?: boolean;
         generateRuntimeConfigTypes?: boolean;
-        generateTsConfig?: boolean;
-        /** the path of the generated `tsconfig.json`, relative to buildDir */
-        tsconfigPath: string;
-        tsConfig?: Partial<TSConfig>;
     };
 }
 
+type IndexerDefinition = {
+    name: string;
+    indexer: string;
+};
 interface Apibara {
     options: ApibaraOptions;
     hooks: Hookable<ApibaraHooks>;
+    indexers: IndexerDefinition[];
     logger: ConsolaInstance;
     close: () => Promise<void>;
     updateConfig: (config: ApibaraDynamicConfig) => void | Promise<void>;
@@ -84,4 +87,4 @@ interface Apibara {
 
 type ApibaraRuntimeConfig = Record<string, unknown>;
 
-export type { Apibara, ApibaraConfig, ApibaraDynamicConfig, ApibaraHooks, ApibaraOptions, ApibaraRuntimeConfig, DeepPartial, LoadConfigOptions, RollupConfig };
+export type { Apibara, ApibaraConfig, ApibaraDynamicConfig, ApibaraHooks, ApibaraOptions, ApibaraRuntimeConfig, DeepPartial, IndexerDefinition, LoadConfigOptions, LoggerFactory, RollupConfig };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "apibara",
-  "version": "2.0.0-beta.9",
+  "version": "2.1.0-beta.3",
   "type": "module",
   "main": "./dist/core/index.mjs",
   "exports": {
@@ -32,13 +32,25 @@
       "types": "./dist/hooks/index.d.ts",
       "import": "./dist/hooks/index.mjs"
     },
-    "./internal/consola": {
-      "import": "./dist/internal/consola/index.mjs",
-      "types": "./dist/internal/consola/index.d.ts"
+    "./runtime": {
+      "types": "./dist/runtime/index.d.ts",
+      "import": "./dist/runtime/index.mjs"
     },
-    "./internal/citty": {
-      "import": "./dist/internal/citty/index.mjs",
-      "types": "./dist/internal/citty/index.d.ts"
+    "./create": {
+      "types": "./dist/create/index.d.ts",
+      "import": "./dist/create/index.mjs"
+    },
+    "./runtime/meta": {
+      "types": "./runtime-meta.d.ts",
+      "import": "./runtime-meta.mjs"
+    },
+    "./runtime/*": {
+      "types": "./dist/runtime/*.d.ts",
+      "import": "./dist/runtime/*.mjs"
+    },
+    "./dist/runtime/*": {
+      "types": "./dist/runtime/*.d.ts",
+      "import": "./dist/runtime/*.mjs"
     }
   },
   "bin": {
@@ -47,6 +59,8 @@
   "files": [
     "dist",
     "src",
+    "runtime-meta.d.ts",
+    "runtime-meta.mjs",
     "README.md"
   ],
   "scripts": {
@@ -55,15 +69,17 @@
     "typecheck": "tsc --noEmit",
     "lint:fix": "pnpm lint --write",
     "format": "biome format . --write",
-    "playground": "JITI_ESM_RESOLVE=1 NODE_OPTIONS=\"--enable-source-maps\" jiti ./src/cli/index.ts",
+    "playground": "JITI_ESM_RESOLVE=1 CONSOLA_LEVEL=debug NODE_OPTIONS=\"--enable-source-maps\" jiti ./src/cli/index.ts",
     "playground:prepare": "pnpm playground prepare --dir playground",
     "playground:dev": "pnpm playground dev --dir playground",
     "playground:build": "pnpm playground build --dir playground",
-    "playground:start": "JITI_ESM_RESOLVE=1 NODE_OPTIONS=\"--enable-source-maps\" jiti ./playground/.apibara/build/main.mjs"
+    "playground:start": "pnpm playground start --dir playground --indexer starknet"
   },
   "devDependencies": {
+    "@apibara/starknet": "2.1.0-beta.3",
     "@types/fs-extra": "^11.0.4",
     "@types/node": "^20.14.0",
+    "@types/prompts": "^2.4.9",
     "jiti": "^1.21.0",
     "starknet": "^6.11.0",
     "unbuild": "^2.0.0",
@@ -71,14 +87,13 @@
     "vitest": "^1.6.0"
   },
   "dependencies": {
-    "@apibara/evm": "2.0.1-beta.1",
-    "@apibara/indexer": "2.0.0-beta.9",
-    "@apibara/protocol": "2.0.0-beta.9",
-    "@apibara/starknet": "2.0.0-beta.9",
+    "@apibara/indexer": "2.1.0-beta.3",
+    "@apibara/protocol": "2.1.0-beta.3",
     "@rollup/plugin-commonjs": "^26.0.1",
     "@rollup/plugin-json": "^6.1.0",
     "@rollup/plugin-node-resolve": "^15.2.3",
     "@rollup/plugin-typescript": "^11.1.6",
+    "@rollup/plugin-virtual": "^3.0.2",
     "c12": "^1.11.1",
     "chokidar": "^3.6.0",
     "citty": "^0.1.6",
@@ -88,10 +103,17 @@
     "fs-extra": "^11.2.0",
     "hookable": "^5.5.3",
     "klona": "^2.0.6",
+    "magic-string": "^0.30.12",
+    "ohash": "^1.1.4",
     "pathe": "^1.1.2",
     "perfect-debounce": "^1.0.0",
+    "picocolors": "^1.1.1",
     "pkg-types": "^1.1.3",
+    "prettier": "^3.5.2",
+    "prompts": "^2.4.2",
     "rollup": "^4.18.1",
+    "rollup-plugin-esbuild": "^6.1.1",
+    "ts-morph": "^25.0.1",
     "tslib": "^2.6.3",
     "untyped": "^1.4.2"
   }

package/runtime-meta.d.ts

@@ -0,0 +1,2 @@
+export declare const pkgDir: string;
+export declare const runtimeDir: string;

package/runtime-meta.mjs

@@ -0,0 +1,7 @@
+import { fileURLToPath } from "node:url";
+
+export const pkgDir = fileURLToPath(new URL(".", import.meta.url));
+
+export const runtimeDir = fileURLToPath(
+  new URL("dist/runtime/", import.meta.url),
+);

package/src/cli/commands/add.ts

@@ -0,0 +1,44 @@
+import { addIndexer } from "apibara/create";
+import { defineCommand } from "citty";
+
+export default defineCommand({
+  meta: {
+    name: "add",
+    description:
+      "apibara add helps you add a new indexer to your project with sensible defaults.",
+  },
+  args: {
+    indexerId: {
+      type: "positional",
+      description: "Indexer ID",
+      required: false,
+    },
+    chain: {
+      type: "string",
+      description: "Chain",
+    },
+    network: {
+      type: "string",
+      description: "Network",
+    },
+    storage: {
+      type: "string",
+      description: "Storage",
+    },
+    dnaUrl: {
+      type: "string",
+      description: "DNA URL",
+    },
+  },
+  async run({ args }) {
+    const { indexerId, chain, network, storage, dnaUrl } = args;
+
+    await addIndexer({
+      argIndexerId: indexerId,
+      argChain: chain,
+      argNetwork: network,
+      argStorage: storage,
+      argDnaUrl: dnaUrl,
+    });
+  },
+});

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,26 +70,35 @@ 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("node", childArgs, {
@@ -99,7 +107,9 @@ export default defineCommand({
 
         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/init.ts

@@ -0,0 +1,36 @@
+import { initializeProject } from "apibara/create";
+import { defineCommand } from "citty";
+
+export default defineCommand({
+  meta: {
+    name: "init",
+    description: "Initialize a new Apibara project",
+  },
+  args: {
+    dir: {
+      type: "positional",
+      description: "Target path to initialize the project",
+      required: true,
+    },
+    language: {
+      type: "string",
+      description: "Language to use: typescript, ts or javascript, js",
+      default: "ts",
+      alias: "l",
+    },
+    noIndexer: {
+      type: "boolean",
+      description: "Do not create an indexer after initialization",
+      default: false,
+    },
+  },
+  async run({ args }) {
+    const { dir: targetDir, noIndexer, language } = args;
+
+    await initializeProject({
+      argTargetDir: targetDir,
+      argLanguage: language,
+      argNoCreateIndexer: noIndexer,
+    });
+  },
+});

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,7 +9,10 @@ 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),
+    init: () => import("./commands/init").then((r) => r.default),
+    add: () => import("./commands/add").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/error.ts

@@ -23,7 +23,6 @@ export function formatRollupError(
         (error as rollup.RollupError).frame;
 
       logs.push(
-        // biome-ignore lint/style/useTemplate: <explanation>
         `Rollup error while processing \`${path}\`` + text ? "\n\n" + text : "",
       );
     }

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;
   }
 }