@dockstat/docker 0.1.0 → 0.1.2

package/src/modules/volumes/index.ts

@@ -1,65 +0,0 @@
-import { BaseModule } from "../base"
-import type {
-  ListVolumesOptions,
-  PruneVolumesOptions,
-  Volume,
-  VolumeCreateRequest,
-  VolumeListResponse,
-  VolumePruneResponse,
-  VolumeUpdateRequest,
-} from "./types"
-
-/**
- * Volume module for Docker API
- */
-export class VolumeModule extends BaseModule {
-  /**
-   * List volumes
-   */
-  async list(options?: ListVolumesOptions): Promise<VolumeListResponse> {
-    const res = await this.request(`/volumes`, "GET", undefined, undefined, options)
-    return (await res.json()) as VolumeListResponse
-  }
-
-  /**
-   * Create a volume
-   */
-  async create(config: VolumeCreateRequest): Promise<Volume> {
-    const res = await this.request("/volumes/create", "POST", config)
-    return (await res.json()) as Volume
-  }
-
-  /**
-   * Inspect a volume
-   */
-  async inspect(name: string): Promise<Volume> {
-    const res = await this.request(`/volumes/${encodeURIComponent(name)}`)
-    return (await res.json()) as Volume
-  }
-
-  /**
-   * Update a volume (for cluster volumes only)
-   */
-  async update(name: string, body: VolumeUpdateRequest, version: number): Promise<void> {
-    await this.request(`/volumes/${encodeURIComponent(name)}`, "PUT", body, undefined, {
-      version,
-    })
-  }
-
-  /**
-   * Remove a volume
-   */
-  async remove(name: string, force: boolean = false): Promise<void> {
-    await this.request(`/volumes/${encodeURIComponent(name)}`, "DELETE", undefined, undefined, {
-      force,
-    })
-  }
-
-  /**
-   * Prune unused volumes
-   */
-  async prune(options?: PruneVolumesOptions): Promise<VolumePruneResponse> {
-    const res = await this.request(`/volumes/prune`, "POST", undefined, undefined, options)
-    return (await res.json()) as VolumePruneResponse
-  }
-}

package/src/modules/volumes/types.ts

@@ -1,197 +0,0 @@
-/**
- * Volume information
- */
-export interface Volume {
-  Name: string
-  Driver: string
-  Mountpoint: string
-  CreatedAt?: string
-  Status?: Record<string, string>
-  Labels: Record<string, string>
-  Scope: "local" | "global"
-  ClusterVolume?: ClusterVolume
-  Options?: Record<string, string>
-  UsageData?: VolumeUsageData
-}
-
-/**
- * Volume usage data
- */
-export interface VolumeUsageData {
-  Size: number
-  RefCount: number
-}
-
-/**
- * Volumes disk usage information
- */
-export interface VolumesDiskUsage {
-  ActiveCount: number
-  TotalCount: number
-  Reclaimable: number
-  TotalSize: number
-  Items?: Volume[]
-}
-
-/**
- * Volume create request
- */
-export interface VolumeCreateRequest {
-  Name?: string
-  Driver?: string
-  DriverOpts?: Record<string, string>
-  Labels?: Record<string, string>
-  ClusterVolumeSpec?: ClusterVolumeSpec
-}
-
-/**
- * Volume list response
- */
-export interface VolumeListResponse {
-  Volumes: Volume[]
-  Warnings?: string[]
-}
-
-/**
- * Volume prune response
- */
-export interface VolumePruneResponse {
-  VolumesDeleted?: string[]
-  SpaceReclaimed: number
-}
-
-/**
- * Cluster volume information (Swarm CSI cluster volumes)
- */
-export interface ClusterVolume {
-  ID?: string
-  Version?: ObjectVersion
-  CreatedAt?: string
-  UpdatedAt?: string
-  Spec?: ClusterVolumeSpec
-  Info?: ClusterVolumeInfo
-  PublishStatus?: ClusterVolumePublishStatus[]
-}
-
-/**
- * Object version
- */
-export interface ObjectVersion {
-  Index: number
-}
-
-/**
- * Cluster volume spec
- */
-export interface ClusterVolumeSpec {
-  Group?: string
-  AccessMode?: ClusterVolumeAccessMode
-  Secrets?: ClusterVolumeSecret[]
-  AccessibilityRequirements?: ClusterVolumeAccessibilityRequirements
-  CapacityRange?: ClusterVolumeCapacityRange
-  Availability?: "active" | "pause" | "drain"
-}
-
-/**
- * Cluster volume access mode
- */
-export interface ClusterVolumeAccessMode {
-  Scope: "single" | "multi"
-  Sharing: "none" | "readonly" | "onewriter" | "all"
-  MountVolume?: ClusterVolumeMountVolume
-  BlockVolume?: ClusterVolumeBlockVolume
-}
-
-/**
- * Cluster volume mount volume options
- */
-export interface ClusterVolumeMountVolume {
-  FsType?: string
-  MountFlags?: string[]
-}
-
-/**
- * Cluster volume block volume options
- */
-export interface ClusterVolumeBlockVolume {
-  [key: string]: string
-}
-
-/**
- * Cluster volume secret
- */
-export interface ClusterVolumeSecret {
-  Key: string
-  Secret: string
-}
-
-/**
- * Cluster volume accessibility requirements
- */
-export interface ClusterVolumeAccessibilityRequirements {
-  Requisite?: Topology[]
-  Preferred?: Topology[]
-}
-
-/**
- * Cluster volume capacity range
- */
-export interface ClusterVolumeCapacityRange {
-  RequiredBytes?: number
-  LimitBytes?: number
-}
-
-/**
- * Cluster volume info
- */
-export interface ClusterVolumeInfo {
-  CapacityBytes?: number
-  VolumeContext?: Record<string, string>
-  VolumeID?: string
-  AccessibleTopology?: Topology[]
-}
-
-/**
- * Cluster volume publish status
- */
-export interface ClusterVolumePublishStatus {
-  NodeID: string
-  State: "pending-publish" | "published" | "pending-node-unpublish" | "pending-controller-unpublish"
-  PublishContext?: Record<string, string>
-}
-
-/**
- * Topology information
- */
-export interface Topology {
-  [key: string]: string
-}
-
-/**
- * List volumes options
- */
-export interface ListVolumesOptions {
-  filters?: {
-    dangling?: boolean[]
-    driver?: string[]
-    label?: string[]
-    name?: string[]
-  }
-}
-
-/**
- * Prune volumes options
- */
-export interface PruneVolumesOptions {
-  filters?: {
-    label?: string[]
-    all?: boolean[]
-  }
-}
-
-/**
- * Volume update request (for cluster volumes)
- */
-export interface VolumeUpdateRequest {
-  Spec: ClusterVolumeSpec
-}

package/src/utils/env.ts

@@ -1,48 +0,0 @@
-import { env } from "node:process"
-import type { ConnectionConfig } from "../modules/base/types"
-
-const loadTls = () => {
-  const hasCerts = env.CERT_FILE && env.KEY_FILE
-  if (!hasCerts) return undefined
-
-  return {
-    ca: env.CA_FILE ? Bun.file(env.CA_FILE) : undefined,
-    cert: env.CERT_FILE ? Bun.file(env.CERT_FILE) : undefined,
-    key: env.KEY_FILE ? Bun.file(env.KEY_FILE) : undefined,
-  }
-}
-
-export const getConnectionConfig = (): ConnectionConfig => {
-  const rawHost = env.DOCKER_SOCKET || "/var/run/docker.sock"
-  const tls = loadTls()
-
-  if (rawHost.startsWith("unix://")) {
-    return {
-      mode: "unix",
-      socketPath: rawHost.replace("unix://", ""),
-      tls,
-    }
-  }
-
-  if (rawHost.startsWith("tcp://") || rawHost.startsWith("http://")) {
-    let protocol = "http://"
-
-    if (tls) {
-      protocol = "https://"
-    }
-
-    const cleanHost = rawHost.replace(/^tcp:\/\/|^http:\/\//, "")
-
-    return {
-      mode: "tcp",
-      baseUrl: `${protocol}${cleanHost}`,
-      tls,
-    }
-  }
-
-  return {
-    mode: "unix",
-    socketPath: rawHost,
-    tls,
-  }
-}

package/src/utils/error.ts

@@ -1,23 +0,0 @@
-export class DockerError extends Error {
-  status: number
-  path: string
-  version: string
-  params: object | string
-
-  constructor(
-    message: string,
-    status: number,
-    path: string,
-    version: string,
-    params: object | string
-  ) {
-    super(message)
-    this.name = "DockerError"
-    this.status = status
-    this.path = path
-    this.version = version
-    this.params = params
-
-    Object.setPrototypeOf(this, DockerError.prototype)
-  }
-}

package/src/utils/request-options.ts

@@ -1,68 +0,0 @@
-import type { BodyInit, HeadersInit } from "bun"
-import type { ConnectionConfig, HttpMethod } from "../modules/base/types"
-
-export function prepareRequestOptions(
-  config: ConnectionConfig,
-  method: HttpMethod,
-  body?: BodyInit | object,
-  headers?: HeadersInit,
-  url?: string
-): BunFetchRequestInit {
-  const isJsonBody = typeof body === "object" && !(body instanceof FormData) && body !== undefined
-
-  const baseHeaders: Record<string, string> = {
-    Host: "localhost",
-  }
-
-  if (isJsonBody) {
-    baseHeaders["Content-Type"] = "application/json"
-  }
-
-  // Merge additional headers
-  if (headers) {
-    if (headers instanceof Headers) {
-      headers.forEach((value, key) => {
-        baseHeaders[key] = value
-      })
-    } else if (Array.isArray(headers)) {
-      headers.forEach(([key, value]) => {
-        if (key !== undefined && value !== undefined) {
-          baseHeaders[key] = value
-        }
-      })
-    } else {
-      Object.assign(baseHeaders, headers)
-    }
-  }
-
-  const requestBody = isJsonBody
-    ? JSON.stringify(body)
-    : (body as unknown as any)
-
-  const options: BunFetchRequestInit = {
-    method,
-    headers: baseHeaders,
-    body: requestBody,
-  }
-
-  if (config.mode !== "unix" && url) {
-    try {
-      const urlObj = new URL(url)
-      baseHeaders["Host"] = urlObj.host
-    } catch (_) {
-      // Ignore URL parsing errors, keep default Host
-    }
-  }
-
-  // Configure Unix socket
-  if (config.mode === "unix" && config.socketPath) {
-    options.unix = config.socketPath
-  }
-
-  // Configure TLS
-  if (config.tls) {
-    options.tls = config.tls
-  }
-
-  return options
-}

package/src/utils/response.ts

@@ -1,31 +0,0 @@
-import { DockerError } from "./error"
-
-export async function handleDockerResponse(
-  response: Response,
-  path: string,
-  apiVersion: string,
-  params:object | undefined
-): Promise<Response> {
-  if (!response.ok) {
-    let text = await response.text()
-
-    try {
-      const parsed = JSON.parse(text)
-      if (parsed.message) {
-        text = parsed.message
-      }
-    } catch (_) {
-      // If JSON parsing fails, we stick with the raw text response
-    }
-
-    throw new DockerError(
-      `Docker API Error (${response.status}): ${text}`,
-      response.status,
-      path,
-      apiVersion,
-      params || "No params defined"
-    )
-  }
-
-  return response
-}

package/src/utils/url.ts

@@ -1,48 +0,0 @@
-import type { ConnectionConfig } from "../modules/base/types"
-
-/**
- * Converts an object of parameters into a URL query string.
- * Handles strings, numbers, booleans, and JSON serializable objects.
- */
-export function buildQueryString(params?: object): string | undefined {
-  if (!params) return undefined
-
-  const urlParams = new URLSearchParams()
-
-  for (const [key, value] of Object.entries(params)) {
-    if (value === undefined) continue
-
-    if (typeof value === "string") {
-      urlParams.append(key, value)
-    } else if (typeof value === "number" || typeof value === "boolean") {
-      urlParams.append(key, value.toString())
-    } else {
-      urlParams.append(key, JSON.stringify(value))
-    }
-  }
-
-  return urlParams.toString()
-}
-
-/**
- * Constructs the full request URL based on the connection mode (Unix/Http) and API version.
- */
-export function buildDockerUrl(
-  config: ConnectionConfig,
-  path: string,
-  query: string | undefined,
-  apiVersion: string
-): string {
-  const queryString = query ? `?${query}` : ""
-
-  if (config.mode === "unix") {
-    // In Unix mode, the hostname doesn't matter
-    return `http://localhost/${apiVersion}${path}${queryString}`
-  }
-
-  // HTTP/HTTPS mode
-  const baseUrl = config.baseUrl || ""
-  const separator = baseUrl.endsWith("/") ? "" : "/"
-
-  return `${baseUrl}${separator}${apiVersion}${path}${queryString}`
-}