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

package/dist/chunks/add.mjs

@@ -0,0 +1,44 @@
+import { addIndexer } from 'apibara/create';
+import { defineCommand } from 'citty';
+
+const add = 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
+    });
+  }
+});
+
+export { add as default };

package/dist/chunks/build.mjs

@@ -1,7 +1,7 @@
 import { createApibara, prepare, writeTypes, build as build$1 } from 'apibara/core';
+import { runtimeDir } from 'apibara/runtime/meta';
 import { defineCommand } from 'citty';
-import consola__default from 'consola';
-import { resolve } from 'pathe';
+import { resolve, join } from 'pathe';
 import { c as commonArgs } from '../shared/apibara.1b515d04.mjs';
 
 const build = defineCommand({
@@ -13,11 +13,11 @@ const build = defineCommand({
     ...commonArgs
   },
   async run({ args }) {
-    consola__default.start("Building");
     const rootDir = resolve(args.dir || args._dir || ".");
     const apibara = await createApibara({
       rootDir
     });
+    apibara.options.entry = join(runtimeDir, "start.mjs");
     await prepare(apibara);
     await writeTypes(apibara);
     await build$1(apibara);

package/dist/chunks/dev.mjs

@@ -1,12 +1,12 @@
 import { spawn } from 'node:child_process';
 import { createApibara, prepare, writeTypes, build } from 'apibara/core';
+import { runtimeDir } from 'apibara/runtime/meta';
 import { defineCommand } from 'citty';
-import consola__default from 'consola';
-import { resolve } from 'pathe';
+import { colors } from 'consola/utils';
+import { resolve, join } from 'pathe';
 import { c as commonArgs } from '../shared/apibara.1b515d04.mjs';
 
 const hmrKeyRe = /^runtimeConfig\./;
-let childProcess;
 const dev = defineCommand({
   meta: {
     name: "dev",
@@ -21,19 +21,15 @@ const dev = defineCommand({
     preset: {
       type: "string",
       description: "Preset to use"
-    },
-    sink: {
-      type: "string",
-      description: "Sink to use"
     }
   },
   async run({ args }) {
-    consola__default.start("Starting dev server");
     const rootDir = resolve(args.dir || args._dir || ".");
     let apibara;
+    let childProcess;
     const reload = async () => {
       if (apibara) {
-        consola__default.info("Restarting dev server");
+        apibara.logger.info("Restarting dev server");
         if ("unwatch" in apibara.options._c12) {
           await apibara.options._c12.unwatch();
         }
@@ -51,8 +47,8 @@ const dev = defineCommand({
               if (diff.length === 0) {
                 return;
               }
-              consola__default.info(
-                `Nitro config updated:
+              apibara.logger.info(
+                `Config updated:
                   ${diff.map((entry) => `  ${entry.toString()}`).join("\n")}`
               );
               await (diff.every((e) => hmrKeyRe.test(e.key)) ? apibara.updateConfig(newConfig.config || {}) : reload());
@@ -62,29 +58,37 @@ const dev = defineCommand({
         true
       );
       apibara.hooks.hookOnce("restart", reload);
+      apibara.options.entry = join(runtimeDir, "dev.mjs");
       await prepare(apibara);
       await writeTypes(apibara);
       await build(apibara);
+      apibara.hooks.hook("dev:restart", () => {
+        if (childProcess) {
+          apibara.logger.info("Change detected, stopping indexers to restart");
+          childProcess.kill();
+          childProcess = void 0;
+        }
+      });
       apibara.hooks.hook("dev:reload", () => {
         if (childProcess) {
-          consola__default.start("Restarting indexers");
           childProcess.kill();
         } else {
-          consola__default.success("Dev server started");
-          consola__default.success("Starting indexers");
+          apibara.logger.success("Restarting indexers");
         }
         const childArgs = [
-          resolve(apibara.options.outputDir || "./.apibara/build", "main.mjs"),
+          resolve(apibara.options.outputDir || "./.apibara/build", "dev.mjs"),
+          "start",
           ...args.indexers ? ["--indexers", args.indexers] : [],
-          ...args.preset ? ["--preset", args.preset] : [],
-          ...args.sink ? ["--sink", args.sink] : []
+          ...args.preset ? ["--preset", args.preset] : []
         ];
         childProcess = spawn("node", childArgs, {
           stdio: "inherit"
         });
         childProcess.on("close", (code) => {
           if (code !== null) {
-            consola__default.log(`Indexers process exited with code ${code}`);
+            apibara.logger.log(
+              `Indexers process exited with code ${colors.red(code)}`
+            );
           }
         });
       });

package/dist/chunks/init.mjs

@@ -0,0 +1,37 @@
+import { initializeProject } from 'apibara/create';
+import { defineCommand } from 'citty';
+
+const init = 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"
+    },
+    noIndexer: {
+      type: "boolean",
+      description: "Do not create an indexer after initialization",
+      default: false
+    }
+  },
+  async run({ args }) {
+    const { dir: targetDir, noIndexer, language } = args;
+    await initializeProject({
+      argTargetDir: targetDir,
+      argLanguage: language,
+      argNoCreateIndexer: noIndexer
+    });
+  }
+});
+
+export { init as default };

package/dist/chunks/prepare.mjs

@@ -1,6 +1,5 @@
 import { createApibara, writeTypes } from 'apibara/core';
 import { defineCommand } from 'citty';
-import consola__default from 'consola';
 import { resolve } from 'pathe';
 import { c as commonArgs } from '../shared/apibara.1b515d04.mjs';
 
@@ -13,7 +12,6 @@ const prepare = defineCommand({
     ...commonArgs
   },
   async run({ args }) {
-    consola__default.start("Preparing Types");
     const rootDir = resolve(args.dir || ".");
     const apibara = await createApibara({ rootDir });
     await writeTypes(apibara);

package/dist/chunks/start.mjs

@@ -0,0 +1,56 @@
+import { spawn } from 'node:child_process';
+import { createApibara } from 'apibara/core';
+import { defineCommand } from 'citty';
+import fse from 'fs-extra';
+import { resolve } from 'pathe';
+import { c as commonArgs } from '../shared/apibara.1b515d04.mjs';
+
+const start = defineCommand({
+  meta: {
+    name: "start",
+    description: "Start one indexer"
+  },
+  args: {
+    ...commonArgs,
+    indexer: {
+      type: "string",
+      description: "The indexer to start",
+      required: true
+    },
+    preset: {
+      type: "string",
+      description: "The preset to use"
+    }
+  },
+  async run({ args }) {
+    const { indexer, preset } = args;
+    const rootDir = resolve(args.dir || args._dir || ".");
+    const apibara = await createApibara({
+      rootDir
+    });
+    apibara.logger.start(
+      `Starting indexer ${indexer}${preset ? ` with preset ${preset}` : ""}`
+    );
+    const outputDir = apibara.options.outputDir || "./.apibara/build";
+    const entry = resolve(outputDir, "start.mjs");
+    if (!fse.existsSync(entry)) {
+      apibara.logger.error(
+        `Output directory ${outputDir} does not exist. Try building the indexer with "apibara build" first.`
+      );
+      return process.exit(1);
+    }
+    await apibara.close();
+    const childArgs = [
+      entry,
+      "start",
+      "--indexer",
+      indexer,
+      ...preset ? ["--preset", preset] : []
+    ];
+    spawn("node", childArgs, {
+      stdio: "inherit"
+    });
+  }
+});
+
+export { start as default };

package/dist/cli/index.mjs

@@ -1,3 +1,4 @@
+#!/usr/bin/env node
 import { defineCommand, runMain } from 'citty';
 
 const mainCli = defineCommand({
@@ -9,7 +10,10 @@ const mainCli = defineCommand({
   subCommands: {
     dev: () => import('../chunks/dev.mjs').then((r) => r.default),
     build: () => import('../chunks/build.mjs').then((r) => r.default),
-    prepare: () => import('../chunks/prepare.mjs').then((r) => r.default)
+    start: () => import('../chunks/start.mjs').then((r) => r.default),
+    prepare: () => import('../chunks/prepare.mjs').then((r) => r.default),
+    init: () => import('../chunks/init.mjs').then((r) => r.default),
+    add: () => import('../chunks/add.mjs').then((r) => r.default)
   }
 });
 runMain(mainCli);

package/dist/config/index.d.mts

@@ -1,5 +1,5 @@
 import { DeepPartial, ApibaraConfig } from 'apibara/types';
 
-declare function defineConfig<T extends Record<string, DeepPartial<ApibaraConfig<T, R>>> = {}, R extends Record<string, unknown> = {}>(config: ApibaraConfig<T, R>): ApibaraConfig<T, R>;
+declare function defineConfig<T extends Record<string, DeepPartial<Pick<ApibaraConfig<T, R>, "runtimeConfig">>> = Record<string, never>, R extends Record<string, unknown> = Record<string, never>>(config: ApibaraConfig<T, R>): ApibaraConfig<T, R>;
 
 export { defineConfig };

package/dist/config/index.d.ts

@@ -1,5 +1,5 @@
 import { DeepPartial, ApibaraConfig } from 'apibara/types';
 
-declare function defineConfig<T extends Record<string, DeepPartial<ApibaraConfig<T, R>>> = {}, R extends Record<string, unknown> = {}>(config: ApibaraConfig<T, R>): ApibaraConfig<T, R>;
+declare function defineConfig<T extends Record<string, DeepPartial<Pick<ApibaraConfig<T, R>, "runtimeConfig">>> = Record<string, never>, R extends Record<string, unknown> = Record<string, never>>(config: ApibaraConfig<T, R>): ApibaraConfig<T, R>;
 
 export { defineConfig };

package/dist/core/index.mjs

@@ -1,30 +1,29 @@
-import consola__default from 'consola';
+import consola from 'consola';
 import { createHooks } from 'hookable';
 import { watchConfig, loadConfig } from 'c12';
 import { klona } from 'klona/full';
-import { resolve, isAbsolute, relative, join, dirname } from 'pathe';
+import { resolve, join, basename, isAbsolute, relative, dirname } from 'pathe';
 import defu from 'defu';
+import fse from 'fs-extra';
 import { getRollupConfig } from 'apibara/rollup';
 import { watch } from 'chokidar';
 import { debounce } from 'perfect-debounce';
 import * as rollup from 'rollup';
 import { rollup as rollup$1 } from 'rollup';
+import { colors } from 'consola/utils';
 import fsp from 'node:fs/promises';
-import fse from 'fs-extra';
 import { generateTypes, resolveSchema } from 'untyped';
 
 const ApibaraDefaults = {
   rootDir: ".",
+  indexersDir: "indexers",
   runtimeConfig: {},
   hooks: {},
   buildDir: ".apibara",
   typescript: {
     strict: false,
-    generateTsConfig: true,
     generateRuntimeConfigTypes: true,
-    tsconfigPath: "types/tsconfig.json",
-    internalPaths: false,
-    tsConfig: {}
+    internalPaths: false
   }
 };
 
@@ -46,7 +45,7 @@ async function presetResolver(options) {
 }
 
 async function resolveRuntimeConfigOptions(options) {
-  options.runtimeConfig = { ...options.runtimeConfig, default: "value" };
+  options.runtimeConfig = { ...options.runtimeConfig };
   process.env.APIBARA_RUNTIME_CONFIG = JSON.stringify(options.runtimeConfig);
 }
 
@@ -83,23 +82,55 @@ async function _loadUserConfig(configOverrides = {}, opts = {}, dev = false) {
   return options;
 }
 
-async function updateApibaraConfig(apibara, config) {
+async function updateApibaraConfig(apibara, _config) {
   await apibara.hooks.callHook("rollup:reload");
-  consola__default.success("Apibara config hot reloaded!");
+  apibara.logger.success("Apibara config hot reloaded!");
+}
+
+const INDEXER_EXTENSIONS = [".indexer.ts", ".indexer.js"];
+async function scanIndexers(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) {
+  for (const extension of INDEXER_EXTENSIONS) {
+    if (file.endsWith(extension)) {
+      return basename(file, extension);
+    }
+  }
 }
 
 async function createApibara(config = {}, opts = {}, dev = false) {
   const options = await loadOptions(config, opts, dev);
   const apibara = {
     options,
+    indexers: [],
     hooks: createHooks(),
     close: () => apibara.hooks.callHook("close"),
-    logger: consola__default.withTag("apibara"),
+    logger: consola.withTag("apibara"),
     async updateConfig(config2) {
       updateApibaraConfig(apibara);
     }
   };
   apibara.hooks.addHooks(apibara.options.hooks);
+  await scanIndexers(apibara);
   return apibara;
 }
 
@@ -116,7 +147,6 @@ function formatRollupError(_error) {
       }
       const text = error.text || error.frame;
       logs.push(
-        // biome-ignore lint/style/useTemplate: <explanation>
         `Rollup error while processing \`${path}\`` + text ? "\n\n" + text : ""
       );
     }
@@ -164,6 +194,7 @@ function startRollupWatcher(apibara, rollupConfig) {
   watcher.on("event", (event) => {
     switch (event.code) {
       case "START": {
+        apibara.hooks.callHook("dev:restart");
         return;
       }
       case "BUNDLE_START": {
@@ -188,6 +219,9 @@ function startRollupWatcher(apibara, rollupConfig) {
 }
 
 async function buildProduction(apibara, rollupConfig) {
+  apibara.logger.start(
+    `Building ${colors.cyan(apibara.indexers.length)} indexers`
+  );
   try {
     const bundle = await rollup$1(rollupConfig);
     if (Array.isArray(rollupConfig.output)) {
@@ -200,9 +234,12 @@ async function buildProduction(apibara, rollupConfig) {
       throw new Error("No output options specified in Rollup config");
     }
     await bundle.close();
-    consola__default.success("Build completed successfully!");
+    apibara.logger.success("Build succeeded!");
+    apibara.logger.info(
+      `You can start the indexers with ${colors.cyan("apibara start")}`
+    );
   } catch (error) {
-    console.error("Build failed:", error);
+    apibara.logger.error("Build failed", error);
     throw error;
   }
 }
@@ -213,10 +250,17 @@ async function build(apibara) {
   return apibara.options.dev ? await watchDev(apibara, rollupConfig) : await buildProduction(apibara, rollupConfig);
 }
 
+function prettyPath(path, highlight = true) {
+  const rel = relative(process.cwd(), path);
+  return highlight ? colors.cyan(rel) : rel;
+}
+
 async function prepare(apibara) {
   await prepareDir(apibara.options.buildDir);
   await prepareDir(apibara.options.outputDir);
-  consola__default.success("Output directory cleaned");
+  apibara.logger.success(
+    `Output directory ${prettyPath(apibara.options.outputDir)} cleaned`
+  );
 }
 async function prepareDir(dir) {
   await fsp.mkdir(dir, { recursive: true });
@@ -245,88 +289,13 @@ 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 = [];
   buildFiles.push({
     path: join(typesDir, "apibara-config.d.ts"),
     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 = 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) => {
-          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, "") : 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);
@@ -334,12 +303,7 @@ declare module "apibara/types" {`,
       await fsp.writeFile(_file, file.contents);
     })
   );
-  consola__default.success("Types generated");
-}
-const RELATIVE_RE = /^\.{1,2}\//;
-function relativeWithDot(from, to) {
-  const rel = relative(from, to);
-  return RELATIVE_RE.test(rel) ? rel : `./${rel}`;
+  apibara.logger.success(`Types written to ${prettyPath(typesDir)}`);
 }
 
 export { build, createApibara, prepare, writeTypes };

package/dist/create/index.d.mts

@@ -0,0 +1,17 @@
+type Options$1 = {
+    argIndexerId?: string;
+    argChain?: string;
+    argNetwork?: string;
+    argStorage?: string;
+    argDnaUrl?: string;
+};
+declare function addIndexer({ argIndexerId, argChain, argNetwork, argStorage, argDnaUrl, }: Options$1): Promise<void>;
+
+type Options = {
+    argTargetDir: string;
+    argLanguage?: string;
+    argNoCreateIndexer?: boolean;
+};
+declare function initializeProject({ argTargetDir, argLanguage, argNoCreateIndexer, }: Options): Promise<void>;
+
+export { addIndexer, initializeProject };

package/dist/create/index.d.ts

@@ -0,0 +1,17 @@
+type Options$1 = {
+    argIndexerId?: string;
+    argChain?: string;
+    argNetwork?: string;
+    argStorage?: string;
+    argDnaUrl?: string;
+};
+declare function addIndexer({ argIndexerId, argChain, argNetwork, argStorage, argDnaUrl, }: Options$1): Promise<void>;
+
+type Options = {
+    argTargetDir: string;
+    argLanguage?: string;
+    argNoCreateIndexer?: boolean;
+};
+declare function initializeProject({ argTargetDir, argLanguage, argNoCreateIndexer, }: Options): Promise<void>;
+
+export { addIndexer, initializeProject };