@eldrforge/git-tools 0.1.1

package/tests/logger.test.ts

@@ -0,0 +1,211 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { ConsoleLogger, setLogger, getLogger, Logger } from '../src/logger';
+
+describe('Logger utilities', () => {
+    describe('ConsoleLogger', () => {
+        let consoleSpy: {
+            error: ReturnType<typeof vi.spyOn>;
+            warn: ReturnType<typeof vi.spyOn>;
+            info: ReturnType<typeof vi.spyOn>;
+            log: ReturnType<typeof vi.spyOn>;
+        };
+
+        beforeEach(() => {
+            // Spy on console methods
+            consoleSpy = {
+                error: vi.spyOn(console, 'error').mockImplementation(() => {}),
+                warn: vi.spyOn(console, 'warn').mockImplementation(() => {}),
+                info: vi.spyOn(console, 'info').mockImplementation(() => {}),
+                log: vi.spyOn(console, 'log').mockImplementation(() => {}),
+            };
+        });
+
+        afterEach(() => {
+            vi.restoreAllMocks();
+        });
+
+        it('should log error messages at error level', () => {
+            const logger = new ConsoleLogger('error');
+            logger.error('Test error message');
+
+            expect(consoleSpy.error).toHaveBeenCalledWith('Test error message');
+        });
+
+        it('should log warn messages at warn level', () => {
+            const logger = new ConsoleLogger('warn');
+            logger.warn('Test warning');
+
+            expect(consoleSpy.warn).toHaveBeenCalledWith('Test warning');
+        });
+
+        it('should log info messages at info level', () => {
+            const logger = new ConsoleLogger('info');
+            logger.info('Test info');
+
+            expect(consoleSpy.info).toHaveBeenCalledWith('Test info');
+        });
+
+        it('should log verbose messages at verbose level', () => {
+            const logger = new ConsoleLogger('verbose');
+            logger.verbose('Test verbose');
+
+            expect(consoleSpy.log).toHaveBeenCalledWith('[VERBOSE]', 'Test verbose');
+        });
+
+        it('should log debug messages at debug level', () => {
+            const logger = new ConsoleLogger('debug');
+            logger.debug('Test debug');
+
+            expect(consoleSpy.log).toHaveBeenCalledWith('[DEBUG]', 'Test debug');
+        });
+
+        it('should not log messages below current log level', () => {
+            const logger = new ConsoleLogger('error');
+
+            logger.warn('Should not log');
+            logger.info('Should not log');
+            logger.verbose('Should not log');
+            logger.debug('Should not log');
+
+            expect(consoleSpy.warn).not.toHaveBeenCalled();
+            expect(consoleSpy.info).not.toHaveBeenCalled();
+            expect(consoleSpy.log).not.toHaveBeenCalled();
+        });
+
+        it('should log all levels when set to debug', () => {
+            const logger = new ConsoleLogger('debug');
+
+            logger.error('error msg');
+            logger.warn('warn msg');
+            logger.info('info msg');
+            logger.verbose('verbose msg');
+            logger.debug('debug msg');
+
+            expect(consoleSpy.error).toHaveBeenCalledWith('error msg');
+            expect(consoleSpy.warn).toHaveBeenCalledWith('warn msg');
+            expect(consoleSpy.info).toHaveBeenCalledWith('info msg');
+            expect(consoleSpy.log).toHaveBeenCalledWith('[VERBOSE]', 'verbose msg');
+            expect(consoleSpy.log).toHaveBeenCalledWith('[DEBUG]', 'debug msg');
+        });
+
+        it('should pass metadata to console methods', () => {
+            const logger = new ConsoleLogger('info');
+            const metadata = { userId: 123, action: 'login' };
+
+            logger.info('User action', metadata);
+
+            expect(consoleSpy.info).toHaveBeenCalledWith('User action', metadata);
+        });
+
+        it('should handle multiple metadata arguments', () => {
+            const logger = new ConsoleLogger('error');
+
+            logger.error('Error occurred', 'context1', { detail: 'value' }, 42);
+
+            expect(consoleSpy.error).toHaveBeenCalledWith('Error occurred', 'context1', { detail: 'value' }, 42);
+        });
+
+        it('should default to info level when not specified', () => {
+            const logger = new ConsoleLogger();
+
+            logger.info('Should log');
+            logger.verbose('Should not log');
+
+            expect(consoleSpy.info).toHaveBeenCalledWith('Should log');
+            expect(consoleSpy.log).not.toHaveBeenCalled();
+        });
+
+        it('should respect warn level threshold', () => {
+            const logger = new ConsoleLogger('warn');
+
+            logger.error('error - should log');
+            logger.warn('warn - should log');
+            logger.info('info - should not log');
+            logger.verbose('verbose - should not log');
+            logger.debug('debug - should not log');
+
+            expect(consoleSpy.error).toHaveBeenCalledWith('error - should log');
+            expect(consoleSpy.warn).toHaveBeenCalledWith('warn - should log');
+            expect(consoleSpy.info).not.toHaveBeenCalled();
+            expect(consoleSpy.log).not.toHaveBeenCalled();
+        });
+    });
+
+    describe('setLogger and getLogger', () => {
+        let originalLogger: Logger;
+
+        beforeEach(() => {
+            originalLogger = getLogger();
+        });
+
+        afterEach(() => {
+            setLogger(originalLogger);
+        });
+
+        it('should set and get custom logger', () => {
+            const customLogger: Logger = {
+                error: vi.fn(),
+                warn: vi.fn(),
+                info: vi.fn(),
+                verbose: vi.fn(),
+                debug: vi.fn(),
+            };
+
+            setLogger(customLogger);
+            const retrievedLogger = getLogger();
+
+            expect(retrievedLogger).toBe(customLogger);
+        });
+
+        it('should use custom logger for logging', () => {
+            const customLogger: Logger = {
+                error: vi.fn(),
+                warn: vi.fn(),
+                info: vi.fn(),
+                verbose: vi.fn(),
+                debug: vi.fn(),
+            };
+
+            setLogger(customLogger);
+            const logger = getLogger();
+
+            logger.error('Test error');
+            logger.info('Test info');
+
+            expect(customLogger.error).toHaveBeenCalledWith('Test error');
+            expect(customLogger.info).toHaveBeenCalledWith('Test info');
+        });
+
+        it('should default to ConsoleLogger', () => {
+            const logger = getLogger();
+            expect(logger).toBeDefined();
+            expect(typeof logger.error).toBe('function');
+            expect(typeof logger.info).toBe('function');
+        });
+
+        it('should allow replacing logger multiple times', () => {
+            const logger1: Logger = {
+                error: vi.fn(),
+                warn: vi.fn(),
+                info: vi.fn(),
+                verbose: vi.fn(),
+                debug: vi.fn(),
+            };
+
+            const logger2: Logger = {
+                error: vi.fn(),
+                warn: vi.fn(),
+                info: vi.fn(),
+                verbose: vi.fn(),
+                debug: vi.fn(),
+            };
+
+            setLogger(logger1);
+            expect(getLogger()).toBe(logger1);
+
+            setLogger(logger2);
+            expect(getLogger()).toBe(logger2);
+        });
+    });
+});
+

package/tests/setup.ts

@@ -0,0 +1,17 @@
+import { vi } from 'vitest';
+
+// Mock console methods to prevent output during tests
+// global.console = {
+//     ...console,
+//     // Keep error logging for debugging
+//     error: vi.fn(),
+//     // Suppress other console output
+//     log: vi.fn(),
+//     warn: vi.fn(),
+//     info: vi.fn(),
+//     debug: vi.fn(),
+// };
+
+// Mock process.exit to prevent actual process termination
+process.exit = vi.fn() as unknown as (code?: number) => never;
+

package/tests/validation.test.ts

@@ -0,0 +1,152 @@
+import { describe, it, expect } from 'vitest';
+import {
+    safeJsonParse,
+    validateString,
+    validateHasProperty,
+    validatePackageJson
+} from '../src/validation';
+
+describe('Validation utilities', () => {
+    describe('safeJsonParse', () => {
+        it('should parse valid JSON string', () => {
+            const jsonString = '{"name": "test", "value": 123}';
+            const result = safeJsonParse(jsonString, 'test context');
+            expect(result).toEqual({ name: 'test', value: 123 });
+        });
+
+        it('should throw error for invalid JSON with context', () => {
+            const invalidJson = '{"invalid": json}';
+            expect(() => safeJsonParse(invalidJson, 'test file')).toThrow('Failed to parse JSON (test file):');
+        });
+
+        it('should throw error for empty string', () => {
+            expect(() => safeJsonParse('', 'empty context')).toThrow('Failed to parse JSON (empty context):');
+        });
+
+        it('should parse JSON arrays', () => {
+            const jsonArray = '[1, 2, 3]';
+            const result = safeJsonParse(jsonArray, 'array context');
+            expect(result).toEqual([1, 2, 3]);
+        });
+
+        it('should parse JSON primitives', () => {
+            expect(safeJsonParse('123', 'number context')).toBe(123);
+            expect(safeJsonParse('"hello"', 'string context')).toBe('hello');
+            expect(safeJsonParse('true', 'boolean context')).toBe(true);
+            expect(() => safeJsonParse('null', 'null context')).toThrow('Failed to parse JSON (null context): Parsed JSON is null or undefined');
+        });
+    });
+
+    describe('validateString', () => {
+        it('should validate valid string', () => {
+            const result = validateString('test string', 'test value');
+            expect(result).toBe('test string');
+        });
+
+        it('should throw error for non-string value', () => {
+            expect(() => validateString(123, 'number value')).toThrow('number value must be a string');
+            expect(() => validateString(null, 'null value')).toThrow('null value must be a string');
+            expect(() => validateString(undefined, 'undefined value')).toThrow('undefined value must be a string');
+        });
+
+        it('should throw error for empty string', () => {
+            expect(() => validateString('', 'empty string')).toThrow('empty string cannot be empty');
+        });
+    });
+
+    describe('validateHasProperty', () => {
+        it('should validate object has required property', () => {
+            const obj = { name: 'test', value: 123 };
+            validateHasProperty(obj, 'name', 'test object');
+            validateHasProperty(obj, 'value', 'test object');
+        });
+
+        it('should throw error for missing property', () => {
+            const obj = { name: 'test' };
+            expect(() => validateHasProperty(obj, 'value', 'test object')).toThrow("Missing required property 'value' in test object");
+        });
+
+        it('should throw error for null/undefined object', () => {
+            expect(() => validateHasProperty(null, 'name', 'null object')).toThrow('Object is null or not an object in null object');
+            expect(() => validateHasProperty(undefined, 'name', 'undefined object')).toThrow('Object is null or not an object in undefined object');
+        });
+
+        it('should work with nested properties', () => {
+            const obj = { nested: { value: 'test' } };
+            validateHasProperty(obj, 'nested', 'test object');
+            validateHasProperty(obj.nested, 'value', 'nested object');
+        });
+    });
+
+    describe('validatePackageJson', () => {
+        it('should validate valid package.json', () => {
+            const validPackage = {
+                name: '@test/package',
+                version: '1.0.0',
+                description: 'Test package',
+                dependencies: {
+                    'react': '^18.0.0'
+                }
+            };
+
+            const result = validatePackageJson(validPackage, '/path/to/package.json');
+            expect(result).toEqual(validPackage);
+        });
+
+        it('should validate minimal package.json', () => {
+            const minimalPackage = {
+                name: 'minimal-package',
+                version: '0.1.0'
+            };
+
+            const result = validatePackageJson(minimalPackage, '/path/to/package.json');
+            expect(result).toEqual(minimalPackage);
+        });
+
+        it('should throw error for missing name', () => {
+            const invalidPackage = {
+                version: '1.0.0'
+            };
+            expect(() => validatePackageJson(invalidPackage, '/path/to/package.json')).toThrow('Invalid package.json (/path/to/package.json): name must be a string');
+        });
+
+        it('should throw error for invalid name type', () => {
+            const invalidPackage = {
+                name: 123,
+                version: '1.0.0'
+            };
+            expect(() => validatePackageJson(invalidPackage, '/path/to/package.json')).toThrow('Invalid package.json (/path/to/package.json): name must be a string');
+        });
+
+        it('should throw error for null/undefined input', () => {
+            expect(() => validatePackageJson(null, '/path/to/package.json')).toThrow('Invalid package.json (/path/to/package.json): not an object');
+            expect(() => validatePackageJson(undefined, '/path/to/package.json')).toThrow('Invalid package.json (/path/to/package.json): not an object');
+        });
+
+        it('should allow missing version', () => {
+            const packageWithoutVersion = {
+                name: 'test-package'
+            };
+
+            const result = validatePackageJson(packageWithoutVersion, '/path/to/package.json');
+            expect(result).toEqual(packageWithoutVersion);
+        });
+
+        it('should validate dependencies object', () => {
+            const packageWithDeps = {
+                name: 'test-package',
+                version: '1.0.0',
+                dependencies: {
+                    'lodash': '^4.17.21',
+                    'react': '^18.0.0'
+                },
+                devDependencies: {
+                    'jest': '^29.0.0'
+                }
+            };
+
+            const result = validatePackageJson(packageWithDeps, '/path/to/package.json');
+            expect(result).toEqual(packageWithDeps);
+        });
+    });
+});

package/tsconfig.json

@@ -0,0 +1,35 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ES2022",
+    "moduleResolution": "bundler",
+    "esModuleInterop": true,
+    "allowSyntheticDefaultImports": true,
+    "strict": true,
+    "outDir": "./dist",
+    "rootDir": ".",
+    "types": [
+      "node",
+      "vitest"
+    ],
+    "incremental": true,
+    "allowJs": true,
+    "resolveJsonModule": true,
+    "declaration": true,
+    "declarationMap": true,
+    "baseUrl": ".",
+    "paths": {
+      "*": [
+        "src/*"
+      ]
+    }
+  },
+  "include": [
+    "src/**/*",
+    "tests/**/*"
+  ],
+  "exclude": [
+    "node_modules"
+  ]
+}
+

package/vite.config.ts

@@ -0,0 +1,78 @@
+import { defineConfig } from 'vite';
+import { VitePluginNode } from 'vite-plugin-node';
+import { execSync } from 'child_process';
+import dts from 'vite-plugin-dts';
+
+let gitInfo = {
+    branch: '',
+    commit: '',
+    tags: '',
+    commitDate: '',
+};
+
+try {
+    gitInfo = {
+        branch: execSync('git rev-parse --abbrev-ref HEAD').toString().trim(),
+        commit: execSync('git rev-parse --short HEAD').toString().trim(),
+        tags: '',
+        commitDate: execSync('git log -1 --format=%cd --date=iso').toString().trim(),
+    };
+
+    try {
+        gitInfo.tags = execSync('git tag --points-at HEAD | paste -sd "," -').toString().trim();
+    } catch {
+        gitInfo.tags = '';
+    }
+} catch {
+    // eslint-disable-next-line no-console
+    console.log('Directory does not have a Git repository, skipping git info');
+}
+
+export default defineConfig({
+    server: {
+        port: 3000
+    },
+    plugins: [
+        ...VitePluginNode({
+            adapter: 'express',
+            appPath: './src/index.ts',
+            exportName: 'viteNodeApp',
+            tsCompiler: 'swc',
+            swcOptions: {
+                sourceMaps: true,
+            },
+        }),
+        dts({
+            include: ['src/**/*'],
+            exclude: ['tests/**/*', 'node_modules/**/*'],
+            rollupTypes: true,
+        }),
+    ],
+    build: {
+        target: 'esnext',
+        outDir: 'dist',
+        lib: {
+            entry: './src/index.ts',
+            formats: ['es'],
+        },
+        rollupOptions: {
+            external: [
+                'semver',
+                'shell-escape',
+                'winston'
+            ],
+            input: 'src/index.ts',
+            output: {
+                format: 'esm',
+                entryFileNames: '[name].js',
+                preserveModules: true,
+                exports: 'named',
+            },
+        },
+        // Make sure Vite generates ESM-compatible code
+        modulePreload: false,
+        minify: false,
+        sourcemap: true
+    },
+});
+

package/vitest.config.ts

@@ -0,0 +1,37 @@
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+    test: {
+        globals: false,
+        environment: 'node',
+        include: ['tests/**/*.test.ts'],
+        env: {
+            TZ: 'America/New_York'
+        },
+        // Add pool configuration to prevent memory issues
+        pool: 'forks',
+        poolOptions: {
+            forks: {
+                maxForks: 2,
+                minForks: 1
+            }
+        },
+        // Add test timeout and memory limits
+        testTimeout: 30000,
+        hookTimeout: 10000,
+        teardownTimeout: 10000,
+        coverage: {
+            provider: 'v8',
+            reporter: ['text', 'lcov', 'html'],
+            all: true,
+            include: ['src/**/*.ts'],
+            thresholds: {
+                statements: 80,
+                branches: 80,
+                functions: 80,
+                lines: 80,
+            }
+        },
+    },
+});
+