@hugomrdias/foxer 0.0.1

package/src/bin/create.ts

@@ -0,0 +1,199 @@
+import {
+  copyFileSync,
+  existsSync,
+  mkdirSync,
+  readdirSync,
+  readFileSync,
+  statSync,
+  writeFileSync,
+} from 'node:fs'
+import { basename, dirname, relative, resolve } from 'node:path'
+import { fileURLToPath } from 'node:url'
+import { downloadTemplate } from '@bluwy/giget-core'
+import * as p from '@clack/prompts'
+import { type Command, command } from 'cleye'
+
+const __dirname = dirname(fileURLToPath(import.meta.url))
+
+const possibleTemplates = ['app', 'cli'] as const
+type Templates = (typeof possibleTemplates)[number]
+
+const Template = (template: Templates) => {
+  if (!possibleTemplates.includes(template)) {
+    throw new Error(
+      `Invalid template: "${template}" (must be one of ${possibleTemplates.join(', ')})`
+    )
+  }
+  return template
+}
+
+interface PkgInfo {
+  name: string
+  version: string
+}
+
+function pkgFromUserAgent(userAgent: string | undefined): PkgInfo | undefined {
+  if (!userAgent) return undefined
+  const pkgSpec = userAgent.split(' ')[0]
+  const pkgSpecArr = pkgSpec.split('/')
+  return {
+    name: pkgSpecArr[0],
+    version: pkgSpecArr[1],
+  }
+}
+
+function formatTargetDir(targetDir: string) {
+  return targetDir
+    .trim()
+    .replace(/[<>:"\\|?*]/g, '')
+    .replace(/\/+$/g, '')
+}
+
+function isEmpty(path: string) {
+  const files = readdirSync(path)
+  return files.length === 0 || (files.length === 1 && files[0] === '.git')
+}
+
+function isValidPackageName(projectName: string) {
+  return /^(?:@[a-z\d\-*~][a-z\d\-*._~]*\/)?[a-z\d\-~][a-z\d\-._~]*$/.test(
+    projectName
+  )
+}
+
+function toValidPackageName(projectName: string) {
+  return projectName
+    .trim()
+    .toLowerCase()
+    .replace(/\s+/g, '-')
+    .replace(/^[._]/, '')
+    .replace(/[^a-z\d\-~]+/g, '-')
+}
+
+function copy(src: string, dest: string) {
+  const stat = statSync(src)
+  if (stat.isDirectory()) {
+    copyDir(src, dest)
+  } else {
+    copyFileSync(src, dest)
+  }
+}
+
+function copyDir(srcDir: string, destDir: string) {
+  mkdirSync(destDir, { recursive: true })
+  for (const file of readdirSync(srcDir)) {
+    const srcFile = resolve(srcDir, file)
+    const destFile = resolve(destDir, file)
+    copy(srcFile, destFile)
+  }
+}
+
+function getInstallCommand(agent: string) {
+  if (agent === 'yarn') {
+    return [agent]
+  }
+  return [agent, 'install']
+}
+
+function getRunCommand(agent: string, script: string) {
+  switch (agent) {
+    case 'yarn':
+    case 'pnpm':
+    case 'bun':
+      return [agent, script]
+    case 'deno':
+      return [agent, 'task', script]
+    default:
+      return [agent, 'run', script]
+  }
+}
+
+export const create: Command = command(
+  {
+    name: 'create',
+    parameters: ['<name>'],
+    flags: {
+      template: {
+        type: Template,
+        default: 'app',
+        description: 'The template to use for the new project (app, cli)',
+      },
+    },
+    help: {
+      description: 'Create a new project',
+      examples: [`foxer create <name>`],
+    },
+  },
+  async (argv) => {
+    const pkgInfo = pkgFromUserAgent(process.env.npm_config_user_agent)
+    const pm = pkgInfo ? pkgInfo.name : 'npm'
+    const targetDir = formatTargetDir(argv._.name)
+    const cwd = process.cwd()
+    const root = resolve(cwd, targetDir)
+
+    if (existsSync(root) && !isEmpty(root)) {
+      p.log.error('Directory already exists and is not empty')
+      process.exit(1)
+    }
+
+    let packageName = basename(resolve(targetDir))
+    if (!isValidPackageName(packageName)) {
+      packageName = toValidPackageName(packageName)
+    }
+
+    let template = argv.flags.template
+    if (!possibleTemplates.includes(template as Templates)) {
+      template = 'app'
+    }
+
+    mkdirSync(root, { recursive: true })
+    p.log.step(`Scaffolding project in ${root}...`)
+
+    const pkg = JSON.parse(
+      readFileSync(resolve(__dirname, `../../template/package.json`), 'utf-8')
+    )
+
+    pkg.name = packageName
+
+    writeFileSync(
+      resolve(root, 'package.json'),
+      `${JSON.stringify(pkg, null, 2)}\n`
+    )
+
+    if (pm === 'pnpm') {
+      copy(
+        resolve(__dirname, `../../template/pnpm-workspace.yaml`),
+        resolve(root, 'pnpm-workspace.yaml')
+      )
+    }
+
+    copy(
+      resolve(__dirname, `../../template/biome.json`),
+      resolve(root, 'biome.json')
+    )
+    copy(
+      resolve(__dirname, `../../template/tsconfig.json`),
+      resolve(root, 'tsconfig.json')
+    )
+
+    // copy apps/foc-api
+    await downloadTemplate('hugomrdias/foxer/examples/api', {
+      dir: resolve(root, 'apps/api'),
+    })
+
+    await downloadTemplate('hugomrdias/foxer/examples/app', {
+      dir: resolve(root, 'apps/app'),
+    })
+
+    let doneMessage = ''
+    const cdProjectName = relative(cwd, root)
+    doneMessage += `Done. Now run:\n`
+    if (root !== cwd) {
+      doneMessage += `\n  cd ${
+        cdProjectName.includes(' ') ? `"${cdProjectName}"` : cdProjectName
+      }`
+    }
+    doneMessage += `\n  ${getInstallCommand(pm).join(' ')}`
+    doneMessage += `\n  ${getRunCommand(pm, 'dev').join(' ')}`
+    p.outro(doneMessage)
+  }
+)

package/src/bin/dev.ts

@@ -0,0 +1,91 @@
+import fs from 'node:fs'
+import path from 'node:path'
+import { type Command, command } from 'cleye'
+import { gracefulExit } from 'exit-hook'
+import { bootstrapApiServer } from '../api/runner.ts'
+import { createEnv } from '../config/env.ts'
+import { createDatabase } from '../db/client.ts'
+import { runMigrations } from '../db/migrate.ts'
+import * as InternalSchema from '../db/schema/index.ts'
+import { HookRegistry } from '../hooks/registry.ts'
+import { bootstrapIndexer } from '../indexer/runner.ts'
+import { createLogger } from '../utils/logger.ts'
+import { createExit, registerUnhandled } from '../utils/shutdown.ts'
+import { globalFlags } from './flags.ts'
+import { loadConfig } from './utils.ts'
+
+export const dev: Command = command(
+  {
+    name: 'dev',
+    flags: { ...globalFlags },
+    help: {
+      description: 'Start the development server with hot reloading',
+    },
+  },
+  async (argv) => {
+    const logger = createLogger({
+      level: argv.flags.logLevel,
+      mode: argv.flags.logMode,
+    })
+
+    registerUnhandled({ logger })
+
+    if (!fs.existsSync(path.join(argv.flags.root, '.env.local'))) {
+      logger.warn({
+        msg: 'Local environment file (.env.local) not found',
+      })
+    }
+
+    try {
+      const env = createEnv(logger)
+
+      const config = await loadConfig(
+        logger,
+        argv.flags.root,
+        argv.flags.config
+      )
+
+      const dbContext = createDatabase({
+        env,
+        schema: { ...config.schema, ...InternalSchema.schema },
+        relations: { ...config.relations, ...InternalSchema.relations },
+      })
+
+      await runMigrations({
+        dbContext,
+        folder: path.resolve(argv.flags.root, config.drizzleFolder),
+        logger,
+      })
+
+      const registry = new HookRegistry()
+      config.hooks({ registry })
+
+      const [api, indexer] = await Promise.all([
+        bootstrapApiServer({
+          db: dbContext.db,
+          config,
+          logger,
+          port: argv.flags.port,
+        }),
+        bootstrapIndexer({
+          logger,
+          db: dbContext.db,
+          registry,
+          config,
+        }),
+      ])
+
+      createExit({
+        logger,
+        stop: async () => {
+          indexer.stop()
+          api.stop()
+          await dbContext.close()
+        },
+      })
+    } catch (error) {
+      logger.error({ error }, 'dev server failed')
+      gracefulExit(1)
+    }
+  }
+)

package/src/bin/flags.ts

@@ -0,0 +1,65 @@
+import path from 'node:path'
+
+const Root = (dir: string) => {
+  return path.resolve(dir)
+}
+
+const possibleLogModes = ['pretty', 'json'] as const
+
+type LogModes = (typeof possibleLogModes)[number]
+
+// Custom type function
+const LogMode = (logMode: LogModes) => {
+  if (!possibleLogModes.includes(logMode)) {
+    throw new Error(`Invalid log mode: "${logMode}"`)
+  }
+
+  return logMode
+}
+
+const LogLevels = [
+  'trace',
+  'debug',
+  'info',
+  'warn',
+  'error',
+  'fatal',
+  'silent',
+] as const
+type LogLevels = (typeof LogLevels)[number]
+
+// Custom type function
+const LogLevel = (logLevel: LogLevels) => {
+  if (!LogLevels.includes(logLevel)) {
+    throw new Error(`Invalid log level: "${logLevel}"`)
+  }
+
+  return logLevel
+}
+export const globalFlags = {
+  config: {
+    type: String,
+    description: 'The path to the config file',
+  },
+  root: {
+    type: Root,
+    description: 'The root directory of the project',
+    default: process.cwd(),
+  },
+
+  logLevel: {
+    type: LogLevel,
+    description: 'The log level to use',
+    default: LogLevel((process.env.LOG_LEVEL as LogLevels) ?? 'info'),
+  },
+  logMode: {
+    type: LogMode,
+    description: 'The log mode to use',
+    default: LogMode(process.env.NODE_ENV !== 'production' ? 'pretty' : 'json'),
+  },
+  port: {
+    type: Number,
+    description: 'The port to use for the API server',
+    default: process.env.PORT ? Number(process.env.PORT) : 4200,
+  },
+} as const

package/src/bin/index.ts

@@ -0,0 +1,28 @@
+#!/usr/bin/env node
+
+import { readFileSync } from 'node:fs'
+import { dirname, resolve } from 'node:path'
+import { fileURLToPath } from 'node:url'
+import { cli } from 'cleye'
+import { create } from './create.ts'
+import { dev } from './dev.ts'
+
+const __dirname = dirname(fileURLToPath(import.meta.url))
+const packageJsonPath = resolve(__dirname, '../../package.json')
+const packageJson = JSON.parse(
+  readFileSync(packageJsonPath, { encoding: 'utf8' })
+)
+
+const argv = cli({
+  name: 'foxer',
+  version: packageJson.version,
+  commands: [dev, create],
+  help: {
+    version: packageJson.version,
+  },
+})
+
+if (!argv.command) {
+  argv.showHelp()
+  process.exit(1)
+}

package/src/bin/utils.ts

@@ -0,0 +1,55 @@
+import path from 'node:path'
+import { pathToFileURL } from 'node:url'
+import { type LilconfigResult, lilconfig } from 'lilconfig'
+import type { InternalConfig } from '../config/config'
+import type { Logger } from '../utils/logger'
+
+const CLI_NAME = 'foxer'
+
+const loadEsm = async (filepath: string) => {
+  const res = await import(pathToFileURL(filepath).href)
+  return res.default ?? res
+}
+
+const configLoaders = {
+  '.js': loadEsm,
+  '.mjs': loadEsm,
+  '.ts': loadEsm,
+  '.mts': loadEsm,
+}
+
+export async function loadConfig(
+  logger: Logger,
+  root: string,
+  filePath?: string
+) {
+  let configFile: LilconfigResult | undefined
+
+  try {
+    if (filePath) {
+      const configPath = path.resolve(root, filePath)
+
+      configFile = await lilconfig(configPath, {
+        loaders: configLoaders,
+        searchPlaces: [],
+      }).load(configPath)
+    } else {
+      configFile = await lilconfig(CLI_NAME, {
+        loaders: configLoaders,
+        searchPlaces: [`${CLI_NAME}.config.ts`, `${CLI_NAME}.config.mts`],
+      }).search()
+    }
+  } catch (error) {
+    logger.error(error, 'config evaluation failed')
+    // ignore
+  }
+
+  if (!configFile || configFile.isEmpty) {
+    logger.error({
+      msg: 'Config file not found',
+    })
+    process.exit(1)
+  }
+
+  return configFile.config.config as InternalConfig
+}

package/src/config/config.ts

@@ -0,0 +1,221 @@
+import type { Abi, AbiEvent } from 'abitype'
+import type { AnyRelations, EmptyRelations } from 'drizzle-orm/relations'
+import type { Hono } from 'hono'
+import type { BlankEnv, BlankSchema } from 'hono/types'
+import type { PoolConfig } from 'pg'
+import type { SetRequired, Simplify, UnknownRecord } from 'type-fest'
+import {
+  type Address,
+  type FallbackTransport,
+  getAbiItem,
+  type HttpTransport,
+  type Narrow,
+  type PublicClientConfig,
+  type WebSocketTransport,
+} from 'viem'
+import type { Database } from '../db/client.ts'
+import type { HookRegistry } from '../hooks/registry.ts'
+import { createRpcClients, type RpcClients } from '../rpc/client.ts'
+import type { UnknownObject } from '../types.ts'
+import type { Logger } from '../utils/logger.ts'
+import type {
+  ContractConfig,
+  ContractsConfig,
+  GetContract,
+} from '../utils/types.ts'
+
+export type ClientConfig = Simplify<
+  SetRequired<PublicClientConfig, 'chain'> & {
+    realtimeTransport?: HttpTransport | WebSocketTransport | FallbackTransport
+  }
+>
+
+export type HonoConfig<
+  TSchema extends UnknownRecord = UnknownRecord,
+  TRelations extends AnyRelations = EmptyRelations,
+> = (options: {
+  logger: Logger
+  db: Database<TSchema, TRelations>
+}) => Hono<BlankEnv, BlankSchema, '/'>
+
+export type HooksConfig<
+  contracts extends ContractsConfig<UnknownObject>,
+  TSchema extends UnknownRecord,
+  TRelations extends AnyRelations,
+> = (context: {
+  registry: HookRegistry<
+    ContractsConfig<Narrow<contracts>>,
+    TSchema,
+    TRelations
+  >
+}) => void
+
+export type DatabaseConfig =
+  | {
+      driver: 'postgres'
+      url?: string
+      options?: PoolConfig
+    }
+  | {
+      driver: 'pglite'
+      directory: string
+    }
+
+export type Config<
+  contracts extends ContractsConfig<UnknownObject>,
+  TSchema extends UnknownRecord,
+  TRelations extends AnyRelations = EmptyRelations,
+> = {
+  /**
+   * The batch size for the backfill. How many blocks to process at a time.
+   * @default 100
+   */
+  batchSize?: number
+  /**
+   * The finality of the chain.
+   * @default 30
+   */
+  finality?: number
+  /**
+   * The folder where the drizzle schema is stored.
+   * @default './drizzle'
+   */
+  drizzleFolder?: string
+  /**
+   * The database configuration.
+   */
+  database?: DatabaseConfig
+  /**
+   * The contracts to index.
+   */
+  contracts: ContractsConfig<Narrow<contracts>>
+  /**
+   * The RPC clients configuration.
+   */
+  client: ClientConfig
+  /**
+   * The Hono configuration.
+   */
+  hono: HonoConfig<TSchema, TRelations>
+  /**
+   * The drizzle schema.
+   */
+  schema: TSchema
+  /**
+   * The drizzle relations.
+   */
+  relations?: TRelations
+  /**
+   * The hooks configuration.
+   */
+  hooks: HooksConfig<contracts, TSchema, TRelations>
+}
+
+export type InternalConfig<
+  TSchema extends UnknownRecord = UnknownRecord,
+  TRelations extends AnyRelations = EmptyRelations,
+> = {
+  batchSize: bigint
+  finality: bigint
+  drizzleFolder: string
+  contracts: { [contractName: string]: GetContract }
+  database?: DatabaseConfig
+  client: ClientConfig
+  hono: HonoConfig<TSchema, TRelations>
+  schema: TSchema
+  relations: TRelations
+  hooks: (context: { registry: HookRegistry }) => void
+  startBlockNumber: bigint
+  contractsForLive: ContractConfig<Abi, readonly string[]>[]
+  clients: RpcClients
+}
+
+export function createConfig<
+  contracts extends ContractsConfig<UnknownObject>,
+  TSchema extends UnknownRecord = UnknownRecord,
+  TRelations extends AnyRelations = EmptyRelations,
+>(config: Config<contracts, TSchema, TRelations>) {
+  let startBlockNumber: bigint = 0n
+  const contractsForLive: ContractConfig<Abi, readonly string[]>[] = []
+
+  for (const contract of Object.values(
+    config.contracts as { [contractName: string]: GetContract }
+  )) {
+    if (contract.endBlock == null) {
+      contractsForLive.push(contract)
+    }
+
+    if (startBlockNumber === 0n && contract.startBlock != null) {
+      startBlockNumber = contract.startBlock
+      continue
+    }
+
+    if (contract.startBlock != null && contract.startBlock < startBlockNumber) {
+      startBlockNumber = contract.startBlock
+    }
+  }
+
+  const clients = createRpcClients(config.client)
+
+  return {
+    ...config,
+    batchSize: BigInt(config.batchSize ?? 100),
+    finality: BigInt(config.finality ?? 30),
+    drizzleFolder: config.drizzleFolder ?? './drizzle',
+    relations: config.relations ? config.relations : ({} as TRelations),
+    startBlockNumber,
+    contractsForLive,
+    clients,
+  }
+}
+
+export type FilteredContracts = {
+  eventAbis: AbiEvent[]
+  addresses: Address[]
+  eventNames: Set<string>
+  contractNameByAddress: Record<Address, string>
+}
+
+export function filterContracts(
+  config: InternalConfig,
+  fromBlock: bigint,
+  toBlock: bigint
+) {
+  const eventAbis: AbiEvent[] = []
+  const addresses: Address[] = []
+  const eventNames: Set<string> = new Set()
+  const contractNameByAddress: Record<Address, string> = {}
+  for (const [contractName, contract] of Object.entries(config.contracts)) {
+    const address = contract.address.toLowerCase() as `0x${string}`
+    const startBlock = contract.startBlock ?? 0n
+
+    if (startBlock > toBlock) {
+      continue
+    }
+    if (contract.endBlock != null && contract.endBlock < fromBlock) {
+      continue
+    }
+
+    addresses.push(address)
+    contractNameByAddress[address] = contractName
+
+    for (const event of contract.events) {
+      eventNames.add(event)
+      const eventAbi = getAbiItem({
+        abi: contract.abi,
+        name: event,
+      })
+      if (!eventAbi) {
+        throw new Error(`Event ${event} not found in contract ${contractName}`)
+      }
+      eventAbis.push(eventAbi as AbiEvent)
+    }
+  }
+
+  return {
+    eventAbis: eventAbis,
+    addresses: addresses,
+    contractNameByAddress: contractNameByAddress,
+    eventNames: eventNames,
+  }
+}

package/src/config/env.ts

@@ -0,0 +1,28 @@
+import dotenv from 'dotenv'
+import { z } from 'zod'
+import type { Logger } from '../utils/logger'
+
+dotenv.config({
+  path: '.env.local',
+})
+
+export type Env = z.infer<typeof envSchema>
+const envSchema = z.object({
+  DATABASE_URL: z.url().optional(),
+  LOG_LEVEL: z
+    .enum(['trace', 'debug', 'info', 'warn', 'error', 'fatal'])
+    .default('info'),
+  LOG_MODE: z.enum(['pretty', 'json']).default('pretty'),
+})
+
+export function createEnv(logger: Logger) {
+  const parsed = envSchema.safeParse(process.env)
+
+  if (!parsed.success) {
+    throw new Error(
+      `Failed to parse environment variables: \n ${z.flattenError(parsed.error)}`
+    )
+  }
+  logger.debug({ env: parsed.data }, 'env parsed')
+  return parsed.data
+}

package/src/contants.ts

@@ -0,0 +1,3 @@
+export const PUBLICATION_NAME = 'foxer_publication'
+export const FOXER_TABLES = ['blocks', 'transactions']
+export const MAX_QUERY_PARAMS = 16000