apibara 2.1.0-beta.4 → 2.1.0-beta.40

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 = [
   {
@@ -58,7 +45,6 @@ const storages = [
 const packageVersions = {
   // Required Dependencies
   apibara: "next",
-  "@apibara/indexer": "next",
   "@apibara/protocol": "next",
   // Chain Dependencies
   "@apibara/evm": "next",
@@ -70,21 +56,20 @@ const packageVersions = {
   "@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 = {
-  ethereum: "https://ethereum.preview.apibara.org",
-  ethereumSepolia: "https://ethereum-sepolia.preview.apibara.org",
+  ethereum: "https://mainnet.ethereum.a5a.ch",
+  ethereumSepolia: "https://sepolia.ethereum.a5a.ch",
   beaconchain: "https://beaconchain.preview.apibara.org",
-  starknet: "https://starknet.preview.apibara.org",
-  starknetSepolia: "https://starknet-sepolia.preview.apibara.org"
+  starknet: "https://mainnet.starknet.a5a.ch",
+  starknetSepolia: "https://sepolia.starknet.a5a.ch"
 };
 
 function isEmpty(path2) {
@@ -106,7 +91,7 @@ function validateLanguage(language, throwError = false) {
   if (!language) {
     return false;
   }
-  if (language === "typescript" || language === "ts" || language === "javascript" || language === "js") {
+  if (language === "typescript" || language === "ts" || language === "javascript" || language === "js" || language === "mjs") {
     return true;
   }
   if (throwError) {
@@ -120,7 +105,7 @@ function getLanguageFromAlias(alias) {
   if (alias === "ts" || alias === "typescript") {
     return "typescript";
   }
-  if (alias === "js" || alias === "javascript") {
+  if (alias === "js" || alias === "javascript" || alias === "mjs") {
     return "javascript";
   }
   throw new Error(
@@ -240,16 +225,21 @@ function validateDnaUrl(dnaUrl, throwError = false) {
 function hasApibaraConfig(cwd) {
   const configPathJS = path.join(cwd, "apibara.config.js");
   const configPathTS = path.join(cwd, "apibara.config.ts");
-  return fs.existsSync(configPathJS) || fs.existsSync(configPathTS);
+  const configPathMJS = path.join(cwd, "apibara.config.mjs");
+  return fs.existsSync(configPathJS) || fs.existsSync(configPathTS) || fs.existsSync(configPathMJS);
 }
 function getApibaraConfigLanguage(cwd) {
   const configPathJS = path.join(cwd, "apibara.config.js");
   const configPathTS = path.join(cwd, "apibara.config.ts");
+  const configPathMJS = path.join(cwd, "apibara.config.mjs");
+  if (fs.existsSync(configPathMJS)) {
+    return { language: "javascript", extension: "mjs" };
+  }
   if (fs.existsSync(configPathJS)) {
-    return "javascript";
+    return { language: "javascript", extension: "js" };
   }
   if (fs.existsSync(configPathTS)) {
-    return "typescript";
+    return { language: "typescript", extension: "ts" };
   }
   throw new Error(red("\u2716") + " No apibara.config found");
 }
@@ -386,20 +376,18 @@ function generatePackageJson(isTypeScript) {
     private: true,
     type: "module",
     scripts: {
-      prepare: "apibara prepare",
+      ...isTypeScript && { prepare: "apibara prepare" },
       dev: "apibara dev",
       start: "apibara start",
       build: "apibara build",
       ...isTypeScript && { typecheck: "tsc --noEmit" }
     },
     dependencies: {
-      "@apibara/indexer": packageVersions["@apibara/indexer"],
       "@apibara/protocol": packageVersions["@apibara/protocol"],
       apibara: packageVersions.apibara
     },
     devDependencies: {
       ...isTypeScript && {
-        "@rollup/plugin-typescript": packageVersions["@rollup/plugin-typescript"],
         "@types/node": packageVersions["@types/node"],
         typescript: packageVersions.typescript
       }
@@ -427,13 +415,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: {},
 });
 `;
 }
@@ -443,27 +428,29 @@ function generateIndexer({
   chain,
   language
 }) {
-  return `import { defineIndexer } from "@apibara/indexer";
-import { useLogger } from "@apibara/indexer/plugins";
+  return `import { defineIndexer } from "apibara/indexer";
+import { useLogger } from "apibara/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,
     finality: "accepted",
     startingBlock: BigInt(startingBlock),
     filter: {
-      header: "always",
+      ${chain === "ethereum" ? "logs: []," : chain === "starknet" ? "events:  []," : ""}
     },
-    plugins: [${storage === "postgres" ? "drizzleStorage({ db, persistState: true })" : ""}],
+    plugins: [${storage === "postgres" ? "drizzleStorage({ db, migrate: { migrationsFolder: './drizzle' } })" : ""}],
     async transform({ endCursor, finality }) {
       const logger = useLogger();
 
@@ -475,14 +462,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}\`,
+      // });` : ""}
     },
   });
 }   
@@ -492,7 +477,7 @@ async function createIndexerFile(options) {
   const indexerFilePath = path.join(
     options.cwd,
     "indexers",
-    `${options.indexerFileId}.indexer.${options.language === "typescript" ? "ts" : "js"}`
+    `${options.indexerFileId}.indexer.${options.extension}`
   );
   const { exists, overwrite } = await checkFileExists(indexerFilePath, {
     askPrompt: true
@@ -541,16 +526,14 @@ async function updateApibaraConfigFile({
   storage,
   language,
   network,
-  dnaUrl
+  dnaUrl,
+  extension
 }) {
-  const pathToConfig = path.join(
-    cwd,
-    `apibara.config.${language === "typescript" ? "ts" : "js"}`
-  );
+  const pathToConfig = path.join(cwd, `apibara.config.${extension}`);
   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,10 +564,15 @@ async function updateApibaraConfigFile({
   await formatFile(pathToConfig);
 }
 async function createDrizzleStorageFiles(options) {
-  const { cwd, language, storage } = options;
+  const {
+    cwd,
+    language,
+    storage,
+    indexerId,
+    extension: fileExtension
+  } = options;
   if (storage !== "postgres")
     return;
-  const fileExtension = language === "typescript" ? "ts" : "js";
   const drizzleConfigFileName = `drizzle.config.${fileExtension}`;
   const drizzleConfigPath = path.join(cwd, drizzleConfigFileName);
   const { exists, overwrite } = await checkFileExists(drizzleConfigPath, {
@@ -595,11 +583,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 +602,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 {};
@@ -629,49 +617,7 @@ export {};
     fs.mkdirSync(path.dirname(schemaPath), { recursive: true });
     fs.writeFileSync(schemaPath, schemaContent);
     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}`)}`);
+    consola.success(`Created ${cyan(`lib/${schemaFileName}`)}`);
   }
   console.log("\n");
   if (!schemaExists || schemaOverwrite) {
@@ -683,20 +629,20 @@ export function getDrizzlePgDatabase(connectionString${language === "typescript"
     
 ${yellow(`
 \u250C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510
-\u2502               lib/schema.ts              \u2502
+\u2502               lib/schema                 \u2502
 \u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518
 
 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 +651,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 +819,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 +859,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 +887,7 @@ async function addIndexer({
       );
     }
   }
-  const language = getApibaraConfigLanguage(process.cwd());
+  const { language, extension } = getApibaraConfigLanguage(cwd);
   validateIndexerId(argIndexerId, true);
   validateChain(argChain, true);
   validateNetwork(argChain, argNetwork, true);
@@ -868,13 +901,9 @@ async function addIndexer({
         message: reset("Indexer ID:"),
         initial: argIndexerId ?? "my-indexer",
         validate: (id) => validateIndexerId(id) ? checkFileExists(
-          path.join(
-            process.cwd(),
-            "indexers",
-            `${id}.indexer.${language === "typescript" ? "ts" : "js"}`
-          )
+          path.join(cwd, "indexers", `${id}.indexer.${extension}`)
         ).then(
-          ({ exists }) => exists ? `Indexer ${cyan(`${id}.indexer.${language === "typescript" ? "ts" : "js"}`)} already exists` : true
+          ({ exists }) => exists ? `Indexer ${cyan(`${id}.indexer.${extension}`)} already exists` : true
         ) : "Invalid indexer ID, it cannot be empty and must be in kebab-case format"
       },
       {
@@ -951,7 +980,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,
@@ -959,23 +988,23 @@ async function addIndexer({
     storage: argStorage ?? prompt_storage?.name,
     dnaUrl: argDnaUrl ?? prompt_dnaUrl,
     language,
-    packageManager: pkgManager.name
+    packageManager: pkgManager.name,
+    extension
   };
   await updateApibaraConfigFile(options);
-  consola$1.success(
-    `Updated ${cyan("apibara.config." + (language === "typescript" ? "ts" : "js"))}`
-  );
+  consola$1.success(`Updated ${cyan(`apibara.config.${extension}`)}`);
   await updatePackageJson(options);
   consola$1.success(`Updated ${cyan("package.json")}`);
   await createIndexerFile(options);
-  consola$1.success(
-    `Created ${cyan(`${indexerFileId}.indexer.${language === "typescript" ? "ts" : "js"}`)}`
-  );
+  consola$1.success(`Created ${cyan(`${indexerFileId}.indexer.${extension}`)}`);
   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)}`
   );
 }
 
 export { addIndexer, initializeProject };
+//# sourceMappingURL=index.mjs.map