@dvukovic/style-guide 0.3.118 → 0.3.120

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@dvukovic/style-guide",
-    "version": "0.3.118",
+    "version": "0.3.120",
     "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,
             },
         },
@@ -22,19 +24,21 @@ export const packageJson = {
         "dvukovic/no-restricted-dependencies": [
             "error",
             {
-                packages: [
+                dependencies: [
                     "@types/*",
                     "cspell",
                     "eslint",
+                    "lambda",
                     "lodash",
-                    "npm-package-json-lint",
                     "prettier",
                     "ramda",
                     "stylelint",
                     "typeorm",
                 ],
+                peerDependencies: ["@types/*"],
             },
         ],
+        "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/no-restricted-dependencies/no-restricted-dependencies.js

@@ -1,9 +1,11 @@
-const DEPENDENCY_TYPES = new Set([
+const DEPENDENCY_TYPES = [
     "dependencies",
     "devDependencies",
     "optionalDependencies",
     "peerDependencies",
-])
+]
+
+const DEPENDENCY_TYPES_SET = new Set(DEPENDENCY_TYPES)
 
 /**
  * Checks if a package name matches a restriction pattern. Supports exact matches and glob-like
@@ -28,11 +30,6 @@ function matchesPattern(packageName, pattern) {
 export const noRestrictedDependencies = {
     create(context) {
         const options = context.options[0] || {}
-        const restricted = options.packages || []
-
-        if (restricted.length === 0) {
-            return {}
-        }
 
         return {
             JSONProperty(node) {
@@ -42,7 +39,7 @@ export const noRestrictedDependencies = {
 
                 const propertyName = node.key.value
 
-                if (!DEPENDENCY_TYPES.has(propertyName)) {
+                if (!DEPENDENCY_TYPES_SET.has(propertyName)) {
                     return
                 }
 
@@ -50,6 +47,12 @@ export const noRestrictedDependencies = {
                     return
                 }
 
+                const patterns = options[propertyName] || []
+
+                if (patterns.length === 0) {
+                    return
+                }
+
                 for (const dep of node.value.properties) {
                     if (dep.key.type !== "JSONLiteral" || typeof dep.key.value !== "string") {
                         continue
@@ -57,7 +60,7 @@ export const noRestrictedDependencies = {
 
                     const packageName = dep.key.value
 
-                    for (const pattern of restricted) {
+                    for (const pattern of patterns) {
                         if (matchesPattern(packageName, pattern)) {
                             context.report({
                                 data: {
@@ -86,9 +89,23 @@ export const noRestrictedDependencies = {
             {
                 additionalProperties: false,
                 properties: {
-                    packages: {
-                        description:
-                            "List of restricted package names or patterns (supports * wildcard)",
+                    dependencies: {
+                        description: "Restricted patterns in dependencies",
+                        items: { type: "string" },
+                        type: "array",
+                    },
+                    devDependencies: {
+                        description: "Restricted patterns in devDependencies",
+                        items: { type: "string" },
+                        type: "array",
+                    },
+                    optionalDependencies: {
+                        description: "Restricted patterns in optionalDependencies",
+                        items: { type: "string" },
+                        type: "array",
+                    },
+                    peerDependencies: {
+                        description: "Restricted patterns in peerDependencies",
                         items: { type: "string" },
                         type: "array",
                     },

package/src/eslint/rules/no-restricted-dependencies/no-restricted-dependencies.test.js

@@ -3,7 +3,7 @@ import jsoncParser from "jsonc-eslint-parser"
 
 import { noRestrictedDependencies } from "./no-restricted-dependencies.js"
 
-const createEslint = (packages) => {
+const createEslint = (options) => {
     return new ESLint({
         overrideConfig: [
             {
@@ -19,7 +19,7 @@ const createEslint = (packages) => {
                     },
                 },
                 rules: {
-                    "custom/no-restricted-dependencies": ["error", { packages }],
+                    "custom/no-restricted-dependencies": ["error", options],
                 },
             },
         ],
@@ -27,9 +27,19 @@ const createEslint = (packages) => {
     })
 }
 
+const getErrors = async (eslint, packageJson) => {
+    const results = await eslint.lintText(packageJson, { filePath: "package.json" })
+
+    return (
+        results[0]?.messages.filter((message) => {
+            return message.ruleId === "custom/no-restricted-dependencies"
+        }) ?? []
+    )
+}
+
 describe("no-restricted-dependencies", () => {
     test("detects restricted package in dependencies", async () => {
-        const eslint = createEslint(["lodash"])
+        const eslint = createEslint({ dependencies: ["lodash"] })
         const packageJson = JSON.stringify(
             {
                 dependencies: {
@@ -41,17 +51,14 @@ describe("no-restricted-dependencies", () => {
             4,
         )
 
-        const results = await eslint.lintText(packageJson, { filePath: "package.json" })
-        const errors = results[0]?.messages.filter((message) => {
-            return message.ruleId === "custom/no-restricted-dependencies"
-        })
+        const errors = await getErrors(eslint, packageJson)
 
-        expect(errors?.length).toBe(1)
-        expect(errors?.[0]?.message).toContain("lodash")
+        expect(errors.length).toBe(1)
+        expect(errors[0]?.message).toContain("lodash")
     })
 
     test("detects restricted package in devDependencies", async () => {
-        const eslint = createEslint(["jest"])
+        const eslint = createEslint({ devDependencies: ["jest"] })
         const packageJson = JSON.stringify(
             {
                 devDependencies: {
@@ -63,16 +70,13 @@ describe("no-restricted-dependencies", () => {
             4,
         )
 
-        const results = await eslint.lintText(packageJson, { filePath: "package.json" })
-        const errors = results[0]?.messages.filter((message) => {
-            return message.ruleId === "custom/no-restricted-dependencies"
-        })
+        const errors = await getErrors(eslint, packageJson)
 
-        expect(errors?.length).toBe(1)
+        expect(errors.length).toBe(1)
     })
 
     test("detects pattern with wildcard", async () => {
-        const eslint = createEslint(["@types/*"])
+        const eslint = createEslint({ devDependencies: ["@types/*"] })
         const packageJson = JSON.stringify(
             {
                 devDependencies: {
@@ -85,16 +89,13 @@ describe("no-restricted-dependencies", () => {
             4,
         )
 
-        const results = await eslint.lintText(packageJson, { filePath: "package.json" })
-        const errors = results[0]?.messages.filter((message) => {
-            return message.ruleId === "custom/no-restricted-dependencies"
-        })
+        const errors = await getErrors(eslint, packageJson)
 
-        expect(errors?.length).toBe(2)
+        expect(errors.length).toBe(2)
     })
 
     test("allows non-restricted packages", async () => {
-        const eslint = createEslint(["lodash"])
+        const eslint = createEslint({ dependencies: ["lodash"] })
         const packageJson = JSON.stringify(
             {
                 dependencies: {
@@ -106,16 +107,13 @@ describe("no-restricted-dependencies", () => {
             4,
         )
 
-        const results = await eslint.lintText(packageJson, { filePath: "package.json" })
-        const errors = results[0]?.messages.filter((message) => {
-            return message.ruleId === "custom/no-restricted-dependencies"
-        })
+        const errors = await getErrors(eslint, packageJson)
 
-        expect(errors?.length).toBe(0)
+        expect(errors.length).toBe(0)
     })
 
     test("detects multiple restricted packages", async () => {
-        const eslint = createEslint(["lodash", "ramda", "underscore"])
+        const eslint = createEslint({ dependencies: ["lodash", "ramda", "underscore"] })
         const packageJson = JSON.stringify(
             {
                 dependencies: {
@@ -129,16 +127,13 @@ describe("no-restricted-dependencies", () => {
             4,
         )
 
-        const results = await eslint.lintText(packageJson, { filePath: "package.json" })
-        const errors = results[0]?.messages.filter((message) => {
-            return message.ruleId === "custom/no-restricted-dependencies"
-        })
+        const errors = await getErrors(eslint, packageJson)
 
-        expect(errors?.length).toBe(2)
+        expect(errors.length).toBe(2)
     })
 
-    test("handles empty packages list", async () => {
-        const eslint = createEslint([])
+    test("handles empty options", async () => {
+        const eslint = createEslint({})
         const packageJson = JSON.stringify(
             {
                 dependencies: {
@@ -150,11 +145,93 @@ describe("no-restricted-dependencies", () => {
             4,
         )
 
-        const results = await eslint.lintText(packageJson, { filePath: "package.json" })
-        const errors = results[0]?.messages.filter((message) => {
-            return message.ruleId === "custom/no-restricted-dependencies"
+        const errors = await getErrors(eslint, packageJson)
+
+        expect(errors.length).toBe(0)
+    })
+
+    test("restricts @types/* in dependencies but allows in devDependencies", async () => {
+        const eslint = createEslint({ dependencies: ["@types/*"] })
+        const packageJson = JSON.stringify(
+            {
+                dependencies: {
+                    "@types/node": "^20.0.0",
+                },
+                devDependencies: {
+                    "@types/react": "^18.0.0",
+                },
+                name: "test",
+            },
+            null,
+            4,
+        )
+
+        const errors = await getErrors(eslint, packageJson)
+
+        expect(errors.length).toBe(1)
+        expect(errors[0]?.message).toContain("@types/node")
+        expect(errors[0]?.message).toContain("dependencies")
+    })
+
+    test("restricts different patterns in different dependency types", async () => {
+        const eslint = createEslint({
+            dependencies: ["@types/*", "lodash"],
+            devDependencies: ["jest"],
         })
+        const packageJson = JSON.stringify(
+            {
+                dependencies: {
+                    "@types/node": "^20.0.0",
+                    lodash: "^4.0.0",
+                },
+                devDependencies: {
+                    "@types/react": "^18.0.0",
+                    jest: "^29.0.0",
+                },
+                name: "test",
+            },
+            null,
+            4,
+        )
+
+        const errors = await getErrors(eslint, packageJson)
+
+        expect(errors.length).toBe(3)
+    })
+
+    test("restricts in peerDependencies", async () => {
+        const eslint = createEslint({ peerDependencies: ["react"] })
+        const packageJson = JSON.stringify(
+            {
+                name: "test",
+                peerDependencies: {
+                    react: "^18.0.0",
+                },
+            },
+            null,
+            4,
+        )
+
+        const errors = await getErrors(eslint, packageJson)
+
+        expect(errors.length).toBe(1)
+    })
+
+    test("restricts in optionalDependencies", async () => {
+        const eslint = createEslint({ optionalDependencies: ["fsevents"] })
+        const packageJson = JSON.stringify(
+            {
+                name: "test",
+                optionalDependencies: {
+                    fsevents: "^2.0.0",
+                },
+            },
+            null,
+            4,
+        )
+
+        const errors = await getErrors(eslint, packageJson)
 
-        expect(errors?.length).toBe(0)
+        expect(errors.length).toBe(1)
     })
 })

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")
+    })
+})