Programmatic API

Use Relizy programmatically in your Node.js scripts and tools.

Installation

npm

npm install -D relizy

pnpm

pnpm add -D relizy

yarn

yarn add -D relizy

bun

bun add -D relizy

Import

import { bump, changelog, providerRelease, publish, release } from 'relizy'

Quick Example

import { release } from 'relizy'

// Perform a minor release
await release({
  type: 'minor',
  publish: true,
  providerRelease: true,
})

Why Use the API?

The programmatic API is useful for:

• 🔧 Custom release workflows
• 🤖 Integration into build tools
• 📦 Custom monorepo tooling
• 🎯 Conditional release logic
• 📊 Release automation scripts

Available Functions

Function	Description
release()	Complete release workflow
bump()	Bump package versions
changelog()	Generate changelogs
publish()	Publish to npm
providerRelease()	Create GitHub/GitLab releases

Basic Usage

Full Release

import { release } from 'relizy'

await release({
  type: 'patch',
  commit: true,
  tag: true,
  push: true,
  publish: false,
})

Version Bump Only

import { bump } from 'relizy'

const result = await bump({
  type: 'minor',
})

console.log(`New version: ${result.newVersion}`)

Changelog Generation

import { changelog } from 'relizy'

await changelog({
  from: 'v1.0.0',
  to: 'HEAD',
})

NPM Publishing

import { publish } from 'relizy'

await publish({
  packages: ['core', 'utils'],
  tag: 'latest',
  access: 'public',
})

Provider Release

import { providerRelease } from 'relizy'

await providerRelease({
  draft: false,
  prerelease: false,
})

Configuration

Load configuration from file:

import { loadConfig, release } from 'relizy'

const config = await loadConfig()

await release({
  ...config,
  type: 'minor',
})

Or define inline:

await release({
  type: 'minor',
  monorepo: {
    versionMode: 'selective',
    packageGlobs: ['packages/*'],
  },
  publish: true,
})

Error Handling

import { release } from 'relizy'

try {
  await release({
    type: 'minor',
  })
  console.log('Release successful!')
}
catch (error) {
  console.error('Release failed:', error.message)
  process.exit(1)
}

TypeScript Support

Relizy is written in TypeScript and provides full type definitions:

import type { BumpOptions, ReleaseOptions } from 'relizy'

const options: ReleaseOptions = {
  type: 'minor',
  publish: true,
  providerRelease: false,
}

Custom Workflows

Conditional Publishing

import { release } from 'relizy'

const isProduction = process.env.NODE_ENV === 'production'

await release({
  type: 'minor',
  publish: isProduction, // Only publish in production
  providerRelease: isProduction,
})

Multi-Stage Release

import { bump, changelog, providerRelease, publish } from 'relizy'

// Stage 1: Bump version
const { newVersion } = await bump({ type: 'minor' })

// Stage 2: Generate changelog
await changelog()

// Stage 3: Run tests
await runTests()

// Stage 4: Publish if tests pass
await publish()

// Stage 5: Create release
await providerRelease()

Monorepo Custom Logic

import { bump } from 'relizy'

// Get changed packages
const { packages } = await bump({
  type: 'minor',
  dryRun: true,
})

// Custom logic for each package
for (const pkg of packages) {
  console.log(`${pkg.name} will be bumped to ${pkg.newVersion}`)

  // Your custom logic here
  if (pkg.name === '@myorg/critical') {
    // Special handling for critical packages
  }
}

// Perform actual bump
await bump({ type: 'minor' })

Examples

Automated Release Script

#!/usr/bin/env node
import { release } from 'relizy'

async function main() {
  const releaseType = process.argv[2] || 'patch'

  console.log(`Starting ${releaseType} release...`)

  await release({
    releaseType,
    yes: true, // Skip prompts
    publish: true,
    providerRelease: true,
    logLevel: 'info',
  })

  console.log('Release complete!')
}

main().catch((error) => {
  console.error(error)
  process.exit(1)
})

CI/CD Integration

import { release } from 'relizy'

const isCI = process.env.CI === 'true'

await release({
  type: 'minor',
  yes: isCI, // Auto-confirm in CI
  noGitChecks: isCI, // Skip git checks in CI
  publish: isCI,
  providerRelease: isCI,
})

Next Steps

Explore individual API functions:

• release() - Complete release workflow
• bump() - Version bumping
• changelog() - Changelog generation
• publish() - NPM publishing
• providerRelease() - Provider releases
• createCommitAndTags() - Create commit and tags
• loadRelizyConfig() - Load Relizy config