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

package/src/core/config/resolvers/runtime.resolver.ts

@@ -0,0 +1,44 @@
+import {
+  ENV_INTERNAL_APIBARA_PRESET,
+  ENV_INTERNAL_APIBARA_PRESETS,
+  ENV_INTERNAL_APIBARA_PROCESSED_RUNTIME,
+  ENV_INTERNAL_APIBARA_RUNTIME,
+  USER_ENV_APIBARA_RUNTIME_CONFIG,
+  getProcessedRuntimeConfig,
+} from "apibara/common";
+import type { ApibaraOptions } from "apibara/types";
+
+export function runtimeConfigResolver(options: Partial<ApibaraOptions>) {
+  try {
+    const { runtimeConfig, preset, presets } = options;
+
+    if (runtimeConfig) {
+      process.env[ENV_INTERNAL_APIBARA_RUNTIME] = JSON.stringify(runtimeConfig);
+    }
+    if (preset) {
+      process.env[ENV_INTERNAL_APIBARA_PRESET] = preset;
+    }
+
+    if (presets) {
+      process.env[ENV_INTERNAL_APIBARA_PRESETS] = JSON.stringify(presets);
+    }
+
+    const userEnvRuntimeConfig = JSON.parse(
+      process.env[USER_ENV_APIBARA_RUNTIME_CONFIG] ?? "{}",
+    );
+
+    // This is final processed runtime config that will be used by the indexer and useRuntimeConfig hook
+    process.env[ENV_INTERNAL_APIBARA_PROCESSED_RUNTIME] = JSON.stringify(
+      getProcessedRuntimeConfig({
+        preset,
+        presets,
+        runtimeConfig,
+        userEnvRuntimeConfig,
+      }),
+    );
+  } catch (error) {
+    throw new Error("Failed to process & set runtime environment variables", {
+      cause: error,
+    });
+  }
+}

package/src/core/config/update.ts

@@ -1,9 +1,13 @@
 import type { Apibara, ApibaraDynamicConfig } from "apibara/types";
+import { runtimeConfigResolver } from "./resolvers/runtime.resolver";
 
 export async function updateApibaraConfig(
   apibara: Apibara,
-  _config: ApibaraDynamicConfig,
+  newConfig: ApibaraDynamicConfig,
 ) {
-  await apibara.hooks.callHook("rollup:reload");
+  // applies new config values to env again during hot reload
+  runtimeConfigResolver(newConfig);
   apibara.logger.success("Apibara config hot reloaded!");
+  // we simply stop indexers and restart them with updated runtime values
+  await apibara.hooks.callHook("dev:reload");
 }

package/src/core/scan.ts

@@ -2,7 +2,7 @@ import type { Apibara } from "apibara/types";
 import fse from "fs-extra";
 import { basename, join } from "pathe";
 
-const INDEXER_EXTENSIONS = [".indexer.ts", ".indexer.js"];
+const INDEXER_EXTENSIONS = [".indexer.ts", ".indexer.js", ".indexer.mjs"];
 
 export async function scanIndexers(apibara: Apibara) {
   apibara.logger.debug("Scanning indexers");

package/src/create/add.ts

@@ -37,6 +37,7 @@ type Options = {
   argNetwork?: string;
   argStorage?: string;
   argDnaUrl?: string;
+  argRootDir?: string;
 };
 
 export async function addIndexer({
@@ -45,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.");
@@ -74,7 +77,7 @@ export async function addIndexer({
     }
   }
 
-  const language = getApibaraConfigLanguage(process.cwd());
+  const { language, extension } = getApibaraConfigLanguage(cwd);
 
   validateIndexerId(argIndexerId, true);
   validateChain(argChain, true);
@@ -92,14 +95,10 @@ export async function addIndexer({
         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`
+                  ? `Indexer ${cyan(`${id}.indexer.${extension}`)} already exists`
                   : true,
               )
             : "Invalid indexer ID, it cannot be empty and must be in kebab-case format",
@@ -197,7 +196,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!,
@@ -206,13 +205,12 @@ export async function addIndexer({
     dnaUrl: argDnaUrl ?? prompt_dnaUrl,
     language,
     packageManager: pkgManager.name,
+    extension,
   };
 
   await updateApibaraConfigFile(options);
 
-  consola.success(
-    `Updated ${cyan("apibara.config." + (language === "typescript" ? "ts" : "js"))}`,
-  );
+  consola.success(`Updated ${cyan(`apibara.config.${extension}`)}`);
 
   await updatePackageJson(options);
 
@@ -220,19 +218,15 @@ export async function addIndexer({
 
   await createIndexerFile(options);
 
-  consola.success(
-    `Created ${cyan(`${indexerFileId}.indexer.${language === "typescript" ? "ts" : "js"}`)}`,
-  );
+  consola.success(`Created ${cyan(`${indexerFileId}.indexer.${extension}`)}`);
 
   await createStorageRelatedFiles(options);
 
   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

@@ -67,7 +67,6 @@ export const storages: StorageDataType[] = [
 export const packageVersions = {
   // Required Dependencies
   apibara: "next",
-  "@apibara/indexer": "next",
   "@apibara/protocol": "next",
   // Chain Dependencies
   "@apibara/evm": "next",
@@ -79,20 +78,19 @@ export 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",
 };
 
 export 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",
 };

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,
@@ -129,7 +130,7 @@ export async function initializeProject({
     JSON.stringify(packageJson, null, 2) + "\n",
   );
   await formatFile(packageJsonPath);
-  consola.success("Created ", cyan("package.json"));
+  consola.success("Created", cyan("package.json"));
 
   // Generate tsconfig.json if TypeScript
   if (isTs) {
@@ -137,7 +138,7 @@ export async function initializeProject({
     const tsConfig = generateTsConfig();
     fs.writeFileSync(tsConfigPath, JSON.stringify(tsConfig, null, 2) + "\n");
     await formatFile(tsConfigPath);
-    consola.success("Created ", cyan("tsconfig.json"));
+    consola.success("Created", cyan("tsconfig.json"));
   }
 
   const apibaraConfigPath = path.join(root, `apibara.config.${configExt}`);
@@ -145,7 +146,7 @@ export async function initializeProject({
   const apibaraConfig = generateApibaraConfig(isTs);
   fs.writeFileSync(apibaraConfigPath, apibaraConfig);
   await formatFile(apibaraConfigPath);
-  consola.success("Created ", cyan(`apibara.config.${configExt}`));
+  consola.success("Created", cyan(`apibara.config.${configExt}`));
 
   // Create "indexers" directory if not exists
   const indexersDir = path.join(root, "indexers");
@@ -154,6 +155,8 @@ export async function initializeProject({
     consola.success(`Created ${cyan("indexers")} directory`);
   }
 
+  await createGitIgnoreFile(root);
+
   console.log("\n");
 
   consola.ready(green("Project initialized successfully"));
@@ -163,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,6 +1,7 @@
 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";
@@ -14,21 +15,18 @@ 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",
       ...(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,
       }),
@@ -58,17 +56,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,9 +69,10 @@ export function generateIndexer({
   chain,
   language,
 }: IndexerOptions) {
-  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";`
@@ -91,19 +83,16 @@ ${
         : ""
 }
 ${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];
+  const { startingBlock, streamUrl } = runtimeConfig["${indexerId}"];
   ${
     storage === "postgres"
-      ? "const { db } = getDrizzlePgDatabase(postgresConnectionString);"
+      ? `const db = drizzle({
+    schema,
+  });`
       : ""
   }
 
@@ -120,9 +109,9 @@ export default function (runtimeConfig${language === "typescript" ? ": ApibaraRu
     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();
 
@@ -136,14 +125,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}\`,
+      // });`
           : ""
       }
     },
@@ -156,7 +143,7 @@ export async function createIndexerFile(options: IndexerOptions) {
   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, {
@@ -227,20 +214,14 @@ export async function updateApibaraConfigFile({
   language,
   network,
   dnaUrl,
+  extension,
 }: IndexerOptions) {
-  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);
@@ -284,12 +265,16 @@ export async function updateApibaraConfigFile({
 }
 
 export async function createDrizzleStorageFiles(options: IndexerOptions) {
-  const { cwd, language, storage } = options;
+  const {
+    cwd,
+    language,
+    storage,
+    indexerId,
+    extension: fileExtension,
+  } = options;
 
   if (storage !== "postgres") return;
 
-  const fileExtension = language === "typescript" ? "ts" : "js";
-
   /**
    *
    *
@@ -312,11 +297,11 @@ 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" : ""};`;
 
@@ -347,14 +332,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 {};
@@ -366,64 +351,7 @@ export {};
 
     await formatFile(schemaPath);
 
-    consola.success(`Created ${cyan("lib/schema.ts")}`);
-  }
-
-  /**
-   *
-   *
-   * DB File
-   *
-   *
-   */
-  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 }) };
-}`;
-
-    // create directory if it doesn't exist
-    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");
@@ -440,22 +368,22 @@ export function getDrizzlePgDatabase(connectionString${language === "typescript"
     
 ${yellow(`
 ┌──────────────────────────────────────────┐
-│               lib/schema.ts              │
+│               lib/schema                 │
 └──────────────────────────────────────────┘
 
 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.`,
   );
 }
 
@@ -466,3 +394,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/types.ts

@@ -16,6 +16,8 @@ export type Network =
 
 export type Storage = "postgres" | "none";
 
+export type FileExtension = "js" | "ts" | "mjs";
+
 export type IndexerOptions = {
   cwd: string;
   indexerFileId: string;
@@ -26,6 +28,7 @@ export type IndexerOptions = {
   dnaUrl?: string;
   packageManager: string;
   language: Language;
+  extension: FileExtension;
 };
 
 export type PkgInfo = {