@dvukovic/style-guide 0.3.118 → 0.3.119

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@dvukovic/style-guide",
-    "version": "0.3.118",
+    "version": "0.3.119",
     "description": "My own style guide",
     "repository": {
         "type": "git",
@@ -111,6 +111,9 @@
     "engines": {
         "node": ">=24.0.0"
     },
+    "volta": {
+        "node": "24.4.1"
+    },
     "publishConfig": {
         "access": "public",
         "registry": "https://registry.npmjs.org"

package/src/eslint/configs/package-json.js

@@ -1,5 +1,7 @@
 import { packageJson as packageJsonRules } from "../plugins/package-json.js"
 
+const DEFAULT_WORKSPACE_PATTERNS = ["**/packages/**/package.json", "**/apps/**/package.json"]
+
 export const packageJsonConfigs = [packageJsonRules]
 
 /**
@@ -15,3 +17,33 @@ export function packageJson(config) {
         ...config,
     }
 }
+
+/**
+ * Package.json ESLint configuration for monorepos
+ *
+ * Returns two configs:
+ *
+ * - Root package.json: all rules including volta.node requirement
+ * - Nested packages: same rules but no volta.node requirement
+ *
+ * @param {{ workspacePatterns?: string[] } & import("@eslint/config-helpers").ConfigWithExtends} [config]
+ * @returns {import("@eslint/config-helpers").ConfigWithExtends[]}
+ */
+export function packageJsonWorkspace(config) {
+    const { workspacePatterns = DEFAULT_WORKSPACE_PATTERNS, ...rest } = config ?? {}
+
+    return [
+        {
+            extends: [...packageJsonConfigs, ...(rest?.extends ?? [])],
+            files: ["package.json"],
+            ...rest,
+        },
+        {
+            extends: [...packageJsonConfigs],
+            files: workspacePatterns,
+            rules: {
+                "dvukovic/require-properties": "off",
+            },
+        },
+    ]
+}

package/src/eslint/configs/package-json.test.js

@@ -1,6 +1,7 @@
 import { ESLint } from "eslint"
+import { defineConfig } from "eslint/config"
 
-import { packageJsonConfigs } from "./package-json.js"
+import { packageJsonConfigs, packageJsonWorkspace } from "./package-json.js"
 
 const eslint = new ESLint({
     overrideConfig: [...packageJsonConfigs, { files: ["**/package.json"] }],
@@ -48,3 +49,106 @@ describe("package-json", () => {
         expect(results[0]?.errorCount).toBeGreaterThan(0)
     })
 })
+
+describe("packageJsonWorkspace", () => {
+    test("returns array of two configs", () => {
+        const configs = packageJsonWorkspace()
+
+        expect(configs).toHaveLength(2)
+    })
+
+    test("root config targets package.json", () => {
+        const configs = packageJsonWorkspace()
+
+        expect(configs[0].files).toEqual(["package.json"])
+    })
+
+    test("nested config targets default workspace patterns", () => {
+        const configs = packageJsonWorkspace()
+
+        expect(configs[1].files).toEqual(["**/packages/**/package.json", "**/apps/**/package.json"])
+    })
+
+    test("nested config disables require-properties rule", () => {
+        const configs = packageJsonWorkspace()
+
+        expect(configs[1].rules).toEqual({
+            "dvukovic/require-properties": "off",
+        })
+    })
+
+    test("accepts custom workspace patterns", () => {
+        const configs = packageJsonWorkspace({
+            workspacePatterns: ["**/libs/**/package.json"],
+        })
+
+        expect(configs[1].files).toEqual(["**/libs/**/package.json"])
+    })
+
+    test("passes through extends to root config", () => {
+        const customExtends = [{ rules: { "custom/rule": "error" } }]
+        const configs = packageJsonWorkspace({ extends: customExtends })
+
+        expect(configs[0].extends).toContain(customExtends[0])
+    })
+
+    test("root config requires volta.node", async () => {
+        const workspaceEslint = new ESLint({
+            overrideConfig: defineConfig(...packageJsonWorkspace()),
+            overrideConfigFile: true,
+        })
+
+        const packageWithoutVolta = JSON.stringify(
+            {
+                author: "Test Author",
+                description: "A test package",
+                engines: { node: ">=24.0.0" },
+                license: "MIT",
+                name: "test-package",
+                repository: { type: "git", url: "https://github.com/test/test" },
+                version: "1.0.0",
+            },
+            null,
+            4,
+        )
+
+        const results = await workspaceEslint.lintText(packageWithoutVolta, {
+            filePath: "package.json",
+        })
+
+        const hasVoltaError = results[0]?.messages.some((message) => {
+            return message.ruleId === "dvukovic/require-properties"
+        })
+        expect(hasVoltaError).toBe(true)
+    })
+
+    test("nested config does not require volta.node", async () => {
+        const workspaceEslint = new ESLint({
+            overrideConfig: defineConfig(...packageJsonWorkspace()),
+            overrideConfigFile: true,
+        })
+
+        const packageWithoutVolta = JSON.stringify(
+            {
+                author: "Test Author",
+                description: "A test package",
+                engines: { node: ">=24.0.0" },
+                license: "MIT",
+                name: "test-package",
+                repository: { type: "git", url: "https://github.com/test/test" },
+                version: "1.0.0",
+            },
+            null,
+            4,
+        )
+
+        const results = await workspaceEslint.lintText(packageWithoutVolta, {
+            filePath: "packages/my-package/package.json",
+        })
+
+        const hasVoltaError = results[0]?.messages.some((message) => {
+            return message.ruleId === "dvukovic/require-properties"
+        })
+        expect(hasVoltaError).toBe(false)
+    })
+})

package/src/eslint/plugins/package-json.js

@@ -2,6 +2,7 @@ import plugin from "eslint-plugin-package-json"
 import jsoncParser from "jsonc-eslint-parser"
 
 import { noRestrictedDependencies } from "../rules/no-restricted-dependencies/no-restricted-dependencies.js"
+import { requireProperties } from "../rules/require-properties/require-properties.js"
 import { validEnginesNode } from "../rules/valid-engines-node/valid-engines-node.js"
 
 /** @type {import("@eslint/config-helpers").Config} */
@@ -13,6 +14,7 @@ export const packageJson = {
         dvukovic: {
             rules: {
                 "no-restricted-dependencies": noRestrictedDependencies,
+                "require-properties": requireProperties,
                 "valid-engines-node": validEnginesNode,
             },
         },
@@ -35,6 +37,7 @@ export const packageJson = {
                 ],
             },
         ],
+        "dvukovic/require-properties": ["error", { properties: ["volta.node"] }],
         "dvukovic/valid-engines-node": ["error", { versions: ["24"] }],
         "package-json/bin-name-casing": "error",
         "package-json/no-empty-fields": "error",

package/src/eslint/rules/require-properties/require-properties.js

@@ -0,0 +1,76 @@
+function getPropertyPath(node) {
+    const parts = []
+    let current = node
+
+    while (current?.type === "JSONProperty") {
+        if (current.key.type === "JSONLiteral" && typeof current.key.value === "string") {
+            parts.unshift(current.key.value)
+        }
+
+        current = current.parent?.parent
+    }
+
+    return parts.join(".")
+}
+
+export const requireProperties = {
+    create(context) {
+        const options = context.options[0] || {}
+        const properties = options.properties || []
+
+        if (properties.length === 0) {
+            return {}
+        }
+
+        const foundPaths = new Set()
+        let programNode = null
+
+        return {
+            JSONExpressionStatement(node) {
+                programNode = node
+            },
+
+            JSONProperty(node) {
+                const path = getPropertyPath(node)
+
+                if (path) {
+                    foundPaths.add(path)
+                }
+            },
+
+            "Program:exit"() {
+                for (const property of properties) {
+                    if (!foundPaths.has(property)) {
+                        context.report({
+                            data: { property },
+                            messageId: "missingProperty",
+                            node: programNode,
+                        })
+                    }
+                }
+            },
+        }
+    },
+    meta: {
+        docs: {
+            description: "Require specified properties in package.json",
+        },
+        messages: {
+            missingProperty: `Missing required property "{{property}}" in package.json.`,
+        },
+        schema: [
+            {
+                additionalProperties: false,
+                properties: {
+                    properties: {
+                        description: "List of required property paths (supports dot notation)",
+                        items: { type: "string" },
+                        type: "array",
+                    },
+                },
+                type: "object",
+            },
+        ],
+        type: "problem",
+    },
+}

package/src/eslint/rules/require-properties/require-properties.test.js

@@ -0,0 +1,164 @@
+import { ESLint } from "eslint"
+import jsoncParser from "jsonc-eslint-parser"
+
+import { requireProperties } from "./require-properties.js"
+
+const createEslint = (properties) => {
+    return new ESLint({
+        overrideConfig: [
+            {
+                files: ["**/package.json"],
+                languageOptions: {
+                    parser: jsoncParser,
+                },
+                plugins: {
+                    custom: {
+                        rules: {
+                            "require-properties": requireProperties,
+                        },
+                    },
+                },
+                rules: {
+                    "custom/require-properties": ["error", { properties }],
+                },
+            },
+        ],
+        overrideConfigFile: true,
+    })
+}
+
+describe("require-properties", () => {
+    test("passes when all required properties exist", async () => {
+        const eslint = createEslint(["name", "version"])
+        const packageJson = JSON.stringify(
+            {
+                name: "test",
+                version: "1.0.0",
+            },
+            null,
+            4,
+        )
+
+        const results = await eslint.lintText(packageJson, { filePath: "package.json" })
+        const errors = results[0]?.messages.filter((message) => {
+            return message.ruleId === "custom/require-properties"
+        })
+
+        expect(errors?.length).toBe(0)
+    })
+
+    test("fails when a required property is missing", async () => {
+        const eslint = createEslint(["name", "version"])
+        const packageJson = JSON.stringify(
+            {
+                name: "test",
+            },
+            null,
+            4,
+        )
+
+        const results = await eslint.lintText(packageJson, { filePath: "package.json" })
+        const errors = results[0]?.messages.filter((message) => {
+            return message.ruleId === "custom/require-properties"
+        })
+
+        expect(errors?.length).toBe(1)
+        expect(errors?.[0]?.message).toContain("version")
+    })
+
+    test("fails with multiple missing properties", async () => {
+        const eslint = createEslint(["name", "version", "description"])
+        const packageJson = JSON.stringify(
+            {
+                name: "test",
+            },
+            null,
+            4,
+        )
+
+        const results = await eslint.lintText(packageJson, { filePath: "package.json" })
+        const errors = results[0]?.messages.filter((message) => {
+            return message.ruleId === "custom/require-properties"
+        })
+
+        expect(errors?.length).toBe(2)
+    })
+
+    test("passes with empty properties config", async () => {
+        const eslint = createEslint([])
+        const packageJson = JSON.stringify(
+            {
+                name: "test",
+            },
+            null,
+            4,
+        )
+
+        const results = await eslint.lintText(packageJson, { filePath: "package.json" })
+        const errors = results[0]?.messages.filter((message) => {
+            return message.ruleId === "custom/require-properties"
+        })
+
+        expect(errors?.length).toBe(0)
+    })
+
+    test("supports dot notation for nested properties", async () => {
+        const eslint = createEslint(["volta.node"])
+        const packageJson = JSON.stringify(
+            {
+                name: "test",
+                volta: {
+                    node: "24.0.0",
+                },
+            },
+            null,
+            4,
+        )
+
+        const results = await eslint.lintText(packageJson, { filePath: "package.json" })
+        const errors = results[0]?.messages.filter((message) => {
+            return message.ruleId === "custom/require-properties"
+        })
+
+        expect(errors?.length).toBe(0)
+    })
+
+    test("fails when nested property is missing", async () => {
+        const eslint = createEslint(["volta.node"])
+        const packageJson = JSON.stringify(
+            {
+                name: "test",
+                volta: {},
+            },
+            null,
+            4,
+        )
+
+        const results = await eslint.lintText(packageJson, { filePath: "package.json" })
+        const errors = results[0]?.messages.filter((message) => {
+            return message.ruleId === "custom/require-properties"
+        })
+
+        expect(errors?.length).toBe(1)
+        expect(errors?.[0]?.message).toContain("volta.node")
+    })
+
+    test("fails when parent of nested property is missing", async () => {
+        const eslint = createEslint(["volta.node"])
+        const packageJson = JSON.stringify(
+            {
+                name: "test",
+            },
+            null,
+            4,
+        )
+
+        const results = await eslint.lintText(packageJson, { filePath: "package.json" })
+        const errors = results[0]?.messages.filter((message) => {
+            return message.ruleId === "custom/require-properties"
+        })
+
+        expect(errors?.length).toBe(1)
+        expect(errors?.[0]?.message).toContain("volta.node")
+    })
+})