skyltmax_config 0.0.8 → 0.0.9

data/scripts/peer-deps/audit.js

@@ -0,0 +1,116 @@
+#!/usr/bin/env node
+
+import { existsSync } from "node:fs"
+import { readFile } from "node:fs/promises"
+import { createRequire } from "node:module"
+import { dirname, resolve } from "node:path"
+import { fileURLToPath } from "node:url"
+
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = dirname(__filename)
+const defaultManifestPath = resolve(__dirname, "..", "..", "package.json")
+const defaultConsumerRoot = process.env.INIT_CWD ?? process.env.npm_config_local_prefix ?? process.cwd()
+
+async function readManifest(path) {
+  const raw = await readFile(path, "utf8")
+  return JSON.parse(raw)
+}
+
+function createConsumerRequire(root) {
+  const candidate = resolve(root, "package.json")
+  if (existsSync(candidate)) {
+    return createRequire(candidate)
+  }
+
+  return createRequire(import.meta.url)
+}
+
+export async function auditPeerDependencies({
+  manifestPath = defaultManifestPath,
+  consumerRoot = defaultConsumerRoot,
+} = {}) {
+  const manifest = await readManifest(manifestPath)
+  const peers = Object.entries(manifest.peerDependencies ?? {})
+
+  if (!peers.length) {
+    return {
+      peers,
+      missing: [],
+      mismatched: [],
+    }
+  }
+
+  const requireFromConsumer = createConsumerRequire(consumerRoot)
+  const missing = []
+  const mismatched = []
+
+  for (const [name, expectedVersion] of peers) {
+    let resolvedPackageJson
+    try {
+      resolvedPackageJson = requireFromConsumer.resolve(`${name}/package.json`)
+    } catch (error) {
+      missing.push({ name, expectedVersion, reason: error.message })
+      continue
+    }
+
+    try {
+      const pkg = JSON.parse(await readFile(resolvedPackageJson, "utf8"))
+      const actualVersion = pkg.version
+      if (actualVersion !== expectedVersion) {
+        mismatched.push({ name, expectedVersion, actualVersion })
+      }
+    } catch (error) {
+      mismatched.push({ name, expectedVersion, actualVersion: "unknown", reason: error.message })
+    }
+  }
+
+  return {
+    peers,
+    missing,
+    mismatched,
+  }
+}
+
+export function formatAuditMessage({ missing, mismatched }) {
+  if (!missing.length && !mismatched.length) {
+    return null
+  }
+
+  const lines = ["[signmax-config] Peer dependency check detected issues:"]
+
+  if (missing.length) {
+    lines.push("  Missing peers:")
+    for (const item of missing) {
+      lines.push(`    - ${item.name}@${item.expectedVersion}`)
+    }
+  }
+
+  if (mismatched.length) {
+    lines.push("  Version mismatches:")
+    for (const item of mismatched) {
+      const details = item.actualVersion ? ` (found ${item.actualVersion})` : ""
+      lines.push(`    - ${item.name}@${item.expectedVersion}${details}`)
+    }
+  }
+
+  lines.push('  Run "npx signmax-config-peers" to install the correct versions.')
+
+  return lines.join("\n")
+}
+
+export async function runPostinstallAudit() {
+  try {
+    const result = await auditPeerDependencies()
+    const message = formatAuditMessage(result)
+
+    if (message) {
+      console.warn(message)
+    }
+  } catch (error) {
+    console.warn(`[signmax-config] Peer dependency check skipped: ${error.message}`)
+  }
+}
+
+if (process.argv[1] === __filename) {
+  runPostinstallAudit()
+}

data/scripts/peer-deps/install.js

@@ -0,0 +1,160 @@
+#!/usr/bin/env node
+import { spawn } from "node:child_process"
+import { existsSync } from "node:fs"
+import { readFile } from "node:fs/promises"
+import { dirname, resolve } from "node:path"
+import { fileURLToPath } from "node:url"
+
+const HELP = `Usage: signmax-config-peers [options]
+
+Options:
+  --manager <name>   npm | pnpm | bun (auto-detected by default)
+  --dry-run          Print the install command without running it
+  --help             Show this help message
+`
+
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = dirname(__filename)
+const defaultManifestPath = resolve(__dirname, "..", "..", "package.json")
+
+export async function loadPeerDependencies(manifestPath = defaultManifestPath) {
+  const manifest = JSON.parse(await readFile(manifestPath, "utf8"))
+  const peers = manifest.peerDependencies ?? {}
+  return Object.entries(peers).map(([name, version]) => `${name}@${version}`)
+}
+
+export function detectManager({ managerArg, userAgent = "", cwd = process.cwd() } = {}) {
+  if (managerArg) return managerArg
+
+  if (userAgent.startsWith("pnpm/")) return "pnpm"
+  if (userAgent.startsWith("bun/")) return "bun"
+  if (userAgent.startsWith("npm/")) return "npm"
+
+  if (existsSync(resolve(cwd, "pnpm-lock.yaml"))) return "pnpm"
+  if (existsSync(resolve(cwd, "bun.lockb"))) return "bun"
+  if (existsSync(resolve(cwd, "package-lock.json"))) return "npm"
+
+  return "npm"
+}
+
+export function buildInstallCommand(manager, packages) {
+  if (!packages.length) {
+    throw new Error("No peer dependencies to install.")
+  }
+
+  const commandByManager = {
+    npm: {
+      command: "npm",
+      args: ["install", "--save-dev", "--save-exact", ...packages],
+    },
+    pnpm: {
+      command: "pnpm",
+      args: ["add", "-D", "--save-exact", ...packages],
+    },
+    bun: {
+      command: "bun",
+      args: ["add", "--dev", "--exact", ...packages],
+    },
+  }
+
+  const selected = commandByManager[manager]
+
+  if (!selected) {
+    const supported = Object.keys(commandByManager).join(", ")
+    throw new Error(`Unsupported package manager: ${manager}. Supported managers: ${supported}`)
+  }
+
+  return selected
+}
+
+export function formatCommand({ command, args }) {
+  return `${command} ${args.join(" ")}`
+}
+
+export async function prepareInstall({
+  managerArg,
+  cwd = process.cwd(),
+  env = process.env,
+  manifestPath = defaultManifestPath,
+} = {}) {
+  const packages = await loadPeerDependencies(manifestPath)
+
+  if (packages.length === 0) {
+    return { packages: [] }
+  }
+
+  const manager = detectManager({ managerArg, userAgent: env.npm_config_user_agent ?? "", cwd })
+  const command = buildInstallCommand(manager, packages)
+
+  return {
+    manager,
+    packages,
+    command: command.command,
+    args: command.args,
+    printable: formatCommand(command),
+  }
+}
+
+export async function runCli({ args = process.argv.slice(2), env = process.env, cwd = process.cwd() } = {}) {
+  if (args.includes("--help")) {
+    process.stdout.write(HELP)
+    return 0
+  }
+
+  const argValue = flag => {
+    const index = args.indexOf(flag)
+    if (index === -1) return undefined
+    return args[index + 1]
+  }
+
+  const managerArg = argValue("--manager")
+  const dryRun = args.includes("--dry-run")
+
+  try {
+    const result = await prepareInstall({ managerArg, cwd, env })
+
+    if (!result.packages || result.packages.length === 0) {
+      process.stdout.write("No peer dependencies found on @signmax/config.\n")
+      return 0
+    }
+
+    if (dryRun) {
+      process.stdout.write(`${result.printable}\n`)
+      return 0
+    }
+
+    process.stdout.write(`Running: ${result.printable}\n`)
+
+    const child = spawn(result.command, result.args, {
+      stdio: "inherit",
+    })
+
+    return await new Promise((resolve, reject) => {
+      child.on("close", code => {
+        if (code === 0) {
+          resolve(0)
+        } else {
+          reject(new Error(`${result.command} exited with code ${code}`))
+        }
+      })
+
+      child.on("error", error => {
+        reject(error)
+      })
+    })
+  } catch (error) {
+    process.stderr.write(`${error.message}\n`)
+    return 1
+  }
+}
+
+if (process.argv[1] === __filename) {
+  runCli()
+    .then(code => {
+      process.exit(code)
+    })
+    .catch(error => {
+      process.stderr.write(`${error.message}\n`)
+      process.exit(1)
+    })
+}

data/tests/check-peers.test.js

@@ -0,0 +1,76 @@
+import { mkdtemp, writeFile, mkdir } from "node:fs/promises"
+import { tmpdir } from "node:os"
+import { join } from "node:path"
+import { fileURLToPath } from "node:url"
+import { describe, expect, test } from "vitest"
+
+import { auditPeerDependencies, formatAuditMessage } from "../scripts/peer-deps/audit.js"
+
+const fixturePath = relative => fileURLToPath(new URL(`./fixtures/${relative}`, import.meta.url))
+
+async function createPackage(root, name, version) {
+  const parts = name.split("/")
+  const packageDir = join(root, "node_modules", ...parts)
+  await mkdir(packageDir, { recursive: true })
+  await writeFile(join(packageDir, "package.json"), JSON.stringify({ name, version }), "utf8")
+}
+
+async function createProjectRoot() {
+  const root = await mkdtemp(join(tmpdir(), "signmax-check-peers-"))
+  await writeFile(join(root, "package.json"), JSON.stringify({ name: "example", version: "1.0.0" }), "utf8")
+  return root
+}
+
+describe("check-peers audit", () => {
+  test("returns empty when all peers match", async () => {
+    const root = await createProjectRoot()
+    await createPackage(root, "eslint", "9.39.1")
+    await createPackage(root, "prettier", "3.6.2")
+
+    const result = await auditPeerDependencies({
+      manifestPath: fixturePath("manifest-with-peers.json"),
+      consumerRoot: root,
+    })
+
+    expect(result.missing).toEqual([])
+    expect(result.mismatched).toEqual([])
+    expect(formatAuditMessage(result)).toBeNull()
+  })
+
+  test("detects missing peers", async () => {
+    const root = await createProjectRoot()
+    await createPackage(root, "eslint", "9.39.1")
+
+    const result = await auditPeerDependencies({
+      manifestPath: fixturePath("manifest-with-peers.json"),
+      consumerRoot: root,
+    })
+
+    expect(result.missing.map(item => item.name)).toEqual(["prettier"])
+    const message = formatAuditMessage(result)
+    expect(message).toContain("Missing peers")
+    expect(message).toContain("prettier@3.6.2")
+  })
+
+  test("detects version mismatches", async () => {
+    const root = await createProjectRoot()
+    await createPackage(root, "eslint", "9.0.0")
+    await createPackage(root, "prettier", "3.6.2")
+
+    const result = await auditPeerDependencies({
+      manifestPath: fixturePath("manifest-with-peers.json"),
+      consumerRoot: root,
+    })
+
+    expect(result.mismatched).toEqual([
+      {
+        name: "eslint",
+        expectedVersion: "9.39.1",
+        actualVersion: "9.0.0",
+      },
+    ])
+    const message = formatAuditMessage(result)
+    expect(message).toContain("Version mismatches")
+    expect(message).toContain("eslint@9.39.1 (found 9.0.0)")
+  })
+})

data/tests/fixtures/manifest-no-peers.json

@@ -0,0 +1,3 @@
+{
+  "name": "example"
+}

data/tests/fixtures/manifest-with-peers.json

@@ -0,0 +1,6 @@
+{
+  "peerDependencies": {
+    "eslint": "9.39.1",
+    "prettier": "3.6.2"
+  }
+}

data/tests/install-peers.test.js

@@ -0,0 +1,79 @@
+import { mkdtemp, writeFile } from "node:fs/promises"
+import { tmpdir } from "node:os"
+import { join } from "node:path"
+import { fileURLToPath } from "node:url"
+import { describe, expect, test } from "vitest"
+
+import {
+  buildInstallCommand,
+  detectManager,
+  formatCommand,
+  loadPeerDependencies,
+  prepareInstall,
+} from "../scripts/peer-deps/install.js"
+
+const fixturePath = relative => fileURLToPath(new URL(`./fixtures/${relative}`, import.meta.url))
+
+describe("install-peers helper", () => {
+  test("loadPeerDependencies returns pinned peers", async () => {
+    const peers = await loadPeerDependencies(fixturePath("manifest-with-peers.json"))
+    expect(peers).toEqual(["eslint@9.39.1", "prettier@3.6.2"])
+  })
+
+  test("loadPeerDependencies handles missing peers", async () => {
+    const peers = await loadPeerDependencies(fixturePath("manifest-no-peers.json"))
+    expect(peers).toEqual([])
+  })
+
+  test("detectManager respects explicit flag", () => {
+    const manager = detectManager({ managerArg: "pnpm" })
+    expect(manager).toBe("pnpm")
+  })
+
+  test("detectManager infers from user agent", () => {
+    const manager = detectManager({ userAgent: "pnpm/9.0.0 npm/?" })
+    expect(manager).toBe("pnpm")
+  })
+
+  test("detectManager infers from lockfile", async () => {
+    const dir = await mkdtemp(join(tmpdir(), "signmax-config-"))
+    await writeFile(join(dir, "bun.lockb"), "")
+    const manager = detectManager({ cwd: dir })
+    expect(manager).toBe("bun")
+  })
+
+  test("buildInstallCommand supports npm", () => {
+    const result = buildInstallCommand("npm", ["eslint@9.39.1"])
+    expect(result.command).toBe("npm")
+    expect(result.args).toEqual(["install", "--save-dev", "--save-exact", "eslint@9.39.1"])
+    expect(formatCommand(result)).toBe("npm install --save-dev --save-exact eslint@9.39.1")
+  })
+
+  test("buildInstallCommand throws on unsupported manager", () => {
+    expect(() => buildInstallCommand("yarn", ["eslint@9.39.1"])).toThrow(/Unsupported package manager/)
+  })
+
+  test("prepareInstall returns printable command", async () => {
+    const result = await prepareInstall({
+      managerArg: "npm",
+      env: {},
+      cwd: process.cwd(),
+      manifestPath: fixturePath("manifest-with-peers.json"),
+    })
+
+    expect(result.manager).toBe("npm")
+    expect(result.packages).toEqual(["eslint@9.39.1", "prettier@3.6.2"])
+    expect(result.printable).toBe("npm install --save-dev --save-exact eslint@9.39.1 prettier@3.6.2")
+  })
+
+  test("prepareInstall returns empty when no peers", async () => {
+    const result = await prepareInstall({
+      managerArg: "npm",
+      env: {},
+      cwd: process.cwd(),
+      manifestPath: fixturePath("manifest-no-peers.json"),
+    })
+
+    expect(result.packages).toEqual([])
+  })
+})

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: skyltmax_config
 version: !ruby/object:Gem::Version
-  version: 0.0.8
+  version: 0.0.9
 platform: ruby
 authors:
 - Signmax AB
@@ -112,7 +112,13 @@ files:
 - reset.d.ts
 - rubocop.rails.yml
 - rubocop.yml
+- scripts/peer-deps/audit.js
+- scripts/peer-deps/install.js
 - skyltmax_config.gemspec
+- tests/check-peers.test.js
+- tests/fixtures/manifest-no-peers.json
+- tests/fixtures/manifest-with-peers.json
+- tests/install-peers.test.js
 - tsconfig.json
 - typescript.json
 homepage: https://github.com/skyltmax/config