apibara 2.0.0-beta.40 → 2.0.0-beta.41

package/dist/rollup/index.d.mts

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

package/dist/rollup/index.d.ts

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "apibara",
-  "version": "2.0.0-beta.40",
+  "version": "2.0.0-beta.41",
   "type": "module",
   "main": "./dist/core/index.mjs",
   "exports": {
@@ -36,6 +36,10 @@
       "types": "./dist/runtime/index.d.ts",
       "import": "./dist/runtime/index.mjs"
     },
+    "./create": {
+      "types": "./dist/create/index.d.ts",
+      "import": "./dist/create/index.mjs"
+    },
     "./runtime/meta": {
       "types": "./runtime-meta.d.ts",
       "import": "./runtime-meta.mjs"
@@ -72,9 +76,10 @@
     "playground:start": "pnpm playground start --dir playground --indexer starknet"
   },
   "devDependencies": {
-    "@apibara/starknet": "2.0.0-beta.40",
+    "@apibara/starknet": "2.0.0-beta.41",
     "@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",
@@ -82,8 +87,8 @@
     "vitest": "^1.6.0"
   },
   "dependencies": {
-    "@apibara/indexer": "2.0.0-beta.40",
-    "@apibara/protocol": "2.0.0-beta.40",
+    "@apibara/indexer": "2.0.0-beta.41",
+    "@apibara/protocol": "2.0.0-beta.41",
     "@rollup/plugin-commonjs": "^26.0.1",
     "@rollup/plugin-json": "^6.1.0",
     "@rollup/plugin-node-resolve": "^15.2.3",
@@ -102,9 +107,12 @@
     "ohash": "^1.1.4",
     "pathe": "^1.1.2",
     "perfect-debounce": "^1.0.0",
+    "picocolors": "^1.1.1",
     "pkg-types": "^1.1.3",
+    "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/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/init.ts

@@ -0,0 +1,40 @@
+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",
+    },
+    "no-create-indexer": {
+      type: "boolean",
+      description: "Do not create an indexer after initialization",
+      default: false,
+    },
+  },
+  async run({ args }) {
+    const {
+      dir: targetDir,
+      "no-create-indexer": noCreateIndexer,
+      language,
+    } = args;
+
+    await initializeProject({
+      argTargetDir: targetDir,
+      argLanguage: language,
+      argNoCreateIndexer: noCreateIndexer,
+    });
+  },
+});

package/src/cli/index.ts

@@ -11,6 +11,8 @@ export const mainCli = defineCommand({
     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/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/create/add.ts

@@ -0,0 +1,225 @@
+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,
+  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) ||
+          "Invalid indexer ID 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,
+  };
+
+  updateApibaraConfigFile(options);
+
+  consola.success(
+    `Updated ${cyan("apibara.config." + (language === "typescript" ? "ts" : "js"))}`,
+  );
+
+  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.0.0-beta.40",
+  "@apibara/indexer": "^2.0.0-beta.40",
+  "@apibara/protocol": "^2.0.0-beta.40",
+  // Chain Dependencies
+  "@apibara/evm": "^2.0.0-beta.40",
+  "@apibara/beaconchain": "^2.0.0-beta.40",
+  "@apibara/starknet": "^2.0.0-beta.40",
+  // Storage Dependencies
+  "@apibara/plugin-drizzle": "^2.0.0-beta.40",
+  "@apibara/plugin-mongo": "^2.0.0-beta.40",
+  "@apibara/plugin-sqlite": "^2.0.0-beta.40",
+  // Postgres Dependencies
+  "@electric-sql/pglite": "^0.2.14",
+  "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";

package/src/create/init.ts

@@ -0,0 +1,164 @@
+import fs from "node:fs";
+import path from "node:path";
+import consola from "consola";
+import prompts from "prompts";
+import { addIndexer } from "./add";
+import { cyan, green } from "./colors";
+import {
+  generateApibaraConfig,
+  generatePackageJson,
+  generateTsConfig,
+} from "./templates";
+import type { Language } from "./types";
+import {
+  cancelOperation,
+  emptyDir,
+  getLanguageFromAlias,
+  getPackageManager,
+  isEmpty,
+  validateLanguage,
+} from "./utils";
+
+type Options = {
+  argTargetDir: string;
+  argLanguage?: string;
+  argNoCreateIndexer?: boolean;
+};
+
+export async function initializeProject({
+  argTargetDir,
+  argLanguage,
+  argNoCreateIndexer,
+}: Options) {
+  const cwd = process.cwd();
+  validateLanguage(argLanguage, true);
+
+  console.log();
+
+  const result = await prompts(
+    [
+      {
+        type: () =>
+          argTargetDir &&
+          (!fs.existsSync(argTargetDir) || isEmpty(argTargetDir))
+            ? null
+            : "select",
+        name: "overwrite",
+        message: () =>
+          (argTargetDir === "."
+            ? "Current directory"
+            : `Target directory "${argTargetDir}"`) +
+          " is not empty. Please choose how to proceed:",
+        initial: 0,
+        choices: [
+          {
+            title: "Cancel operation",
+            value: "no",
+          },
+          {
+            title: "Remove existing files and continue",
+            value: "yes",
+          },
+          {
+            title: "Ignore files and continue",
+            value: "ignore",
+          },
+        ],
+        hint: "\nCurrent Working Directory: " + cwd,
+      },
+      {
+        type: (_, { overwrite }: { overwrite?: string }) => {
+          if (overwrite === "no") {
+            cancelOperation();
+          }
+          return null;
+        },
+        name: "overwriteChecker",
+      },
+      {
+        type: argLanguage ? null : "select",
+        name: "prompt_language",
+        message: "Select a language:",
+        choices: [
+          {
+            title: "Typescript",
+            value: "typescript",
+          },
+          {
+            title: "Javascript",
+            value: "javascript",
+          },
+        ],
+      },
+    ],
+    {
+      onCancel: () => {
+        cancelOperation();
+      },
+    },
+  );
+
+  const { overwrite, prompt_language } = result as {
+    overwrite: "no" | "yes" | "ignore";
+    prompt_language: "typescript" | "javascript";
+  };
+
+  const root = path.join(cwd, argTargetDir);
+  if (overwrite === "yes") {
+    emptyDir(root);
+  } else if (!fs.existsSync(root)) {
+    fs.mkdirSync(root, { recursive: true });
+  }
+
+  const lang: Language = argLanguage
+    ? getLanguageFromAlias(argLanguage)
+    : prompt_language;
+
+  const isTs = lang === "typescript";
+  const configExt = isTs ? "ts" : "js";
+
+  console.log("\n");
+  consola.info(`Initializing project in ${argTargetDir}\n\n`);
+
+  // Generate package.json
+  const packageJson = generatePackageJson(isTs);
+  fs.writeFileSync(
+    path.join(root, "package.json"),
+    JSON.stringify(packageJson, null, 2) + "\n",
+  );
+  consola.success("Created ", cyan("package.json"));
+
+  // Generate tsconfig.json if TypeScript
+  if (isTs) {
+    const tsConfig = generateTsConfig();
+    fs.writeFileSync(
+      path.join(root, "tsconfig.json"),
+      JSON.stringify(tsConfig, null, 2) + "\n",
+    );
+    consola.success("Created ", cyan("tsconfig.json"));
+  }
+
+  // Generate apibara.config
+  const apibaraConfig = generateApibaraConfig(isTs);
+  fs.writeFileSync(
+    path.join(root, `apibara.config.${configExt}`),
+    apibaraConfig,
+  );
+  consola.success("Created ", cyan(`apibara.config.${configExt}`), "\n\n");
+  consola.ready(green("Project initialized successfully"));
+
+  console.log();
+
+  if (!argNoCreateIndexer) {
+    consola.info("Let's create an indexer\n");
+
+    await addIndexer({});
+  } else {
+    const pkgManager = getPackageManager();
+    consola.info(
+      "Run ",
+      green(`${pkgManager.name} run install`),
+      " to install all dependencies",
+    );
+  }
+}