Function bodies 30 total

export function setInputs(map) {
  Object.keys(inputs).forEach((k) => delete inputs[k])
  Object.assign(inputs, map)
}

export function getInput(name, options) {
  const val = inputs[name] || ''
  if (options?.required && !val) {
    throw new Error(`Input required and not supplied: ${name}`)
  }
  return val
}

export function setOutput(name, value) {
  outputs[name] = value
}

export function setFailed(message) {
  errors.push(message)
}

export function getOutputs() {
  return { ...outputs }
}

export function getErrors() {
  return [...errors]
}

export function reset() {
  Object.keys(inputs).forEach((k) => delete inputs[k])
  Object.keys(outputs).forEach((k) => delete outputs[k])
  errors.length = 0
  summaryLines.length = 0
  summary._buffer = ''
}

export async function run() {
  try {
    const command = core.getInput('command', { required: true })
    const handler = COMMANDS[command]

    if (!handler) {
      core.setFailed(`Unknown command: "${command}". Available: ${Object.keys(COMMANDS).join(', ')}`)
      return
    }

    const client = new SxtClient({
      apiUrl: core.getInput('api-url') || undefined,
      apiKey: core.getInput('api-key') || undefined,
      authUrl: core.getInput('auth-url') || undefined,
      authSecret: core.getInput('auth-secret') || undefined,
      biscuitPrivateKey: core.getInput('biscuit-private-key') || undefined,
      schemaName: core.getInput('schema-name', { required: true }),
      originApp: core.getInput('origin-app') || undefined,
      maxRetries: core.getInput('max-retries') ? Number(core.getInput('max-retries')) : undefined,
      retryDelay: core.getInput('retry-delay') ? Number(core.getInput('retry-delay')) : undefined,
      timeout: core.getInput('timeout') ? Number(core.getI

function parseList(input) {
  if (!input) return undefined
  return input
    .split(',')
    .map((s) => s.trim())
    .filter(Boolean)
}

async function runQuery(client) {
  const sql = core.getInput('sql', { required: true })
  const resources = parseList(core.getInput('resources'))
  const queryType = core.getInput('query-type') || undefined

  return client.query(sql, { resources, queryType })
}

async function runExecute(client) {
  const sql = core.getInput('sql', { required: true })
  const resources = parseList(core.getInput('resources'))

  return client.execute(sql, { resources })
}

async function runDdl(client) {
  const sql = core.getInput('sql', { required: true })
  return client.ddl(sql)
}

async function runListTables(client) {
  return client.listTables()
}

async function runListChains(client) {
  const chain = core.getInput('chain') || undefined
  return client.listChains(chain)
}

function writeSummary(command, result) {
  const heading = `Space and Time: ${command}`

  if (Array.isArray(result) && result.length > 0) {
    const columns = Object.keys(result[0])
    const headerRow = columns.map((c) => ({ data: c, header: true }))
    const dataRows = result.slice(0, 20).map((row) => columns.map((c) => String(row[c] ?? '')))

    core.summary.addHeading(heading, 3)

    if (result.length > 20) {
      core.summary.addRaw(`Showing 20 of ${result.length} rows\n\n`)
    }

    core.summary.addTable([headerRow, ...dataRows]).write()
    return
  }

  core.summary
    .addHeading(heading, 3)
    .addCodeBlock(JSON.stringify(result, null, 2), 'json')
    .write()
}

export class SxtError extends Error {
  constructor(message, { status, body, code } = {}) {
    super(message)
    this.name = 'SxtError'
    this.status = status
    this.body = body
    this.code = code
  }
}

  constructor(message, { status, body, code } = {}) {
    super(message)
    this.name = 'SxtError'
    this.status = status
    this.body = body
    this.code = code
  }

export class SxtClient {
  constructor({
    apiUrl,
    apiKey,
    authUrl,
    authSecret,
    biscuitPrivateKey,
    schemaName,
    originApp = 'w3-sxt-action',
    maxRetries = 3,
    retryDelay = 2,
    timeout = 30,
  } = {}) {
    if (!schemaName) throw new SxtError('schema-name is required', { code: 'MISSING_SCHEMA' })

    // Determine auth mode
    // JWT mode: either explicit auth-url + auth-secret, or api-key with JWT bootstrap
    this.jwtMode = Boolean(authUrl && authSecret) || Boolean(apiKey)
    this.hasExplicitAuth = Boolean(authUrl && authSecret)

    if (!apiKey && !this.hasExplicitAuth) {
      throw new SxtError(
        'Authentication required: provide api-key (recommended) or auth-url + auth-secret',
        { code: 'MISSING_AUTH' },
      )
    }

    // Auth config
    this.apiKey = apiKey
    this.authUrl = authUrl
    this.authSecret = authSecret
    this.biscuitPrivateKey = biscuitPrivateKey

    // API URL
    this.apiUrl = apiUrl ? apiUrl.replace(/\/+$/

  constructor({
    apiUrl,
    apiKey,
    authUrl,
    authSecret,
    biscuitPrivateKey,
    schemaName,
    originApp = 'w3-sxt-action',
    maxRetries = 3,
    retryDelay = 2,
    timeout = 30,
  } = {}) {
    if (!schemaName) throw new SxtError('schema-name is required', { code: 'MISSING_SCHEMA' })

    // Determine auth mode
    // JWT mode: either explicit auth-url + auth-secret, or api-key with JWT bootstrap
    this.jwtMode = Boolean(authUrl && authSecret) || Boolean(apiKey)
    this.hasExplicitAuth = Boolean(authUrl && authSecret)

    if (!apiKey && !this.hasExplicitAuth) {
      throw new SxtError(
        'Authentication required: provide api-key (recommended) or auth-url + auth-secret',
        { code: 'MISSING_AUTH' },
      )
    }

    // Auth config
    this.apiKey = apiKey
    this.authUrl = authUrl
    this.authSecret = authSecret
    this.biscuitPrivateKey = biscuitPrivateKey

    // API URL
    this.apiUrl = apiUrl ? apiUrl.replace(/\/+$/, '') : DEFAULT_PROXY_URL

  async execute(sql, { resources } = {}) {
    if (!sql) throw new SxtError('sql is required', { code: 'MISSING_SQL' })
    return this.executeSql(sql, { resources })
  }

  async ddl(sql) {
    if (!sql) throw new SxtError('sql is required', { code: 'MISSING_SQL' })
    return this.executeSql(sql)
  }

  async listTables() {
    const sql = `SHOW TABLES IN ${this.schemaName}`
    return this.executeSql(sql)
  }

  async listChains(chain) {
    const schema = chain ? chain.toUpperCase() : 'ETHEREUM'
    const sql = `SELECT BLOCK_NUMBER, TIME_STAMP FROM ${schema}.BLOCKS ORDER BY BLOCK_NUMBER DESC LIMIT 5`
    return this.executeSql(sql)
  }

  async executeSql(sql, { resources, queryType } = {}) {
    const endpoint = '/v1/sql'
    const biscuit = this.biscuitPrivateKey ? this.generateBiscuit(sql) : null
    const token = await this.getToken()

    const body = {
      sqlText: sql,
      ...(biscuit && { biscuits: [biscuit] }),
      ...(resources?.length && { resources }),
      ...(queryType && { queryType }),
    }

    // Always include API key when available (proxy requires it),
    // plus Bearer token for JWT-authenticated requests
    const auth = {}
    if (this.apiKey) auth.apiKey = this.apiKey
    if (token) auth.bearer = token

    return this.requestWithRetry('POST', endpoint, body, auth)
  }

  invalidateToken() {
    this.cachedToken = null
    this.tokenExpiresAt = 0
  }

  generateBiscuit(sql) {
    try {
      const operation = this.detectOperation(sql)
      const resource = this.extractResource(sql)

      const payload = {
        operation,
        resource: resource.toLowerCase(),
        timestamp: Math.floor(Date.now() / 1000),
      }

      const payloadStr = JSON.stringify(payload)
      const keyBuffer = Buffer.from(this.biscuitPrivateKey, 'hex')

      const sign = createSign('Ed25519')
      sign.update(payloadStr)
      const signature = sign.sign({ key: keyBuffer, format: 'der', type: 'pkcs8' })

      const biscuitData = {
        payload: Buffer.from(payloadStr).toString('base64'),
        signature: signature.toString('base64'),
      }
      return Buffer.from(JSON.stringify(biscuitData)).toString('base64')
    } catch {
      return null
    }
  }

  detectOperation(sql) {
    const trimmed = sql.trim().toUpperCase()
    if (trimmed.startsWith('SELECT')) return 'dql_select'
    if (trimmed.startsWith('INSERT')) return 'dml_insert'
    if (trimmed.startsWith('UPDATE')) return 'dml_update'
    if (trimmed.startsWith('DELETE')) return 'dml_delete'
    if (trimmed.startsWith('CREATE')) return 'ddl_create'
    if (trimmed.startsWith('DROP')) return 'ddl_drop'
    if (trimmed.startsWith('ALTER')) return 'ddl_alter'
    return 'dql_select'
  }

  async requestWithRetry(method, path, body, auth) {
    let lastError

    for (let attempt = 0; attempt <= this.maxRetries; attempt++) {
      try {
        return await this.request(method, path, body, auth)
      } catch (error) {
        lastError = error

        if (error.status === 401 && this.jwtMode && attempt < this.maxRetries) {
          this.invalidateToken()
          auth = { bearer: await this.getToken() }
          continue
        }

        if (error.status === 429 && attempt < this.maxRetries) {
          await this.sleep(this.retryDelay * 1000 * Math.pow(2, attempt))
          continue
        }

        if (error.status >= 500 && attempt < this.maxRetries) {
          await this.sleep(this.retryDelay * 1000 * Math.pow(2, attempt))
          continue
        }

        throw error
      }
    }

    throw lastError
  }

  async request(method, path, body, auth) {
    const url = `${this.apiUrl}${path}`
    const headers = {
      'Content-Type': 'application/json',
      Accept: 'application/json',
      originApp: this.originApp,
    }

    if (auth.apiKey) {
      headers.apikey = auth.apiKey
    }
    if (auth.bearer) {
      headers.Authorization = `Bearer ${auth.bearer}`
    }

    const options = { method, headers, signal: AbortSignal.timeout(this.timeout) }
    if (body) options.body = JSON.stringify(body)

    const response = await fetch(url, options)
    const text = await response.text()

    if (!response.ok) {
      throw new SxtError(`SxT API error: ${response.status}`, {
        status: response.status,
        body: text,
        code: response.status === 429 ? 'RATE_LIMIT' : 'API_ERROR',
      })
    }

    // DDL operations (CREATE, DROP) may return empty body on success
    if (!text || !text.trim()) {
      return { success: true }
    }

    try {
      return JSON.parse(text)
   

  sleep(ms) {
    return new Promise((resolve) => setTimeout(resolve, ms))
  }