@webpieces/dev-config 0.2.95 → 0.2.97

package/architecture/lib/package-validator.ts

@@ -1,170 +0,0 @@
-/**
- * Package Validator
- *
- * Validates that package.json dependencies match the project.json build.dependsOn
- * This ensures the two sources of truth don't drift apart.
- */
-
-import * as fs from 'fs';
-import * as path from 'path';
-import {
-    createProjectGraphAsync,
-    readProjectsConfigurationFromProjectGraph,
-} from '@nx/devkit';
-
-/**
- * Validation result for a single project
- */
-export interface ProjectValidationResult {
-    project: string;
-    valid: boolean;
-    missingInPackageJson: string[];
-    extraInPackageJson: string[];
-}
-
-/**
- * Overall validation result
- */
-export interface ValidationResult {
-    valid: boolean;
-    errors: string[];
-    projectResults: ProjectValidationResult[];
-}
-
-/**
- * Read package.json dependencies for a project
- * Returns null if package.json doesn't exist (apps often don't have one)
- */
-function readPackageJsonDeps(workspaceRoot: string, projectRoot: string): string[] | null {
-    const packageJsonPath = path.join(workspaceRoot, projectRoot, 'package.json');
-
-    if (!fs.existsSync(packageJsonPath)) {
-        return null; // No package.json - skip validation for this project
-    }
-
-    try {
-        const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'));
-        const deps: string[] = [];
-
-        // Collect ALL dependencies from package.json
-        for (const depType of ['dependencies', 'peerDependencies']) {
-            const depObj = packageJson[depType] || {};
-            for (const depName of Object.keys(depObj)) {
-                if (!deps.includes(depName)) {
-                    deps.push(depName);
-                }
-            }
-        }
-
-        return deps.sort();
-    } catch (err: unknown) {
-        console.warn(`Could not read package.json at ${packageJsonPath}`);
-        return [];
-    }
-}
-
-/**
- * Build map of project names to their package names
- * e.g., "core-util" → "@webpieces/core-util"
- */
-function buildProjectToPackageMap(
-    workspaceRoot: string,
-    projectsConfig: any
-): Map<string, string> {
-    const map = new Map<string, string>();
-
-    for (const [projectName, config] of Object.entries<any>(projectsConfig.projects)) {
-        const packageJsonPath = path.join(workspaceRoot, config.root, 'package.json');
-        if (fs.existsSync(packageJsonPath)) {
-            try {
-                const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'));
-                if (packageJson.name) {
-                    map.set(projectName, packageJson.name);
-                }
-            } catch {
-                // Ignore parse errors
-            }
-        }
-    }
-
-    return map;
-}
-
-/**
- * Validate that package.json dependencies match the dependency graph
- *
- * For each project in the graph:
- * - Check that all graph dependencies exist in package.json
- * - Maps project names to package names for accurate comparison
- *
- * @param graph - Enhanced graph with project dependencies (uses project names)
- * @param workspaceRoot - Absolute path to workspace root
- * @returns Validation result with errors if any
- */
-export async function validatePackageJsonDependencies(
-    graph: Record<string, { level: number; dependsOn: string[] }>,
-    workspaceRoot: string
-): Promise<ValidationResult> {
-    const projectGraph = await createProjectGraphAsync();
-    const projectsConfig = readProjectsConfigurationFromProjectGraph(projectGraph);
-
-    // Build map: project name → package name
-    const projectToPackage = buildProjectToPackageMap(workspaceRoot, projectsConfig);
-
-    const errors: string[] = [];
-    const projectResults: ProjectValidationResult[] = [];
-
-    for (const [projectName, entry] of Object.entries(graph)) {
-        // Find the project config using project name directly
-        const projectConfig = projectsConfig.projects[projectName];
-        if (!projectConfig) {
-            continue;
-        }
-
-        const projectRoot = projectConfig.root;
-        const packageJsonDeps = readPackageJsonDeps(workspaceRoot, projectRoot);
-
-        if (packageJsonDeps === null) {
-            continue;
-        }
-
-        // Convert graph dependencies (project names) to package names for comparison
-        const missingInPackageJson: string[] = [];
-        for (const depProjectName of entry.dependsOn) {
-            const depPackageName = projectToPackage.get(depProjectName) || depProjectName;
-            if (!packageJsonDeps.includes(depPackageName)) {
-                missingInPackageJson.push(depProjectName);
-            }
-        }
-
-        // Check for extra dependencies in package.json (not critical, just informational)
-        const extraInPackageJson: string[] = [];
-        for (const dep of packageJsonDeps) {
-            if (!entry.dependsOn.includes(dep)) {
-                extraInPackageJson.push(dep);
-            }
-        }
-
-        const valid = missingInPackageJson.length === 0;
-
-        if (!valid) {
-            errors.push(
-                `Project ${projectName} (${projectRoot}/package.json) is missing dependencies: ${missingInPackageJson.join(', ')}\n` +
-                    `  Fix: Add these to package.json dependencies`
-            );
-        }
-
-        projectResults.push({
-            project: projectName,
-            valid,
-            missingInPackageJson,
-            extraInPackageJson,
-        });
-    }
-
-    return {
-        valid: errors.length === 0,
-        errors,
-        projectResults,
-    };
-}

package/eslint-plugin/__tests__/catch-error-pattern.test.ts

@@ -1,374 +0,0 @@
-/**
- * Tests for catch-error-pattern ESLint rule
- */
-
-import { RuleTester } from 'eslint';
-import rule from '../rules/catch-error-pattern';
-
-// Use require to load parser at runtime (avoids TypeScript import issues)
-const tsParser = require('@typescript-eslint/parser');
-
-const ruleTester = new RuleTester({
-    languageOptions: {
-        parser: tsParser,
-        parserOptions: {
-            ecmaVersion: 2020,
-            sourceType: 'module',
-        },
-    },
-});
-
-ruleTester.run('catch-error-pattern', rule, {
-    valid: [
-        // Pattern 1: Standard toError usage
-        {
-            code: `try {
-    doSomething();
-} catch (err: unknown) {
-    const error = toError(err);
-}`,
-        },
-        // Pattern 1 with additional statements after toError
-        {
-            code: `try {
-    doSomething();
-} catch (err: unknown) {
-    const error = toError(err);
-    console.log('Error occurred:', error);
-    throw error;
-}`,
-        },
-        // Pattern 2: Explicitly ignored error
-        {
-            code: `try {
-    doSomething();
-} catch (err: unknown) {
-    //const error = toError(err);
-}`,
-        },
-        // Pattern 2 with extra whitespace
-        {
-            code: `try {
-    doSomething();
-} catch (err: unknown) {
-    // const error = toError(err);
-}`,
-        },
-        // Pattern 3: Nested catch blocks
-        {
-            code: `try {
-    doSomething();
-} catch (err: unknown) {
-    const error = toError(err);
-    try {
-        cleanup();
-    } catch (err2: unknown) {
-        const error2 = toError(err2);
-    }
-}`,
-        },
-        // Triple nested
-        {
-            code: `try {
-    operation1();
-} catch (err: unknown) {
-    const error = toError(err);
-    try {
-        operation2();
-    } catch (err2: unknown) {
-        const error2 = toError(err2);
-        try {
-            operation3();
-        } catch (err3: unknown) {
-            const error3 = toError(err3);
-        }
-    }
-}`,
-        },
-        // With finally block
-        {
-            code: `try {
-    doSomething();
-} catch (err: unknown) {
-    const error = toError(err);
-} finally {
-    cleanup();
-}`,
-        },
-        // Re-throwing after toError
-        {
-            code: `try {
-    doSomething();
-} catch (err: unknown) {
-    const error = toError(err);
-    logger.error(error);
-    throw error;
-}`,
-        },
-    ],
-
-    invalid: [
-        // Wrong parameter name (e instead of err)
-        {
-            code: `
-                try {
-                    doSomething();
-                } catch (e: unknown) {
-                    const error = toError(e);
-                }
-            `,
-            errors: [
-                {
-                    messageId: 'wrongParameterName',
-                    data: { actual: 'e' },
-                },
-            ],
-        },
-        // Wrong parameter name (error instead of err) AND wrong variable name
-        {
-            code: `
-                try {
-                    doSomething();
-                } catch (error: unknown) {
-                    const error2 = toError(error);
-                }
-            `,
-            errors: [
-                {
-                    messageId: 'wrongParameterName',
-                    data: { actual: 'error' },
-                },
-                {
-                    messageId: 'wrongVariableName',
-                    data: { expected: 'error', actual: 'error2' },
-                },
-            ],
-        },
-        // Missing type annotation
-        {
-            code: `
-                try {
-                    doSomething();
-                } catch (err) {
-                    const error = toError(err);
-                }
-            `,
-            errors: [
-                {
-                    messageId: 'missingTypeAnnotation',
-                },
-            ],
-        },
-        // Wrong type annotation (Error instead of unknown)
-        {
-            code: `
-                try {
-                    doSomething();
-                } catch (err: Error) {
-                    const error = toError(err);
-                }
-            `,
-            errors: [
-                {
-                    messageId: 'missingTypeAnnotation',
-                },
-            ],
-        },
-        // Wrong type annotation (any instead of unknown)
-        {
-            code: `
-                try {
-                    doSomething();
-                } catch (err: any) {
-                    const error = toError(err);
-                }
-            `,
-            errors: [
-                {
-                    messageId: 'missingTypeAnnotation',
-                },
-            ],
-        },
-        // Empty catch block
-        {
-            code: `
-                try {
-                    doSomething();
-                } catch (err: unknown) {
-                }
-            `,
-            errors: [
-                {
-                    messageId: 'missingToError',
-                },
-            ],
-        },
-        // Missing toError call
-        {
-            code: `
-                try {
-                    doSomething();
-                } catch (err: unknown) {
-                    console.log(err);
-                }
-            `,
-            errors: [
-                {
-                    messageId: 'missingToError',
-                },
-            ],
-        },
-        // Wrong variable name (e instead of error)
-        {
-            code: `
-                try {
-                    doSomething();
-                } catch (err: unknown) {
-                    const e = toError(err);
-                }
-            `,
-            errors: [
-                {
-                    messageId: 'wrongVariableName',
-                    data: { expected: 'error', actual: 'e' },
-                },
-            ],
-        },
-        // Wrong variable name (myError instead of error)
-        {
-            code: `
-                try {
-                    doSomething();
-                } catch (err: unknown) {
-                    const myError = toError(err);
-                }
-            `,
-            errors: [
-                {
-                    messageId: 'wrongVariableName',
-                    data: { expected: 'error', actual: 'myError' },
-                },
-            ],
-        },
-        // toError not first statement
-        {
-            code: `
-                try {
-                    doSomething();
-                } catch (err: unknown) {
-                    console.log('caught error');
-                    const error = toError(err);
-                }
-            `,
-            errors: [
-                {
-                    messageId: 'missingToError',
-                },
-            ],
-        },
-        // Using wrong function (not toError)
-        {
-            code: `
-                try {
-                    doSomething();
-                } catch (err: unknown) {
-                    const error = handleError(err);
-                }
-            `,
-            errors: [
-                {
-                    messageId: 'missingToError',
-                },
-            ],
-        },
-        // Nested: wrong parameter name for err2
-        {
-            code: `
-                try {
-                    operation1();
-                } catch (err: unknown) {
-                    const error = toError(err);
-                    try {
-                        operation2();
-                    } catch (e: unknown) {
-                        const error2 = toError(e);
-                    }
-                }
-            `,
-            errors: [
-                {
-                    messageId: 'wrongParameterName',
-                    data: { actual: 'e' },
-                },
-            ],
-        },
-        // Nested: wrong variable name for error2
-        {
-            code: `
-                try {
-                    operation1();
-                } catch (err: unknown) {
-                    const error = toError(err);
-                    try {
-                        operation2();
-                    } catch (err2: unknown) {
-                        const err = toError(err2);
-                    }
-                }
-            `,
-            errors: [
-                {
-                    messageId: 'wrongVariableName',
-                    data: { expected: 'error2', actual: 'err' },
-                },
-            ],
-        },
-        // No parameter at all
-        {
-            code: `
-                try {
-                    doSomething();
-                } catch {
-                    console.log('error');
-                }
-            `,
-            errors: [
-                {
-                    messageId: 'missingTypeAnnotation',
-                },
-            ],
-        },
-        // Variable declared but not initialized
-        {
-            code: `
-                try {
-                    doSomething();
-                } catch (err: unknown) {
-                    const error;
-                }
-            `,
-            errors: [
-                {
-                    messageId: 'missingToError',
-                },
-            ],
-        },
-        // Using new Error instead of toError
-        {
-            code: `
-                try {
-                    doSomething();
-                } catch (err: unknown) {
-                    const error = new Error(err.message);
-                }
-            `,
-            errors: [
-                {
-                    messageId: 'missingToError',
-                },
-            ],
-        },
-    ],
-});
-
-console.log('✅ All catch-error-pattern rule tests passed!');