apibara 2.0.0-beta.4 → 2.0.0-beta.41

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

@@ -0,0 +1,28 @@
+import { createApibara, prepare, writeTypes, build as build$1 } from 'apibara/core';
+import { runtimeDir } from 'apibara/runtime/meta';
+import { defineCommand } from 'citty';
+import { resolve, join } from 'pathe';
+import { c as commonArgs } from '../shared/apibara.1b515d04.mjs';
+
+const build = defineCommand({
+  meta: {
+    name: "build",
+    description: "Build indexer"
+  },
+  args: {
+    ...commonArgs
+  },
+  async run({ args }) {
+    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);
+    await apibara.close();
+  }
+});
+
+export { build as default };

package/dist/chunks/dev.mjs

@@ -0,0 +1,100 @@
+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 { colors } from 'consola/utils';
+import { resolve, join } from 'pathe';
+import { c as commonArgs } from '../shared/apibara.1b515d04.mjs';
+
+const hmrKeyRe = /^runtimeConfig\./;
+const dev = defineCommand({
+  meta: {
+    name: "dev",
+    description: "Start the development server"
+  },
+  args: {
+    ...commonArgs,
+    indexers: {
+      type: "string",
+      description: "Comma-separated list of indexers to run"
+    },
+    preset: {
+      type: "string",
+      description: "Preset to use"
+    }
+  },
+  async run({ args }) {
+    const rootDir = resolve(args.dir || args._dir || ".");
+    let apibara;
+    let childProcess;
+    const reload = async () => {
+      if (apibara) {
+        apibara.logger.info("Restarting dev server");
+        if ("unwatch" in apibara.options._c12) {
+          await apibara.options._c12.unwatch();
+        }
+        await apibara.close();
+      }
+      apibara = await createApibara(
+        {
+          rootDir
+        },
+        {
+          watch: true,
+          c12: {
+            async onUpdate({ getDiff, newConfig }) {
+              const diff = getDiff();
+              if (diff.length === 0) {
+                return;
+              }
+              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());
+            }
+          }
+        },
+        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) {
+          childProcess.kill();
+        } else {
+          apibara.logger.success("Restarting indexers");
+        }
+        const childArgs = [
+          resolve(apibara.options.outputDir || "./.apibara/build", "dev.mjs"),
+          "start",
+          ...args.indexers ? ["--indexers", args.indexers] : [],
+          ...args.preset ? ["--preset", args.preset] : []
+        ];
+        childProcess = spawn("node", childArgs, {
+          stdio: "inherit"
+        });
+        childProcess.on("close", (code) => {
+          if (code !== null) {
+            apibara.logger.log(
+              `Indexers process exited with code ${colors.red(code)}`
+            );
+          }
+        });
+      });
+    };
+    await reload();
+  }
+});
+
+export { dev as default };

package/dist/chunks/init.mjs

@@ -0,0 +1,41 @@
+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"
+    },
+    "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
+    });
+  }
+});
+
+export { init as default };

package/dist/chunks/prepare.mjs

@@ -0,0 +1,21 @@
+import { createApibara, writeTypes } from 'apibara/core';
+import { defineCommand } from 'citty';
+import { resolve } from 'pathe';
+import { c as commonArgs } from '../shared/apibara.1b515d04.mjs';
+
+const prepare = defineCommand({
+  meta: {
+    name: "prepare",
+    description: "Generate types for the project"
+  },
+  args: {
+    ...commonArgs
+  },
+  async run({ args }) {
+    const rootDir = resolve(args.dir || ".");
+    const apibara = await createApibara({ rootDir });
+    await writeTypes(apibara);
+  }
+});
+
+export { prepare as default };

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.d.mts

@@ -0,0 +1,5 @@
+import * as citty from 'citty';
+
+declare const mainCli: citty.CommandDef<citty.ArgsDef>;
+
+export { mainCli };

package/dist/cli/index.d.ts

@@ -0,0 +1,5 @@
+import * as citty from 'citty';
+
+declare const mainCli: citty.CommandDef<citty.ArgsDef>;
+
+export { mainCli };

package/dist/cli/index.mjs

@@ -0,0 +1,21 @@
+#!/usr/bin/env node
+import { defineCommand, runMain } from 'citty';
+
+const mainCli = defineCommand({
+  meta: {
+    name: "apibara",
+    description: "Apibara CLI",
+    version: "2.0.0"
+  },
+  subCommands: {
+    dev: () => import('../chunks/dev.mjs').then((r) => r.default),
+    build: () => import('../chunks/build.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);
+
+export { mainCli };

package/dist/config/index.d.mts

@@ -0,0 +1,5 @@
+import { DeepPartial, ApibaraConfig } from 'apibara/types';
+
+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

@@ -0,0 +1,5 @@
+import { DeepPartial, ApibaraConfig } from 'apibara/types';
+
+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.mjs

@@ -0,0 +1,5 @@
+function defineConfig(config) {
+  return config;
+}
+
+export { defineConfig };

package/dist/core/index.d.mts

@@ -0,0 +1,11 @@
+import { ApibaraConfig, LoadConfigOptions, Apibara } from 'apibara/types';
+
+declare function createApibara(config?: ApibaraConfig, opts?: LoadConfigOptions, dev?: boolean): Promise<Apibara>;
+
+declare function build(apibara: Apibara): Promise<void>;
+
+declare function prepare(apibara: Apibara): Promise<void>;
+
+declare function writeTypes(apibara: Apibara): Promise<void>;
+
+export { build, createApibara, prepare, writeTypes };

package/dist/core/index.d.ts

@@ -0,0 +1,11 @@
+import { ApibaraConfig, LoadConfigOptions, Apibara } from 'apibara/types';
+
+declare function createApibara(config?: ApibaraConfig, opts?: LoadConfigOptions, dev?: boolean): Promise<Apibara>;
+
+declare function build(apibara: Apibara): Promise<void>;
+
+declare function prepare(apibara: Apibara): Promise<void>;
+
+declare function writeTypes(apibara: Apibara): Promise<void>;
+
+export { build, createApibara, prepare, writeTypes };

package/dist/core/index.mjs

@@ -0,0 +1,309 @@
+import consola from 'consola';
+import { createHooks } from 'hookable';
+import { watchConfig, loadConfig } from 'c12';
+import { klona } from 'klona/full';
+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 { generateTypes, resolveSchema } from 'untyped';
+
+const ApibaraDefaults = {
+  rootDir: ".",
+  indexersDir: "indexers",
+  runtimeConfig: {},
+  hooks: {},
+  buildDir: ".apibara",
+  typescript: {
+    strict: false,
+    generateRuntimeConfigTypes: true,
+    internalPaths: false
+  }
+};
+
+async function resolvePathOptions(options) {
+  options.rootDir = resolve(options.rootDir || ".");
+  for (const key of ["buildDir"]) {
+    options[key] = resolve(options.rootDir, options[key]);
+  }
+  if (!options.outputDir) {
+    options.outputDir = resolve(options.rootDir, ".apibara/build");
+  }
+}
+
+async function presetResolver(options) {
+  if (options.preset && options.presets?.[options.preset]) {
+    const new_options = defu(options.presets[options.preset], options);
+    Object.assign(options, new_options);
+  }
+}
+
+async function resolveRuntimeConfigOptions(options) {
+  options.runtimeConfig = { ...options.runtimeConfig };
+  process.env.APIBARA_RUNTIME_CONFIG = JSON.stringify(options.runtimeConfig);
+}
+
+const configResolvers = [
+  resolvePathOptions,
+  resolveRuntimeConfigOptions,
+  presetResolver
+];
+async function loadOptions(configOverrides = {}, opts = {}, dev = false) {
+  const options = await _loadUserConfig(configOverrides, opts, dev);
+  for (const resolver of configResolvers) {
+    await resolver(options);
+  }
+  return options;
+}
+async function _loadUserConfig(configOverrides = {}, opts = {}, dev = false) {
+  configOverrides = klona(configOverrides);
+  const loadedConfig = await (opts.watch ? watchConfig : loadConfig)({
+    name: "apibara",
+    dotenv: dev,
+    cwd: configOverrides.rootDir,
+    overrides: {
+      ...configOverrides
+    },
+    defaults: { ...ApibaraDefaults },
+    ...opts.c12
+  });
+  const options = klona(loadedConfig.config);
+  options._config = configOverrides;
+  options._c12 = loadedConfig;
+  if (dev) {
+    options.dev = dev;
+  }
+  return options;
+}
+
+async function updateApibaraConfig(apibara, _config) {
+  await apibara.hooks.callHook("rollup:reload");
+  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.withTag("apibara"),
+    async updateConfig(config2) {
+      updateApibaraConfig(apibara);
+    }
+  };
+  apibara.hooks.addHooks(apibara.options.hooks);
+  await scanIndexers(apibara);
+  return apibara;
+}
+
+function formatRollupError(_error) {
+  try {
+    const logs = [_error.toString()];
+    const errors = _error?.errors || [_error];
+    for (const error of errors) {
+      const id = error.path || error.id || _error.id;
+      let path = isAbsolute(id) ? relative(process.cwd(), id) : id;
+      const location = error.loc || error.location;
+      if (location) {
+        path += `:${location.line}:${location.column}`;
+      }
+      const text = error.text || error.frame;
+      logs.push(
+        `Rollup error while processing \`${path}\`` + text ? "\n\n" + text : ""
+      );
+    }
+    return logs.join("\n");
+  } catch {
+    return _error?.toString();
+  }
+}
+
+async function watchDev(apibara, rollupConfig) {
+  let rollupWatcher;
+  async function load() {
+    if (rollupWatcher) {
+      await rollupWatcher.close();
+    }
+    rollupWatcher = startRollupWatcher(apibara, rollupConfig);
+  }
+  const reload = debounce(load);
+  const watchPatterns = [join(apibara.options.rootDir, "indexers")];
+  const watchReloadEvents = /* @__PURE__ */ new Set(["add", "addDir", "unlink", "unlinkDir"]);
+  const reloadWatcher = watch(watchPatterns, { ignoreInitial: true }).on(
+    "all",
+    (event) => {
+      if (watchReloadEvents.has(event)) {
+        reload();
+      }
+    }
+  );
+  apibara.hooks.hook("close", () => {
+    rollupWatcher.close();
+    reloadWatcher.close();
+  });
+  apibara.hooks.hook("rollup:reload", () => reload());
+  await load();
+}
+function startRollupWatcher(apibara, rollupConfig) {
+  const watcher = rollup.watch(
+    defu(rollupConfig, {
+      watch: {
+        chokidar: apibara.options.watchOptions
+      }
+    })
+  );
+  let start;
+  watcher.on("event", (event) => {
+    switch (event.code) {
+      case "START": {
+        apibara.hooks.callHook("dev:restart");
+        return;
+      }
+      case "BUNDLE_START": {
+        start = Date.now();
+        return;
+      }
+      case "END": {
+        apibara.hooks.callHook("compiled", apibara);
+        apibara.logger.success(
+          "Indexers built",
+          start ? `in ${Date.now() - start} ms` : ""
+        );
+        apibara.hooks.callHook("dev:reload");
+        return;
+      }
+      case "ERROR": {
+        apibara.logger.error(formatRollupError(event.error));
+      }
+    }
+  });
+  return watcher;
+}
+
+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)) {
+      for (const outputOptions of rollupConfig.output) {
+        await bundle.write(outputOptions);
+      }
+    } else if (rollupConfig.output) {
+      await bundle.write(rollupConfig.output);
+    } else {
+      throw new Error("No output options specified in Rollup config");
+    }
+    await bundle.close();
+    apibara.logger.success("Build succeeded!");
+    apibara.logger.info(
+      `You can start the indexers with ${colors.cyan("apibara start")}`
+    );
+  } catch (error) {
+    apibara.logger.error("Build failed", error);
+    throw error;
+  }
+}
+
+async function build(apibara) {
+  const rollupConfig = getRollupConfig(apibara);
+  await apibara.hooks.callHook("rollup:before", apibara, rollupConfig);
+  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);
+  apibara.logger.success(
+    `Output directory ${prettyPath(apibara.options.outputDir)} cleaned`
+  );
+}
+async function prepareDir(dir) {
+  await fsp.mkdir(dir, { recursive: true });
+  await fse.emptyDir(dir);
+}
+
+async function writeTypes(apibara) {
+  const typesDir = resolve(apibara.options.buildDir, "types");
+  const config = [
+    "// Generated by apibara",
+    `
+declare module "apibara/types" {`,
+    apibara.options.typescript.generateRuntimeConfigTypes ? generateTypes(
+      await resolveSchema(
+        Object.fromEntries(
+          Object.entries(apibara.options.runtimeConfig)
+        )
+      ),
+      {
+        interfaceName: "ApibaraRuntimeConfig",
+        addExport: false,
+        addDefaults: false,
+        allowExtraKeys: false,
+        indentation: 2
+      }
+    ) : "",
+    "}",
+    // Makes this a module for augmentation purposes
+    "export type {};"
+  ];
+  const buildFiles = [];
+  buildFiles.push({
+    path: join(typesDir, "apibara-config.d.ts"),
+    contents: config.join("\n")
+  });
+  await Promise.all(
+    buildFiles.map(async (file) => {
+      const _file = resolve(apibara.options.buildDir, file.path);
+      await fsp.mkdir(dirname(_file), { recursive: true });
+      await fsp.writeFile(_file, file.contents);
+    })
+  );
+  apibara.logger.success(`Types written to ${prettyPath(typesDir)}`);
+}
+
+export { build, createApibara, prepare, writeTypes };