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

package/src/rolldown/plugins/config.ts

@@ -0,0 +1,17 @@
+import virtual from "@rollup/plugin-virtual";
+import type { Apibara } from "apibara/types";
+import type { RolldownPluginOption } from "rolldown";
+
+export function appConfig(apibara: 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);
+    `,
+  }) as RolldownPluginOption;
+}

package/src/{rollup → rolldown}/plugins/indexers.ts

@@ -1,17 +1,17 @@
 import virtual from "@rollup/plugin-virtual";
 import type { Apibara } from "apibara/types";
 import { hash } from "ohash";
+import type { RolldownPluginOption } from "rolldown";
 
 export function indexers(apibara: Apibara) {
   const indexers = [...new Set(apibara.indexers)];
-
   return virtual({
     "#apibara-internal-virtual/indexers": `
-    ${indexers.map((i) => `import _${hash(i)} from '${i.indexer}';`).join("\n")}
+    ${indexers.map((i) => `import * as _${hash(i)} from '${i.indexer}';`).join("\n")}
 
     export const indexers = [
       ${indexers.map((i) => `{ name: "${i.name}", indexer: _${hash(i)} }`).join(",\n")}
     ];
     `,
-  });
+  }) as RolldownPluginOption;
 }

package/src/rolldown/plugins/instrumentation.ts

@@ -0,0 +1,68 @@
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import virtual from "@rollup/plugin-virtual";
+import type { Apibara } from "apibara/types";
+import type { RolldownPluginOption } from "rolldown";
+
+export function instrumentation(apibara: 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 };
+      `,
+    }) as RolldownPluginOption;
+  }
+
+  /**
+   * We are importing the instrumentation file inline with "require" instead of "import" at the top of the file to avoid warnings from rolldown
+   * when some methods are not defined in the instrumentation file.
+   *
+   * Example warning:
+   * 
+   * [IMPORT_IS_UNDEFINED] Warning: Import `logger` will always be undefined because there is no matching export in 'instrumentation.ts'
+   *     ╭─[virtual:#apibara-internal-virtual/instrumentation:11:35]
+   *     │
+   *  11 │     if (instrumentation && typeof instrumentation.logger === "function") {
+   *     │                                   ───────────┬──────────  
+   *     │                                              ╰──────────── 
+   * ────╯
+
+  * [IMPORT_IS_UNDEFINED] Warning: Import `logger` will always be undefined because there is no matching export in 'instrumentation.ts'
+  *     ╭─[virtual:#apibara-internal-virtual/instrumentation:12:16]
+  *     │
+  *  12 │       logger = instrumentation.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 };
+    `,
+  }) as RolldownPluginOption;
+}

package/src/runtime/dev.ts

@@ -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";
+import { blueBright } from "picocolors";
+import {
+  availableIndexers,
+  createAuthenticatedClient,
+  createIndexer,
+} from "./internal/app";
 
 const startCommand = defineCommand({
   meta: {
@@ -36,13 +40,21 @@ const startCommand = defineCommand({
 
     await Promise.all(
       selectedIndexers.map(async (indexer) => {
-        const indexerInstance = createIndexer(indexer, preset);
+        const { indexer: indexerInstance, logger } =
+          createIndexer(indexer, preset) ?? {};
+        if (!indexerInstance) {
+          return;
+        }
 
-        const client = createClient(
+        const client = createAuthenticatedClient(
           indexerInstance.streamConfig,
           indexerInstance.options.streamUrl,
         );
 
+        if (logger) {
+          logger.info(`Indexer ${blueBright(indexer)} started`);
+        }
+
         await runWithReconnect(client, indexerInstance);
       }),
     );

package/src/runtime/internal/app.ts

@@ -8,31 +8,31 @@ import {
   inMemoryPersistence,
   logger,
 } from "@apibara/indexer/plugins";
+import {
+  type CreateClientOptions,
+  Metadata,
+  type StreamConfig,
+  createClient,
+} from "@apibara/protocol";
+import consola from "consola";
 import { config } from "#apibara-internal-virtual/config";
 import { indexers } from "#apibara-internal-virtual/indexers";
+import { logger as instrumentationLogger } from "#apibara-internal-virtual/instrumentation";
+import { getProcessedRuntimeConfig } from "./helper";
 import { createLogger } from "./logger";
 
 export const availableIndexers = indexers.map((i) => i.name);
 
 export function createIndexer(indexerName: string, preset?: string) {
-  let runtimeConfig: Record<string, unknown> = { ...config.runtimeConfig };
-
-  if (preset) {
-    if (config.presets === undefined) {
-      throw new Error(
-        `Specified preset "${preset}" but no presets were defined`,
-      );
-    }
-
-    if (config.presets[preset] === undefined) {
-      throw new Error(`Specified preset "${preset}" but it was not defined`);
-    }
+  // Get merged runtime config from preset and process.env.APIBARA_RUNTIME_CONFIG and defaults.
+  const runtimeConfig = getProcessedRuntimeConfig({
+    preset,
+    presets: config.presets,
+    runtimeConfig: config.runtimeConfig,
+  });
 
-    const presetValue = config.presets[preset] as {
-      runtimeConfig: Record<string, unknown>;
-    };
-    runtimeConfig = { ...runtimeConfig, ...presetValue.runtimeConfig };
-  }
+  // Set the runtime config in the environment so that it can be used by the useRuntimeConfig hook.
+  process.env.APIBARA_RUNTIME_CONFIG_HOOK_DATA = JSON.stringify(runtimeConfig);
 
   const indexerDefinition = indexers.find((i) => i.name === indexerName);
 
@@ -42,10 +42,18 @@ export function createIndexer(indexerName: string, preset?: string) {
     );
   }
 
+  const indexerModule = indexerDefinition.indexer?.default;
+  if (indexerModule === undefined) {
+    consola.warn(
+      `Specified indexer "${indexerName}" but it does not export a default. Ignoring.`,
+    );
+    return;
+  }
+
   const definition =
-    typeof indexerDefinition.indexer === "function"
-      ? indexerDefinition.indexer(runtimeConfig)
-      : indexerDefinition.indexer;
+    typeof indexerModule === "function"
+      ? indexerModule(runtimeConfig)
+      : indexerModule;
 
   let reporter: ConsolaReporter = createLogger({
     indexer: indexerName,
@@ -53,26 +61,59 @@ export function createIndexer(indexerName: string, preset?: string) {
     indexers: availableIndexers,
   });
 
-  if (config.logger) {
-    reporter = config.logger({
+  // Check if a custom logger is provided through instrumentation
+  if (instrumentationLogger) {
+    // Create a reporter using the custom logger function
+    const _reporter = instrumentationLogger({
       indexer: indexerName,
       preset,
       indexers: availableIndexers,
     });
+
+    // If the reporter is valid (has a log method), use it instead of the default
+    if (_reporter && "log" in _reporter) {
+      reporter = _reporter;
+    }
   }
 
   // Put the in-memory persistence plugin first so that it can be overridden by any user-defined
   // persistence plugin.
-  // Put the logger last since we want to override any user-defined logger.
   definition.plugins = [
     internalContext({
       indexerName,
       availableIndexers,
     } as InternalContext),
+    logger({ logger: reporter }),
     inMemoryPersistence(),
     ...(definition.plugins ?? []),
-    logger({ logger: reporter }),
   ];
 
-  return _createIndexer(definition);
+  return {
+    indexer: _createIndexer(definition),
+    logger: consola.create({ reporters: [reporter] }),
+  };
+}
+
+export function createAuthenticatedClient(
+  config: StreamConfig<unknown, unknown>,
+  streamUrl: string,
+  options?: CreateClientOptions,
+) {
+  const dnaToken = process.env.DNA_TOKEN;
+  if (!dnaToken) {
+    consola.warn(
+      "DNA_TOKEN environment variable is not set. Trying to connect without authentication.",
+    );
+  }
+
+  return createClient(config, streamUrl, {
+    ...options,
+    defaultCallOptions: {
+      "*": {
+        metadata: Metadata({
+          Authorization: `Bearer ${dnaToken}`,
+        }),
+      },
+    },
+  });
 }

package/src/runtime/internal/helper.ts

@@ -0,0 +1,55 @@
+import defu from "defu";
+
+/**
+ * Get the merged runtime config from the process.env.APIBARA_RUNTIME_CONFIG, presets and defaults.
+ * Priority (Highest to lowest):
+ * 1. process.env.APIBARA_RUNTIME_CONFIG
+ * 2. Preset
+ * 3. Defaults
+ */
+export function getProcessedRuntimeConfig({
+  preset,
+  presets,
+  runtimeConfig,
+}: {
+  preset?: string;
+  presets?: Record<string, unknown>;
+  runtimeConfig?: Record<string, unknown>;
+}) {
+  let _runtimeConfig: Record<string, unknown> = { ...runtimeConfig };
+  const envRuntimeConfig = process.env.APIBARA_RUNTIME_CONFIG;
+
+  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>;
+    };
+
+    // Preset applied
+    _runtimeConfig = defu(presetValue.runtimeConfig, _runtimeConfig);
+  }
+
+  if (envRuntimeConfig) {
+    try {
+      // Environment runtime config applied
+      const envRuntimeConfigValue = JSON.parse(envRuntimeConfig);
+      _runtimeConfig = defu(envRuntimeConfigValue, _runtimeConfig);
+    } catch (error) {
+      throw new Error(
+        "Failed to parse runtime config from process.env.APIBARA_RUNTIME_CONFIG. Please ensure it is a valid JSON string.",
+        { cause: error },
+      );
+    }
+  }
+
+  return _runtimeConfig;
+}

package/src/runtime/project-info.ts

@@ -0,0 +1,72 @@
+import { writeFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { defineCommand, runMain } from "citty";
+import { config } from "#apibara-internal-virtual/config";
+import { availableIndexers, createIndexer } from "./internal/app";
+
+type ProjectInfo = {
+  indexers: {
+    [indexerName: string]: {
+      [presetName: string]: {
+        type: string;
+        isFactory: boolean;
+      };
+    };
+  };
+};
+
+const startCommand = defineCommand({
+  meta: {
+    name: "write-project-info",
+    description: "Write json-encoded information about the project.",
+  },
+  args: {
+    "build-dir": {
+      type: "string",
+      description: "project build directory",
+    },
+  },
+  async run({ args }) {
+    const projectInfo: ProjectInfo = {
+      indexers: {},
+    };
+
+    for (const preset of Object.keys(config.presets ?? {})) {
+      for (const indexer of availableIndexers) {
+        const { indexer: indexerInstance } =
+          createIndexer(indexer, preset) ?? {};
+        if (!indexerInstance) {
+          continue;
+        }
+        projectInfo.indexers[indexer] = {
+          ...(projectInfo.indexers[indexer] ?? {}),
+          [preset]: {
+            type: indexerInstance.streamConfig.name,
+            isFactory: indexerInstance.options.factory !== undefined,
+          },
+        };
+      }
+    }
+
+    const projectInfoPath = resolve(
+      args["build-dir"] ?? ".apibara",
+      "project-info.json",
+    );
+
+    writeFileSync(projectInfoPath, JSON.stringify(projectInfo, null, 2));
+  },
+});
+
+export const mainCli = defineCommand({
+  meta: {
+    name: "write-project-info-runner",
+    description: "Write json-encoded information about the project.",
+  },
+  subCommands: {
+    start: () => startCommand,
+  },
+});
+
+runMain(mainCli);
+
+export default {};

package/src/runtime/start.ts

@@ -1,7 +1,9 @@
 import { runWithReconnect } from "@apibara/indexer";
-import { createClient } from "@apibara/protocol";
 import { defineCommand, runMain } from "citty";
-import { createIndexer } from "./internal/app";
+import consola from "consola";
+import { blueBright } from "picocolors";
+import { register } from "#apibara-internal-virtual/instrumentation";
+import { createAuthenticatedClient, createIndexer } from "./internal/app";
 
 const startCommand = defineCommand({
   meta: {
@@ -22,13 +24,28 @@ const startCommand = defineCommand({
   async run({ args }) {
     const { indexer, preset } = args;
 
-    const indexerInstance = createIndexer(indexer, preset);
+    const { indexer: indexerInstance, logger } =
+      createIndexer(indexer, preset) ?? {};
+    if (!indexerInstance) {
+      consola.error(`Specified indexer "${indexer}" but it was not defined`);
+      process.exit(1);
+    }
 
-    const client = createClient(
+    const client = createAuthenticatedClient(
       indexerInstance.streamConfig,
       indexerInstance.options.streamUrl,
     );
 
+    if (register) {
+      consola.start("Registering from instrumentation");
+      await register();
+      consola.success("Registered from instrumentation");
+    }
+
+    if (logger) {
+      logger.info(`Indexer ${blueBright(indexer)} started`);
+    }
+
     await runWithReconnect(client, indexerInstance);
   },
 });

package/src/types/config.ts

@@ -1,21 +1,29 @@
 import type { ConsolaReporter } from "@apibara/indexer/plugins";
-import type { RollupCommonJSOptions } from "@rollup/plugin-commonjs";
 import type {
   C12InputConfig,
   ConfigWatcher,
   ResolvedConfig,
   WatchConfigOptions,
 } from "c12";
-import type { WatchOptions } from "chokidar";
 import type { NestedHooks } from "hookable";
+import type { WatchOptions } from "rolldown";
+import type { RolldownOptions } from "rolldown";
 import type { DeepPartial } from "./_utils";
 import type { ApibaraHooks } from "./hooks";
-import type { RollupConfig } from "./rollup";
 
-export type LoggerFactory = ({
+export type RegisterFn = () => Promise<void>;
+
+export type LoggerFactoryFn = ({
   indexer,
+  indexers,
   preset,
-}: { indexer: string; indexers: string[]; preset?: string }) => ConsolaReporter;
+}: LoggerFactoryArgs) => ConsolaReporter;
+
+export type LoggerFactoryArgs = {
+  indexer: string;
+  indexers: string[];
+  preset?: string;
+};
 
 /**
  * Apibara Config type (apibara.config)
@@ -31,7 +39,6 @@ export interface ApibaraConfig<
   runtimeConfig?: R;
   presets?: T;
   preset?: keyof T;
-  logger?: LoggerFactory;
 }
 
 export type ApibaraDynamicConfig = Pick<ApibaraConfig, "runtimeConfig">;
@@ -68,22 +75,26 @@ export interface ApibaraOptions<
   buildDir: string;
   outputDir: string;
   indexersDir: string;
+  disableLogs?: boolean;
 
   // Dev
   dev: boolean;
-  watchOptions: WatchOptions;
+  watchOptions: WatchOptions["watch"];
 
   // Hooks
   hooks: NestedHooks<ApibaraHooks>;
 
-  // Logging
-  logger?: LoggerFactory;
+  // Rolldown
+  rolldownConfig?: Partial<RolldownOptions>;
 
-  // Rollup
-  rollupConfig?: Partial<RollupConfig>;
+  /**
+   * @deprecated Use rolldownConfig instead. This option will be removed in future releases.
+   */
+  rollupConfig?: unknown;
   sourceMap?: boolean;
   entry: string;
-  commonJS?: RollupCommonJSOptions;
+  node: boolean;
+  exportConditions?: string[];
 
   // Advanced
   typescript: {

package/src/types/hooks.ts

@@ -1,12 +1,15 @@
+import type { RolldownOptions } from "rolldown";
 import type { Apibara } from "./apibara";
-import type { RollupConfig } from "./rollup";
 
 export interface ApibaraHooks {
-  "rollup:before": (apibara: Apibara, rollupConfig: RollupConfig) => void;
+  "rolldown:before": (
+    apibara: Apibara,
+    rolldownConfig: RolldownOptions,
+  ) => void;
   compiled: (apibara: Apibara) => void;
-  "dev:restart": () => void;
-  "dev:reload": () => void;
-  "rollup:reload": () => void;
+  "dev:restart": () => Promise<void>;
+  "dev:reload": () => Promise<void>;
+  "rolldown:reload": () => Promise<void>;
   restart: () => void;
   close: () => void;
 }

package/src/types/index.ts

@@ -2,5 +2,5 @@ export * from "./apibara";
 export * from "./_utils";
 export * from "./config";
 export * from "./hooks";
-export * from "./rollup";
+export * from "./rolldown";
 export * from "./runtime";

package/src/types/rolldown.ts

@@ -0,0 +1,5 @@
+import type { InputOptions, OutputOptions } from "rolldown";
+
+export type RolldownConfig = InputOptions & {
+  output: OutputOptions;
+};

package/src/types/virtual/config.d.ts

@@ -1,3 +1,6 @@
 import type { ApibaraConfig } from "apibara/types";
 
-export const config: ApibaraConfig = {};
+export const config: Pick<
+  ApibaraConfig,
+  "runtimeConfig" | "preset" | "presets"
+> = {};

package/src/types/virtual/indexers.d.ts

@@ -7,4 +7,7 @@ export type IndexerConstructor =
     ) => IndexerWithStreamConfig<unknown, unknown, unknown>)
   | IndexerWithStreamConfig<unknown, unknown, unknown>;
 
-export const indexers: { name: string; indexer: IndexerConstructor }[] = [];
+export const indexers: {
+  name: string;
+  indexer: { default?: IndexerConstructor | undefined };
+}[] = [];

package/src/types/virtual/instrumentation.d.ts

@@ -0,0 +1,4 @@
+import type { LoggerFactoryFn, RegisterFn } from "apibara/types";
+
+export const register: RegisterFn | undefined = undefined;
+export const logger: LoggerFactoryFn | undefined = undefined;

package/dist/rollup/index.d.mts

@@ -1,6 +0,0 @@
-import { Apibara, RollupConfig } from 'apibara/types';
-export { Plugin } from 'rollup';
-
-declare function getRollupConfig(apibara: Apibara): RollupConfig;
-
-export { getRollupConfig };

package/dist/rollup/index.d.ts

@@ -1,6 +0,0 @@
-import { Apibara, RollupConfig } from 'apibara/types';
-export { Plugin } from 'rollup';
-
-declare function getRollupConfig(apibara: Apibara): RollupConfig;
-
-export { getRollupConfig };