apibara 2.1.0-beta.1 → 2.1.0-beta.10

package/src/create/add.ts

@@ -1,3 +1,4 @@
+import path from "node:path";
 import consola from "consola";
 import prompts from "prompts";
 import { cyan, red, reset } from "./colors";
@@ -18,6 +19,7 @@ import {
 import type { Chain, IndexerOptions, Network, Storage } from "./types";
 import {
   cancelOperation,
+  checkFileExists,
   convertKebabToCamelCase,
   getApibaraConfigLanguage,
   getPackageManager,
@@ -35,6 +37,7 @@ type Options = {
   argNetwork?: string;
   argStorage?: string;
   argDnaUrl?: string;
+  argRootDir?: string;
 };
 
 export async function addIndexer({
@@ -43,8 +46,10 @@ export async function addIndexer({
   argNetwork,
   argStorage,
   argDnaUrl,
+  argRootDir,
 }: Options) {
-  const configExists = hasApibaraConfig(process.cwd());
+  const cwd = path.join(process.cwd(), argRootDir ?? ".");
+  const configExists = hasApibaraConfig(cwd);
 
   if (!configExists) {
     consola.error("No apibara.config found in the current directory.");
@@ -72,7 +77,7 @@ export async function addIndexer({
     }
   }
 
-  const language = getApibaraConfigLanguage(process.cwd());
+  const language = getApibaraConfigLanguage(cwd);
 
   validateIndexerId(argIndexerId, true);
   validateChain(argChain, true);
@@ -88,8 +93,19 @@ export async function addIndexer({
         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",
+          validateIndexerId(id)
+            ? checkFileExists(
+                path.join(
+                  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",
@@ -184,7 +200,7 @@ export async function addIndexer({
   const pkgManager = getPackageManager();
 
   const options: IndexerOptions = {
-    cwd: process.cwd(),
+    cwd: cwd,
     indexerFileId,
     indexerId: convertKebabToCamelCase(indexerFileId),
     chain: (argChain as Chain) ?? prompt_chain?.name!,
@@ -195,13 +211,13 @@ export async function addIndexer({
     packageManager: pkgManager.name,
   };
 
-  updateApibaraConfigFile(options);
+  await updateApibaraConfigFile(options);
 
   consola.success(
     `Updated ${cyan("apibara.config." + (language === "typescript" ? "ts" : "js"))}`,
   );
 
-  updatePackageJson(options);
+  await updatePackageJson(options);
 
   consola.success(`Updated ${cyan("package.json")}`);
 
@@ -215,11 +231,9 @@ export async function addIndexer({
 
   console.log();
 
+  const baseCommand = `${options.packageManager} install`;
+  const tsCommand = `${baseCommand} && ${options.packageManager} run prepare`;
   consola.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/src/create/constants.ts

@@ -66,17 +66,17 @@ export const storages: StorageDataType[] = [
 
 export const packageVersions = {
   // Required Dependencies
-  apibara: "^2.1.0-beta.1",
-  "@apibara/indexer": "^2.1.0-beta.1",
-  "@apibara/protocol": "^2.1.0-beta.1",
+  apibara: "next",
+  "@apibara/indexer": "next",
+  "@apibara/protocol": "next",
   // Chain Dependencies
-  "@apibara/evm": "^2.1.0-beta.1",
-  "@apibara/beaconchain": "^2.1.0-beta.1",
-  "@apibara/starknet": "^2.1.0-beta.1",
+  "@apibara/evm": "next",
+  "@apibara/beaconchain": "next",
+  "@apibara/starknet": "next",
   // Storage Dependencies
-  "@apibara/plugin-drizzle": "^2.1.0-beta.1",
-  "@apibara/plugin-mongo": "^2.1.0-beta.1",
-  "@apibara/plugin-sqlite": "^2.1.0-beta.1",
+  "@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",
@@ -85,7 +85,6 @@ export const packageVersions = {
   "drizzle-kit": "^0.29.0",
   // Typescript Dependencies
   typescript: "^5.6.2",
-  "@rollup/plugin-typescript": "^11.1.6",
   "@types/node": "^20.5.2",
 };
 

package/src/create/init.ts

@@ -5,6 +5,7 @@ import prompts from "prompts";
 import { addIndexer } from "./add";
 import { cyan, green } from "./colors";
 import {
+  createGitIgnoreFile,
   generateApibaraConfig,
   generatePackageJson,
   generateTsConfig,
@@ -13,6 +14,7 @@ import type { Language } from "./types";
 import {
   cancelOperation,
   emptyDir,
+  formatFile,
   getLanguageFromAlias,
   getPackageManager,
   isEmpty,
@@ -121,30 +123,42 @@ export async function initializeProject({
   consola.info(`Initializing project in ${argTargetDir}\n\n`);
 
   // Generate package.json
+  const packageJsonPath = path.join(root, "package.json");
   const packageJson = generatePackageJson(isTs);
   fs.writeFileSync(
-    path.join(root, "package.json"),
+    packageJsonPath,
     JSON.stringify(packageJson, null, 2) + "\n",
   );
-  consola.success("Created ", cyan("package.json"));
+  await formatFile(packageJsonPath);
+  consola.success("Created", cyan("package.json"));
 
   // Generate tsconfig.json if TypeScript
   if (isTs) {
+    const tsConfigPath = path.join(root, "tsconfig.json");
     const tsConfig = generateTsConfig();
-    fs.writeFileSync(
-      path.join(root, "tsconfig.json"),
-      JSON.stringify(tsConfig, null, 2) + "\n",
-    );
-    consola.success("Created ", cyan("tsconfig.json"));
+    fs.writeFileSync(tsConfigPath, JSON.stringify(tsConfig, null, 2) + "\n");
+    await formatFile(tsConfigPath);
+    consola.success("Created", cyan("tsconfig.json"));
   }
 
+  const apibaraConfigPath = path.join(root, `apibara.config.${configExt}`);
   // 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");
+  fs.writeFileSync(apibaraConfigPath, apibaraConfig);
+  await formatFile(apibaraConfigPath);
+  consola.success("Created", cyan(`apibara.config.${configExt}`));
+
+  // Create "indexers" directory if not exists
+  const indexersDir = path.join(root, "indexers");
+  if (!fs.existsSync(indexersDir)) {
+    fs.mkdirSync(indexersDir, { recursive: true });
+    consola.success(`Created ${cyan("indexers")} directory`);
+  }
+
+  await createGitIgnoreFile(root);
+
+  console.log("\n");
+
   consola.ready(green("Project initialized successfully"));
 
   console.log();
@@ -152,12 +166,12 @@ export async function initializeProject({
   if (!argNoCreateIndexer) {
     consola.info("Let's create an indexer\n");
 
-    await addIndexer({});
+    await addIndexer({ argRootDir: argTargetDir });
   } else {
     const pkgManager = getPackageManager();
     consola.info(
       "Run ",
-      green(`${pkgManager.name} run install`),
+      green(`${pkgManager.name} install`),
       " to install all dependencies",
     );
   }

package/src/create/templates.ts

@@ -1,11 +1,12 @@
 import fs from "node:fs";
 import path from "node:path";
 import { consola } from "consola";
+import prompts from "prompts";
 import { type ObjectLiteralExpression, Project, SyntaxKind } from "ts-morph";
 import { cyan, green, magenta, yellow } from "./colors";
 import { packageVersions } from "./constants";
 import type { IndexerOptions } from "./types";
-import { checkFileExists, getDnaUrl } from "./utils";
+import { checkFileExists, formatFile, getDnaUrl } from "./utils";
 
 export function generatePackageJson(isTypeScript: boolean) {
   return {
@@ -14,7 +15,7 @@ export function generatePackageJson(isTypeScript: boolean) {
     private: true,
     type: "module",
     scripts: {
-      prepare: "apibara prepare",
+      ...(isTypeScript && { prepare: "apibara prepare" }),
       dev: "apibara dev",
       start: "apibara start",
       build: "apibara build",
@@ -27,8 +28,6 @@ export function generatePackageJson(isTypeScript: boolean) {
     },
     devDependencies: {
       ...(isTypeScript && {
-        "@rollup/plugin-typescript":
-          packageVersions["@rollup/plugin-typescript"],
         "@types/node": packageVersions["@types/node"],
         typescript: packageVersions.typescript,
       }),
@@ -58,17 +57,10 @@ export function generateTsConfig() {
 }
 
 export function generateApibaraConfig(isTypeScript: boolean) {
-  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: {},
 });\n`;
 }
 
@@ -78,24 +70,21 @@ export function generateIndexer({
   chain,
   language,
 }: IndexerOptions) {
-  return `${
-    chain === "ethereum"
-      ? `import { EvmStream } from "@apibara/evm";`
-      : chain === "beaconchain"
-        ? `import { BeaconChainStream } from "@apibara/beaconchain";`
-        : chain === "starknet"
-          ? `import { StarknetStream } from "@apibara/starknet";`
-          : ""
-  }
-import { defineIndexer } from "@apibara/indexer";
-${storage === "postgres" ? `import { drizzleStorage } from "@apibara/plugin-drizzle";` : ""}
-${language === "typescript" ? `import type { ApibaraRuntimeConfig } from "apibara/types";` : ""}
+  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";` : ""}
 ${
-  storage === "postgres"
-    ? `import { getDrizzlePgDatabase } from "../lib/db";`
-    : ""
+  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 * as schema from "../lib/schema";` : ""}
 
 
 export default function (runtimeConfig${language === "typescript" ? ": ApibaraRuntimeConfig" : ""}) {
@@ -103,7 +92,10 @@ export default function (runtimeConfig${language === "typescript" ? ": ApibaraRu
   const { startingBlock, streamUrl${storage === "postgres" ? ", postgresConnectionString" : ""} } = runtimeConfig[indexerId];
   ${
     storage === "postgres"
-      ? "const { db } = getDrizzlePgDatabase(postgresConnectionString);"
+      ? `const db = drizzle({
+    schema,
+    connectionString: postgresConnectionString,
+  });`
       : ""
   }
 
@@ -122,7 +114,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();
 
@@ -136,14 +128,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}\`,
+      // });`
           : ""
       }
     },
@@ -169,17 +159,19 @@ export async function createIndexerFile(options: IndexerOptions) {
 
   fs.mkdirSync(path.dirname(indexerFilePath), { recursive: true });
   fs.writeFileSync(indexerFilePath, indexerContent);
+
+  await formatFile(indexerFilePath);
 }
 
-export function updatePackageJson({
+export async function updatePackageJson({
   cwd,
   chain,
   storage,
   language,
 }: IndexerOptions) {
-  const packageJson = JSON.parse(
-    fs.readFileSync(path.join(cwd, "package.json"), "utf8"),
-  );
+  const packageJsonPath = path.join(cwd, "package.json");
+
+  const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf8"));
 
   if (chain === "ethereum") {
     packageJson.dependencies["@apibara/evm"] = packageVersions["@apibara/evm"];
@@ -212,13 +204,12 @@ export function updatePackageJson({
     }
   }
 
-  fs.writeFileSync(
-    path.join(cwd, "package.json"),
-    JSON.stringify(packageJson, null, 2),
-  );
+  fs.writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, 2));
+
+  await formatFile(packageJsonPath);
 }
 
-export function updateApibaraConfigFile({
+export async function updateApibaraConfigFile({
   indexerId,
   cwd,
   chain,
@@ -279,15 +270,11 @@ export function updateApibaraConfigFile({
   // Save the changes
   sourceFile.saveSync();
 
-  sourceFile.formatText({
-    tabSize: 2,
-    insertSpaceAfterOpeningAndBeforeClosingEmptyBraces: true,
-    insertSpaceAfterOpeningAndBeforeClosingNonemptyBraces: true,
-  });
+  await formatFile(pathToConfig);
 }
 
 export async function createDrizzleStorageFiles(options: IndexerOptions) {
-  const { cwd, language, storage } = options;
+  const { cwd, language, storage, indexerId } = options;
 
   if (storage !== "postgres") return;
 
@@ -315,16 +302,18 @@ export async function createDrizzleStorageFiles(options: IndexerOptions) {
     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);
 
+    await formatFile(drizzleConfigPath);
+
     consola.success(`Created ${cyan(drizzleConfigFileName)}`);
   }
 
@@ -348,14 +337,14 @@ export default {
     });
 
   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 {};
@@ -365,62 +354,9 @@ export {};
     fs.mkdirSync(path.dirname(schemaPath), { recursive: true });
     fs.writeFileSync(schemaPath, schemaContent);
 
-    consola.success(`Created ${cyan("lib/schema.ts")}`);
-  }
-
-  /**
-   *
-   *
-   * DB File
-   *
-   *
-   */
-  const dbFileName = `db.${fileExtension}`;
-
-  const dbPath = path.join(cwd, "lib", dbFileName);
+    await formatFile(schemaPath);
 
-  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 }) };
-}`;
-
-    // create directory if it doesn't exist
-    fs.mkdirSync(path.dirname(dbPath), { recursive: true });
-    fs.writeFileSync(dbPath, dbContent);
-
-    consola.success(`Created ${cyan(`lib/${dbFileName}`)}`);
+    consola.success(`Created ${cyan("lib/schema.ts")}`);
   }
 
   console.log("\n");
@@ -442,17 +378,17 @@ ${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.`,
   );
 }
 
@@ -463,3 +399,103 @@ export async function createStorageRelatedFiles(options: IndexerOptions) {
     await createDrizzleStorageFiles(options);
   }
 }
+
+const gitIgnoreItems: {
+  isRecommended: boolean;
+  description?: string;
+  value: string;
+}[] = [
+  {
+    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",
+  },
+];
+
+export async function createGitIgnoreFile(cwd: string) {
+  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: (overwrite: "append" | "ignore" | "overwrite") =>
+          overwrite === "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 as {
+      overwrite: "append" | "ignore" | "overwrite";
+      ignoreItems: string[];
+    };
+
+    if (overwrite === "append" && ignoreItems.length > 0) {
+      const gitIgnoreContent = fs.readFileSync(gitIgnorePath, "utf8");
+      fs.writeFileSync(
+        gitIgnorePath,
+        `${gitIgnoreContent}\n${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")}`);
+}

package/src/create/utils.ts

@@ -1,5 +1,6 @@
 import fs from "node:fs";
 import path, { basename } from "node:path";
+import * as prettier from "prettier";
 import prompts from "prompts";
 import { blue, cyan, red, yellow } from "./colors";
 import { dnaUrls, networks } from "./constants";
@@ -410,3 +411,12 @@ function pkgFromUserAgent(userAgent: string | undefined): PkgInfo | undefined {
     version: pkgSpecArr[1],
   };
 }
+
+export async function formatFile(path: string) {
+  const file = fs.readFileSync(path, "utf8");
+  const formatted = await prettier.format(file, {
+    filepath: path,
+    tabWidth: 2,
+  });
+  fs.writeFileSync(path, formatted);
+}