@atproto/common

import { subsystemLogger } from '@atproto/common'

// Create a subsystem logger
const log = subsystemLogger('my-service')

log.info({ msg: 'Service started', port: 3000 })
log.error({ err, msg: 'Request failed' })
log.debug({ user: 'alice.bsky.social', msg: 'Processing request' })

import { envInt, envStr, envBool, envList } from '@atproto/common'

// Parse integer with fallback
const port = envInt('PORT') ?? 3000

// Get string value
const hostname = envStr('HOSTNAME')

// Parse boolean
const enableCache = envBool('ENABLE_CACHE') ?? false

// Parse comma-separated list
const allowedOrigins = envList('ALLOWED_ORIGINS')

import { 
  bufferToStream,
  streamToBuffer,
  streamToNodeBuffer,
  readStreamAsBuffer
} from '@atproto/common'

// Convert buffer to stream
const stream = bufferToStream(Buffer.from('hello'))

// Convert stream to buffer
const buf = await streamToBuffer(stream)

// Convert web ReadableStream to Node Buffer
const nodeBuf = await streamToNodeBuffer(webStream)

import { 
  cloneStream,
  streamSize,
  MaxSizeChecker
} from '@atproto/common'

// Clone a stream for multiple consumers
const [stream1, stream2] = cloneStream(originalStream)

// Check stream size
const size = await streamSize(stream)

// Create a size-checking transform stream
const checker = new MaxSizeChecker(1024 * 1024) // 1MB max
inputStream.pipe(checker).pipe(outputStream)

import { 
  ensureDir,
  fileExists,
  readFile,
  writeFile,
  deleteFile
} from '@atproto/common'

// Ensure directory exists
await ensureDir('/path/to/dir')

// Check if file exists
const exists = await fileExists('/path/to/file')

// Read file as buffer
const data = await readFile('/path/to/file')

// Write buffer to file
await writeFile('/path/to/file', data)

// Delete file
await deleteFile('/path/to/file')

import { 
  verifyBlocks,
  readFromBlockstore,
  writeToBlockstore
} from '@atproto/common'

import { BlockMap } from '@atproto/repo'

// Verify block integrity
await verifyBlocks(cid, blockMap)

// Read IPLD data from blockstore
const data = await readFromBlockstore(cid, blockstore)

// Write IPLD data to blockstore
await writeToBlockstore(obj, blockstore)

import { parseDate, isValidDate } from '@atproto/common'

// Parse ISO 8601 date string
const date = parseDate('2024-03-04T12:00:00Z')

// Validate date string
if (isValidDate('2024-03-04T12:00:00Z')) {
  // Valid ISO 8601 date
}

import { obfuscateString } from '@atproto/common'

// Obfuscate sensitive string (shows first/last chars)
const obfuscated = obfuscateString('my-secret-token-12345')
// Returns: 'my...45'

// Useful for logging
log.info({ 
  token: obfuscateString(apiToken), 
  msg: 'API request' 
})

import { TID, retry, chunkArray } from '@atproto/common'

// All common-web utilities work the same way
const tid = TID.nextStr()
const chunks = chunkArray([1, 2, 3, 4, 5], 2)

import express from 'express'
import { 
  subsystemLogger, 
  envInt, 
  envStr, 
  envBool 
} from '@atproto/common'

// Create logger
const log = subsystemLogger('server')

// Load configuration
const config = {
  port: envInt('PORT') ?? 3000,
  hostname: envStr('HOSTNAME') ?? 'localhost',
  debug: envBool('DEBUG') ?? false
}

// Create server
const app = express()

app.get('/health', (req, res) => {
  log.debug({ msg: 'Health check' })
  res.json({ status: 'ok' })
})

app.listen(config.port, () => {
  log.info({ 
    port: config.port, 
    hostname: config.hostname,
    msg: 'Server started' 
  })
})

import type { Logger } from 'pino'
import { subsystemLogger } from '@atproto/common'

// Logger type is exported from pino
const log: Logger = subsystemLogger('my-service')