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

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

package/src/create/add.ts

@@ -0,0 +1,238 @@
+import path from "node:path";
+import consola from "consola";
+import prompts from "prompts";
+import { cyan, red, reset } from "./colors";
+import {
+  type ChainDataType,
+  type NetworkDataType,
+  type StorageDataType,
+  chains,
+  storages,
+} from "./constants";
+import { initializeProject } from "./init";
+import {
+  createIndexerFile,
+  createStorageRelatedFiles,
+  updateApibaraConfigFile,
+  updatePackageJson,
+} from "./templates";
+import type { Chain, IndexerOptions, Network, Storage } from "./types";
+import {
+  cancelOperation,
+  checkFileExists,
+  convertKebabToCamelCase,
+  getApibaraConfigLanguage,
+  getPackageManager,
+  hasApibaraConfig,
+  validateChain,
+  validateDnaUrl,
+  validateIndexerId,
+  validateNetwork,
+  validateStorage,
+} from "./utils";
+
+type Options = {
+  argIndexerId?: string;
+  argChain?: string;
+  argNetwork?: string;
+  argStorage?: string;
+  argDnaUrl?: string;
+};
+
+export async function addIndexer({
+  argIndexerId,
+  argChain,
+  argNetwork,
+  argStorage,
+  argDnaUrl,
+}: Options) {
+  const configExists = hasApibaraConfig(process.cwd());
+
+  if (!configExists) {
+    consola.error("No apibara.config found in the current directory.");
+
+    const prompt_initialize = await prompts({
+      type: "confirm",
+      name: "prompt_initialize",
+      message: reset(
+        "Do you want to initialize a apibara project here before adding an indexer?",
+      ),
+    });
+
+    if (prompt_initialize.prompt_initialize) {
+      await initializeProject({
+        argTargetDir: process.cwd(),
+        argNoCreateIndexer: true,
+      });
+    } else {
+      consola.info(
+        `Initialize a project with ${cyan("apibara init")} before adding an indexer`,
+      );
+      throw new Error(
+        red("✖") + " Operation cancelled: No apibara.config found",
+      );
+    }
+  }
+
+  const language = getApibaraConfigLanguage(process.cwd());
+
+  validateIndexerId(argIndexerId, true);
+  validateChain(argChain, true);
+  validateNetwork(argChain, argNetwork, true);
+  validateStorage(argStorage, true);
+  validateDnaUrl(argDnaUrl, true);
+
+  const result = await prompts(
+    [
+      {
+        type: argIndexerId ? null : "text",
+        name: "prompt_indexerId",
+        message: reset("Indexer ID:"),
+        initial: argIndexerId ?? "my-indexer",
+        validate: (id) =>
+          validateIndexerId(id)
+            ? checkFileExists(
+                path.join(
+                  process.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",
+        name: "prompt_chain",
+        message: reset("Select a chain:"),
+        choices: chains.map((chain) => ({
+          title: chain.color(chain.display),
+          value: chain,
+        })),
+      },
+      {
+        type: argNetwork ? null : "select",
+        name: "prompt_network",
+        message: reset("Select a network:"),
+        choices: (chain: ChainDataType | undefined) => [
+          ...(
+            chain?.networks ??
+            chains.find((c) => c.name === argChain)?.networks ??
+            []
+          ).map((network) => ({
+            title: network.color(network.display),
+            value: network,
+          })),
+          {
+            title: cyan("Other"),
+            value: {
+              color: cyan,
+              display: "Other",
+              name: "other",
+            } as NetworkDataType,
+          },
+        ],
+      },
+      {
+        type: (network: NetworkDataType | undefined) => {
+          if (network || argNetwork) {
+            return network?.name === "other" || argNetwork === "other"
+              ? "text"
+              : null;
+          }
+          return null;
+        },
+        name: "prompt_dnaUrl",
+        message: reset("Enter a DNA URL:"),
+        validate: (url) => validateDnaUrl(url) || "Provide a valid DNA Url",
+      },
+      {
+        type: argStorage ? null : "select",
+        name: "prompt_storage",
+        message: reset("Select a storage:"),
+        choices: storages.map((storage) => ({
+          title: storage.color(storage.display),
+          value: storage,
+        })),
+      },
+    ],
+    {
+      onCancel: () => {
+        cancelOperation();
+      },
+    },
+  );
+
+  const {
+    prompt_indexerId,
+    prompt_chain,
+    prompt_network,
+    prompt_storage,
+    prompt_dnaUrl,
+  } = result as {
+    prompt_indexerId: string | undefined;
+    prompt_chain: ChainDataType | undefined;
+    prompt_network: NetworkDataType | undefined;
+    prompt_storage: StorageDataType | undefined;
+    prompt_dnaUrl: string | undefined;
+  };
+
+  if (!argIndexerId && !prompt_indexerId) {
+    throw new Error(red("✖") + " Indexer ID is required");
+  }
+
+  if (!argChain && !prompt_chain) {
+    throw new Error(red("✖") + " Chain is required");
+  }
+
+  if (!argNetwork && !prompt_network) {
+    throw new Error(red("✖") + " Network is required");
+  }
+
+  const indexerFileId = argIndexerId! ?? prompt_indexerId!;
+
+  const pkgManager = getPackageManager();
+
+  const options: IndexerOptions = {
+    cwd: process.cwd(),
+    indexerFileId,
+    indexerId: convertKebabToCamelCase(indexerFileId),
+    chain: (argChain as Chain) ?? prompt_chain?.name!,
+    network: (argNetwork as Network) ?? prompt_network?.name!,
+    storage: (argStorage as Storage) ?? prompt_storage?.name!,
+    dnaUrl: argDnaUrl ?? prompt_dnaUrl,
+    language,
+    packageManager: pkgManager.name,
+  };
+
+  await updateApibaraConfigFile(options);
+
+  consola.success(
+    `Updated ${cyan("apibara.config." + (language === "typescript" ? "ts" : "js"))}`,
+  );
+
+  await updatePackageJson(options);
+
+  consola.success(`Updated ${cyan("package.json")}`);
+
+  await createIndexerFile(options);
+
+  consola.success(
+    `Created ${cyan(`${indexerFileId}.indexer.${language === "typescript" ? "ts" : "js"}`)}`,
+  );
+
+  await createStorageRelatedFiles(options);
+
+  console.log();
+
+  consola.info(
+    `Before running the indexer, run ${cyan(`${options.packageManager} run install`)}${
+      language === "typescript"
+        ? " & " + cyan(`${options.packageManager} run prepare`)
+        : ""
+    }`,
+  );
+}

package/src/create/colors.ts

@@ -0,0 +1,15 @@
+import colors from "picocolors";
+
+export const {
+  blue,
+  blueBright,
+  cyan,
+  gray,
+  green,
+  greenBright,
+  magenta,
+  red,
+  redBright,
+  reset,
+  yellow,
+} = colors;

package/src/create/constants.ts

@@ -0,0 +1,98 @@
+import { blue, green, red, yellow } from "./colors";
+import type { Chain, ColorFunc, Network } from "./types";
+
+export type ChainDataType = {
+  name: Chain;
+  display: string;
+  color: ColorFunc;
+  networks: NetworkDataType[];
+};
+
+export type NetworkDataType = {
+  name: Network;
+  display: string;
+  color: ColorFunc;
+};
+
+export type LanguageDataType = {
+  name: "typescript" | "javascript";
+  display: string;
+  color: ColorFunc;
+};
+
+export type StorageDataType = {
+  name: "postgres" | "none";
+  display: string;
+  color: ColorFunc;
+};
+
+export const chains: ChainDataType[] = [
+  {
+    name: "starknet",
+    display: "Starknet",
+    color: blue,
+    networks: [
+      { name: "mainnet", display: "Mainnet", color: blue },
+      { name: "sepolia", display: "Sepolia", color: yellow },
+    ],
+  },
+  {
+    name: "ethereum",
+    display: "Ethereum",
+    color: green,
+    networks: [
+      { name: "mainnet", display: "Mainnet", color: blue },
+      { name: "sepolia", display: "Sepolia", color: yellow },
+    ],
+  },
+  {
+    name: "beaconchain",
+    display: "Beacon Chain",
+    color: yellow,
+    networks: [{ name: "mainnet", display: "Mainnet", color: yellow }],
+  },
+];
+
+export const networks: NetworkDataType[] = [
+  { name: "mainnet", display: "Mainnet", color: blue },
+  { name: "sepolia", display: "Sepolia", color: green },
+  { name: "other", display: "Other", color: red },
+];
+
+export const storages: StorageDataType[] = [
+  { name: "postgres", display: "Postgres", color: green },
+  { name: "none", display: "None", color: red },
+];
+
+export const packageVersions = {
+  // Required Dependencies
+  apibara: "^2.1.0-beta.2",
+  "@apibara/indexer": "^2.1.0-beta.2",
+  "@apibara/protocol": "^2.1.0-beta.2",
+  // Chain Dependencies
+  "@apibara/evm": "^2.1.0-beta.2",
+  "@apibara/beaconchain": "^2.1.0-beta.2",
+  "@apibara/starknet": "^2.1.0-beta.2",
+  // 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",
+  // Postgres Dependencies
+  "@electric-sql/pglite": "^0.2.17",
+  "drizzle-orm": "^0.37.0",
+  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",
+};
+
+export const dnaUrls = {
+  ethereum: "https://ethereum.preview.apibara.org",
+  ethereumSepolia: "https://ethereum-sepolia.preview.apibara.org",
+  beaconchain: "https://beaconchain.preview.apibara.org",
+  starknet: "https://starknet.preview.apibara.org",
+  starknetSepolia: "https://starknet-sepolia.preview.apibara.org",
+};

package/src/create/index.ts

@@ -0,0 +1,2 @@
+export * from "./add";
+export * from "./init";