feat(plugin-typescript): add plugin logic

Author: BioPhoton

packages/plugin-typescript/src/lib/schema.ts

@@ -0,0 +1,24 @@
+import { z } from 'zod';
+import { AUDITS, DEFAULT_TS_CONFIG } from './constants.js';
+import type { AuditSlug } from './types.js';
+
+const auditSlugs = AUDITS.map(({ slug }) => slug) as [
+  AuditSlug,
+  ...AuditSlug[],
+];
+export const typescriptPluginConfigSchema = z.object({
+  tsconfig: z
+    .string({
+      description: 'Path to the TsConfig',
+    })
+    .default(DEFAULT_TS_CONFIG),
+  onlyAudits: z
+    .array(z.enum(auditSlugs), {
+      description: 'Array with specific TsCodes to measure',
+    })
+    .optional(),
+});
+
+export type TypescriptPluginOptions = z.infer<
+  typeof typescriptPluginConfigSchema
+>;

packages/plugin-typescript/src/lib/schema.unit.test.ts

@@ -0,0 +1,72 @@
+import { describe, expect, it } from 'vitest';
+import {
+  type TypescriptPluginOptions,
+  typescriptPluginConfigSchema,
+} from './schema.js';
+
+describe('typescriptPluginConfigSchema', () => {
+  const tsConfigPath = 'tsconfig.json';
+
+  it('accepts a empty configuration', () => {
+    expect(() => typescriptPluginConfigSchema.parse({})).not.toThrow();
+  });
+
+  it('accepts a configuration with tsConfigPath set', () => {
+    expect(() =>
+      typescriptPluginConfigSchema.parse({
+        tsConfigPath,
+      } satisfies TypescriptPluginOptions),
+    ).not.toThrow();
+  });
+
+  it('accepts a configuration with tsConfigPath and empty onlyAudits', () => {
+    expect(() =>
+      typescriptPluginConfigSchema.parse({
+        tsConfigPath,
+        onlyAudits: [],
+      } satisfies TypescriptPluginOptions),
+    ).not.toThrow();
+  });
+
+  it('accepts a configuration with tsConfigPath and full onlyAudits', () => {
+    expect(() =>
+      typescriptPluginConfigSchema.parse({
+        tsConfigPath,
+        onlyAudits: [
+          'syntax-errors',
+          'semantic-errors',
+          'configuration-errors',
+        ],
+      } satisfies TypescriptPluginOptions),
+    ).not.toThrow();
+  });
+
+  it('throws for invalid onlyAudits', () => {
+    expect(() =>
+      typescriptPluginConfigSchema.parse({
+        onlyAudits: 123,
+      }),
+    ).toThrow('invalid_type');
+  });
+
+  it('throws for invalid onlyAudits items', () => {
+    expect(() =>
+      typescriptPluginConfigSchema.parse({
+        tsConfigPath,
+        onlyAudits: [123, true],
+      }),
+    ).toThrow('invalid_type');
+  });
+
+  it('throws for unknown audit slug', () => {
+    expect(
+      () =>
+        typescriptPluginConfigSchema.parse({
+          tsConfigPath,
+          onlyAudits: ['unknown-audit'],
+        }),
+      // Message too large because enums validation
+      // eslint-disable-next-line vitest/require-to-throw-message
+    ).toThrow();
+  });
+});

packages/plugin-typescript/src/lib/typescript-plugin.ts

@@ -0,0 +1,57 @@
+import { createRequire } from 'node:module';
+import type { PluginConfig } from '@code-pushup/models';
+import { DEFAULT_TS_CONFIG, TYPESCRIPT_PLUGIN_SLUG } from './constants.js';
+import { createRunnerFunction } from './runner/runner.js';
+import type { DiagnosticsOptions } from './runner/ts-runner.js';
+import { typescriptPluginConfigSchema } from './schema.js';
+import type { AuditSlug } from './types.js';
+import { getAudits, getGroups, logSkippedAudits } from './utils.js';
+
+const packageJson = createRequire(import.meta.url)(
+  '../../package.json',
+) as typeof import('../../package.json');
+
+export type FilterOptions = { onlyAudits?: AuditSlug[] | undefined };
+export type TypescriptPluginOptions = Partial<DiagnosticsOptions> &
+  FilterOptions;
+
+export async function typescriptPlugin(
+  options?: TypescriptPluginOptions,
+): Promise<PluginConfig> {
+  const { tsconfig = DEFAULT_TS_CONFIG, onlyAudits } = parseOptions(
+    options ?? {},
+  );
+
+  const filteredAudits = getAudits({ onlyAudits });
+  const filteredGroups = getGroups({ onlyAudits });
+
+  logSkippedAudits(filteredAudits);
+
+  return {
+    slug: TYPESCRIPT_PLUGIN_SLUG,
+    packageName: packageJson.name,
+    version: packageJson.version,
+    title: 'Typescript',
+    description: 'Official Code PushUp Typescript plugin.',
+    docsUrl: 'https://www.npmjs.com/package/@code-pushup/typescript-plugin/',
+    icon: 'typescript',
+    audits: filteredAudits,
+    groups: filteredGroups,
+    runner: createRunnerFunction({
+      tsconfig,
+      expectedAudits: filteredAudits,
+    }),
+  };
+}
+
+function parseOptions(
+  tsPluginOptions: TypescriptPluginOptions,
+): TypescriptPluginOptions {
+  try {
+    return typescriptPluginConfigSchema.parse(tsPluginOptions);
+  } catch (error) {
+    throw new Error(
+      `Error parsing TypeScript Plugin options: ${(error as Error).message}`,
+    );
+  }
+}

packages/plugin-typescript/src/lib/typescript-plugin.unit.test.ts

@@ -0,0 +1,31 @@
+import { expect } from 'vitest';
+import { pluginConfigSchema } from '@code-pushup/models';
+import { AUDITS, GROUPS } from './constants.js';
+import { typescriptPlugin } from './typescript-plugin.js';
+
+describe('typescriptPlugin-config-object', () => {
+  it('should create valid plugin config without options', async () => {
+    const pluginConfig = await typescriptPlugin();
+
+    expect(() => pluginConfigSchema.parse(pluginConfig)).not.toThrow();
+
+    const { audits, groups } = pluginConfig;
+    expect(audits).toHaveLength(AUDITS.length);
+    expect(groups).toBeDefined();
+    expect(groups!).toHaveLength(GROUPS.length);
+  });
+
+  it('should create valid plugin config', async () => {
+    const pluginConfig = await typescriptPlugin({
+      tsConfigPath: 'mocked-away/tsconfig.json',
+      onlyAudits: ['syntax-errors', 'semantic-errors', 'configuration-errors'],
+    });
+
+    expect(() => pluginConfigSchema.parse(pluginConfig)).not.toThrow();
+
+    const { audits, groups } = pluginConfig;
+    expect(audits).toHaveLength(3);
+    expect(groups).toBeDefined();
+    expect(groups!).toHaveLength(2);
+  });
+});

packages/utils/src/lib/string.ts

@@ -0,0 +1,58 @@
+import type { CamelCaseToKebabCase } from './types';
+
+/**
+ * Converts a kebab-case string to camelCase.
+ * @param string - The kebab-case string to convert.
+ * @returns The camelCase string.
+ */
+export function kebabCaseToCamelCase(string: string) {
+  return string
+    .split('-')
+    .map((segment, index) =>
+      index === 0
+        ? segment
+        : segment.charAt(0).toUpperCase() + segment.slice(1),
+    )
+    .join('');
+}
+
+/**
+ * Converts a camelCase string to kebab-case.
+ * @param string - The camelCase string to convert.
+ * @returns The kebab-case string.
+ */
+export function camelCaseToKebabCase<T extends string>(
+  string: T,
+): CamelCaseToKebabCase<T> {
+  return string
+    .replace(/([A-Z])([A-Z][a-z])/g, '$1-$2') // Split between uppercase followed by uppercase+lowercase
+    .replace(/([a-z])([A-Z])/g, '$1-$2') // Split between lowercase followed by uppercase
+    .replace(/([A-Z]+)([A-Z][a-z])/g, '$1-$2') // Additional split for consecutive uppercase
+    .replace(/[\s_]+/g, '-') // Replace spaces and underscores with hyphens
+    .toLowerCase() as CamelCaseToKebabCase<T>;
+}
+
+/**
+ * Formats a slug to a readable title.
+ * @param slug - The slug to format.
+ * @returns The formatted title.
+ */
+export function kebabCaseToSentence(slug: string = '') {
+  return slug
+    .replace(/-/g, ' ')
+    .replace(/\b\w/g, letter => letter.toUpperCase());
+}
+
+/**
+ * Formats a slug to a readable title.
+ * @param slug - The slug to format.
+ * @returns The formatted title.
+ */
+export function camelCaseToSentence(slug: string = '') {
+  return slug
+    .replace(/([A-Z])([A-Z][a-z])/g, '$1-$2') // Split between uppercase followed by uppercase+lowercase
+    .replace(/([a-z])([A-Z])/g, '$1-$2') // Split between lowercase followed by uppercase
+    .replace(/([A-Z]+)([A-Z][a-z])/g, '$1-$2') // Additional split for consecutive uppercase
+    .replace(/[\s_]+/g, ' ') // Replace spaces and underscores with hyphens
+    .replace(/\b\w/g, letter => letter.toUpperCase());
+}

packages/utils/src/lib/string.unit.test.ts

@@ -0,0 +1,81 @@
+import {
+  camelCaseToKebabCase,
+  kebabCaseToCamelCase,
+  kebabCaseToSentence,
+} from './string.js';
+
+describe('kebabCaseToCamelCase', () => {
+  it('should convert simple kebab-case to camelCase', () => {
+    expect(kebabCaseToCamelCase('hello-world')).toBe('helloWorld');
+  });
+
+  it('should handle multiple hyphens', () => {
+    expect(kebabCaseToCamelCase('this-is-a-long-string')).toBe(
+      'thisIsALongString',
+    );
+  });
+
+  it('should preserve numbers', () => {
+    expect(kebabCaseToCamelCase('user-123-test')).toBe('user123Test');
+  });
+
+  it('should handle single word', () => {
+    expect(kebabCaseToCamelCase('hello')).toBe('hello');
+  });
+
+  it('should handle empty string', () => {
+    expect(kebabCaseToCamelCase('')).toBe('');
+  });
+});
+
+describe('camelCaseToKebabCase', () => {
+  it('should convert simple camelCase to kebab-case', () => {
+    expect(camelCaseToKebabCase('helloWorld')).toBe('hello-world');
+  });
+
+  it('should handle multiple capital letters', () => {
+    expect(camelCaseToKebabCase('thisIsALongString')).toBe(
+      'this-is-a-long-string',
+    );
+  });
+
+  it('should handle consecutive capital letters', () => {
+    expect(camelCaseToKebabCase('myXMLParser')).toBe('my-xml-parser');
+  });
+
+  it('should handle spaces and underscores', () => {
+    expect(camelCaseToKebabCase('hello_world test')).toBe('hello-world-test');
+  });
+
+  it('should handle single word', () => {
+    expect(camelCaseToKebabCase('hello')).toBe('hello');
+  });
+
+  it('should handle empty string', () => {
+    expect(camelCaseToKebabCase('')).toBe('');
+  });
+});
+
+describe('kebabCaseToSentence', () => {
+  it('should convert simple slug to title case', () => {
+    expect(kebabCaseToSentence('hello-world')).toBe('Hello World');
+  });
+
+  it('should handle multiple hyphens', () => {
+    expect(kebabCaseToSentence('this-is-a-title')).toBe('This Is A Title');
+  });
+
+  it('should handle empty string', () => {
+    expect(kebabCaseToSentence()).toBe('');
+  });
+
+  it('should handle single word', () => {
+    expect(kebabCaseToSentence('hello')).toBe('Hello');
+  });
+
+  it('should handle numbers in slug', () => {
+    expect(kebabCaseToSentence('chapter-1-introduction')).toBe(
+      'Chapter 1 Introduction',
+    );
+  });
+});