@book000/node-utils 1.2.28 → 1.2.30

package/src/discord.ts

@@ -0,0 +1,219 @@
+import axios from 'axios'
+import FormData from 'form-data'
+
+interface DiscordBotOptions {
+  token: string
+  channelId: string
+}
+
+interface DiscordWebhookOptions {
+  webhookUrl: string
+}
+
+export type DiscordOptions = DiscordBotOptions | DiscordWebhookOptions
+export interface DiscordEmbedFooter {
+  text: string
+  icon_url?: string
+  proxy_icon_url?: string
+}
+
+export interface DiscordEmbedImage {
+  url?: string
+  proxy_url?: string
+  height?: number
+  width?: number
+}
+
+export interface DiscordEmbedThumbnail {
+  url?: string
+  proxy_url?: string
+  height?: number
+  width?: number
+}
+
+export interface DiscordEmbedVideo {
+  url?: string
+  proxy_url?: string
+  height?: number
+  width?: number
+}
+
+export interface DiscordEmbedProvider {
+  name?: string
+  url?: string
+}
+
+export interface DiscordEmbedAuthor {
+  name?: string
+  url?: string
+  icon_url?: string
+  proxy_icon_url?: string
+}
+
+export interface DiscordEmbedField {
+  name: string
+  value: string
+  inline?: boolean
+}
+
+export interface DiscordEmbed {
+  title?: string
+  type?: 'rich' | 'image' | 'video' | 'gifv' | 'article' | 'link'
+  description?: string
+  url?: string
+  timestamp?: string
+  color?: number
+  footer?: DiscordEmbedFooter
+  image?: DiscordEmbedImage
+  thumbnail?: DiscordEmbedThumbnail
+  video?: DiscordEmbedVideo
+  provider?: DiscordEmbedProvider
+  author?: DiscordEmbedAuthor
+  fields?: DiscordEmbedField[]
+}
+
+interface DiscordNormalMessage {
+  content: string
+}
+
+interface DiscordEmbedMessage {
+  embeds: DiscordEmbed[]
+}
+
+interface DiscordFile {
+  name: string
+  file: ArrayBuffer
+  contentType?: string
+  isSpoiler?: boolean
+}
+
+interface DiscordFileMessage {
+  file: DiscordFile
+}
+
+export type DiscordMessage =
+  | DiscordNormalMessage
+  | DiscordEmbedMessage
+  | DiscordFileMessage
+
+export class Discord {
+  private options: DiscordOptions
+
+  constructor(options: DiscordOptions) {
+    // token があれば Bot として動作する
+    // webhookUrl と channelId があれば Webhook として動作する
+    // どちらもなければエラーを投げる
+
+    if (this.isDiscordBotOptions(options)) {
+      this.options = options
+    } else if (this.isDiscordWebhookOptions(options)) {
+      this.options = options
+    } else {
+      throw new Error('Invalid options')
+    }
+  }
+
+  public static get validations(): {
+    [key: string]: (options: any) => boolean
+  } {
+    return {
+      'token or webhookUrl and channelId': (options: any) =>
+        'token' in options ||
+        ('webhookUrl' in options && 'channelId' in options),
+      'token is valid': (options: any) => typeof options.token === 'string',
+      'webhookUrl is valid': (options: any) =>
+        typeof options.webhookUrl === 'string',
+      'channelId is valid': (options: any) =>
+        typeof options.channelId === 'string',
+    }
+  }
+
+  public async sendMessage(message: string | DiscordMessage): Promise<void> {
+    const formData = new FormData()
+
+    if (typeof message === 'string') {
+      formData.append('payload_json', JSON.stringify({ content: message }))
+    } else {
+      formData.append(
+        'payload_json',
+        JSON.stringify({
+          content: 'content' in message ? message.content : undefined,
+          embeds: 'embeds' in message ? message.embeds : undefined,
+        })
+      )
+
+      if ('file' in message) {
+        formData.append('file', message.file.file, {
+          filename: `${message.file.isSpoiler === true ? 'SPOILER_' : ''}${
+            message.file.name
+          }`,
+          contentType: message.file.contentType,
+        })
+      }
+    }
+
+    await (this.isDiscordBotOptions(this.options)
+      ? this.sendBot(formData)
+      : this.sendWebhook(formData))
+  }
+
+  private async sendBot(formData: FormData): Promise<void> {
+    if (!this.isDiscordBotOptions(this.options)) {
+      throw new Error('Invalid bot options')
+    }
+
+    const response = await axios.post(
+      `https://discord.com/api/channels/${this.options}/messages`,
+      formData,
+      {
+        headers: {
+          ...formData.getHeaders(),
+          Authorization: `Bot ${this.options.token}`,
+        },
+        validateStatus: () => true,
+      }
+    )
+    if (response.status !== 200) {
+      throw new Error(`Discord API returned ${response.status}`)
+    }
+  }
+
+  private async sendWebhook(formData: FormData): Promise<void> {
+    if (!this.isDiscordWebhookOptions(this.options)) {
+      throw new Error('Invalid webhook options')
+    }
+
+    const response = await axios.post(this.options.webhookUrl, formData, {
+      headers: {
+        ...formData.getHeaders(),
+      },
+      validateStatus: () => true,
+    })
+    if (response.status !== 200 && response.status !== 204) {
+      throw new Error(`Discord API returned ${response.status}`)
+    }
+  }
+
+  private isDiscordBotOptions(
+    options: DiscordOptions
+  ): options is DiscordBotOptions {
+    return (
+      'token' in options &&
+      typeof options.token === 'string' &&
+      options.token.length > 0 &&
+      'channelId' in options &&
+      typeof options.channelId === 'string' &&
+      options.channelId.length > 0
+    )
+  }
+
+  private isDiscordWebhookOptions(
+    options: DiscordOptions
+  ): options is DiscordWebhookOptions {
+    return (
+      'webhookUrl' in options &&
+      typeof options.webhookUrl === 'string' &&
+      options.webhookUrl.length > 0
+    )
+  }
+}

package/src/examples/example-configuration.ts

@@ -0,0 +1,33 @@
+import { ConfigFramework, Logger } from '..'
+
+export interface Configuration {
+  foo: string
+  bar: number
+}
+
+class ExampleConfiguration extends ConfigFramework<Configuration> {
+  protected validates(): { [key: string]: (config: Configuration) => boolean } {
+    return {
+      // ...Discord.validations, // When using a message transmission to Discord
+      'foo is required': (config) => config.foo !== undefined,
+      'foo is string': (config) => typeof config.foo === 'string',
+      'foo is 3 or more characters': (config) => config.foo.length >= 3,
+      'bar is required': (config) => config.bar !== undefined,
+      'bar is number': (config) => typeof config.bar === 'number',
+    }
+  }
+}
+
+export function exampleConfiguration() {
+  const logger = Logger.configure('exampleConfiguration')
+  const config = new ExampleConfiguration()
+  config.load()
+  if (!config.validate()) {
+    logger.error('Configuration validation failed')
+    logger.error(config.getValidateFailures().join(', '))
+    return
+  }
+
+  logger.info(`foo: ${config.get('foo')}`)
+  logger.info(`bar: ${config.get('bar')}`)
+}

package/src/examples/example-discord.ts

@@ -0,0 +1,28 @@
+import { Discord, Logger } from '..'
+
+export async function exampleDiscord() {
+  const logger = Logger.configure('exampleDiscord')
+
+  const discordWebhookUrl = process.env.DISCORD_WEBHOOK_URL
+  if (!discordWebhookUrl) {
+    logger.error('DISCORD_WEBHOOK_URL are required')
+    return
+  }
+
+  const discord = new Discord({
+    webhookUrl: discordWebhookUrl,
+  })
+
+  await discord.sendMessage('Hello world!')
+
+  await discord.sendMessage({
+    embeds: [
+      {
+        title: 'Hello world!',
+        description:
+          'Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.',
+        color: 0x00_ff_00,
+      },
+    ],
+  })
+}

package/src/examples/example-logger.ts

@@ -0,0 +1,6 @@
+import { Logger } from '..'
+
+export function exampleLogger() {
+  const logger = Logger.configure('exampleLogger')
+  logger.info('Hello world!')
+}

package/src/examples/main.ts

@@ -0,0 +1,38 @@
+import { Logger } from '@/logger'
+import { Configuration, exampleConfiguration } from './example-configuration'
+import { exampleLogger } from './example-logger'
+import { exampleDiscord } from './example-discord'
+import fs from 'node:fs'
+import os from 'node:os'
+
+async function main() {
+  const logger = Logger.configure('main')
+  logger.info('Running main()')
+
+  logger.info('Calling exampleLogger()')
+  exampleLogger()
+
+  logger.info('Create dummy configuration file')
+  const config: Configuration = {
+    foo: 'foo',
+    bar: 123,
+  }
+  const temporaryConfigPath = `${os.tmpdir()}/config.json`
+  fs.writeFileSync(temporaryConfigPath, JSON.stringify(config))
+
+  logger.info('Set environment variable')
+  process.env.CONFIG_PATH = temporaryConfigPath
+
+  logger.info('Calling exampleConfiguration()')
+  exampleConfiguration()
+
+  logger.info('Remove dummy configuration file')
+  fs.unlinkSync(temporaryConfigPath)
+
+  logger.info('Calling exampleDiscord()')
+  await exampleDiscord()
+}
+
+;(async () => {
+  await main()
+})()

package/src/index.ts

@@ -0,0 +1,3 @@
+export * from './configuration'
+export * from './discord'
+export * from './logger'

package/src/logger.ts

@@ -0,0 +1,168 @@
+import winston, { format } from 'winston'
+import WinstonDailyRotateFile from 'winston-daily-rotate-file'
+import { Format } from 'logform'
+import cycle from 'cycle'
+
+/**
+ * ロガーラッパークラス
+ */
+export class Logger {
+  private readonly logger: winston.Logger
+
+  private constructor(logger: winston.Logger) {
+    this.logger = logger
+  }
+
+  /**
+   * デバッグログを出力する
+   *
+   * @param message メッセージ
+   * @param metadata メタデータ
+   */
+  public debug(message: string, metadata?: Record<string, unknown>): void {
+    this.logger.debug(message, metadata || {})
+  }
+
+  /**
+   * 情報ログを出力する
+   *
+   * @param message メッセージ
+   * @param metadata メタデータ
+   */
+  public info(message: string, metadata?: Record<string, unknown>): void {
+    this.logger.info(message, metadata || {})
+  }
+
+  /**
+   * 警告ログを出力する
+   *
+   * @param message メッセージ
+   * @param error エラー
+   */
+  public warn(message: string, error?: Error): void {
+    this.logger.warn(message, error)
+  }
+
+  /**
+   * エラーログを出力する
+   *
+   * @param message メッセージ
+   * @param error エラー
+   */
+  public error(message: string, error?: Error): void {
+    this.logger.error(message, error)
+  }
+
+  /**
+   * ロガーを初期化・設定する
+   *
+   * 環境変数で以下の設定が可能
+   * - LOG_LEVEL: ログレベル (デフォルト info)
+   * - LOG_FILE_LEVEL: ファイル出力のログレベル (デフォルト info)
+   * - LOG_DIR: ログ出力先 (デフォルト logs)
+   * - LOG_FILE_MAX_AGE: ログファイルの最大保存期間 (デフォルト 30d)
+   * - LOG_FILE_FORMAT: ログファイルのフォーマット (デフォルト text)
+   *
+   * @param category カテゴリ
+   * @returns ロガー
+   */
+  public static configure(category: string): Logger {
+    const logLevel = process.env.LOG_LEVEL || 'info'
+    const logFileLevel = process.env.LOG_FILE_LEVEL || 'info'
+    const logDirectory = process.env.LOG_DIR || 'logs'
+    const logFileMaxAge = process.env.LOG_FILE_MAX_AGE || '30d'
+    const selectLogFileFormat = process.env.LOG_FILE_FORMAT || 'text'
+
+    const textFormat = format.printf((info) => {
+      const { timestamp, level, message, ...rest } = info
+      // eslint-disable-next-line unicorn/no-array-reduce
+      const filteredRest = Object.keys(rest).reduce((accumulator, key) => {
+        if (key === 'stack') {
+          return accumulator
+        }
+        return {
+          ...accumulator,
+          [key]: rest[key],
+        }
+      }, {})
+      const standardLine = [
+        '[',
+        timestamp,
+        '] [',
+        category ?? '',
+        category ? '/' : '',
+        level.toLocaleUpperCase(),
+        ']: ',
+        message,
+        Object.keys(filteredRest).length > 0
+          ? ` (${JSON.stringify(filteredRest)})`
+          : '',
+      ].join('')
+      const errorLine = info.stack
+        ? info.stack.split('\n').slice(1).join('\n')
+        : undefined
+
+      return [standardLine, errorLine].filter((l) => l !== undefined).join('\n')
+    })
+    const logFileFormat =
+      selectLogFileFormat === 'ndjson' ? format.json() : textFormat
+    const decycleFormat = format((info) => cycle.decycle(info))
+    const fileFormat = format.combine(
+      ...([
+        format.errors({ stack: true }),
+        selectLogFileFormat === 'ndjson'
+          ? format.colorize({
+              message: true,
+            })
+          : format.uncolorize(),
+        decycleFormat(),
+        format.timestamp({
+          format: 'YYYY-MM-DD hh:mm:ss.SSS',
+        }),
+        logFileFormat,
+      ].filter((f) => f !== undefined) as Format[])
+    )
+    const consoleFormat = format.combine(
+      ...([
+        format.colorize({
+          message: true,
+        }),
+        decycleFormat(),
+        format.timestamp({
+          format: 'YYYY-MM-DD hh:mm:ss.SSS',
+        }),
+        textFormat,
+      ].filter((f) => f !== undefined) as Format[])
+    )
+    const extension = selectLogFileFormat === 'ndjson' ? 'ndjson' : 'log'
+    const transportRotateFile = new WinstonDailyRotateFile({
+      level: logFileLevel,
+      dirname: logDirectory,
+      filename: `%DATE%.` + extension,
+      datePattern: 'YYYY-MM-DD',
+      maxFiles: logFileMaxAge,
+      format: fileFormat,
+      auditFile: `${logDirectory}/audit.json`,
+    })
+
+    const logger = winston.createLogger({
+      transports: [
+        new winston.transports.Console({
+          level: logLevel,
+          format: consoleFormat,
+        }),
+        transportRotateFile,
+      ],
+    })
+    return new Logger(logger)
+  }
+}
+
+process.on('unhandledRejection', (reason) => {
+  const logger = Logger.configure('main')
+  logger.error('unhandledRejection', reason as Error)
+})
+process.on('uncaughtException', (error) => {
+  const logger = Logger.configure('main')
+  logger.error('uncaughtException', error)
+})

package/tsconfig.json

@@ -0,0 +1,32 @@
+{
+  "ts-node": { "files": true },
+  "compilerOptions": {
+    "target": "es2020",
+    "module": "commonjs",
+    "moduleResolution": "Node",
+    "lib": ["ESNext", "esnext.AsyncIterable"],
+    "outDir": "./dist",
+    "removeComments": true,
+    "esModuleInterop": true,
+    "allowJs": true,
+    "checkJs": true,
+    "incremental": true,
+    "sourceMap": true,
+    "declaration": true,
+    "declarationMap": true,
+    "strict": true,
+    "noImplicitAny": true,
+    "strictBindCallApply": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "noImplicitReturns": true,
+    "noFallthroughCasesInSwitch": true,
+    "experimentalDecorators": true,
+    "baseUrl": ".",
+    "newLine": "LF",
+    "paths": {
+      "@/*": ["src/*"]
+    }
+  },
+  "include": ["src/**/*"]
+}