apibara 2.1.0-beta.3 → 2.1.0-beta.30

package/dist/create/index.mjs

@@ -1,24 +1,11 @@
 import path, { basename } from 'node:path';
 import consola$1, { consola } from 'consola';
 import prompts from 'prompts';
-import colors from 'picocolors';
+import { a as blue, y as yellow, c as green, r as red, d as cyan, m as magenta, e as reset } from '../shared/apibara.730bb1e4.mjs';
 import fs from 'node:fs';
 import { Project, SyntaxKind } from 'ts-morph';
 import * as prettier from 'prettier';
-
-const {
-  blue,
-  blueBright,
-  cyan,
-  gray,
-  green,
-  greenBright,
-  magenta,
-  red,
-  redBright,
-  reset,
-  yellow
-} = colors;
+import 'picocolors';
 
 const chains = [
   {
@@ -57,26 +44,25 @@ const storages = [
 ];
 const packageVersions = {
   // Required Dependencies
-  apibara: "^2.1.0-beta.2",
-  "@apibara/indexer": "^2.1.0-beta.2",
-  "@apibara/protocol": "^2.1.0-beta.2",
+  apibara: "next",
+  "@apibara/indexer": "next",
+  "@apibara/protocol": "next",
   // Chain Dependencies
-  "@apibara/evm": "^2.1.0-beta.2",
-  "@apibara/beaconchain": "^2.1.0-beta.2",
-  "@apibara/starknet": "^2.1.0-beta.2",
+  "@apibara/evm": "next",
+  "@apibara/beaconchain": "next",
+  "@apibara/starknet": "next",
   // Storage Dependencies
-  "@apibara/plugin-drizzle": "^2.1.0-beta.2",
-  "@apibara/plugin-mongo": "^2.1.0-beta.2",
-  "@apibara/plugin-sqlite": "^2.1.0-beta.2",
+  "@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",
+  "drizzle-orm": "^0.40.1",
   pg: "^8.13.1",
   "@types/pg": "^8.11.10",
   "drizzle-kit": "^0.29.0",
   // Typescript Dependencies
   typescript: "^5.6.2",
-  "@rollup/plugin-typescript": "^11.1.6",
   "@types/node": "^20.5.2"
 };
 const dnaUrls = {
@@ -386,7 +372,7 @@ function generatePackageJson(isTypeScript) {
     private: true,
     type: "module",
     scripts: {
-      prepare: "apibara prepare",
+      ...isTypeScript && { prepare: "apibara prepare" },
       dev: "apibara dev",
       start: "apibara start",
       build: "apibara build",
@@ -399,7 +385,6 @@ function generatePackageJson(isTypeScript) {
     },
     devDependencies: {
       ...isTypeScript && {
-        "@rollup/plugin-typescript": packageVersions["@rollup/plugin-typescript"],
         "@types/node": packageVersions["@types/node"],
         typescript: packageVersions.typescript
       }
@@ -427,13 +412,10 @@ function generateTsConfig() {
   };
 }
 function generateApibaraConfig(isTypeScript) {
-  return `${isTypeScript ? 'import typescript from "@rollup/plugin-typescript";\nimport type { Plugin } from "apibara/rollup";\n' : ""}import { defineConfig } from "apibara/config";
+  return `import { defineConfig } from "apibara/config";
 
 export default defineConfig({
-  runtimeConfig: {},${isTypeScript ? `
-  rollupConfig: {
-    plugins: [typescript()${isTypeScript ? " as Plugin" : ""}],
-  },` : ""}
+  runtimeConfig: {},
 });
 `;
 }
@@ -446,15 +428,18 @@ function generateIndexer({
   return `import { defineIndexer } from "@apibara/indexer";
 import { useLogger } from "@apibara/indexer/plugins";
 ${storage === "postgres" ? `import { drizzleStorage } from "@apibara/plugin-drizzle";` : ""}
+${storage === "postgres" ? `import { drizzle } from "@apibara/plugin-drizzle";` : ""}
 ${chain === "ethereum" ? `import { EvmStream } from "@apibara/evm";` : chain === "beaconchain" ? `import { BeaconChainStream } from "@apibara/beaconchain";` : chain === "starknet" ? `import { StarknetStream } from "@apibara/starknet";` : ""}
 ${language === "typescript" ? `import type { ApibaraRuntimeConfig } from "apibara/types";` : ""}
-${storage === "postgres" ? `import { getDrizzlePgDatabase } from "../lib/db";` : ""}
+${storage === "postgres" ? `import * as schema from "../lib/schema";` : ""}
 
 
 export default function (runtimeConfig${language === "typescript" ? ": ApibaraRuntimeConfig" : ""}) {
   const indexerId = "${indexerId}";
-  const { startingBlock, streamUrl${storage === "postgres" ? ", postgresConnectionString" : ""} } = runtimeConfig[indexerId];
-  ${storage === "postgres" ? "const { db } = getDrizzlePgDatabase(postgresConnectionString);" : ""}
+  const { startingBlock, streamUrl } = runtimeConfig[indexerId];
+  ${storage === "postgres" ? `const db = drizzle({
+    schema,
+  });` : ""}
 
   return defineIndexer(${chain === "ethereum" ? "EvmStream" : chain === "beaconchain" ? "BeaconChainStream" : chain === "starknet" ? "StarknetStream" : ""})({
     streamUrl,
@@ -463,7 +448,7 @@ export default function (runtimeConfig${language === "typescript" ? ": ApibaraRu
     filter: {
       header: "always",
     },
-    plugins: [${storage === "postgres" ? "drizzleStorage({ db, persistState: true })" : ""}],
+    plugins: [${storage === "postgres" ? "drizzleStorage({ db, migrate: { migrationsFolder: './drizzle' } })" : ""}],
     async transform({ endCursor, finality }) {
       const logger = useLogger();
 
@@ -475,14 +460,12 @@ export default function (runtimeConfig${language === "typescript" ? ": ApibaraRu
       );
 
       ${storage === "postgres" ? `// Example snippet to insert data into db using drizzle with postgres
-      //   const { db } = useDrizzleStorage();
-      //   const { logs } = block;
-      //   for (const log of logs) {
-      //     await db.insert(exampleTable).values({
-      //       number: Number(endCursor?.orderKey),
-      //       hash: log.transactionHash,
-      //     });
-      //   }` : ""}
+      // const { db: database } = useDrizzleStorage();
+
+      // await database.insert(schema.cursorTable).values({
+      //   endCursor: Number(endCursor?.orderKey),
+      //   uniqueKey: \`\${endCursor?.uniqueKey}\`,
+      // });` : ""}
     },
   });
 }   
@@ -549,8 +532,8 @@ async function updateApibaraConfigFile({
   );
   const runtimeConfigString = `{
   startingBlock: 0,
-  streamUrl: "${dnaUrl ?? getDnaUrl(chain, network)}"${storage === "postgres" ? `,
-  postgresConnectionString: process.env["POSTGRES_CONNECTION_STRING"] ?? "memory://${indexerId}"` : ""}}`;
+  streamUrl: "${dnaUrl ?? getDnaUrl(chain, network)}"  
+}`;
   const project = new Project();
   const sourceFile = project.addSourceFileAtPath(pathToConfig);
   const defineConfigCall = sourceFile.getFirstDescendantByKind(
@@ -581,7 +564,7 @@ async function updateApibaraConfigFile({
   await formatFile(pathToConfig);
 }
 async function createDrizzleStorageFiles(options) {
-  const { cwd, language, storage } = options;
+  const { cwd, language, storage, indexerId } = options;
   if (storage !== "postgres")
     return;
   const fileExtension = language === "typescript" ? "ts" : "js";
@@ -595,11 +578,11 @@ async function createDrizzleStorageFiles(options) {
     const drizzleConfigContent = `${language === "typescript" ? 'import type { Config } from "drizzle-kit";' : ""}
 
 export default {
-  schema: "./lib/schema.ts",
+  schema: "./lib/schema.${fileExtension}",
   out: "./drizzle",
   dialect: "postgresql",
   dbCredentials: {
-    url: process.env["POSTGRES_CONNECTION_STRING"] ?? "",
+    url: process.env["POSTGRES_CONNECTION_STRING"] ?? "memory://${indexerId}",
   },
 }${language === "typescript" ? " satisfies Config" : ""};`;
     fs.writeFileSync(drizzleConfigPath, drizzleConfigContent);
@@ -614,14 +597,14 @@ export default {
     fileName: `lib/${schemaFileName}`
   });
   if (!schemaExists || schemaOverwrite) {
-    const schemaContent = `//  --- Add your pg table schemas here ---- 
+    const schemaContent = `//  --- Add your pg table schemas here ----
 
 // import { bigint, pgTable, text, uuid } from "drizzle-orm/pg-core";
 
-// export const exampleTable = pgTable("example_table", {
+// export const cursorTable = pgTable("cursor_table", {
 //   id: uuid("id").primaryKey().defaultRandom(),
-//   number: bigint("number", { mode: "number" }),
-//   hash: text("hash"),
+//   endCursor: bigint("end_cursor", { mode: "number" }),
+//   uniqueKey: text("unique_key"),
 // });
 
 export {};
@@ -631,48 +614,6 @@ export {};
     await formatFile(schemaPath);
     consola.success(`Created ${cyan("lib/schema.ts")}`);
   }
-  const dbFileName = `db.${fileExtension}`;
-  const dbPath = path.join(cwd, "lib", dbFileName);
-  const { exists: dbExists, overwrite: dbOverwrite } = await checkFileExists(
-    dbPath,
-    {
-      askPrompt: true,
-      fileName: `lib/${dbFileName}`,
-      allowIgnore: true
-    }
-  );
-  if (!dbExists || dbOverwrite) {
-    const dbContent = `import * as schema from "./schema";
-import { drizzle as nodePgDrizzle } from "drizzle-orm/node-postgres";
-import { drizzle as pgLiteDrizzle } from "drizzle-orm/pglite";
-import pg from "pg";
-
-
-export function getDrizzlePgDatabase(connectionString${language === "typescript" ? ": string" : ""}) {
-  // Create pglite instance
-  if (connectionString.includes("memory")) {
-    return {
-      db: pgLiteDrizzle({
-        schema,
-        connection: {
-          dataDir: connectionString,
-        },
-      }),
-    };
-  }
-
-  // Create node-postgres instance
-  const pool = new pg.Pool({
-    connectionString,
-  });
-
-  return { db: nodePgDrizzle(pool, { schema }) };
-}`;
-    fs.mkdirSync(path.dirname(dbPath), { recursive: true });
-    fs.writeFileSync(dbPath, dbContent);
-    await formatFile(dbPath);
-    consola.success(`Created ${cyan(`lib/${dbFileName}`)}`);
-  }
   console.log("\n");
   if (!schemaExists || schemaOverwrite) {
     consola.info(
@@ -688,15 +629,15 @@ ${yellow(`
 
 import { bigint, pgTable, text, uuid } from "drizzle-orm/pg-core";
 
-export const exampleTable = pgTable("example_table", {
+export const cursorTable = pgTable("cursor_table", {
   id: uuid("id").primaryKey().defaultRandom(),
-  number: bigint("number", { mode: "number" }),
-  hash: text("hash"),
+  endCursor: bigint("end_cursor", { mode: "number" }),
+  uniqueKey: text("unique_key"),
 });`)}`);
     console.log("\n");
   }
   consola.info(
-    `Run ${green(`${options.packageManager} run drizzle:generate`)} & ${green(`${options.packageManager} run drizzle:migrate`)} to generate and apply migrations.`
+    `Run ${green(`${options.packageManager}${options.packageManager === "npm" ? " run" : ""} drizzle:generate`)} & ${green(`${options.packageManager}${options.packageManager === "npm" ? " run" : ""} drizzle:migrate`)} to generate and apply migrations.`
   );
 }
 async function createStorageRelatedFiles(options) {
@@ -705,6 +646,90 @@ async function createStorageRelatedFiles(options) {
     await createDrizzleStorageFiles(options);
   }
 }
+const gitIgnoreItems = [
+  {
+    isRecommended: false,
+    value: "node_modules"
+  },
+  {
+    isRecommended: false,
+    value: "dist"
+  },
+  {
+    isRecommended: true,
+    description: "build and dev files of apibara",
+    value: ".apibara"
+  },
+  {
+    isRecommended: false,
+    value: ".env"
+  },
+  {
+    isRecommended: false,
+    description: "for mac users",
+    value: ".DS_Store"
+  }
+];
+async function createGitIgnoreFile(cwd) {
+  const gitIgnorePath = path.join(cwd, ".gitignore");
+  if (fs.existsSync(gitIgnorePath)) {
+    const result = await prompts([
+      {
+        type: "select",
+        name: "overwrite",
+        message: `${cyan(".gitignore")} already exists. Please choose how to proceed:`,
+        initial: 0,
+        choices: [
+          {
+            title: "Choose items to append in your .gitignore",
+            value: "append"
+          },
+          {
+            title: "Keep original",
+            value: "ignore"
+          },
+          {
+            title: "Overwrite",
+            value: "overwrite"
+          }
+        ]
+      },
+      {
+        type: (overwrite2) => overwrite2 === "append" ? "multiselect" : null,
+        name: "ignoreItems",
+        message: "Choose items to append in your .gitignore",
+        choices: gitIgnoreItems.map((item) => ({
+          title: `${yellow(item.value)}${item.description ? ` - ${item.description}` : ""}${item.isRecommended ? ` ${green("(recommended)")}` : ""}`,
+          value: item.value
+        }))
+      }
+    ]);
+    const { overwrite, ignoreItems } = result;
+    if (overwrite === "append" && ignoreItems.length > 0) {
+      const gitIgnoreContent = fs.readFileSync(gitIgnorePath, "utf8");
+      fs.writeFileSync(
+        gitIgnorePath,
+        `${gitIgnoreContent}
+${result.ignoreItems.join("\n")}`
+      );
+      consola.success(`Updated ${cyan(".gitignore")}`);
+      return;
+    }
+    if (overwrite === "overwrite") {
+      fs.writeFileSync(
+        gitIgnorePath,
+        gitIgnoreItems.map((item) => item.value).join("\n")
+      );
+      consola.success(`Updated ${cyan(".gitignore")}`);
+      return;
+    }
+  }
+  fs.writeFileSync(
+    gitIgnorePath,
+    gitIgnoreItems.map((item) => item.value).join("\n")
+  );
+  consola.success(`Created ${cyan(".gitignore")}`);
+}
 
 async function initializeProject({
   argTargetDir,
@@ -789,35 +814,36 @@ async function initializeProject({
     JSON.stringify(packageJson, null, 2) + "\n"
   );
   await formatFile(packageJsonPath);
-  consola$1.success("Created ", cyan("package.json"));
+  consola$1.success("Created", cyan("package.json"));
   if (isTs) {
     const tsConfigPath = path.join(root, "tsconfig.json");
     const tsConfig = generateTsConfig();
     fs.writeFileSync(tsConfigPath, JSON.stringify(tsConfig, null, 2) + "\n");
     await formatFile(tsConfigPath);
-    consola$1.success("Created ", cyan("tsconfig.json"));
+    consola$1.success("Created", cyan("tsconfig.json"));
   }
   const apibaraConfigPath = path.join(root, `apibara.config.${configExt}`);
-  const apibaraConfig = generateApibaraConfig(isTs);
+  const apibaraConfig = generateApibaraConfig();
   fs.writeFileSync(apibaraConfigPath, apibaraConfig);
   await formatFile(apibaraConfigPath);
-  consola$1.success("Created ", cyan(`apibara.config.${configExt}`));
+  consola$1.success("Created", cyan(`apibara.config.${configExt}`));
   const indexersDir = path.join(root, "indexers");
   if (!fs.existsSync(indexersDir)) {
     fs.mkdirSync(indexersDir, { recursive: true });
     consola$1.success(`Created ${cyan("indexers")} directory`);
   }
+  await createGitIgnoreFile(root);
   console.log("\n");
   consola$1.ready(green("Project initialized successfully"));
   console.log();
   if (!argNoCreateIndexer) {
     consola$1.info("Let's create an indexer\n");
-    await addIndexer({});
+    await addIndexer({ argRootDir: argTargetDir });
   } else {
     const pkgManager = getPackageManager();
     consola$1.info(
       "Run ",
-      green(`${pkgManager.name} run install`),
+      green(`${pkgManager.name} install`),
       " to install all dependencies"
     );
   }
@@ -828,9 +854,11 @@ async function addIndexer({
   argChain,
   argNetwork,
   argStorage,
-  argDnaUrl
+  argDnaUrl,
+  argRootDir
 }) {
-  const configExists = hasApibaraConfig(process.cwd());
+  const cwd = path.join(process.cwd(), argRootDir ?? ".");
+  const configExists = hasApibaraConfig(cwd);
   if (!configExists) {
     consola$1.error("No apibara.config found in the current directory.");
     const prompt_initialize = await prompts({
@@ -854,7 +882,7 @@ async function addIndexer({
       );
     }
   }
-  const language = getApibaraConfigLanguage(process.cwd());
+  const language = getApibaraConfigLanguage(cwd);
   validateIndexerId(argIndexerId, true);
   validateChain(argChain, true);
   validateNetwork(argChain, argNetwork, true);
@@ -869,7 +897,7 @@ async function addIndexer({
         initial: argIndexerId ?? "my-indexer",
         validate: (id) => validateIndexerId(id) ? checkFileExists(
           path.join(
-            process.cwd(),
+            cwd,
             "indexers",
             `${id}.indexer.${language === "typescript" ? "ts" : "js"}`
           )
@@ -951,7 +979,7 @@ async function addIndexer({
   const indexerFileId = argIndexerId ?? prompt_indexerId;
   const pkgManager = getPackageManager();
   const options = {
-    cwd: process.cwd(),
+    cwd,
     indexerFileId,
     indexerId: convertKebabToCamelCase(indexerFileId),
     chain: argChain ?? prompt_chain?.name,
@@ -973,8 +1001,10 @@ async function addIndexer({
   );
   await createStorageRelatedFiles(options);
   console.log();
+  const baseCommand = `${options.packageManager} install`;
+  const tsCommand = `${baseCommand} && ${options.packageManager} run prepare`;
   consola$1.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/dist/hooks/index.mjs

@@ -1,5 +1,5 @@
 function useRuntimeConfig() {
-  return JSON.parse(process.env.APIBARA_RUNTIME_CONFIG || "{}");
+  return JSON.parse(process.env.APIBARA_RUNTIME_CONFIG_HOOK_DATA || "{}");
 }
 
 export { useRuntimeConfig };

package/dist/rolldown/index.d.mts

@@ -0,0 +1,7 @@
+import { Apibara } from 'apibara/types';
+import { RolldownOptions } from 'rolldown';
+export { Plugin } from 'rolldown';
+
+declare function getRolldownConfig(apibara: Apibara): RolldownOptions;
+
+export { getRolldownConfig };

package/dist/rolldown/index.d.ts

@@ -0,0 +1,7 @@
+import { Apibara } from 'apibara/types';
+import { RolldownOptions } from 'rolldown';
+export { Plugin } from 'rolldown';
+
+declare function getRolldownConfig(apibara: Apibara): RolldownOptions;
+
+export { getRolldownConfig };

package/dist/rolldown/index.mjs

@@ -0,0 +1,159 @@
+import { existsSync } from 'node:fs';
+import { builtinModules } from 'node:module';
+import replace from '@rollup/plugin-replace';
+import defu from 'defu';
+import { join as join$1 } from 'pathe';
+import virtual from '@rollup/plugin-virtual';
+import { hash } from 'ohash';
+import { join } from 'node:path';
+
+function appConfig(apibara) {
+  return virtual({
+    "#apibara-internal-virtual/config": `
+    const serializedConfig = \`process.env.APIBARA_CONFIG\`;
+
+    if (serializedConfig === undefined || serializedConfig === "") {
+      throw new Error("APIBARA_CONFIG is not defined");
+    }
+
+    export const config = JSON.parse(serializedConfig);
+    `
+  });
+}
+
+function indexers(apibara) {
+  const indexers2 = [...new Set(apibara.indexers)];
+  return virtual({
+    "#apibara-internal-virtual/indexers": `
+    ${indexers2.map((i) => `import * as _${hash(i)} from '${i.indexer}';`).join("\n")}
+
+    export const indexers = [
+      ${indexers2.map((i) => `{ name: "${i.name}", indexer: _${hash(i)} }`).join(",\n")}
+    ];
+    `
+  });
+}
+
+function instrumentation(apibara) {
+  const instrumentationPath = join(
+    apibara.options._c12.cwd,
+    `instrumentation.${apibara.options._c12.configFile?.endsWith(".ts") ? "ts" : "js"}`
+  );
+  if (!existsSync(instrumentationPath)) {
+    return virtual({
+      "#apibara-internal-virtual/instrumentation": `
+      let register = undefined;
+      let logger = undefined;
+  
+      export { register, logger };
+      `
+    });
+  }
+  return virtual({
+    "#apibara-internal-virtual/instrumentation": `
+    let register = undefined;
+    let logger = undefined;
+
+    try {
+      const instrumentation = require('${instrumentationPath}');
+      
+      if (instrumentation?.register && typeof instrumentation.register === "function") {
+        register = instrumentation.register;
+      }
+      
+      if (instrumentation?.logger && typeof instrumentation.logger === "function") {
+        logger = instrumentation.logger;
+      }
+    } catch {
+      // Silently handle any require errors
+    }
+
+    export { register, logger };
+    `
+  });
+}
+
+const runtimeDependencies = [
+  "better-sqlite3",
+  "@electric-sql/pglite",
+  "pg",
+  // https://socket.io/docs/v4/server-installation/#additional-packages
+  "utf-8-validate",
+  "bufferutil",
+  // was giving unresolved import warnings from `node-fetch` library.
+  "encoding"
+];
+function getRolldownConfig(apibara) {
+  const extensions = [
+    ".ts",
+    ".mjs",
+    ".js",
+    ".json",
+    ".node",
+    ".tsx",
+    ".jsx"
+  ];
+  const tsConfigExists = existsSync(
+    join$1(apibara.options.rootDir, "tsconfig.json")
+  );
+  const rolldownConfig = defu(
+    // biome-ignore lint/suspicious/noExplicitAny: apibara.options.rolldownConfig is typed
+    apibara.options.rolldownConfig,
+    {
+      platform: "node",
+      input: apibara.options.entry,
+      output: {
+        dir: join$1(apibara.options.outputDir || "./.apibara/build"),
+        format: "esm",
+        entryFileNames: "[name].mjs",
+        chunkFileNames: "chunks/[name]-[hash].mjs",
+        sourcemap: true
+      },
+      plugins: [],
+      onwarn(warning, rolldownWarn) {
+        if (!["CIRCULAR_DEPENDENCY", "EVAL", "THIS_IS_UNDEFINED"].includes(
+          warning.code || ""
+        ) && !warning.message.includes("Unsupported source map comment") && !warning.message.includes("@__PURE__") && !warning.message.includes("/*#__PURE__*/")) {
+          rolldownWarn(warning);
+        }
+      },
+      resolve: {
+        extensions,
+        preferBuiltins: !!apibara.options.node,
+        mainFields: ["main"],
+        exportConditions: apibara.options.exportConditions,
+        tsconfigFilename: tsConfigExists ? "tsconfig.json" : void 0
+      },
+      treeshake: true,
+      external: [...builtinModules, ...runtimeDependencies]
+    }
+  );
+  rolldownConfig.plugins?.push(
+    replace({
+      preventAssignment: true,
+      values: {
+        "process.env.APIBARA_CONFIG": getSerializedRuntimeConfig(apibara)
+      }
+    })
+  );
+  rolldownConfig.plugins?.push(instrumentation(apibara));
+  rolldownConfig.plugins?.push(indexers(apibara));
+  rolldownConfig.plugins?.push(appConfig());
+  return rolldownConfig;
+}
+function getSerializedRuntimeConfig(apibara) {
+  try {
+    return JSON.stringify({
+      runtimeConfig: apibara.options.runtimeConfig,
+      preset: apibara.options.preset,
+      presets: apibara.options.presets
+    });
+  } catch (error) {
+    throw new Error(
+      "Failed to serialize runtime config. Please ensure all values in your runtime configuration are JSON serializable.",
+      { cause: error }
+    );
+  }
+}
+
+export { getRolldownConfig };

package/dist/runtime/dev.mjs

@@ -1,7 +1,11 @@
 import { runWithReconnect } from "@apibara/indexer";
-import { createClient } from "@apibara/protocol";
 import { defineCommand, runMain } from "citty";
-import { availableIndexers, createIndexer } from "./internal/app.mjs";
+import { blueBright } from "picocolors";
+import {
+  availableIndexers,
+  createAuthenticatedClient,
+  createIndexer
+} from "./internal/app.mjs";
 const startCommand = defineCommand({
   meta: {
     name: "start",
@@ -32,11 +36,17 @@ const startCommand = defineCommand({
     }
     await Promise.all(
       selectedIndexers.map(async (indexer) => {
-        const indexerInstance = createIndexer(indexer, preset);
-        const client = createClient(
+        const { indexer: indexerInstance, logger } = createIndexer(indexer, preset) ?? {};
+        if (!indexerInstance) {
+          return;
+        }
+        const client = createAuthenticatedClient(
           indexerInstance.streamConfig,
           indexerInstance.options.streamUrl
         );
+        if (logger) {
+          logger.info(`Indexer ${blueBright(indexer)} started`);
+        }
         await runWithReconnect(client, indexerInstance);
       })
     );

package/dist/runtime/internal/app.d.ts

@@ -1,2 +1,7 @@
+import { type CreateClientOptions, type StreamConfig } from "@apibara/protocol";
 export declare const availableIndexers: any;
-export declare function createIndexer(indexerName: string, preset?: string): import("@apibara/indexer").Indexer<unknown, unknown>;
+export declare function createIndexer(indexerName: string, preset?: string): {
+    indexer: import("@apibara/indexer").Indexer<unknown, unknown>;
+    logger: any;
+} | undefined;
+export declare function createAuthenticatedClient(config: StreamConfig<unknown, unknown>, streamUrl: string, options?: CreateClientOptions): import("@apibara/protocol").GrpcClient<unknown, unknown>;